学习JavaEE日子 Day24 TreeSet，内置比较器，外置比较器，HashMap

Day24 TreeSet

1.TreeSet

1.1 TreeSet的使用

注意：TreeSet的使用和HashSet一样

public class Test01 {
	public static void main(String[] args) {
		
		//创建TreeSet集合的对象
		TreeSet<String> set = new TreeSet<>();
		
		//添加元素
		set.add("麻生希");
		set.add("椎名空");
		set.add("水菜丽");
		set.add("朝桐光");
		set.add("三上悠亚");
		set.add("水野朝阳");
		set.add("古川伊织");
		set.add("xxx");
		set.add("yyy");
		set.add("zzz");
		
		//获取元素个数
		int size = set.size();
		System.out.println("获取元素个数：" + size);//10
		
		TreeSet<String> newSet1 = new TreeSet<>();
		Collections.addAll(newSet1, "aaa","bbb","ccc","ccc");//利用Collections工具类给集合做批量添加
		set.addAll(newSet1);//将newSet1中所有的元素添加到set集合的末尾
		
		//清空集合中所有的元素
		//set.clear();
		
		System.out.println("判断集合中是否包含指定元素：" + set.contains("王益升"));//true
		System.out.println("判断集合中是否包含子集合中所有的元素：" + set.containsAll(newSet1));//true
		
		System.out.println("判断集合中是否没有元素：" + set.isEmpty());//false
		
		set.remove("朝桐光");//根据元素删除元素
		set.removeAll(newSet1);//删除set中包含newset1的元素（去除交集）
		
		TreeSet<String> newSet2 = new TreeSet<>();
		Collections.addAll(newSet2, "xxx","yyy","zzz","zzz");//利用Collections工具类给集合做批量添加
		set.retainAll(newSet2);//保留set中包含newset2的元素（保留交集）
		
		//将集合转成数组
		Object[] objs = set.toArray();
		System.out.println(Arrays.toString(objs));
		
		//将集合转成数组
		String[] ss = new String[set.size()];
		set.toArray(ss);
		System.out.println(Arrays.toString(ss));
		
		System.out.println("--------------------------------");
		
		//遍历数据 -- foreach
		for (String element : set) {
			System.out.println(element);
		}
		
		System.out.println("--------------------------------");
		
		//遍历数据 -- Iterator
		Iterator<String> it = set.iterator();
		while(it.hasNext()){//判断是否有可迭代的元素
			
			String element = it.next();//返回下一个元素
			System.out.println(element);
		}
		
	}
}

1.2 TreeSet的特点 -- 自然排序

理解：TreeSet会根据元素类型的不同自动选择排序规则

TreeSet存储Integer的排序规则：数字升序

TreeSet存储String的排序规则：字典排序

public class Test02 {
	public static void main(String[] args) {
		
		//TreeSet存储Integer的排序规则：数字升序
		TreeSet<Integer> set1 = new TreeSet<>();
		set1.add(30);
		set1.add(10);
		set1.add(50);
		set1.add(40);
		set1.add(20);
		for (Integer element : set1) {
			System.out.println(element);
		}
		
		System.out.println("---------------------------");
		
		
		//TreeSet存储String的排序规则：字典排序
		TreeSet<String> set2 = new TreeSet<>();
		set2.add("b");
		set2.add("d");
		set2.add("a");
		set2.add("c");
		set2.add("ad");
		set2.add("ab");
		set2.add("ac");
		for (String element : set2) {
			System.out.println(element);
		}		
		
	}
}

1.3 研究内置比较器的使用 -- Comparable

需求：创建学生类，将学生类的对象添加到TreeSet中

