java可变参数、数组工具类Arrays、集合工具类Collections

package com.qianfeng.test;

/*
*可变参数：参数的个数可以改变
*作用：简化代码，方便操作。
*/
public class Demo5 {

public static void main(String[] args) {

	// 值传递
	int he1 = sum(2, 2, 4);
	System.out.println(he1);

	// 址传递
	int[] arr1 = { 3, 4, 5 };
	int he2 = sum(arr1);
	System.out.println(he2);
	
	//通过可变参数求和
	int[] arr2 = { 3, 4, 5 };
	int he3 = sum1(arr2);
	System.out.println(he3);

	//可变参数的注意点：
	//1.给可变参数传值的实参可以直接是多个值
	int he4 = sum1(3,4,5,6,7,8);
	System.out.println(he4);
	//2.当包括可变参数在内有多个参数时，可变参数必须放在最后，并且一个方法只能同时有一个可变参数。
	int he5 = sum2(3,4,5);
	System.out.println(he5);
	//3.当固定参数的方法与可变参数的方法是重载时，固定参数方法的优先级高于可变参数。
	sum3(3,4);//这里调用的是固定参数的方法。
	
}

// 求和
public static int sum(int a, int b, int c) {
	return a + b + c;
}

public static int sum(int[] a) {
	int sum = 0;
	for (int i : a) {
		sum += i;
	}
	return sum;
}

// 通过可变参数求和
// 可变参数的构成： 数据类型+... 可变参数可以直接理解成数组 int... = int[]
public static int sum1(int... a) {
	int sum = 0;
	for (int i : a) {
		sum += i;
	}
	return sum;
}

//当包括可变参数在内有多个参数时，可变参数必须放在最后，并且一个方法只能同时有一个可变参数。
public static int sum2(int b,int... a) {
	int sum = 0;
	for (int i : a) {
		sum += i;
	}
	return sum;
}

//下面两个方法是重载的关系
//当固定参数的方法与可变参数的方法是重载时，固定参数方法的优先级高于可变参数。
public static int sum3(int b,int... a) {
	System.out.println("可变参数");
	int sum = 0;
	for (int i : a) {
		sum += i;
	}
	return sum;
}
public static int sum3(int a,int b) {
	System.out.println("固定参数");
	return 0;
}

}

---

package com.qianfeng.test;

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

/*
*Arrays：数组工具类，内部封装了大量操作数组的方法，包括排序，查找，求最大值等。
*/
public class Demo4 {

public static void main(String[] args) {
	
	//1.简单数据类型转换成字符串--方便查看内容
	int[] arr1 = new int[]{3,5,8,9,3};
	System.out.println(arr1.toString());//[I@2a139a55,默认打印的是数组的地址。
	System.out.println(Arrays.toString(arr1));//[3, 5, 8, 9, 3],数组被转换成了字符串。
	
	//2.数组转集合？----集合的方法多，方便查看内容。
	//简单数组类型转集合。
	int[] arr2 = new int[]{3,5,8,9,3};
	List<int[]> list = Arrays.asList(arr2);
	System.out.println(list.size());//1,说明对应简单数据类型的数组，asList方法会将整体当成一个元素扔到集合中。
	
	//引用数据类型转集合
	String[] strings = {"a","b","c"};
	List<String> list2 = Arrays.asList(strings);
	System.out.println(list2.size());//3,说明对于引用数据类型的数组，asList方法会将数组的一个元素作为集合的一个元素。
	
	//数组转集合的注意点：
	//转成的集合的元素个数是固定的，所以不能进行添加和删除，但能进行修改和遍历。
	//list2.add("java");//运行报异常UnsupportedOperationException
	list2.set(0, "d");
	System.out.println(list2);
	
	//二分查找--数组必须是有序的
	int[] arr3 ={2,4,6,8,90};
	int index = Arrays.binarySearch(arr3, 98);//-6 负数说明未找到，6是98该有的下标。
	System.out.println(index);
	
}

}

---

package com.qianfeng.test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

/*
*Collections：集合工具类，封装了大量操作集合的方法。
*
*实例：要求存储多个数据，数据可以排序，也可以重复。
*/
public class Demo6 {

public static void main(String[] args) {

	ArrayList<String> list = new ArrayList<>();
	list.add("java");
	list.add("html");
	list.add("python");
	list.add("iOS");
	list.add("iOS");
	list.add("BigData");
	// 自然顺序
	System.out.println("自然顺序" + list);

	// 字典顺序--默认都是升序
	// 这里要想实现排序，要求元素必须实现Comparable接口的compareTo方法
	Collections.sort(list);
	System.out.println("字典排序" + list);

	// 按照从短到长排序--默认的方法无法实现，创造自己的比较器
	ComWithLength comWithLength = new ComWithLength();
	Collections.sort(list, comWithLength);
	System.out.println("从短到长排序" + list);

	// 按照从长到短排序--利用现有的从短到长的比较器得到新的比较器对象-从长到短
	Comparator<String> comparator1 = Collections.reverseOrder(comWithLength);
	Collections.sort(list, comparator1);
	System.out.println("从长到短排序" + list);

	// 字典顺序的倒序
	Comparator<String> comparator2 = Collections.reverseOrder();
	Collections.sort(list, comparator2);
	System.out.println("字典顺序的倒序" + list);

	// 现有顺序的倒序
	Collections.reverse(list);
	System.out.println("现有顺序的倒序" + list);
	
	//求最大值
	String max1 = Collections.max(list);
	System.out.println("默认的字典顺序的最大值："+max1);
	String max2 = Collections.max(list,comWithLength);
	System.out.println("从短到长排序的最大值："+max2);

}

}

// 创造自己的比较器–字符串从短到长
class ComWithLength implements Comparator {

@Override
public int compare(String o1, String o2) {
	int num = o1.length() - o2.length();
	return num == 0 ? o1.compareTo(o2) : num;
}

}

---