JAVA 可变参数、比较器(Comparable、Comparator)、数组工具类(Arrays)、集合工具类(Collections) Java第十四天(一)

可变(动态)参数

  当一个成员方法内需要传入多个同类型的参数时，可以使用可变参数。
  语法：
 其中参数类型 ... p参数是一个指定参数类型的数组(相当于 参数类型[] p)

访问限定修饰符  返回值类型  方法名(数据类型 ... 变量名){
		方法体;
}
	public static void main(String[] args) {
		add(1,3,5,89,7);
		}
		
	public static int add(int ... o) {
		int sum =0;
		for(int i:o) {
			sum +=  sum + i;
		}
		System.out.println("可变参数的和为："+sum);
		return sum;
	}
输出结果：
可变参数的和为：245

比较器(Comparable、Comparator)

  对于基本数据类型，Java已经定义好了比较规则，但对于类需要我们自己定义比较规则，其中Comparable和Comparator接口都是为了对类进行比较。
  在上个章节中我们讲了Comparable(详见JAVA第十三天(二))，你可以将它理解为内置比较器。这次主要讲解Comparator，同样的你可以将它理解为外置比较器。

Student类

/**
 * Student类
 */
public class Student<Student> {
	//定义学生类成员变量
	private int id;
	private String name;
	private int age;
	/*
	 * 封装学生类的成员变量
	 */
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	//生成相应的构造器
	public Student(int id, String name, int age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}
	//重写toString方法
	@Override
	public String toString() {
		return "Student [学号=" + id + ", 姓名=" + name + ", 年龄=" + age + "]";
	}
}

Comparator(外置比较器)类
(由于已经将Student类封装了，所以需要使用get方法获取相应的成员变量)

import java.util.Comparator;

public class StuComparator implements Comparator<Student> {

	@Override
	public int compare(Student stu1, Student stu2) {
			//先比较学号
			int val = stu1.getId() - stu2.getId();
			if(val == 0) {
				//若学号相同比较年龄
				val = stu1.getAge() - stu2.getAge();
				if(val == 0) {
					//判断两个对象的姓名是否为空
					if(stu1.getName() != null && stu2.getName() != null) {
						//若学号、年龄都相同，比较姓名
						val = stu1.getName().compareTo(stu2.getName());
					}
				}
			}
			return val;
		}
	}

测试类

	public static void main(String[] args) {

		Student stu = new Student(1, "zhangsan", 20);
		Student stu2 = new Student(4, "lisi", 25);
		Student stu3 = new Student(3, "wangwu", 27);
		Student stu4 = new Student(2, "zhaoliu", 30);
		Student[] students = {stu,stu2,stu3,stu4};
		Arrays.sort(students,new StuComparator());
		System.out.println(Arrays.toString(students));
	}
输出结果：
[Student [学号=1, 姓名=zhangsan, 年龄=20], Student [学号=2, 姓名=zhaoliu, 年龄=30],
 Student [学号=3, 姓名=wangwu, 年龄=27], Student [学号=4, 姓名=lisi, 年龄=25]]

工具类

 工具类(Arrays)

  此类为数组的工具类，这里的方法都是静态的。

  将数组转换成字符串

返回值类型				方法名		参数列表
static String 			toString(int[] a) 
(byte、short、int、long、char、float、double、boolean、Object类型都可以)
返回指定数组的内容的字符串表示形式。  
例：
		int[] i = {14,28,54,79,12,29};
		String str = Arrays.toString(i);
		System.out.println(str);
输出结果：
[14, 28, 54, 79, 12, 29]
---------------------------------------------------------------------------------

  对任意数组排序

 注意：Object类型将根据元素的自然顺序排序，也可以自定义Comparable(重写compareTo方法,详见JAVA第十三天(二))。
 T类型(自定义泛型)根据指定的比较器(实现Comparator接口)进行排序(详见上方比较器)

static <T> void 	sort(T[] a, Comparator<? super T> c) 
根据指定的比较器引发的顺序对指定的对象数组进行排序。

static void 		sort(Object[] a) 
对指定对象升序排列的阵列，根据natural ordering的元素。  

static <T> void 	sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c) 
根据指定的比较器引发的顺序对指定的对象数组的指定范围进行排序。 

static void 		sort(Object[] a, int fromIndex, int toIndex) 
对指定对象升序排列的数组的指定范围内，根据natural ordering的元素。 

static void 			sort(int[] a) 
按照数字顺序排列指定的数组。(升序)注意：这里i的类型是数组，所以不能直接打印出来
(byte、short、int、long、char、float、double、boolean、Object、T类型都可以)  
例：
		int[] i = {14,28,54,79,12,29};
		Arrays.sort(i);
		//增强for循环进行打印数组
		for(int a:i) {
			System.out.print(a+" ");
		}
输出结果：
12 14 28 29 54 79
---------------------------------------------------------------------------------
static void sort(int[] a, int fromIndex, int toIndex) 
按升序排列数组的指定范围。(包含起始索引，但不包含结束索引)
(byte、short、int、long、char、float、double、boolean、Object、T类型都可以)  	
例：
		int[] i = {14,28,54,79,12,29};
		Arrays.sort(i,2,5);
		//这里直接使用上面的toString方法来打印
		System.out.println(Arrays.toString(i));
