24Collection(TreeSet)、内置比较器：Comparable - compareTo()、外置比较器：Comparator - compare()、Map(Hash)

程序奇男子

已于 2024-07-10 15:22:57 修改

阅读量490

点赞数 11

分类专栏： JavaSE 文章标签： java-ee 学习 java 集合比较器

于 2024-03-07 23:19:08 首次发布

本文链接：https://blog.csdn.net/gangain/article/details/136548830

版权

JavaSE 专栏收录该内容

52 篇文章 1 订阅

订阅专栏

本文详细介绍了Java中的TreeSet集合的自然排序特性，以及如何使用Comparable接口的compareTo方法进行排序。同时讨论了如何在外部提供Comparator接口来定制排序规则，以及HashMap的使用注意事项和面试题中的value排序问题。

摘要由CSDN通过智能技术生成

day24

集合框架图

标红的为已经学习内容

Collection家族

Set接口

3.TreeSet

继Collection家族Set接口下

使用

注意：TreeSet的使用和HashSet一样

特点 – 自然排序

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

		//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);
		}

内置比较器：Comparable - compareTo()

使用

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

Comparable接口中的compareTo方法是排序用的，重写compareTo方法根据自己需求编写

（测试发现是去重的）


public class Test03 {
	public static void main(String[] args) {
		
		TreeSet<Student> set = new TreeSet<>();
		
		set.add(new Student("小陈", '男', 25, "2401", "001"));    
		set.add(new Student("小刘", '女', 23, "2401", "002"));    
		......      
		set.add(new Student("小ge", '女', 28, "2402", "007"));      
		set.add(new Student("小马", '女', 34, "2402", "008"));      

		for (Student stu : set) {
			System.out.println(stu);
		}	
//直接运行会报错，类型转换异常
//Exception in thread"main"java.lang.ClassCastException:com.qf.treeset_class.Student cannot be cast to java.lang.Comparable
//Student类实现Comparable接口重写compareTo方法就不会报错

	}
}


public class Student implements Comparable<Student>{

	.......
	//排序规则：按照年龄排序
	@Override
	public int compareTo(Student o) {
		//this表示添加到TreeSet中的学生对象
		//o表示TreeSet中的学生对象
		return this.age - o.age;
		//返回0，相同已存在不存；返回负数，小排前存；返回负数，大排后存
	}
}

//Comparable接口中的compareTo方法是排序用的
//返回值类型为int的原因：
//排序其实就是比较大小，返回三种情况正（比比较对象大）负（比比较对象小）零（相等），表现形式更丰富，如果是boolean只有两种

外置比较器：Comparator - compare()

使用

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

场景 - 联合开发：

1.Student类是A开发的

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

3.B想的是按照名字长度排序，长度一致按照年龄排序

注意：

在实际开发中不要轻易去改动别人写的类
compare的底层十方简单
public static int compare(int x, int y) {
    return (x < y) ? -1 : ((x == y) ? 0 : 1);
}


import java.util.Comparator;
import java.util.TreeSet;

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;//返回1的原因：名字和年龄不同一定可以加
			}
		});
		
		set.add(new Student("小陈", '男', 25, "2401", "001"));    
		set.add(new Student("小刘", '女', 23, "2401", "002"));    
		......      
		set.add(new Student("小ge", '女', 28, "2402", "007"));      
		set.add(new Student("小马", '女', 34, "2402", "008"));        

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

比较器接口

作用：排序时使用

分类：

内置比较器：Comparable - compareTo()

外置比较器：Comparator - compare()

使用场景：

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

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

优先级别：外置比较器 > 内置比较器

Map家族

实现类：

HashMap
LinkedHashMap
Hashtable
ConcurrentHashMap
TreeMap
Properties

1.HashMap

使用

	
		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);
		}

注意事项

put方法既是添加也是替换

		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);
		}

特点

注意：

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

2.HashMap的value允许重复

HashMap的特点：无序 + key去重

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);
}

面试题：针对于HashMap的value排序

		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);
		}