⑪Java SE知识点回顾与小结(Arrays常用类)

Arrays 常用类

Arrays是操作数组的工具类

java中自定义对象类型进行排序,必须要执行排序规则:

​ 1.内部比较器|自然排序|自然比较方法–默认

​ 2.外部比较器|自定义排序|自定义比较器

​ 1)内部比较器需实现java.lang 接口 Comparable,再重写内部比较方法

​ 2)外部比较器需另创建一个类,并实现Comparator接口,再重写外部比较方法,再new一个类对象传入sort 方法

实例:

public class ArraysDemo01 {
	public static void main(String[] args) {
		int[] arr1={1,2,3,4,5};
		int[] arr2={1,2,3,4,5};
		//equals(数组1,数组2)  比较两个数组的元素是否相等
		System.out.println(arr1==arr2);//false
		System.out.println(arr1.equals(arr2));//比较的还是地址false
		System.out.println(Arrays.equals(arr1,arr2));//ture   Arrays.equals比较两个数组的内容
		
		//Arrays.toString(数组)   返回指定数组内容的字符串表示形式
		System.out.println(arr1);//[I@15db9742]
		System.out.println(Arrays.toString(arr1));//[1, 2, 3, 4, 5]
		
		//多维数组 deepEquals(数组1,数组2) 比较两个多维数组的元素是否相等  deepToString(数组1,数组2)
		double[][] arr3={{1.1,2.2,  3.3},{4.4,5.5},{6.6}};
		double[][] arr4={{1.1,2.2,3.3},{4.4,5.5},{6.6}};
		System.out.println(Arrays.equals(arr3,arr4));//false
		System.out.println(Arrays.deepEquals(arr3,arr4));//比较二维数组的值是否深层相等 返回true
		System.out.println(Arrays.toString(arr3));//打印的是[[D@6d06d69c, [D@7852e922, [D@4e25154f]
		System.out.println(Arrays.deepToString(arr3));//[[1.1, 2.2, 3.3], [4.4, 5.5], [6.6]]
		
		
		//static int[] copyOf(int[] original, int newLength)   从索引为0的位置开始截取
		//参数1 original:要拷贝的数组   参数2 newLength:要截取的长度即新数组的长度   返回值:新数组
		System.out.println(Arrays.toString(Arrays.copyOf(arr1, 3)));  //截取,从索引为0的位置开始截取3位并打印
		System.out.println(Arrays.toString(Arrays.copyOf(arr1, 10)));  //填充,截取不到的用0填充
		
		
		//static int[] copyOfRange(int[] original, int from, int to)  将指定数组的指定范围复制到一个新数组
		//参数1 original:要拷贝的数组 	 参数2 from:起始索引		参数3 to:结束索引   结束位置不包含
		System.out.println(Arrays.toString(Arrays.copyOfRange(arr1, 2, 4)));//[3,4]不包含索引4
		
		
		//System类中方法-->static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 
        //从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
		//src - 源数组。
		//srcPos - 源数组中的起始位置。
		//dest - 目标数组。
		//destPos - 目标数据中的起始位置。
		//length - 要复制的数组元素的数量。 
		int[] arr5=new int[8];
		System.arraycopy(arr1, 1, arr5, 2, 3);
		System.out.println(Arrays.toString(arr5));//[0,0,2,3,4,0,0,0]
		
		
		boolean[] arr6=new boolean[6];
		System.out.println(Arrays.toString(arr6));//[false, false, false, false, false, false]
		//static void fill(要填充的数组,要填充的数据)  填充     所有位置全部以指定数据填充
		Arrays.fill(arr6,true);
		System.out.println(Arrays.toString(arr6));//[true, true, true, true, true, true]
		//static void fill(int[] a, int fromIndex, int toIndex, int val) *int[] a要填充的数组,指定索引范围填充,结束位置不包含
		Arrays.fill(arr6,2,4,false);
		System.out.println(Arrays.toString(arr6));//[true, true, false, false, true, true]
		
		
		
		//static void sort(int[] a)  对指定的 int 型数组按数字升序进行排序。 
		int[] arr7={3,1,7,5,2,4};
		System.out.println(Arrays.toString(arr7));//[3, 1, 7, 5, 2, 4]
		Arrays.sort(arr7); //sort升序
		System.out.println(Arrays.toString(arr7));//[1, 2, 3, 4, 5, 7]
		
		
		
		String[] arr8={"美国","日本","中国"};  //Unicode
		System.out.println(Arrays.toString(arr8));//[美国, 日本, 中国]
		Arrays.sort(arr8);
		System.out.println(Arrays.toString(arr8));//[中国, 日本, 美国]
		//默认按字符编码升序
		System.out.println((int)'美');  //32654
		System.out.println((int)'日');  //26085
		System.out.println((int)'中');  //20013
		
		
		
		//*****数组可以存储对象*****
		Person[] arr9=new Person[3];
		Person p1=new Person("张三",18);
		Person p2=new Person("李四",17);
		Person p3=new Person("王五",19);
		arr9[0]=p1;
		arr9[1]=p2;
		arr9[2]=p3;
		//打印 类重写的 toString方法
		System.out.print(Arrays.toString(arr9));//不重写打印的就是对象的地址
		
		
		
		//对象类型排序    默认内部比较器(默认调用类中实现Comparable接口重写的compareTo方法)
		//		Arrays.sort(arr9);
		//		System.out.println(Arrays.toString(arr9));
		
		//static <T> void  sort(T[] a, Comparator<? super T> c) 根据指定自定义外部比较器产生的顺序对指定对象数组进行排序。 
		//这个外部比较器要实现comparator接口
		Arrays.sort(arr9,new ComPerson());//new一个实现外部比较器的类的对象,传入sort方法
		System.out.println(Arrays.toString(arr9));
		
		
		
		
		/*	使用二分法要先对数组进行搜索(要先升序)
		 *  static int binarySearch(int[] a要搜的数组, int key要搜的值)  存在则返回排序后的索引位置, 如果不存在数据,则返回 -(插入点)-1
			          使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。   
			static int binarySearch(int[] a, int fromIndex, int toIndex, int key)
											要搜的第一个元素的索引 最后一个元素的索引(不包括)
			          使用二分搜索法来搜索指定范围的 int 型数组，以获得指定的值。 
		 */
		System.out.println(Arrays.toString(arr7));
		System.out.println(Arrays.binarySearch(arr7, 8));
		
	}
}

