在 Java 中反轉數組

數組在編碼中經常使用，是一種在一個變量中存儲相同類型的多個值的方法。編碼人員想要反轉數組的原因可能有很多。可能需要反轉數組，例如，當問題的邏輯需要從最後一個元素開始時。在這種情況下，最佳做法是進行反轉，然後在代碼中必要時使用反轉數組。更重要的是，反轉數組是 Java Juniors 面試中非常受歡迎的任務。

如何反轉數組

反轉數組的方法有很多種，這裡我們考慮 5。對於選項 1，使用從原始數組末尾按升序填充的附加數組反轉數組（降序），在選項 2 中是就地反轉在開始和結束的數組元素交換的地方進行，在選項3中，使用Collections框架中的reverse()方法進行反轉，在選項4中，List.add()和List.remove()被使用，最後，在選項5中，使用了遞歸。

選項 1：使用附加數組反轉數組

讓我們編寫一個簡單的方法來使用附加數組反轉數組。此選項使用一個附加數組，該數組從原始數組的最後一個元素開始按降序填充，即第一個元素與原始數組中的最後一個元素相同，第二個與倒數第二個元素相同，依此類推直到附加數組被填滿。

import java.util.Arrays;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       int[] array = {7, 8, 9, 10, 11};
       System.out.println("Array : " + Arrays.toString(array)); // print array

       // Call function to get reversed array
       int[] reversedArray = reverse(array);
       System.out.println("Reversed array : " + Arrays.toString(reversedArray)); // print reversed array
   }

   // Method returns a new reversed array, based on the array which was passed to it.
   static int[] reverse(int[] array) {
       int[] newArray = new int[array.length];

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

       return newArray;
   }
}

在這個例子中，我們編寫了一個方法來反轉數組並根據傳遞給它的數組返回一個新的反轉數組。數組在main中聲明，然後調用方法reverse 。該方法的參數是數組。在方法reverse中，創建了一個新數組newArray ，它的大小與array相同，只是完全為空。for循環用於填充 newArray並在數組的整個長度上運行。這是通過從數組的第一個元素開始並將其分配給newArray的最後一個元素來完成的，然後獲取數組的第二個元素並將其分配給newArray的倒數第二個元素，依此類推；newArray向後填充。當 for 循環完成時，newArray完全充滿並且是array的完全反轉。

選項 2：以相反順序打印數組元素

對於這個反轉數組的選項，不需要使用額外的數組，也不會轉換成數組列表。相反，數組元素就地按相反順序放置。這意味著它們實際上被交換了。第一個元素與最後一個元素交換，第二個元素與倒數第二個元素交換，依此類推。使用for循環，完成後，數組將被反轉。代碼如下所示：

import java.util.Arrays;
/*
reversing an array in-place
*/
public class ReverseArrayDemo {

   public static void main(String[] args) {
       int[] array = {1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       arrayReverse(array);
       System.out.println("Array after reverse : " + Arrays.toString(array));
   }
//arrayReverse is a method that reverses array in-place
   static void arrayReverse(int[] array) {
       for (int i = 0; i < array.length / 2; i++) {
           int temp = array[i];
           array[i] = array[array.length - i - 1];
           array[array.length - i - 1] = temp;
       }
   }
}

使用Arrays.toString(array) 將原始數組打印為字符串，然後將我們的數組作為參數傳遞給reverse。在for循環的reverse方法中，創建並使用了一個變量 temp。在for循環中，反向順序分三步實現：

1. 將第一個元素分配給temp
2. 將最後一個元素分配給第一個元素
3. 將temp分配給最後一個元素

這次再次對第二個元素和從最後一個元素開始的第二個元素執行此操作，依此類推。這是針對數組的連續元素完成的，但循環僅迭代到數組大小的一半。本質上，交換數組兩端的元素。此方法的運行速度是使用從 0 到 size 的for循環的方法的兩倍。結果實現了數組的倒序，我們展示瞭如何以倒序打印數組並打印出值：

選項 3：使用 Collections.reverse()

在 Java 中，reverse方法是現有 Collections 框架的一部分，可用於反轉數組。讓我們用它來做反轉。

import java.util.Arrays;
import java.util.Collections;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       Integer[] array = {1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       reverse(array);
       System.out.println("Array after reverse : " + Arrays.toString(array));
   }
//method that reverses an array
   static void reverse(Integer[] array) {
       Collections.reverse(Arrays.asList(array));
   }
}