public class Test03 {
	public static void main(String[] args) {
		
		TreeSet<Student> set = new TreeSet<>();
		
		set.add(new Student("麻生希", '女', 27, "2401", "001"));        
		set.add(new Student("椎名空", '女', 23, "2401", "002"));        
		set.add(new Student("水菜丽", '女', 21, "2401", "003"));        
		set.add(new Student("朝桐光", '女', 31, "2401", "004"));        
		set.add(new Student("北岛玲", '女', 36, "2401", "005"));        
		set.add(new Student("樱井步", '女', 29, "2401", "006"));        
		set.add(new Student("爱田奈奈", '女', 32, "2401", "007"));       
		set.add(new Student("水野朝阳", '女', 31, "2401", "008"));       
		set.add(new Student("古川伊织", '女', 27, "2401", "009"));       
		set.add(new Student("巴得伟", '男', 21, "2401", "010"));        
		set.add(new Student("李星乐", '男', 20, "2401", "011"));        
		set.add(new Student("北条麻衣", '女', 34, "2402", "001"));       
		set.add(new Student("濑亚美莉", '女', 23, "2402", "002"));       
		set.add(new Student("三上悠亚", '女', 21, "2402", "003"));       
		set.add(new Student("小西满里惠", '女', 31, "2402", "004"));      
		set.add(new Student("桃谷绘里香", '女', 27, "2402", "005"));      
		set.add(new Student("铃原爱蜜莉", '女', 23, "2402", "006"));      
		set.add(new Student("明日花绮罗", '女', 28, "2402", "007"));      
		set.add(new Student("京香Julia", '女', 34, "2402", "008"));    
		set.add(new Student("巴得伟", '男', 18, "2402", "009"));        
		set.add(new Student("张海杰", '男', 20, "2402", "010"));        

		for (Student stu : set) {
			System.out.println(stu);
		}
		
	}
}

public class Student implements Comparable<Student>{//要实现Comparable<Student>

	private String name;
	private char sex;
	private int age;
	private String classId;
	private String id;
	
	//无参构造，有参构造，get/set方法省略
	
	//判断两个学生是否相同
	//比较规则：班级号+学号
	@Override
	public boolean equals(Object obj) {
		if(this == obj){
			return true;
		}
		
		if(obj instanceof Student){
			Student stu = (Student) obj;
			if(this.classId.equals(stu.classId) && this.id.equals(stu.id)){
				return true;
			}
		}
		return false;
	}

	@Override
	public String toString() {
		return name + "\t" + sex + "\t" + age + "\t" + classId + "\t" + id;
	}

	//排序规则：按照年龄排序
	@Override
	public int compareTo(Student o) {
		//this表示添加到TreeSet中的学生对象
		//o表示TreeSet中的学生对象
		return this.age - o.age;
	}
}

1.4 研究外置比较器的使用 -- Comparator

需求：将学生类的对象添加到TreeSet中

场景 - 联合开发：

1.Student类是小伟开发的

2.小李要把Student类的对象添加到TreeSet中，但是Student的排序规则不满足小李的需求

3.小李想的是按照名字长度排序，长度一致按照年龄排序
比较器的优先级别：外置比较器 > 内置比较器

