对集合的知识补充，可变参数

import java.util.*;

/*
 * TreeMap使用的注意点：
 * 1.什么类型的数据类型可以作为key?
 * a实现了Comparable接口的CompareTo()方法
 * b实现了Comparator接口的Compare()方法
 * 
 * JAVA的三种引用引用类型：类，接口，数组。
 * 其中类和数组的父类都是Object(问了老师，数组的父类是Object)
 * 而Object类没有做a,b处理
 * TreeMap添加键时调用的put方法会去检测是否做了a,b中的任何一个处理，没有会有运行时异常
 * 可以的代表:String 包装类,自定义的实现了这两个接口重写了相应方法的任意一个的类
 * 不可以的代表:没有做a,b处理的自定义类，数组，ArrayList和LinkedList
 * 
 * 
 * 疑问：为什么HashMap就任何引用类型都可以作为key?
 * JAVA的三种引用引用类型：类，接口，数组。
 * 其中类和数组的父类都是Object(问了老师，数组的父类是Object)
 * 接口是没有父类的
 * Object类中里有equals()方法和hashCode()方法的声明及方法体
 * 所以在HashMap里存对象和数组是没有问题的
 * 
 * 2.元素可不可以作为key,跟元素内部的元素类型有没有关系
 */

class A{}
public class Demo1 {

	public static void main(String[] args) 
	{
		TreeMap <char[],String> map=new TreeMap<>();
		map.put(new char[] {'d'}, "String");
		//在调用put方法的时候会报运行时异常，数组内部没有实现那两个接口
		
		TreeMap<A,Integer> map1=new TreeMap<>();
		map1.put(new A(),1);
		//在调用put方法的时候会报运行时异常，类A内部没有实现那两个接
		
		//2.元素可不可以作为key,跟元素内部的元素类型有没有关系
		TreeMap<Test,String> tree=new TreeMap()	;
		tree.put(new Test(), "ok");
		System.out.println(tree);
	}
}
class Test implements Comparable{
	Object object = new Object();
	@Override
	public int compareTo(Object o) {
		return 0;
	}
}

import java.util.*;

public class Demo3 {

	public static void main(String[] args) {
		/*
		 * 增强for循环
		 * 可以遍历的内容：
		 * 数组,Collction---直接遍历    
		 * Map---间接遍历
		 */
		
		
		/*
		 * 1遍历数组,Collction:
		 * for(元素的数据类型 变量:数组/Collection)
		 * {
		 *	循环体
		 * }
		 */
		
		//遍历数组
		/*
		 * 原理:当执行增强for循环时，会从数组中自动按顺序取值，取出的值放入前面的变量中，
		 * 本次循环使用的就是当前的变量
		 * 结束后，自动开始第二个变量，会自动从数组中取出第二个变量，再次放入
		 * 前面的变量中一次进行下去，直到将数组中的元素取完为止
		 * 总结：增强for循环会自动生成数组中的每一项将它赋值给指定元素，从而达到遍历的作用
		 */
		
		 int[] arr=new int[] {4,5,7,8,8};
		 for(int i:arr){
		 System.out.println(i);
		 }
		 
		 //对Collection实现类的遍历
		 ArrayList<String> list=new ArrayList<>();
		 list.add("java2");
		 list.add("java3");
		 for(String str:list)
			 System.out.println(str);
		 
		 //对Map的遍历
		 Map<String,String> map=new HashMap<>();
		 map.put("01","java");
		 map.put("04","java3");
		 map.put("06","java7");
		 System.out.println(map);
		 
		 //得到set
		 Set<String> set=map.keySet();
		 //使用增强for循环遍历
		 for(String key:set) {
			 System.out.println(key+" "+map.get(key));
		 }

	}

}

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

public class Demo4 {