person类:

//实现了内部比较器
public class Person implements Comparable<Person>{
	private String name;
	private int age;
	
	public Person() {
		// TODO Auto-generated constructor stub
	}

	//alt+shift+o-->enter
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	//alt+shift+s-->r-->tab-->enter-->shift+tab-->enter
	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;
	}

	//alt+shift+s-->s->enter
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}

    //重写内部比较器方法compareTo
	@Override
	public int compareTo(Person o) {//可以加一个Person类的泛型
		// TODO Auto-generated method stub
		return this.age-o.age;//升序
	}

	//自定义比较规则  按照年龄比较  年龄大的就放后面
	// p1.compareTo(p2)-->this当前对象p1,指定对象-->参数p2
	/*@Override
	public int compareTo(Object o) {
		// TODO Auto-generated method stub
		return this.age-((Person)o).age;  
		return ((Person)o).age-this.age;
	}*/
}

外部比较器类:

/*
 * java中自定义对象类型进行排序,必须要执行排序规则:
 * 	1.内部比较器|自然排序|自然比较方法--默认(硬编码,不推荐)
 * 		实现 java.lang 接口 Comparable<T>  重写public int compareTo(T o);方法自定义比较规则
 * 		<T> 泛型,默认任意类型T	指定其他类型,比较指定的类型数据
 * 
 * 不符合开闭原则:对修改关闭,对扩展开放  经常修改源码-->硬编码
 * 
 * 	2.外部比较器|自定义排序|自定义比较器
 * 		实现java.util 接口 Comparator<T> 重写 int compare(T o1, T o2)   比较用来排序的两个参数。 
 * 		能达到解耦的效果,不能使用Person实现接口,外部实现
 * 
 * 		注意:可以根据比较规则不同的相减的顺序控制升序|降序
 *  
 */
public class CompareDemo02 {
	public static void main(String[] args) {
		Person p1=new Person("张三",18);
		Person p2=new Person("李四",10);
		Person p3=new Person("王五",19);
		//内部比较器实现排序
		System.out.println(p1.compareTo(p2));
		//System.out.println(p2.compareTo(p3));
		//对象调用重写的compare方法
		System.out.println(new ComPerson().compare(p1, p2));
		
		//比较学生对象
		Student s1=new Student("学生1",28); 
		Student s2=new Student("学生2",27); 
		//定义一个数组,存放学生对象
		Student[] arr={s1,s2};
		//进行数组的排序,父类有排序规则--使用内部比较器
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));
		//-----------------------------------------------------------------------
		//Arrays.sort(arr,new ComPerson());根据指定比较器产生的顺序对指定对象数组进行排序
		
		//匿名内部类  可以给泛型  若不想在外部定义自定义比较器类,可直接使用匿名内部类及lambda表达式
		/*Arrays.sort(arr,new Comparator<Person>(){   new父类接口,类体存实现类改写方法

			@Override
			public int compare(Person o1, Person o2) {
				return o2.getAge()-o1.getAge();
			}
			
		});*/
		//Lambda表达式  可省略参数的数据类型
		Arrays.sort(arr,(o1,o2) -> o2.getAge()-o1.getAge());
		
		System.out.println(Arrays.toString(arr));
		
	}
}
//定义外部比较器类重写compare方法用来比较Person对象  
class ComPerson implements Comparator<Person>{
	//重写compare方法
	@Override
	public int compare(Person o1, Person o2) {
		// TODO Auto-generated method stub
		return o1.getAge()-o2.getAge();
		//return o2.getAge()-o1.getAge();
	}
	//可以根据比较规则不同的相减的顺序控制升序|降序
	/*@Override
	public int compare(Object o1, Object o2) {
		return ((Person)o1).getAge()-((Person)o2).getAge();
//		return ((Person)o2).getAge()-((Person)o1).getAge();
	}*/
	
}