可变参数与`Collections`
- 1. 可变参数
- 1. 概述
- 2. 格式
- 3. 代码示例
- 4. 注意事项
- 2. `Collections`集合工具类
- 2.1 概述
- 2.2 方法
- 2.3 代码示例
- 2.4 注意事项
1. 可变参数
1. 概述
可变参数（Variable Arguments）是指在参数列表中允许传入不定个数的参数。在许多编程语言中，可变参数通常用于传递相同类型的参数，并且允许传入任意个数的参数。
- 可变参数的语法通常是通过使用"
..." (省略号)来表示，它可以将传递的参数打包成数组。
例如：
public void method(String... args) {for (String arg : args) {System.out.println(arg);}
}method("Hello", "World"); // 打印结果：Hello World
method("a", "b", "c"); // 打印结果：a b c
2. 格式
-
格式：
修饰符 返回值类型 方法名(参数类型... 形参名){ } -
底层：
其实是一个数组，只不过是java已经创建好的
-
作用：
在形参中接受多个数据
-
注意：
1. 一个方法只能有一个可变参数
2. 如果方法中有多个参数，可变参数要放到最后。
3. 代码示例
- 代码示例
需求：利用可变参数求几个数的和package text.text02;/*可变参数（JDK5以后）： 1.格式修饰符 返回值类型 方法名(参数类型... 形参名){ }参数类型... 形参名例如：int... args 2.底层：其实是一个数组，只不过是java已经创建好的 3.作用：在形参中接受多个数据 4.注意事项：1.形参列表中可变参数只能有一个2.可变参数必须放在形参列表的最后面需求：利用可变参数求几个数的和*/ public class text55 {public static void main(String[] args) {int sum = getSum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);System.out.println("这几个数的和为：" + sum); //这几个数的和为：55}//利用可变参数定义方法public static int getSum(int... args) {int sum = 0;for (int arg : args) {sum = sum + arg;}return sum;} } - 输出结果
4. 注意事项
-
可变参数通常应该作为参数列表的最后一个参数，因为在调用函数时，可变参数后面的参数将无法被传递或者识别。
-
在函数内部，可变参数实际上被当作一个数组（或者其他类似的数据结构）处理。因此，可以使用数组相关的操作来处理可变参数，如索引访问、遍历等。
-
当没有传递任何参数时，可变参数的值将为一个空数组（或者类似结构）。在函数内部，应该适当处理这种情况，以避免出现空指针异常或其他错误。
-
可变参数只能用于传递相同类型的参数。如果需要传递不同类型的参数，可以考虑使用重载函数或其他方式来处理。
-
使用可变参数时，需要注意参数的顺序。如果同时使用可变参数和其他类型的参数，需要确保传递参数时的顺序是正确的。
2. Collections集合工具类
2.1 概述
Collections 是 Java 编程语言中提供的一个集合工具类，位于 java.util 包中。它提供了一系列静态方法，用于对集合进行常见的操作和算法实现。
Collections 类的主要功能：
-
创建不可变集合：
Collections提供了一系列的emptyXxx()方法，用于创建不可变的空集合（如emptyList()、emptySet()等）。 -
创建单元素集合：提供了一系列的
singletonXxx()方法，用于创建只包含一个元素的不可变集合。 -
集合操作：提供了一系列的静态方法用于对集合进行操作，如排序、反转、查找、填充等。这些方法包括：
sort()、shuffle()、reverse()、binarySearch()、fill()等。 -
同步集合：提供了一系列的线程安全的集合类的静态方法（如
synchronizedList()、synchronizedSet()等），用于将现有的集合转换为线程安全的集合，以便在多线程环境下使用。
2.2 方法
| 方法 | 描述 |
|---|---|
public static <T> boolean addAll(Collection<T> c, T ... elements) | 批量添加元素 |
public static void shuffle(List<?> list) | 打乱集合顺序 |
public static <T> void sort(List<T> list) | 将集合中元素按照默认规则排序（默认规则：需要重写Comparable接口compareTo方法，默认按照从小到大的顺序排列） |
public static <T> void sort(List<T> list, Comparator<? super T> c) | 将集合中元素按照指定规则排序（指定规则在创建对象时指定比较器规则）（自定义对象，需要自己指定规则） |
public static <T> int binarySearch(List<? super T> list, T key) | 以二分查找法查找元素 |
public static void fill(List<? super T> list, T obj) | 使用指定元素填充集合 |
public static <T> T max(Collection<? extends T> coll) | 返回指定 collection 中的最大元素 |
public static <T> T min(Collection<? extends T> coll) | 返回指定 collection 中的最小元素 |
public static void swap(List<?> list, int i, int j) | 交换指定列表中指定位置的元素 |
详细描述：
-
public static <T> boolean addAll(Collection<T> c, T ... elements)- 描述：批量添加元素到指定集合中。
- 参数：
c：目标集合elements：要添加的元素数组
- 返回值：如果集合发生更改，则返回
true；否则返回false。
-
public static void shuffle(List<?> list)- 描述：打乱指定列表中元素的顺序。
- 参数：
list：要进行打乱顺序操作的列表。
-
public static <T> void sort(List<T> list)- 描述：将集合中的元素按照默认规则排序。
- 参数：
list：要排序的列表
- 默认规则：集合中的元素必须实现 Comparable 接口，并重写 compareTo 方法来定义排序规则。默认按照从小到大的顺序排列。
-
public static <T> void sort(List<T> list, Comparator<? super T> c)- 描述：将集合中的元素按照指定规则排序。
- 参数：
list：要排序的列表c：比较器规则，需要在创建对象时指定比较器规则。对于自定义对象，需要自己指定排序规则。
-
public static <T> int binarySearch(List<? super T> list, T key)- 描述：使用二分查找法在指定列表中搜索指定的元素。
- 参数：
list：要进行搜索的有序列表key：要搜索的元素
- 返回值：如果找到元素，则返回其在列表中的位置；否则返回负数。
-
public static void fill(List<? super T> list, T obj)- 描述：使用指定元素填充列表中的所有元素。
- 参数：
list：要进行填充操作的列表obj：要填充的元素
-
public static <T> T max(Collection<? extends T> coll)- 描述：返回指定 collection 中的最大元素。
- 参数：
coll：要进行查找最大元素的集合
- 返回值：集合中的最大元素。
-
public static <T> T min(Collection<? extends T> coll)- 描述：返回指定 collection 中的最小元素。
- 参数：
coll：要进行查找最小元素的集合
- 返回值：集合中的最小元素。
-
public static void swap(List<?> list, int i, int j)- 描述：交换指定列表中指定位置的元素。
- 参数：
list：要进行元素交换的列表i，j：要交换的元素索引位置。
2.3 代码示例
- 代码示例
package text.text02;import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.function.Consumer;/*Collections：集合工具类
1.java.util.Collections：是集合的工具类
2.作用：Collections不是集合，而是集合的工具类
3.方法：
public static <T> boolean addAll(Collection <T> c,T ... elements)`:批量添加元素
public static void shuffle(List<?> list) `:打乱集合顺序
public static <T> void sort(List<T> list)`:将集合中元素按照默认规则排序默认规则：需要重写Comparable接口compareTo方法，默认按照从小到大的顺序排列public static <T> void sort(List<T> list，Comparator<? super T> )`:将集合中元素按照指定规则排序指定规则：在创建对象时，指定比较器规则（自定义对象，需要自己指定规则）public static <T> int binarySearch(List<? super T> list, T key)` ：以二分查找法查找元素前提元素必须有序，该方法返回的是该元素所在的索引public static void fill(List<? super T> list, T obj)`： 使用指定元素填充集合
public static <T> T max(Collection<? extends T> coll)` ： 返回指定 Collection 中的最大元素
public static <T> T min(Collection<? extends T> coll)` ： 返回指定 Collection 中的最小元素
public static void swap(List<?> list, int i, int j)` ：交换指定列表中指定位置的元素*/
public class text56 {public static void main(String[] args) {//1.public static <T> boolean addAll(Collection <T> c,T ... elements)`:批量添加元素System.out.println("===================== 1.批量添加元素 =====================");//创建集合Collection<String> list1 = new ArrayList<>();//添加元素Collections.addAll(list1, "abc", "def", "ghi", "jkl", "mno", "por");//遍历集合list1.forEach(new Consumer<String>() {@Overridepublic void accept(String str) {System.out.print(str + " "); //abc def ghi jkl mno por}});System.out.println();//2.public static void shuffle(List<?> list) `:打乱集合顺序System.out.println("===================== 2.打乱集合顺序 =====================");//创建集合ArrayList<String> list2 = new ArrayList<>();//添加元素Collections.addAll(list2, "abc", "def", "ghi", "jkl", "mno", "por");//打乱元素Collections.shuffle(list2);//遍历集合for (String str : list2) {System.out.print(str + " "); //打乱顺序了，每次输出结果都不一样}System.out.println();//3.public static <T> void sort(List<T> list)`:将集合中元素按照默认规则排序System.out.println("===================== 3.将集合中元素按照默认规则排序 =====================");//默认规则：需要重写Comparable接口compareTo方法，默认按照从小到大的顺序排列//创建集合ArrayList<String> list3 = new ArrayList<>();//添加元素Collections.addAll(list3, "0004", "0002", "0006", "0001", "0003", "0005");//默认规则排序(即从小到大排列)Collections.sort(list3);//遍历集合for (String str : list3) {System.out.print(str + " "); //0001 0002 0003 0004 0005 0006}System.out.println();//4.public static <T> void sort(List<T> list，Comparator<? super T> )`:将集合中元素按照指定规则排序System.out.println("===================== 4.将集合中元素按照指定规则排序 =====================");//指定规则：在创建对象时，指定比较器规则（自定义对象，需要自己指定规则）//创建集合ArrayList<String> list4 = new ArrayList<>();//添加元素Collections.addAll(list4, "0004", "0002", "0006", "0001", "0003", "0005");//指定规则排序Collections.sort(list4, new Comparator<String>() {@Overridepublic int compare(String o1, String o2) {return o2.compareTo(o1);}});//遍历集合for (String str : list4) {System.out.print(str + " "); //0006 0005 0004 0003 0002 0001}System.out.println();//5.public static <T> int binarySearch(List<? super T> list, T key)` ：以二分查找法查找元素System.out.println("===================== 5.以二分查找法查找元素 =====================");//前提元素必须有序//创建集合ArrayList<Integer> list5 = new ArrayList<>();//添加元素Collections.addAll(list5, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 10);//二分查找法查找元素//该方法返回的是该元素所在的索引int binarySearch = Collections.binarySearch(list5, 6);System.out.println("该元素所在的索引为：" + binarySearch); //该元素所在的索引为：5//遍历集合for (Integer str : list5) {System.out.print(str + " "); //1 2 3 4 5 6 7 8 8 9 10}System.out.println();//6.public static void fill(List<? super T> list, T obj)`： 使用指定元素填充集合System.out.println("===================== 6.使用指定元素填充集合 =====================");//创建集合ArrayList<Integer> list6 = new ArrayList<>();//添加元素Collections.addAll(list6, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 10);//指定元素填充集合Collections.fill(list6, 1314);//遍历集合for (Integer str : list6) {System.out.print(str + " "); //1314 1314 1314 1314 1314 1314 1314 1314 1314 1314 1314}System.out.println();//7.public static <T> T max(Collection<? extends T> coll)`：返回指定Collection 中的最大元素System.out.println("===================== 7.返回指定Collection 中的最大元素 =====================");//创建集合ArrayList<Integer> list7 = new ArrayList<>();//添加元素Collections.addAll(list7, 1, 2, 3, 4, 5, 1314, 520, 6, 7, 8, 8, 9, 10);//返回指定Collection 中的最大元素Integer max = Collections.max(list7);System.out.println("最大元素为：" + max); //最大元素为：1314//遍历集合for (Integer str : list7) {System.out.print(str + " "); //1 2 3 4 5 1314 520 6 7 8 8 9 10}System.out.println();//8.public static <T> T min(Collection<? extends T> coll)`：返回指定 Collection 中的最小元素System.out.println("===================== 8.返回指定 Collection 中的最小元素 =====================");//创建集合ArrayList<Integer> list8 = new ArrayList<>();//添加元素Collections.addAll(list8, 1, 2, 3, 4, 5, 0, -1, 6, 7, 8, 8, 9, 10);//返回指定Collection 中的最小元素Integer min = Collections.min(list8);System.out.println("最小元素为：" + min); //最小元素为：-1//遍历集合for (Integer str : list8) {System.out.print(str + " "); //1 2 3 4 5 0 -1 6 7 8 8 9 10}System.out.println();//9.public static void swap(List<?> list, int i, int j)` ：交换指定列表中指定位置的元素System.out.println("===================== 9.交换指定列表中指定位置的元素 =====================");//创建集合ArrayList<Integer> list9 = new ArrayList<>();//添加元素Collections.addAll(list9, 1, 2, 3, 4, 5, 0, -1, 6, 7, 8, 8, 9, 10);//交换指定列表中指定位置的元素Collections.swap(list9, 0, 12);//遍历集合for (Integer str : list9) {System.out.print(str + " "); //10 2 3 4 5 0 -1 6 7 8 8 9 1 }}
}- 输出结果
-
1.批量添加元素
-
2.打乱集合顺序
-
3.将集合中元素按照默认规则排序
-
4.将集合中元素按照指定规则排序
-
5.以二分查找法查找元素
-
6.使用指定元素填充集合
-
7.返回指定Collection 中的最大元素
-
8.返回指定 Collection 中的最小元素
-
9.交换指定列表中指定位置的元素
-
2.4 注意事项
-
集合的同步性：
Collections类提供了一些线程安全的集合方法，如synchronizedList()、synchronizedSet()等。但是需要注意，这些方法只是将现有的集合转换为线程安全的集合，并不能保证对集合中的元素的操作是原子性的。如果需要在多线程环境下对集合进行并发操作，建议使用并发集合类 （如ConcurrentHashMap、CopyOnWriteArrayList等）来代替。 -
不可变集合：
Collections类提供了创建不可变集合的方法（如unmodifiableList()、unmodifiableSet()），返回的不可变集合不允许对其进行修改操作。需要注意的是，如果原始的集合发生了变化，不可变集合可能会反映这些变化。因此，当需要确保集合不会被修改时，应该使用不可变集合。 -
自然排序和自定义排序：
Collections.sort()方法用于对集合进行排序，默认使用集合元素的自然顺序，即元素的类必须实现Comparable接口并重写compareTo()方法。如果需要使用自定义排序规则，可以使用重载的sort()方法，其中传入一个自定义的比较器 Comparator。 -
对象的比较和相等：在使用排序或查找方法时，需要确保集合中的元素正确地实现了
equals()和compareTo()方法，以保证比较和查找的准确性。 -
注意泛型的使用：
Collections类中的方法通常使用了泛型来增加灵活性和类型安全性。在使用这些方法时，需要注意传入的集合类型和元素类型需要匹配。 -
注意性能和效率：某些
Collections方法的实现可能会产生额外的开销，比如排序方法可能需要额外的内存空间。在处理大量数据时，需要考虑这些性能和效率因素。