public class Test04 {
	public static void main(String[] args) {
		
		//扩展：new Comparator 匿名内部类的使用场景！！！
		
		TreeSet<Student> set = new TreeSet<>(new Comparator<Student>() {
			@Override
			public int compare(Student o1, Student o2) {
				if(o1.equals(o2)){
					return 0;
				}
				
				int nameLen1 = o1.getName().length();
				int nameLen2 = o2.getName().length();
				if(nameLen1 != nameLen2){
					//return nameLen1 - nameLen2;
					return Integer.compare(nameLen1, nameLen2);
				}
				
				int age1 = o1.getAge();
				int age2 = o2.getAge();
				if(age1 != age2){
					return Integer.compare(age1, age2);
				}
				return 1;
			}
		});
		
		set.add(new Student("麻生希", '女', 27, "2401", "001"));        
		set.add(new Student("椎名空", '女', 23, "2401", "002"));        
		set.add(new Student("水菜丽", '女', 21, "2401", "003"));        
		set.add(new Student("朝桐光", '女', 31, "2401", "004"));        
		set.add(new Student("北岛玲", '女', 36, "2401", "005"));        
		set.add(new Student("樱井步", '女', 29, "2401", "006"));        
		set.add(new Student("爱田奈奈", '女', 32, "2401", "007"));       
		set.add(new Student("水野朝阳", '女', 31, "2401", "008"));       
		set.add(new Student("古川伊织", '女', 27, "2401", "009"));       
		set.add(new Student("巴得伟", '男', 21, "2401", "010"));        
		set.add(new Student("李星乐", '男', 20, "2401", "011"));        
		set.add(new Student("北条麻衣", '女', 34, "2402", "001"));       
		set.add(new Student("濑亚美莉", '女', 23, "2402", "002"));       
		set.add(new Student("三上悠亚", '女', 21, "2402", "003"));       
		set.add(new Student("小西满里惠", '女', 31, "2402", "004"));      
		set.add(new Student("桃谷绘里香", '女', 27, "2402", "005"));      
		set.add(new Student("铃原爱蜜莉", '女', 23, "2402", "006"));      
		set.add(new Student("明日花绮罗", '女', 28, "2402", "007"));      
		set.add(new Student("京香Julia", '女', 34, "2402", "008"));    
		set.add(new Student("巴得伟", '男', 18, "2402", "009"));        
		set.add(new Student("张海杰", '男', 20, "2402", "010"));        

		for (Student stu : set) {
			System.out.println(stu);
		}
		
	}
}

小结：比较器接口

作用：排序时使用
分类：

​ 内置比较器：Comparable - compareTo()

​ 外置比较器：Comparator - compare()
使用场景：

​ 内置比较器：对象要想存入TreeSet、TreeMap中，对象所属的类必须要实现内置比较器

​ 外置比较器：当内置比较的规则不满足现在的需求，但又不能改动内置比较器规则时
优先级别：外置比较器 > 内置比较器

2.HashMap

2.1 HashMap的使用

public class Test01 {
	public static void main(String[] args) {
		
		HashMap<String, Integer> map = new HashMap<>();
		
		//添加元素
		map.put("麻生希", 27);
		map.put("椎名空", 23);
		map.put("水菜丽", 28);
		map.put("朝桐光", 36);
		map.put("爱田奈奈", 32);
		map.put("水野朝阳", 28);
		map.put("波多野结衣", 28);
		
		//将newMap中所有的元素添加到map集合中
		HashMap<String, Integer> newMap = new HashMap<>();
		newMap.put("aaa", 10);
		newMap.put("bbb", 20);
		newMap.put("ccc", 30);
		newMap.put("ddd", 40);
		map.putAll(newMap);
		
		//如果key存在就获取value值，如果不存在就添加
		Integer putIfAbsent = map.putIfAbsent("麻生希111", 28);
		System.out.println("putIfAbsent：" + putIfAbsent);
		
		//通过Key获取到对应的Value
		Integer integer1 = map.get("水菜丽");
		System.out.println("通过Key获取对应的value：" + integer1);//28
		
		//通过Key获取对应的value，如果key不存在则返回默认值
		Integer integer2 = map.getOrDefault("麻生希111", 888);
		System.out.println("通过Key获取对应的value：" + integer2);//888
		
		//清空集合中的元素
		//map.clear();
		
		System.out.println("判断集合中是否有指定的key：" + map.containsKey("麻生希"));//true
		System.out.println("判断集合中是否有指定的value：" + map.containsValue(27));//true
		
		System.out.println("判断集合中是否没有元素：" + map.isEmpty());//false
		
		//通过key删除映射关系(key+value)
		map.remove("aaa");
		
		//通过key+value删除映射关系(key+value)
		map.remove("bbb", 20);
		
		//通过key替换value
		map.replace("麻生希", 30);
		
		//通过key+value替换value
		map.replace("椎名空", 23, 25);
		
		//获取映射关系的个数（映射关系内包含了key和value）
		int size = map.size();
		System.out.println("获取映射关系的个数：" + size);//10
		
		//获取map中所有的value
		Collection<Integer> values = map.values();
		System.out.println(Arrays.toString(values.toArray()));//将集合转换为数组，再将数组转换为字符串
		
		System.out.println("-----------------------");
		
		//遍历 -- keySet()
		//思路：获取map集合中所有的key放在一个Set集合中，遍历Set集合获取出key，再通过key获取到Map集合中对应的value
		Set<String> keySet = map.keySet();
		for (String key : keySet) {
			Integer value = map.get(key);
			System.out.println(key + " -- " + value);
		}
		
		System.out.println("-----------------------");
		
		//遍历 -- entrySet()
		//思路：获取map集合中所有的映射关系对象放在一个Set集合中，遍历Set集合获取出映射关系对象(Key+Value)
		Set<Entry<String,Integer>> entrySet = map.entrySet();
		for (Entry<String, Integer> entry : entrySet) {
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key + " -- " + value);
		}
	}
}

