2021-07-16比较器、set、map、散射-CSDN博客

本文链接：https://blog.csdn.net/weixin_59544199/article/details/118814619

1.Set和排序

1.1概述

set特点 : 无序不可重复,添加顺序和取出顺序不一定一致
*
* Set -> SortedSet -> TreeSet : 底层是红黑树,要添加的元素必须按照某个规则进行排序

数字默认升序 , 字符串默认比较每一位的ASCII码值 , 时间默认自然日期(昨天,今天,明天,后天...)

1.2Treeset

1.2.1使用

public static void main(String[] args) throws ParseException {
		// String , Integer  , Date
		TreeSet treeSet = new TreeSet();
		// 数字按照升序排序
		treeSet.add(2);
		treeSet.add(3);
		treeSet.add(1);
		System.out.println(treeSet);
		treeSet = new TreeSet();
		// 字符串按照ASCII升序排序
		// 每位比较,相同则比较后面一位
		// [1, 10, 12, 2]
		treeSet.add("1");
		treeSet.add("12");
		treeSet.add("10");
		treeSet.add("2");
		System.out.println(treeSet);
		// 时间 自然日期
		String strTime1 = "2021-07-15";
		String strTime2 = "2021-07-13";
		String strTime3 = "2020-08-15";
		String strTime4 = "2022-02-11";
		treeSet = new TreeSet();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Date d1 = sdf.parse(strTime1);
		Date d2 = sdf.parse(strTime2);
		Date d3 = sdf.parse(strTime3);
		Date d4 = sdf.parse(strTime4);
		treeSet.add(strTime1);
		treeSet.add(strTime2);
		treeSet.add(strTime3);
		treeSet.add(strTime4);
		System.out.println(treeSet);
	}	
}

1.2.2为什么会排序？其他类型行不行？

比较器类有两种
*        1 java.lang.Comparable 接口并实现 compareTo方法
*        2 java.util.Comparator 比较器类
*
* 为什么 String , Integer , Date 能排序? 其他类型行不行
*        因为他们三个类都实现了Comparable接口并实现了compareTo()方法
*        而往treeSet中添加数据的时候,会自动调用该对象的 compareTo方法,因此他们可以排序
*        但是如果我们想添加其他元素,尤其是自定义类型的时候,就不行了,需要实现Comparable接口并实现了compareTo()方法

1.2.3树

1.2.3.1二叉查找树

类似于二分法查找,查询效率比较高

左叶子用于小于根节点的值

右叶子永远大于根节点的值

这种方式是二分查找的思想,查询所需要的最大次数,等同于二叉树的高度

在添加数据的时候,也是类似的方式,一层层找,一直找到适合新节点的位置

但是二叉查找树也有问题

比如一直添加比根节点小的或者大的数据

这样的话,虽然符合二叉查找树特性,但是性能大打折扣,几乎变成了线性的

1.2.3.2红黑树

为了解决二叉查找树多次插入新节点而导致的不平衡,红黑树就诞生了

完全符合二叉查找的特性

1 节点是红色或者黑色

2 根节点一定是黑色

3 每个子节点都是黑色的空节点

4 每个红节点的两个子节点都是黑色(从每个叶子到根节点的路径上不能有连续两个的红色节点)

5 从任何节点到其每一个子节点都有相同数量的黑色节点

左旋转 : 逆时针旋转,父节点被右节点取代,而自己成为左节点

右旋转 : 顺时针旋转,父节点被左节点取代,而自己成为右节点

右边黑色数量多,就左旋转

左边黑色数量多,就右旋转

1.3排序

1.3.1概述

1.3.2Comparable

如果我们的自定义类型想要放到treeSet中,必须实现Comparable接口,否则就无法使用treeSet进行数据保存

@Override
	public int compareTo(Object o) {
		// this 是要要添加的元素 , o 是集合中的每一个元素
		// 返回值为0 , 说明相等, 就不添加
		// 返回小于0 的, 说明要添加的元素比集合中的元素小,就放到前面
		// 返回大于0的,说明要添加的元素比集合中的元素大,就放到后面

public static void main(String[] args) {
		// java.lang.ClassCastException: day_02.User cannot be cast to java.lang.Comparable
		TreeSet treeSet = new TreeSet();
		treeSet.add(new User(12));
		treeSet.add(new User(13));
		treeSet.add(new User(11));
		System.out.println(treeSet);
	}
}
class User implements Comparable{
	int age;
	@Override
	public String toString() {
		return "User [age=" + age + "]";
	}
	public User(int age) {
		this.age = age;
	}
	@Override
	public int compareTo(Object o) {
		// this 是要要添加的元素 , o 是集合中的每一个元素
		// 返回值为0 , 说明相等, 就不添加
		// 返回小于0 的, 说明要添加的元素比集合中的元素小,就放到前面
		// 返回大于0的,说明要添加的元素比集合中的元素大,就放到后面
		if (o instanceof User) {
			User user = (User) o;
			// 升序 
			// return this.age - user.age;
			// 降序
			return user.age - this.age;
		}
		return -1;
	}
	
}

1.3.3Comoparator

1.3.3.1概述