在main中，創建數組並將其填充為包含 5 個數字的整數數組。然後使用Arrays.asList(array)將其作為列表打印出來，然後調用函數reverse並將數組作為參數傳遞給該函數。在reverse中，使用了Collections.reverse，它用在數組列表Arrays.asList(array)上，而不是數組本身。然後在下一步中，我們將展示如何使用System.out.println以相反的順序打印數組，這次每個元素都打印在同一行上：

選項 4：使用 List.add() 和 List.remove() 反轉數組

在這個新選項中，List.add()和List.remove()用於進行反轉。其工作方式是將數組轉換為列表，刪除列表的最後一個元素並將其放在列表的開頭。在整個列表被迭代之後，新列表是原始列表的反轉。在main()方法中，創建了一個包含 5 個數字的數組。然後將數組的原始狀態輸出到控制台。然後將該數組作為方法的參數放入reverse()。此方法的工作原理基本上是刪除最後一個元素並將其插入數組的前面。最後，數組的新（反轉）狀態被輸出到控制台。在相反（）方法，通過Arrays.asList(array)將數組寫入 List ，以啟用add()和remove()方法執行反轉。此方法的工作原理基本上是刪除最後一個元素並將其插入數組的前面。reverse()使用的步驟如下。它使用for循環來執行列表元素的反轉。它通過初始化變量i來做到這一點。最初i設置為 0。當i = 0時，列表中list.size() - 1處的元素被刪除，並且這將始終是最後一個元素，因為i < list.size() - 1. 由於remove()方法返回它已刪除的元素，因此該元素現在被添加到索引i = 0的列表中，即插入到開頭。然後列表的其餘部分向右移動，但新列表仍然具有相同數量的元素，即size。繼續使用i的下一個值i = 1執行for循環，執行相同的一組步驟，因此最後一個元素被刪除並放入 nums 中i = 1並且列表向右移動。這一直持續到i的最後一個增量值和列表中的所有元素都已更改。在第二個索引為 i 的列表的循環元素設置為索引為i的數組元素，其中i從 0 到list.size() - 1。總而言之，使用的步驟是： 步驟：

1. 我 = 0
2. 刪除list.size() - 1 處的元素
3. 插入元素，它位於list.size() - 1，位於 i = 0
4. 遞增我
5. 重複步驟 2 到 4（在步驟 3 中使用新的 i 值）直到 i 的最後一個增量值被使用

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       Integer[] array = new Integer[]{1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       reverse(array);
       System.out.println("Array after reverse : " + Arrays.toString(array));
   }

   static void reverse(Integer[] array) {
       List list = new ArrayList<>(Arrays.asList(array));

       for (int i = 0; i < list.size() - 1; i++) {
           list.add(i, list.remove(list.size() - 1));
       }

       for (int i = 0; i < list.size(); i++) {
           array[i] = list.get(i);
       }
   }
}

此代碼給出輸出：

選項 5：通過遞歸反轉數組

遞歸方法在編碼中被廣泛使用，可用於創建一種關於如何反轉數組的有效方法。在此選項中，數組被轉換為列表，然後每次刪除列表末尾的最後一個元素時，代碼都會進入方法reverse() ，並且列表會以相反的順序將刪除的值添加到其中。與前面的方法一樣，創建了一個由 5 個數字組成的數組。然後它作為參數傳遞給函數reverse()。在reverse()中，要做的第一件事是將數組轉換為列表並檢查列表大小。如果它只有一個元素或為空，則該方法結束並返回。如果不是，則刪除第一個元素，但將其複制為Integer，價值。然後再次調用方法reverse()並再次開始遞歸。當輸入函數時，執行相同的步驟，檢查大小，如果列表大於 1，下一步將刪除第一個元素，然後再次進行遞歸。當列表的大小為 1 時，reverse()返回到調用它的位置，然後列表將每個值添加到它以將其構建為原始列表的完全反向。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       Integer[] array = new Integer[]{1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       List list = new ArrayList<>(Arrays.asList(array));
       reverse(list);
       System.out.println("Array after reverse : " + Arrays.toString(list.toArray()));
   }

   public static void reverse(List list) {
       if (list== null || list.size() <= 1) {
           return;
       }

       Integer value = list.remove(0);

       reverse(list);

       list.add(value);
   }
}

輸出是：

結論

所以在這裡我們研究了 5 種不同的方法來反轉數組。使用 Collections 框架的選項 3 可能是最好的方法，因為Collections.reverse是一個已經存在的、經過試驗和測試的 Java 函數。當然可以使用其他選項，尤其是在學習時，但通常標準方法（如果存在）是最好的，因為它們通常經過高度優化和測試。但是，您可以自己創建此類方法，因為這是一個很好的編碼練習，將幫助您在 Java Junior 面試中取得成功。