The **`order`** method of the `ByteBuffer` class in Java either retrieves or modifies a buffer's byte order, based on the parameters passed to the function.

The process is illustrated below.

To use the `order` method, you will need to import the `ByteBuffer` class into your program, as shown below.

```Java
import java.nio.ByteBuffer
```

#   
#  Variations and parameters

There are $2$ variations of the `order` method.

1. The first variation of the `order` method has no parameters and returns a buffer's byte order. The prototype of this method is shown below:.

```Java
public final ByteOrder order()
```

2. The second variation of the `order` method takes a single parameter that represents a byte order. It sets this parameter as the byte order of a specified buffer. The prototype of this method is shown below.

```Java
public final ByteBuffer order(ByteOrder bo)
```

#   
## Return value

The `order` method returns either a buffer's byte order or the buffer itself, depending on what parameters were passed to the method.

If no parameters are passed to the `order` method, it returns the buffer's byte order. The **byte order** is used when values need to be read or written to the buffer or new buffers need to be created as views of the current buffer. 
>By default, the order of a `ByteBuffer` object is [BIG_ENDIAN](https://docs.oracle.com/javase/7/docs/api/java/nio/ByteOrder.html#BIG_ENDIAN). 

If a byte order is passed as a parameter to the `order` method, it modifies the byte order of the buffer and returns the buffer itself. The new byte order may be either [LITTLE_ENDIAN](https://docs.oracle.com/javase/7/docs/api/java/nio/ByteOrder.html#LITTLE_ENDIAN) or [BIG_ENDIAN](https://docs.oracle.com/javase/7/docs/api/java/nio/ByteOrder.html#BIG_ENDIAN).

##  
## Example

The code below shows how the `order` method can be used in Java.


import java.nio.*;
import java.util.*;

class orderMethods {
  public static void main(String[] args) {

    // initialize buffer instance
    ByteBuffer sourceBuffer = ByteBuffer.allocate(5);
    
    byte values[] = {2, 1, 6, 7, 10};

    // add values to buffer
    for(int i = 0; i < 5; i++)
    {
      sourceBuffer.put(values[i]);
    }

    // Print buffer
    System.out.println("The ByteBuffer is: " + Arrays.toString(sourceBuffer.array()));
    
    // Retrieve current byte order of buffer
    ByteOrder currentByteOrder = sourceBuffer.order();
    System.out.println("The current byte order is: " + currentByteOrder);
    
    // Update the byte order
    ByteBuffer modifiedBuffer = sourceBuffer.order(ByteOrder.nativeOrder());
    currentByteOrder = modifiedBuffer.order();
    System.out.println("The modified byte order is: " + currentByteOrder);

  }
}

#   
## Explanation

First, a `ByteBuffer` object called `sourceBuffer` is initialized through the `allocate()` method.

Since `sourceBuffer` has the capacity to store $5$ elements, the `put()` method is repeatedly invoked to add values to the buffer through a `for-loop`.

The `order` method in line $22$ retrieves the byte order of the buffer. By default, the order of a `ByteBuffer` object is `BIG_ENDIAN`.
 
Finally, the `order` method in line $26$ is invoked to modify the byte order. The `ByteOrder.nativeOrder()` method returns the `LITTLE_ENDIAN` byte order. The `order` method creates a new buffer `modifiedBuffer`, and sets the byte order to `LITTLE_ENDIAN`.

What is the ByteBuffer order method in Java?

Sets or retrieves a ByteBuffer's byte order, default is BIG_ENDIAN. Variations: no parameter returns the order, ByteOrder parameter sets it.