As we know, arrays are one of the most used data structures for storing multiple values in a single variable.

So, we are going to explore different ways to invert the order of an array’s values using Java core methods and external libraries.

## Reverse Array Using Java 7

Java 7 provides several approaches to invert an array. Let’s go down the rabbit hole and take a close look at each approach.

### Using Swapping Approach

To reverse the order of an array’s elements, we can simply use a traditional for loop.

First, we need to iterate over the given array. Then, we alternate the element at the index i with the element at the index arrayLength - i - 1 until we reach the middle of the array. Now, let’s see how to implement this in Java:

```    ```
@Test
public void reverseArrayUsingSwapping() {
String[] initialArray = { "A", "B", "C", "D", "E", "F" };
for (int i = 0; i < initialArray.length / 2; i++) {
String temp = initialArray[i];
initialArray[i] = initialArray[initialArray.length - i - 1];
initialArray[initialArray.length - i - 1] = temp;
}

String[] reversedArray = { "F", "E", "D", "C", "B", "A" };
assertArrayEquals(reversedArray, initialArray);
}
```
```

### Using Copying Approach

Here, we will use the for loop as well, but with a different logic.

The basic idea is to use another array that acts as a copy of the initial array. However, we need to copy the elements in reverse order.

Now, let’s illustrate this using a practical example:

```    ```
@Test
public void reverseArrayUsingCopying() {
String[] initialArray = { "A", "B", "C", "D", "E", "F" };
String[] result = new String[initialArray.length];

for (int i = 0; i < initialArray.length; i++) {
result[i] = initialArray[initialArray.length - i - 1];
}

String[] reversedArray = { "F", "E", "D", "C", "B", "A" };
assertArrayEquals(reversedArray, result);
}
```
```

Please note that we can’t use the enhanced for loop to iterate through an array backward.

### Using Collections.reverse() Method

Collections is a utility class that comes with multiple ready-to-use static methods for operating and manipulating collections.

Among these methods, we find the reverse() method. It was introduced with the aim of reversing a collection of elements.

```    ```
@Test
public void reverseArrayUsingCollections() {
String[] initialArray = { "A", "B", "C", "D", "E", "F" };
Collections.reverse(Arrays.asList(initialArray));

String[] reversedArray = { "F", "E", "D", "C", "B", "A" };
assertArrayEquals(reversedArray, initialArray);
}
```
```

Please note that the method accepts a list and not an array. This is why we used the Arrays.asList() method.

## Array in Reverse Order Using Java 8

The Java 8 stream API provides another convenient way to reverse the order of the elements in a particular array.

So, let’s exemplify this using a test case:

```    ```
@Test
public void reverseArrayUsingStreamApi() {
int[] initialArray = { 1, 9, 5, 8, 3, 2 };
int[] result = IntStream.rangeClosed(1, initialArray.length)
.map(i -> initialArray[initialArray.length - i])
.toArray();

int[] reversedArray = { 2, 3, 8, 5, 9, 1 };
assertArrayEquals(reversedArray, result);
}
```
```

As we can see, we used map to swap the elements. Then, we called the terminal operation toArray() to return the reversed array.

## Using Guava API

Guava is a library provided by Google. It comes with a set of utility and helper classes.

For instance, it offers Lists.reverse() to return a reversed view of a given list.

Typically, the method accepts a list as a parameter. So, we need to call Arrays.asList() to pass an array:

```    ```
@Test
public void reverseArrayUsingGuava() {
Object[] initialArray = { "A", "B", "C", "D", "E", "F" };
Object[] result = Lists.reverse(Arrays.asList(initialArray))
.toArray();

Object[] reversedArray = { "F", "E", "D", "C", "B", "A" };
assertArrayEquals(reversedArray, result);
}
```
```

As shown above, since Lists.reverse() returns a list, we used the toArray() method to get the reversed elements as an array.

## Using Apache Commons Library

Another solution would be using the Apache Commons Lang library.

It provides the ArrayUtils.reverse() method for inversing an array in a null-safe manner (it accepts null as a parameter).

```    ```
@Test
public void reverseArrayUsingApacheCommonsLang() {
String[] initialArray = { "A", "B", "C", "D", "E", "F" };
ArrayUtils.reverse(initialArray);

String[] reversedArray = { "F", "E", "D", "C", "B", "A" };
assertArrayEquals(reversedArray, initialArray);
}
```
```

Please bear in mind that Guava and Apache Commons are external libraries, so we need to add their dependencies in pom.xml

## Conclusion

To sum it up, we have covered in-depth everything you need to know about how to reverse an array in Java.

Along the way, we have seen how to use Java 7 and Java 8 methods to achieve this.

Then, we showcased how to use external libraries such as Guava and Apache Commons to accomplish the same objective.