15. Write a Java program to reverse the elements of an integer array ?

Type-1:

 Here's a Java program to reverse the elements of an integer array, along with an explanation of each step:

public class ReverseArray { 
public static void main(String[] args) {
// Step 1: Define an integer array with some elements

        int[] numbers = { 1, 2, 3, 4, 5 }; 
// Step 2: Call the function to reverse the array

        reverseArray(numbers);
// Step 3: Print the reversed array

        System.out.println("Reversed Array: "); 
for (int number : numbers) { 
 System.out.print(number + " "); 
 } 
 } 
// Function to reverse the array 
public static void reverseArray(int[] arr) {
// Step 4: Use two pointers to swap elements from the ends

        int start = 0;
int end = arr.length - 1; 
while (start < end) {
int temp = arr[start];
 arr[start] = arr[end]; 
 arr[end] = temp; 
 start++; 
 end--;
        }
 } 
}

Explanation of each step:

1. We start by defining an integer array named numbers. In this example, we have an array with elements {1, 2, 3, 4, 5}. You can modify this array to have any set of integer elements.
2. We call the function reverseArray(numbers) to reverse the array numbers.
3. We then print the reversed array using a for-each loop to iterate through each element and display it.
4. The function reverseArray takes an integer array as input and reverses its elements. It uses two pointers, start and end, initialized to the first and last index of the array, respectively.
5. We enter a while loop that continues until start is less than end. In each iteration of the loop, we swap the elements at positions start and end by using a temporary variable temp. This effectively reverses the elements in the array.
6. After the loop has finished, the array will be reversed.

When you run this program with the provided array, it will output:

Reversed Array:

5 4 3 2 1

This is because the original array {1, 2, 3, 4, 5} has been reversed to {5, 4, 3, 2, 1}. If you modify the array elements, the program will reverse them accordingly.

Type-2:

Here's another way to reverse the elements of an integer array using a traditional for loop without using additional pointers:

public class ReverseArray {
public static void main(String[] args) { 
// Step 1: Define an integer array with some elements

        int[] numbers = { 1, 2, 3, 4, 5 }; 
// Step 2: Call the function to reverse the array

        reverseArray(numbers);
// Step 3: Print the reversed array 
 System.out.println("Reversed Array: "); 
for (int number : numbers) {
 System.out.print(number + " "); 
 } 
 } 
// Function to reverse the array

    public static void reverseArray(int[] arr) { 
// Step 4: Use a traditional for loop to swap elements 
int n = arr.length; 
for (int i = 0; i < n / 2; i++) { 
int temp = arr[i];
 arr[i] = arr[n - 1 - i]; 
 arr[n - 1 - i] = temp; 
 } 
 } 
}

Explanation of the alternative method:

1. We start by defining an integer array named numbers, just like in the previous example.
2. We call the function reverseArray(numbers) to reverse the array numbers.
3. We then print the reversed array using a for-each loop to iterate through each element and display it.
4. The function reverseArray takes an integer array as input and reverses its elements. It uses a traditional for loop to iterate only up to half of the array's length. This is because when we swap elements, we are effectively reversing the array.
5. Inside the loop, we use the n variable to store the length of the array (arr.length). We use this length to calculate the index of the element on the other side of the array (the element that needs to be swapped with the current element).
6. We use the temporary variable temp to swap the elements. The first element (arr[i]) is swapped with the element from the end of the array (arr[n - 1 - i]). This effectively reverses the elements in the array.

When you run this program with the provided array, it will output:

Reversed Array:

5 4 3 2 1

This is because the original array {1, 2, 3, 4, 5} has been reversed to {5, 4, 3, 2, 1}. As before, if you modify the array elements, the program will reverse them accordingly.

Type-3:

Here's another way to reverse the elements of an integer array using Java Collections:

import java.util.Collections;
import java.util.Arrays; 
public class ReverseArray { 
public static void main(String[] args) {
// Step 1: Define an integer array with some elements 
int[] numbers = { 1, 2, 3, 4, 5 }; 
// Step 2: Call the function to reverse the array 
 reverseArray(numbers);
// Step 3: Print the reversed array 
 System.out.println("Reversed Array: ");
for (int number : numbers) { 
 System.out.print(number + " ");
 } 
 } 
// Function to reverse the array

    public static void reverseArray(int[] arr) { 
// Step 4: Use Java Collections to reverse the array 
 Integer[] boxedArray = Arrays.stream(arr).boxed().toArray(Integer[]::new);
 Collections.reverse(Arrays.asList(boxedArray)); 
for (int i = 0; i < arr.length; i++) { 
 arr[i] = boxedArray[i];
        }
 }
 }

Explanation of the alternative method:

1. We start by defining an integer array named numbers, just like in the previous examples.
2. We call the function reverseArray(numbers) to reverse the array numbers.
3. We then print the reversed array using a for-each loop to iterate through each element and display it.
4. The function reverseArray takes an integer array as input and reverses its elements using Java Collections.
5. Inside the function, we first convert the primitive int array to an array of boxed Integer objects using the Arrays.stream(arr).boxed().toArray(Integer[]::new) method. This allows us to use the Collections class, which works with objects.
6. Next, we use Collections.reverse() to reverse the list of boxed Integer objects.
7. Finally, we convert the reversed list back to an array of primitive int values and store it back in the original array.

When you run this program with the provided array, it will output:

Reversed Array:

5 4 3 2 1

This is because the original array {1, 2, 3, 4, 5} has been reversed to {5, 4, 3, 2, 1}.

 As before, if you modify the array elements, the program will reverse them accordingly. Using Java Collections provides a convenient way to reverse an array, 

but it is slightly less efficient than the previous methods due to the boxing and unboxing process.