	public static void main(String[] args) {
		/*
		 * Arrays:数组工具类，内部封装了大量操作数组的方法--工具类的方法都是静态的
		 */
		//简单数组类型转字符串
		int[] arr1= {23,4,6,7,8};
		System.out.println(arr1.toString());//[I@7852e922
		//打印的hash码，哈希码通常也成为地址
		//因为这个值唯一，但是它其实并不是真正的物理地址
        //打印出hash码值说明数组并没有重写toString方法
		
		//简单数组类型转字符串---方便查看数组的内容
		//内部其实是遍历了这个数组，拼接成字符串
		String s1=Arrays.toString(arr1);
		System.out.println(s1);//[23, 4, 6, 7, 8]
		
		//数组转集合？---集合的方法多，方便操作
		//基本数据类型的数组转集合
		int[] arr2={23,4,6,7,8};
		List<int[]> list=Arrays.asList(arr2);
		//返回一个List集合，集合的泛型为int[]，也就是说该List数组的元素是整型的数组
		System.out.println(list);[[I@4e25154f]
		System.out.println(list.size());//1
		//该集合中只有一个整形数组元素
		
		//引用类型的数组转集合
		String[] strs= {"haha","java","xiake"};
		List<String> list2=Arrays.asList(strs);
		//此时List泛型的类型为String,也就是集合里的元素是String
		System.out.println(list2);//此时数组与集合的元素一一对应 //[haha, java, xiake]
		System.out.println(list2.size());//3
		
		//注意点：转过来的集合，内存空间是固定的，即长度不能变，所以不能进行增删元素
		//但是可以修改，遍历
		//list2.add("hehe");运行时异常
		for(String s:list2) {
			System.out.println(s);
		}
		
		//二分查找
		int[] arr3= {3,9,7,8,1};
		Arrays.sort(arr3);//二分查找的前提是数组有序，所以要先对数组排序
		System.out.println(Arrays.toString(arr3));//[1, 3, 7, 8, 9]
		int i=Arrays.binarySearch(arr3, 1);//找得到返回>=0，负数表示找不到,这里并不是简单的找不到返回-1，而是任意的复数
		System.out.println(i);
	}

}

public class Demo5 {
	
	//可变参数
	//作用：简化代码，方便能操作

	//求三个数的和--值传递
	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=0;i<=a.length-1;i++)
			sum=sum+a[i];
		return sum;
	}
	//通过可变参数求和
	//可变参数的格式：数据类型...
	//可变参数可以直接理解成一个数组
	//int... 等价于int[]
	
	//public static int sum(int... a)系统认为这是和上面的sum名字相同，参数表相同的方法，会编译异常
	public static int sum1(int... a)
	{
		int sum=0;
		for(int i=0;i<=a.length-1;i++)
	 		sum=sum+a[i];
		return sum;
	}
	//public static int sum2(int... a,int b)编译异常，因为会把传的参数都存到a里
	public static int sum2(int b,int... a)//
	{
		int sum=0;
		for(int i=0;i<=a.length-1;i++)
	 		sum=sum+a[i];
		return sum;
	}
	
	//-------------这两个sum3是重载方法-------------
	public static int sum3(int a ,int b)
	{
		System.out.println("不可变");
		return a+b;
	}
	
	//当可变参数的方法与不可变参数的方法是重载关系时，调用的顺序是固定参数的优先于可变参数的
	public static int sum3(int...a)
	{
		System.out.println("可变");
		int sum=0;
		for(int i=0;i<=a.length-1;i++)
	 		sum=sum+a[i];
		return sum;
	}
	
	public static void main(String[] args) {
		//可变参数：参数的个数可以改变
		//求和1:
		System.out.println(sum(9,8,2));
		int[] arr1= {3,5,7,9};
		sum(arr1);
		int[] arr2= {3,5,7,9};
		sum1(arr2);
		
		//注意点：
		//1.给这个可变参数传值的实参可以直接写且个数不限制
		sum1(35,7,8);//系统自动把数封装到一个数组，把数组作为一个参数传给方法
		
		//2.当包括可变参数在内有多个参数时，可变参数必须写在参数表的最后，并且一个方法只能有一个可变参数
		System.out.println(sum3(3,4));
	}

}

import java.util.*;

/*
 * Collections：操作类，内部封装了大量的操作Collections的方法
 */
public class Demo6 {

	public static void main(String[] args) {
		//要求：存储多个数据，可重复，能排序
		//可以想到的集合：
		//1.ArrayList，LinkedList:可重复，不能排序（它的有序只是和添加顺序相同）
		//2.TreeSet:不可重复，能排序
		//这两个都不符合我们的要求
		//这里使用ArrayList实现可重复，能排序
		//即要想实现排序，元素必须实现了Comparable接口的comapreTo()方法
		//或Comparator接口的compare()方法
		ArrayList<String> list=new ArrayList<>();
		list.add("java");
		list.add("ios");
		list.add("html");
		list.add("html");
		list.add("BigData");
		list.add("python");
		list.add("javascripts");
		System.out.println("默认的顺序:"+list);//默认顺序
		
		//升序排序
		Collections.sort(list);//String方法已经实现了comapreTo()
		//所以这里直接用就行了
		System.out.println("升序排序:"+list);
		
		//按照长短排序
		//实现从短到长排序---让元素(String),实现Comparator接口
		//创建比较器对象
		ComWithLength comWithLength=new ComWithLength();
		Collections.sort(list,comWithLength);//第二个参数为List内元素的比较器
		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<String>{
	public int compare(String o1,String o2) {
		int num=o1.length()-o2.length();
		return num;
	}
}