2.2 HashMap的注意事项

注意：put方法即使添加也是替换

public class Test02 {
	public static void main(String[] args) {
		
		HashMap<String, Integer> map = new HashMap<>();		
		
		//put第一次添加数据，返回为nuull
		Integer put1 = map.put("麻生希", 27);
		Integer put2 = map.put("椎名空", 23);
		Integer put3 = map.put("水菜丽", 28);
		System.out.println("put1：" + put1);//null
		System.out.println("put2：" + put2);//null
		System.out.println("put3：" + put3);//null
		
		//使用put添加数据，如果map中有key，就替换value值，返回被替换的值
		Integer put4 = map.put("水菜丽", 29);
		System.out.println("put4：" + put4);//28
	
		//遍历 -- entrySet()
		//思路：获取map集合中所有的映射关系对象放在一个Set集合中，遍历Set集合获取出映射关系对象(Key+Value)
		Set<Entry<String,Integer>> entrySet = map.entrySet();
		for (Entry<String, Integer> entry : entrySet) {
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key + " -- " + value);
		}	
	
	}
}

2.3 针对于HashMap的value排序

1.将map的映射关系对象取出，返回Set集合

2.将Set集合转换为ArrayList集合

3.利用ArrayList的sort方法去排序

public class Test03 {
	public static void main(String[] args) {
		
		HashMap<String, Integer> map = new HashMap<>();		
		
		map.put("麻生希", 27);
		map.put("椎名空", 23);
		map.put("水菜丽", 28);
		map.put("朝桐光", 36);
		map.put("爱田奈奈", 32);
		map.put("水野朝阳", 28);
		map.put("波多野结衣", 28);
		
		//将map的映射关系对象取出，返回Set集合
		Set<Entry<String,Integer>> entrySet = map.entrySet();
		
		//将Set集合转换为ArrayList集合
		ArrayList<Entry<String,Integer>> list = new ArrayList<>(entrySet);
		
		//利用ArrayList的sort方法去排序
		list.sort(new Comparator<Entry<String,Integer>>() {

			@Override
			public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
				Integer v1 = o1.getValue();
				Integer v2 = o2.getValue();
				return Integer.compare(v1, v2);
			}
		});
		
		//遍历ArrayList
		for (Entry<String, Integer> entry : list) {
			System.out.println(entry);
		}	
	
	}
}

2.4 HashMap的特点

注意：

1.HashMap的key不允许重复，Key是唯一的

2.HashMap的value允许重复
HashMap的特点：无序 + key去重

public class Test04 {
	public static void main(String[] args) {
		
		HashMap<String, Integer> map = new HashMap<>();		
		
		map.put("麻生希", 27);
		map.put("椎名空", 23);
		map.put("北岛玲", 23);
		map.put("水菜丽", 28);
		map.put("水菜丽", 29);
		map.put("水菜丽", 30);
		
		Set<Entry<String,Integer>> entrySet = map.entrySet();
		for (Entry<String, Integer> entry : entrySet) {
			System.out.println(entry);
		}
			
	}
}

总结

1.TreeSet

使用

特点（TreeSet的排序规则是怎样实现的 -- 思想）

内置比较器

外置比较器
2.HashMap

使用

注意事项

面试题