java第16天----TreeMap的注意点，增强for循环，Arrays和Collecttions工具类，多线程简介

昨天知识总结

• 1.泛型
• 泛型的定义
• 泛型的基础
• 泛型在类上，接口上，方法上的使用
• 泛型–限制上限，限制下线
  2.Map
• Map与Collection的比较
• Map接口常用方法
• Map的遍历----会—重点
• HashMap的去重和TreeMap的排序

TreeMap的注意点

1.什么类型的数据可以作为TreeMap的key

• 答：实现了Comparable接口，或者使用了比较器（实现了Comparator接口）的元素，常见：String，Integer,Double
• 不行的类型：ArrayList，数组，因为他们本身都没有实现Comparable接口

2.作为key的类型，与他的内部有没有关系

• 答：没有关系，元素能不能充当key，与它内部无关，只看他有没有实现comparable接口

增强for循环

• 增强for循环使用的场景：数组，集合
• 用于数组，Collection的遍历，直接使用
• 用于Map的遍历，我们需要得到Map的set形式，再遍历
• 增强for循环的构成：
• for（元素类型 变量：数组/Collection）{

•   循环体
  

• }

	public static void main(String[] args) {
			//遍历数组
		int[] arr = new int[] {3,5,35,684,86};
		for (int i : arr) {
			System.out.println("数组："+i);
		}
				//遍历Collection
		ArrayList<String> list = new ArrayList<>();
		list.add("java");
		list.add("html");
		for (String string : list) {
			System.out.println("字符串"+string);
		}
		//遍历Map
		HashMap<String, String> map = new HashMap<>();
		map.put("01", "java");
		map.put("02", "html");
		map.put("03", "ios");
		map.put("04", "BigData");
		//1.先得到Set集合
		Set<Map.Entry<String, String>> set = map.entrySet();
		//3.遍历
		for (Map.Entry<String, String> entry : set) {
			System.out.println("key:"+entry.getKey()+"   value:"+entry.getValue());
		}
	}

Arrays工具类

• Arrays:数组工具类，内部封装了大量操作数组的方法，包括排序，查找，求最大值等
• 几种常用的方法

	public static void main(String[] args) {
	//1.简单数据类型转成字符串----方便查看内容
		int[] arr = new int[] {3,5,8,9,3};
		System.out.println(arr.toString());//默认打印的是数组的地址
		String str = Arrays.toString(arr);
		System.out.println(str);//数组被转化成了字符串
		
		//2.数组专集合?----结合方法多，操作便捷
		//简单数据类型转集合
		int[] arr2 = new int[] {3,5,8,9,3};
		Arrays.asList(arr2);
		System.out.println(Arrays.asList(arr2));//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, 5);
		System.out.println(index);

可变参数

• 可变参数：参数的个数可以改变
• 作用：简化代码，方便操作
• 构成：数据类型加… 可变参数可以直接理解成数组 int[] = int…

注意点：

• 1.给可变参数传值的实参，可以直接是多个值
• 2.包括可变参数在内，有多个参数时，可变参数必须放在最后，并且一个方法只能同时有一个可变参数
• 3.当固定参数的方法与可变参数的方法是重载时，固定参数的优先级高于可变参数的方法

	public static void main(String[] args) {
			int[] arr = {3,5,7,6,1}; 
		System.out.println(sum1(arr));
		System.out.println(sum1(2,5,486,464,64,6));
		System.out.println(sum2(3,4,3));
				System.out.println(sum3(3,4));//这里调用的是固定参数的方法
	}
	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) {
		int sum = 0;
		for (int i : a) {
			sum += i;
 		}
		return sum;
	}
	public static int sum3(int a,int b) {
		return a;
	}

Collections

• Collections:集合工具类，封装了大量操作集合的方法
• 实例：要求存储多个数据，数据可以排序，也可以重复

	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("BigDota");
		//自然顺序
		System.out.println("自然顺序："+list);
		
		//按照字典排序--默认都是升序
		//这里要向实现排序，要求元素必须实现Compar接口的compareTo方法
		Collections.sort(list);
		System.out.println("字典顺序："+list);
		
		//这里从短到长排序---默认的方法无法实现，创造自己的方法
		ComWithLength comWithLength = new ComWithLength();
		Collections.sort(list, comWithLength);
		System.out.println("从短到长排序："+list);
		
		//按照从长到短排序--利用现有的从短到长的比较器得到新的比较器对象
		Comparator<String> comparator= Collections.reverseOrder(comWithLength);
		Collections.sort(list, comparator);
		System.out.println("从长到短排序");
		//字典顺序的倒叙
		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>{

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

多线程

• 多线程：
• 程序：是一个可执行文件
• 进程：是一个正在运行的程序，在内存中开辟了一块空间
• 线程：负责程序的运行，可以看做是程序运行的一条通道，或者一个执行单元，我们通常将进程的工作理解成线程的工作
• 进程中可不可以没有线程？ 必须有线程，至少有一个，当有一个线程存在的时候，我们称为单线程，这个惟一的线程就是主线程（main线程）
• 当有一个以上的线程存在的时候，我们成为多线程
• 多线程存在的意义：为了实现同一时间做多个事情。
• 任务区：我们将线程完成工作的方法称为任务区，
• 每一个线程都有自己的任务区

• JVM是多线程？
• 一定是多线程
• 至少有两个
• 主线程的任务区：main方法
• 垃圾回收线程：finallize（）方法
• 线程是随着任务的开始而开始，结束而结束，只要任务没有结束，线程就不会结束，当线程还在工作的时候，进程没有办法结束
• 多个线程是抢cup的关系，CPU有随机性
• 自己创建线程的原因：系统的线程无法完成我们自己的功能，我们就自己创建线程，系统将线程面向对象了，形成的类就是Thred
• Thread的任务区是run（）方法
• 注意：如果我们想让run（0方法作为任务区，必须通过start方法，让run自动执行
  *两种创建线程的方式：
• 1.通过Thread直接创建线程

    public static void main(String[] args) {
    Thread thread1 = newh Tread();
    Thread thread2 = new Thread();
    		thread1.start();
		thread2.start();//这里有三个线程，两个子线程，一个主线程
		System.out.println("main");
	}

2.通过创建Thread的子类

    public static void main(String[] args) {
		//1.通过Thread子类创建线程
		//创建两个线程
		Thread thread1 = new MyThread("bingbing");//thread-0
		Thread thread2 = new MyThread("yingying");//thread-1
		
		//通过start方法让线程工作
		thread1.start();
		thread2.start();//这里有三个线程，两个子线程，一个主线程
		for(int i = 0;i < 10;i++) {
			System.out.println(Thread.currentThread().getName()+" main  i"+i);
		}
		/*
		 * 当手动调用时，run变成了普通方法，失去了任务区的功能
		 * run内部对应的线程就是run方法或手动调用的位置对应的线程
		 */
	}
}

class MyThread extends Thread{
	String myname;
	public void run() {
		/*
		 * 重写run方法，作为任务区
		 * Thread.currentThread():获取当前线程
		 * Thread.currentThread(.getname():获取的是当前线程的名字，系统给的名字
		 */
		for(int i = 0;i < 10;i++) {
			System.out.println(Thread.currentThread().getName()+"   "+myname+"   i:"+i);
		}
	}
	public MyThread(String myname) {
		super();
		this.myname = myname;
	}
}