在 Java 中反转数组的4种详细方法

电玩女神 2023-09-25 16:41 93阅读 0赞

# 1.问题 #

> Input : 1, 2, 3, 4, 5  
> Output :5, 4, 3, 2, 1

> Input : 10, 20, 30, 40  
> Output : 40, 30, 20, 10

# 2.方法 #

## 方法1：使用临时数组 ##

1.  输入数组的大小和数组的元素。
2.  考虑一个函数 reverse，它接受参数——数组（比如 arr）和数组的大小（比如 n）
3.  在函数内部，一个新数组（具有第一个数组的数组大小，arr）被初始化。
4.  数组arr\[\]从第一个元素开始迭代，数组arr\[\]的每个元素从后面开始放入新数组，即新数组从最后一个元素开始迭代。
5.  这样就把数组arr\[\]的所有元素都倒序放到了新数组中。

public class reverseArray {
        
      
        // function that reverses array and stores it 
        // in another array
        static void reverse(int a[], int n)
        {
        
            int[] b = new int[n];
            int j = n;
            for (int i = 0; i < n; i++) {
        
                b[j - 1] = a[i];
                j = j - 1;
            }
      
            // printing the reversed array
            System.out.println("Reversed array is: \n");
            for (int k = 0; k < n; k++) {
        
                System.out.println(b[k]);
            }
        }
      
        public static void main(String[] args)
        {
        
            int [] arr = {
        10, 20, 30, 40, 50};
            reverse(arr, arr.length);
        }
    }

Reversed array is: 
    
    50
    40
    30
    20
    10

## 方法2：使用交换 ##

交换数组的元素。第一个元素与最后一个元素交换。第二个元素与最后一个元素交换，依此类推。 例如，考虑数组 \[1, 2, 3, …., n-2, n-1, n\]。我们将 1 与 n 交换，2 与 n-1 交换，3 与 n-2 交换，等等。

public class Test {
        
        public static void main(String[] args) {
        
            int [] arr = {
        10, 20, 30, 40, 50};
            reverse(arr,arr.length);
        }
        static void reverse(int[] a,int n) {
        
            int i, k, t;
            for (i = 0; i < n / 2; i++) {
        
                t = a[i];
                a[i] = a[n - i - 1];
                a[n - i - 1] = t;
            }
            
            System.out.println("Reversed array is: \n");
            for (k = 0; k < n; k++) {
        
                System.out.println(a[k]);
            }
        }
    }

Reversed array is: 
    
    50
    40
    30
    20
    10

## 方法3：使用 Collections.reverse() 方法 ##

java.util.Collections.reverse(List list) 方法。  
使用 java.util.Arrays.asList(array) 将数组转换为列表，然后反转列表。

public class Test {
        
        public static void main(String[] args) {
        
            Integer [] arr = {
        10, 20, 30, 40, 50};
            reverse(arr);
        }
        static void reverse(Integer[] a) {
        
            Collections.reverse(Arrays.asList(a));
            System.out.println(Arrays.asList(a));
    
        }
    }

[50, 40, 30, 20, 10]

## 方法4：使用 StringBuilder.append() 方法 ##

如果您使用的是 String 数组，我们可以使用 StringBuilder 并为每个数组元素附加一个 for 循环，从数组的长度开始递减，将 StringBuilder 转换为字符串，然后拆分回数组。

public class Test {
        
        public static void main(String[] args) {
        
            String[] arr = {
        "Hello", "World"};
            StringBuilder reversed = new StringBuilder();
    
            for (int i = arr.length-1; i >= 0; i--) {
        
                reversed.append(arr[i]).append(" ");
            };
    
            String[] reversedArray = reversed.toString().split(" ");
    
            System.out.println(Arrays.toString(reversedArray));
        }
    }

[World, Hello]