基礎概念

int[] anArray = new int[10];

只有創建對象時才會使用new關鍵字，所以數組是個對象。

數組中的每個元素都會被初始化為默認值，int 類型的就為 0，Object 類型的就為 null。 不同數據類型的默認值不同

可變參數組

1. 基本概念

• 定義：允許函數接受不確定數量的同類型參數，這些參數會被自動封裝為一個數組。
• 作用：簡化方法調用，避免為不同參數數量重載多個方法。

2. 語法示例

public void printNumbers(int... numbers) {for (int num : numbers) {System.out.println(num);}
}// 調用方式
printNumbers(1, 2, 3);      // 輸出: 1 2 3
printNumbers(10, 20);       // 輸出: 10 20
printNumbers();            // 可以不傳參數

數組與List

將數組轉為List，使用Arrays類

//1
List<Integer> aList = Arrays.asList(1, 2, 3, 4, 5);
//2
int[] anArray = new int[] {1, 2, 3, 4, 5};
List<Integer> aList = Arrays.stream(anArray).boxed().collect(Collectors.toList());

• .boxed()轉換為對應的包裝類對象。
• **.collect(Collectors.toList())**此操作會把流中的元素收集到一個List集合中。

還有一個需要注意的是，Arrays.asList 方法返回的 ArrayList 并不是 java.util.ArrayList，它其實是 Arrays 類的一個內部類：

private static class ArrayList<E> extends AbstractList<E>implements RandomAccess, java.io.Serializable{}

如果需要添加元素或者刪除元素的話，需要把它轉成 java.util.ArrayList。

new ArrayList<>(Arrays.asList(anArray));

Comparator類

1,基本概念

int compare(T o1, T o2)

返回值	含義
負整數	o1 應該排在 o2 前面 (o1 < o2)
零	o1 和 o2 相等 (o1 == o2)
正整數	o1 應該排在 o2 后面 (o1 > o2)

因此

• o1 - o2 → 升序排序
• o2 - o1 → 降序排序

Comparator<String> lengthComparator = new Comparator<String>() {@Overridepublic int compare(String s1, String s2) {return s1.length() - s2.length();}
};
//使用Lamda
Comparator<String> lengthComparator = (s1, s2) -> s1.length() - s2.length();

2,使用Comparator的靜態方法（Java 8+）

// 按字符串長度排序
Comparator<String> lengthComparator = Comparator.comparingInt(String::length);// 按字符串長度降序排序
Comparator<String> descLengthComparator = Comparator.comparingInt(String::length).reversed();

3,常用Comparator方法

1. comparing() 和 comparingInt()/comparingLong()/comparingDouble()

// 按Person的age屬性排序
Comparator<Person> byAge = Comparator.comparing(Person::getAge);// 按字符串長度排序
Comparator<String> byLength = Comparator.comparingInt(String::length);

特性	comparing()	comparingInt()/comparingLong()/comparingDouble()
適用類型	任何Comparable類型	僅限基本數據類型(int/long/double)
性能	可能有裝箱開銷	無裝箱開銷，性能更好
方法參數	Function	ToIntFunction/ToLongFunction/ToDoubleFunction
null處理	需要額外處理	需要額外處理
鏈式調用	支持thenComparing()	支持thenComparingInt()等對應方法

2. thenComparing() - 多級排序

// 先按age排序，age相同再按name排序
Comparator<Person> byAgeThenName = Comparator.comparingInt(Person::getAge).thenComparing(Person::getName);

3. naturalOrder() 和 reverseOrder()

// 自然順序排序
Comparator<String> natural = Comparator.naturalOrder();// 逆序排序
Comparator<String> reverse = Comparator.reverseOrder();

4. nullsFirst() 和 nullsLast() - 處理null值

// null值排在前面
Comparator<String> nullsFirst = Comparator.nullsFirst(Comparator.naturalOrder());// null值排在后面
Comparator<String> nullsLast = Comparator.nullsLast(Comparator.naturalOrder());

4,例子

----------------基本排序--------------
List<String> words = Arrays.asList("apple", "banana", "pear", "orange");// 按長度排序
words.sort(Comparator.comparingInt(String::length));
System.out.println(words); // [pear, apple, banana, orange]// 按長度降序
words.sort(Comparator.comparingInt(String::length).reversed());
System.out.println(words); // [banana, orange, apple, pear]
--------------對象排序-----------------
class Person {String name;int age;// 構造方法、getter、setter省略
}List<Person> people = Arrays.asList(new Person("Alice", 25),new Person("Bob", 30),new Person("Charlie", 20)
);// 按年齡排序
people.sort(Comparator.comparingInt(Person::getAge));
System.out.println(people); // [Charlie(20), Alice(25), Bob(30)]// 按年齡降序，然后按姓名升序
people.sort(Comparator.comparingInt(Person::getAge).reversed().thenComparing(Person::getName));
System.out.println(people); // [Bob(30), Alice(25), Charlie(20)]
-----------處理null值-------------
List<String> wordsWithNull = Arrays.asList("apple", null, "banana", null, "pear");// null值排在前面
wordsWithNull.sort(Comparator.nullsFirst(Comparator.naturalOrder()));
System.out.println(wordsWithNull); // [null, null, apple, banana, pear]// null值排在后面
wordsWithNull.sort(Comparator.nullsLast(Comparator.reverseOrder()));
System.out.println(wordsWithNull); // [pear, banana, apple, null, null]

排序與查找

• Arrays.sort（）方法。

• 自定義排序（使用Comparator）

//本數據類型按照升序排列
int[] anArray = new int[] {5, 2, 1, 4, 8};
Arrays.sort(anArray);//自定義排序
//只對 1-3 位置上的元素進行反序，[A, Z, E, B, C]
String[] yetAnotherArray = new String[] {"A", "E", "Z", "B", "C"};
Arrays.sort(yetAnotherArray, 1, 3,Comparator.comparing(String::toString).reversed());

• 二分查找，Arrays.binarySearch()

//保證數組已排序
int[] anArray = new int[] {1, 2, 3, 4, 5};
int index = Arrays.binarySearch(anArray, 4);

數組復制

// 復制整個數組（長度相同）
static int[] copyOf(int[] original, int newLength)// 復制數組的指定范圍
static int[] copyOfRange(int[] original, int from, int to)
------------例子-------------
int[] original = {1, 2, 3, 4, 5};
int[] copy = Arrays.copyOf(original, 3);  // [1, 2, 3]
int[] rangeCopy = Arrays.copyOfRange(original, 1, 4);  // [2, 3, 4]

其他

數組去重

int[] numbers = {1, 2, 2, 3, 4, 4, 4, 5};
Arrays.sort(numbers);int[] unique = Arrays.stream(numbers).distinct().toArray();
// 結果: [1, 2, 3, 4, 5]

數組填充

// 用指定值填充整個數組
static void fill(int[] a, int val)// 填充數組的指定范圍 [fromIndex, toIndex)
static void fill(int[] a, int fromIndex, int toIndex, int val)
--------------例子-----------
int[] numbers = new int[5];
Arrays.fill(numbers, 1);  // [1, 1, 1, 1, 1]// 部分填充
Arrays.fill(numbers, 1, 3, 9);  // [1, 9, 9, 1, 1]