应用场景
*
* 比如我们现在要保存数字 , 并且是降序排序
*
* 而 Integer中默认是升序,我们没有办法更改他的源码,所以可以使用Comparator解决该问题
*
* 通过treeMap源码发现,Comparator优先级大于 Comparable
*
* 所以我们可以利用Comparator的优先级,来自定义排序规则
*
* 我们自定义类型需要排序,优先使用Comparable来实现,这样如果不能满足别人的需求,还可以通过comparator对排序进行扩展
*
* 我们操作的是别人定义的类型的话,都需要使用comparator进行扩展,因为你改不了人家源码
*            1 本来有排序,比如Integer,默认升序,但是不能满足我们的排序需求,此时需要使用comparator进行扩展
*            2 不支持排序,也就是说该类型没有实现comparable接口,不能排序.但是此时我们需要排序,也可以通过comparator进行扩展
*            3 总之其他类型.无法满足我们的排序规则的时候,都可以使用comparator进行扩展排序
*

1.3.3.2使用

保存数字,并降序

public class Collection_03_Comparator {
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static void main(String[] args) {
		// Integer
		// TreeSet treeSet = new TreeSet(new ScorTest());
		// 匿名内部类写法
		TreeSet treeSet = new TreeSet( new Comparator() {
			@Override
			public int compare(Object o1, Object o2) {
				// o1是要添加的元素,o2是集合中的元素
				Integer i1 = (Integer) o1;
				Integer i2 = (Integer) o2;
				// i1-i2是升序, i2-i1是降序
				return i2 - i1;
			}
		} );
		treeSet.add(22);
		treeSet.add(1);
		treeSet.add(41);
		treeSet.add(21);
		System.out.println(treeSet);
	}
}
//class ScorTest implements Comparator{
//
//	@Override
//	public int compare(Object o1, Object o2) {
//		// o1是要添加的元素,o2是集合中的元素
//		Integer i1 = (Integer) o1;
//		Integer i2 = (Integer) o2;
//		// i1-i2是升序, i2-i1是降序
//		return i2 - i1;
//	}
//}

public class Collection_03_Comparator {
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static void main(String[] args) {
		// Integer
		// TreeSet treeSet = new TreeSet(new ScorTest());
		// 匿名内部类写法
		TreeSet treeSet = new TreeSet( new Comparator() {
			@Override
			public int compare(Object o1, Object o2) {
				// o1是要添加的元素,o2是集合中的元素
				Integer i1 = (Integer) o1;
				Integer i2 = (Integer) o2;
				// i1-i2是升序, i2-i1是降序
				return i2 - i1;
			}
		} );
		treeSet.add(22);
		treeSet.add(1);
		treeSet.add(41);
		treeSet.add(21);
		System.out.println(treeSet);
	}
}

1.3.4Collections

list想要排序,元素必须实现comparable接口

如果元素自身没有实现comparable接口,是不能调用sort方法的,会报错

但是想要比较也可以,不管他是否实现comparable接口,或者是排序规则不是我们想要的

都可以使用comparable进行比较,那么sort方法有一个重载,接受comparator

public static void main(String[] args) {
		ArrayList arrayList = new ArrayList();
		arrayList.add(2);
		arrayList.add(21);
		arrayList.add(12);
		arrayList.add(4);

		// Collections.sort(arrayList);
		Collections.sort(arrayList, new Comparator() {

			@Override
			public int compare(Object o1, Object o2) {
				Integer i1 = (Integer) o1;
				Integer i2 = (Integer) o2;
				return i2 - i1;
			}
		});
		System.out.println(arrayList);
	}
}

1.3.5总结

如果添加的元素是我们写的,那么我们应该使用comparable进行排序,因为对扩展开放,当满足不了别人需求的时候,人家还可以使用comparator进行扩展

如果添加的元素不是我们写的,是别人写的,那么我们肯定不能更改人家的源码

此时我们可以通过comparator进行重新排序

因为comparator和comparable同时存在的时候,comparator优先级要高

1.4HashSet

1.4.1 散列表

散列表 : 数组中保存的链表
*
* HashSet 底层就是HashMap 的key部分,屏蔽了HashMap的value
*
* 而HashMap底层是散列表
*
* 添加过程 :
*        1 根据key生成hash值(hashCode方法)
*        2 根据生成hash值,通过hash算法得到数组下标
*                    i = (n - 1) & hash
*        3 调用key的equals方法,和数组中对应的链表的每一个节点进行比较
*        4 如果不存在,就添加进去,如果存在,就不添加
*        5 java8开始.,引入了红黑树,如果链表个数大于等于9 就把链表转型为红黑树从而加快查询效率
*
* 覆写equals的时候还需要考虑什么? hashCode 因为需要使用hashCode和equals共同表示对象的唯一性

1 调用 key的hashCode方法生成hash值,所以记得重写哦~

2 散列存储方式

3 生成数组索引

4 判断数组对应索引中是否有节点

5 没有节点直接添加

6 有节点判断是否存在当前元素

7 如果链表中节点个数大于等于8 就转为树

1.4.2 HashSet

public static void main(String[] args) {
		HashSet set = new HashSet();
		set.add("a");
		set.add("b");
		set.add("c");
		set.add("d");
		set.add("e");
		System.out.println(set);
		// set.remove(o)
		for (Object object : set) {
			System.out.println(object);
		}
	}
}