What is the use of little endian and big endian?

Answer 1

"Little Endian" means that the lower-order byte of the number is stored in memory at the lowest address, and the high-order byte at the highest address. For example, a 4 byte Integer

Byte3 Byte2 Byte1 Byte0

will be arranged in memory as follows:

Base Address+0 Byte0

Base Address+1 Byte1

Base Address+2 Byte2

Base Address+3 Byte3

Intel processors (those used in PC's) use "Little Endian" byte order.

"Big Endian" means that the high-order byte of the number is stored in memory at the lowest address, and the low-order byte at the highest address. The same 4 byte integer would be stored as:

Base Address+0 Byte3

Base Address+1 Byte2

Base Address+2 Byte1

Base Address+3 Byte0

Motorola processors (those used in Mac's) use "Big Endian" byte order.

Answer 2

"Little Endian" means that the lower-order byte of the number is stored in memory at the lowest address, and the high-order byte at the highest address.

"Big Endian" means that the high-order byte of the number is stored in memory at the lowest address, and the low-order byte at the highest address.

Answer 3

Big-endian and little-endian describe the byte order of multi-byte values (words), whether in computer memory or during transmission. Humans use big-endian notation, such that the most-significant digit always comes first when we read a numeric symbol from left-to-right. That is, the three-digit symbol 123 means one-hundred-and-twenty-three. By contrast, little-endian notation would completely reverse the significance, such that 123 would mean three-hundred-and-twenty-one.

Many of the early binary computers used the "normal" big-endian convention, such that the four-byte binary value 0x01020304 would be written with the most-significant byte (0x01) at the lowest address and the least-significant byte (0x04) in the highest address. If assume the four bytes are allocated to address A, the memory layout would be as follows:

A[0] = 0x01 (A + 0 bytes (lowest address))

A[1] = 0x02 (A + 1 byte)

A[2] = 0x03 (A + 2 bytes)

A[3] = 0x04 (A + 3 bytes (highest address))

While this seems to make perfect sense because it matches the way we imagine all values should be written (whether in decimal, binary or some other base), it does create a subtle but not insignificant problem. Let's imagine we've actually stored the binary value 0x00000001 in those four bytes. The memory layout would then be:

A[0] = 0x00 (lowest address: A + 0 bytes) A[1] = 0x00

A[2] = 0x00

A[3] = 0x01 (highest address: A + 3 bytes)

Now, imagine we have allocated one byte of storage at address B and we wish to perform the assignment operation B = A. If we did this naively, without taking the byte-order into account, B = A would really mean B = A[0] because A and A[0] have the exact same address (A+0 bytes). Thus the value of B after assignment would be 0x00. This is clearly not what we expect because A is a four-byte value with the decimal value 1. So when we said B = A what we really meant was B = A[3]. The computer can easily take this into account on our behalf, but it does add a minute overhead to the assignment operation.

To eliminate this overhead completely, many modern computers use little-endian notation. Thus our four-byte value would actually be written in reverse order:

A[0] = 0x01 (lowest address: A + 0 bytes)

A[1] = 0x00

A[2] = 0x00

A[3] = 0x00 (highest address: A + 3 bytes)

Now when we say B = A we really do mean B = A[0], thus B = 0x01.

It should be noted at this point that many systems today still use big-endian notation. This is largely due to historical reasons, such as maintaining backward compatibility. It should also be noted that little-endian notation has no effect on the order of character arrays (strings), only the order of the bytes used to encode the individual characters within the string. That is, 16-bit UNICODE characters may be individually encoded using little-endian notation, but the order of the characters within the string remains big-endian, as you would expect.

There are also some systems that support both big-endian and little-endian notations. In addition, there are also other "endians" where the byte order may be partially big-endian or little-endian, such that a 4-byte word might use little-endian notation for each pair of bytes, but the order of those pairs with respect to each other may be big-endian. Such endians are often called middle-endian or mixed-endien.

Big-endian notation is also widely-used in data networks. This, of course, is vital since systems with different endians still require a consistent means of transmitting data back and forth. As such, the internet protocol suite (IPv4, IPv6, TCP and UDP) advocate big-endian byte order. For that reason, big-endian is also known as network byte order.

Answer 4

The big-endians assert that you have to open an egg at the bigger end, the little-endians, at the smaller end. The two groups are engaged in bitter fightings. (This is from Gulliver's Travels.)

In programming, it refers to the order in which bytes are saved for a number; I believe this refers especially to integers. The difference is whether the highest-order byte is stored first (big-endian), or last (little-endian).

Answer 5

Basic Memory Concepts

A bit has two values (on or off, 1 or 0)

A byte is a sequence of 8 bits.

Integer, and float type variables are stored in 4 bytes or 32 bits, while long, and double are stored in 8 bytes or 64 bits.

Memory is a one large array containing bytes as its elements.

In computer terminology, index for memory array is called an address, which refers to a location in the memory array

Each address stores one element of the memory "array", which is typically one byte. There are some memory configurations where each address stores something besides a byte, but here we are dealing with only bytes.

Big and Little - Endian formats:

Represents the order in which a sequence of bytes is stored in computer memory.

Everything in Java binary format files is stored in big-endian format, MSB (Most Significant Byte) first. This is referred to as big-endian byte sex or sometimes network order.

For example, consider the number 1025 stored in a 4-byteinteger:

1025 in binary = 10000000001 (2 to the tenth power plus one).

The "leftmost" bit in a byte is the biggest. So, the binary sequence 00000100 00000001 is the decimal number 1025.

00000100 00000001 = (210 + 20 = 1024 + 1 = 1025).

Bits in a byte are numbered from right-to-left, and bit 0 is the rightmost and the smallest; bit 7 is leftmost and largest.

Thus (underlined) 1 (which is 2 to the power of 10 = 1024) is the most significant digit, and the other 1 (which is 2 to the power of 0 = 1) is the least significant digit.

In a little-endian system, the least significant byte (LSB) in the sequence is stored first, therefore it is stored exactly opposite of big-endian format as follows:

Address

Big-Endian representation of 1025

Little-Endian representation of 1025

00

01

02

03

00000000

00000000

00000100

00000001

00000001

00000100

00000000

00000000

Big-endian: used by

Java virtual machine (JVM),

Motorola

Little-endian: used by

Intel processors (CPUs) and DEC Alphas,

Windows on x86, x64

Many mainframe computers, particularly IBM mainframes, use big-endian architecture. Most modern computers, including PCs, use the little-endian system.

Answer 6

"Little Endian" means that the lower-order byte of the number is stored in memory at the lowest address, and the high-order byte at the highest address.

"Big Endian" means that the high-order byte of the number is stored in memory at the lowest address, and the low-order byte at the highest address.