输出结果：
[14, 28, 12, 54, 79, 29]
---------------------------------------------------------------------------------

  对任意数组做二分法查找

  方法使用前提：有序的数组
  在对自定义泛型<T>使用时要指定外置比较器

static int 			binarySearch(byte[] a, byte key) 
使用二进制搜索算法搜索指定值的指定字节数组
(byte、short、int、long、char、float、double、boolean、Object、T类型都可以) 
例：
		int[] i = {14,28,54,79,12,29};
		//对数组进行排序
		Arrays.sort(i);
		System.out.println(Arrays.binarySearch(i, 54));
		//这里直接使用上面的方法来打印
		System.out.println(Arrays.toString(i));
输出结果：
4
[12, 14, 28, 29, 54, 79]
---------------------------------------------------------------------------------
static int 			binarySearch(byte[] a, int fromIndex, int toIndex, byte key) 
使用二进制搜索算法搜索指定值的指定字节数组的范围。
(如果目标值不在指定范围内则返回"-插入点-1"(-(insertion point) - 1))
例：
		int[] i = {14,28,54,79,12,29};
		//对数组进行排序
		Arrays.sort(i);
		System.out.println(Arrays.binarySearch(i, 2, 5,12));
		//这里直接使用上面的方法来打印
		System.out.println(Arrays.toString(i));
输出结果：
-3
[12, 14, 28, 29, 54, 79]
---------------------------------------------------------------------------------
static <T> int binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c) 
使用二进制搜索算法搜索指定对象的指定数组的范围。  

static <T> int binarySearch(T[] a, T key, Comparator<? super T> c) 
使用二叉搜索算法搜索指定对象的指定数组。  

  将数组转换成List

注意：从数组转换过来的List，不能对其做添加和删除，只能做修改操作。

static <T> List<T> 			asList(T... a) 
返回由指定数组支持的固定大小的列表。  
例：
		Integer[] i = {14,28,54,79,12,29};
		List list = new ArrayList<Integer>();
		list = Arrays.asList(i);
		System.out.println(list);
输出结果：
[14, 28, 54, 79, 12, 29]
---------------------------------------------------------------------------------

 工具类(Collections)

  此类为集合的工具类，这里的方法都是静态的。

static void 			reverse(List<?> list) 
反转指定列表中元素的顺序。  
例：
		List list = new ArrayList<Integer>();
		for(int i = 1;list.size()<5;i++) {
			list.add("元素"+i);
		}
		System.out.println(list);
		Collections.reverse(list);
		System.out.println(list);
输出结果：
[元素1, 元素2, 元素3, 元素4, 元素5]
[元素5, 元素4, 元素3, 元素2, 元素1]
---------------------------------------------------------------------------------
static void 			shuffle(List<?> list) 
使用默认的随机源随机排列指定的列表。 (将集合随机打乱)
例：
		List list = new ArrayList<Integer>();
		for(int i = 1;list.size()<5;i++) {
			list.add("元素"+i);
		}
		System.out.println(list);
		Collections.shuffle(list);
		System.out.println(list);
输出结果：
[元素1, 元素2, 元素3, 元素4, 元素5]
[元素3, 元素4, 元素1, 元素2, 元素5]
---------------------------------------------------------------------------------
static <T extends Comparable<? super T>>void 			sort(List<T> list) 
根据其元素的natural ordering对指定的列表进行排序。(升序)
例：
		List list = new ArrayList<Integer>();
		for(int i = 1;list.size()<5;i++) {
			list.add("元素"+i);
		}
		Collections.reverse(list);
		System.out.println(list);
		Collections.sort(list);
		System.out.println(list);
输出结果：
[元素5, 元素4, 元素3, 元素2, 元素1]
[元素1, 元素2, 元素3, 元素4, 元素5]
---------------------------------------------------------------------------------
static <T> void 		sort(List<T> list, Comparator<? super T> c) 
根据指定的比较器引起的顺序对指定的列表进行排序。
注意：新建Student类与StuComparator类，详见上方比较器  
例：
		List<Student> list = new ArrayList<Student>();
		list.add(new Student(1, "zhangsan", 20));
		list.add(new Student(3, "lisi", 25));
		list.add(new Student(2, "wangwu", 20));
		Collections.sort(list,new StuComparator());
		System.out.println(list);
输出结果：
[Student [学号=1, 姓名=zhangsan, 年龄=20], 
Student [学号=2, 姓名=wangwu, 年龄=20], 
Student [学号=3, 姓名=lisi, 年龄=25]]
---------------------------------------------------------------------------------
static <T> List<T> 		synchronizedList(List<T> list) 
返回由指定列表支持的同步（线程安全）列表。
(此方法将List变为线程安全的，详见JAVA第十三天(一))  
例：
		List list = new ArrayList<Integer>();
		for(int i = 1;list.size()<5;i++) {
			list.add("元素"+i);
		}
		Collections.synchronizedList(list);
---------------------------------------------------------------------------------