set、map、散列

Day20 set、map、散列

1. Set和排序

1.1 概述

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

1.2 TreeSet

1.2.1 概述

 * set特点：无序 不可重复，添加循序和取出循序不一定一致
 * 	
 * Set ——>SortedSet——>TreeSet：底层是红黑树，要添加的元素必须按照某个规则进行排序
 * 
 * 数字默认升序，字符串 默认比较每一位的ASCII码值，时间 默认自然日期(昨，今，明，后)

1.2.2 使用

public static void main(String[] args) throws ParseException {
		TreeSet treeSet = new TreeSet();
		//数字按照升序排序
		treeSet.add(3);
		treeSet.add(2);
		treeSet.add(1);
		System.out.println(treeSet);

		//字符串按照ASCII升序排序
		//每位比较，相同则比较后面一位
		//1和12的1比，然后12的2和1的第二位比，没有则12大
		//1,10,12,2
		treeSet = new TreeSet();
		treeSet.add("1");//49
		treeSet.add("12");
		treeSet.add("11");
		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.3 为什么会排序?其他类型行不行?

* 为什么 String ，Integer ，Data能排序？其他类型行不行
 * 		因为他们三个类都实现了Comparable接口 并实现了compareTo()方法
 * 		而 往treeSet中添加数据的时候，会自动调用该对象的 compareTo方法，因此，他们可以排序
 * 		但是如果我们想添加其他元素，尤其是自定义类型的时候，就不行了，需要实现Comparable接口，并实现了compareTo()方法

1.2.4 树

1.2.4.1 二叉查找树

类似于二分法查找,查询效率比较高
左叶子 用于小于根节点的值
右叶子 永远大于根节点的值

这种方式是二分查找的思想,查询所需要的最大次数,等同于二叉树的高度
在添加数据的时候,也是类似的方式,一层层找,一直找到适合新节点的位置

但是二叉查找树也有问题
比如 一直添加比根节点小的或者大的数据

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

1.2.4.2 红黑树

为了解决二叉查找树多次插入新节点而导致的不平衡,红黑树就诞生了
完全符合二叉查找的特性
1 节点是红色或者黑色
2 根节点一定是黑色
3 每个子节点都是黑色的空节点
4 每个红节点的两个子节点都是黑色(从每个叶子到根节点的路径上不能有连续两个的红色节点)
5 从任何节点到其每一个子节点都有相同数量的黑色节点

左旋转 : 逆时针旋转,父节点被右节点取代,而自己成为左节点
右旋转 : 顺时针旋转,父节点被左节点取代,而自己成为右节点
右边黑色数量多,就左旋转
左边黑色数量多,就右旋转

1.3 排序

1.3.1 概述

 * 		1 java.lang.Comparable 接口 并实现 compareTo方法
 * 		2 java.util.Comparator 比较器类

1.3.2 Comparable

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

		//this 是要添加的元素，o是集合中的每一个元素
		//返回值为0，说明相等，就不添加
		//TreeMap只看返回值 返回小于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(11));
		treeSet.add(new User(13));
		System.out.println(treeSet);
	}
}

class User implements Comparable {
	int age;

	public User(int i) {
		// TODO Auto-generated constructor stub
		this.age = i;
	}

	public int compareTo(Object o) {
		//this 是要添加的元素，o是集合中的每一个元素
		//返回值为0，说明相等，就不添加
		//TreeMap只看返回值 返回小于0的，就放到前面
		//返回大于0的，就放到后面  所以升序降序是自定义的
		if (o instanceof User) {
			User user = (User) o;
			//升序
			return this.age - user.age;
			//降序
			//			return user.age - this.age;
		}
		return -1;
	}

	@Override
	public String toString() {
		return "User [age=" + age + "]";
	}

[User [age=11], User [age=12], User [age=13]]

1.3.3 Comparator

1.3.3.1 概述

 * 比如我们现在要保存 数字，并且是降序排序
 * 
 * 而Integer 中默认是升序，我们没有办法更改他的源码，所以可以使用Comparator解决该问题
 * 通过treeMap源码发现，Comparator优先级大于Comparable

1.3.3.2 使用

保存数字,并降序

public static void main(String[] args) {
		//Integer 要求降序排序
		//		TreeSet treeSet = new TreeSet(new ScorTest());
		//可以用匿名内部类
		TreeSet treeSet = new TreeSet(new Comparator() {
			public int compare(Object o1, Object o2) {
				//o1是要添加的元素，o2是集合中的元素
				Integer i1 = (Integer) o1;
				Integer i2 = (Integer) o2;

				return i2 - i1;
			}
		});
		treeSet.add(22);
		treeSet.add(1);
		treeSet.add(33);
		treeSet.add(44);
		System.out.println(treeSet);
	}
}

class ScorTest implements Comparator {
	public int compare(Object o1, Object o2) {
		//o1是要添加的元素，o2是集合中的元素
		Integer i1 = (Integer) o1;
		Integer i2 = (Integer) o2;

		return i2 - i1;
	}
}

1.3.4 Collections

 * list想要排序，元素必须实现comparable接口
 * 
 * 如果元素自身没有实现comparable接口，是不能调用sort方法，会报错
 * 
 * 但是 想要比较也可以，不管他是否实现comparable接口，或者是排序规则不是我们想要的
 * 
 * 都可以使用comparator进行比较，sort方法有一个重载，接收comparator

```java
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);
		System.out.println(arrayList);
		Collections.sort(arrayList, new Comparator() {
			public int compare(Object o1, Object o2) {
				//o1是要添加的元素，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.4 HashSet

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 obj : set) {
			System.out.println(obj);
		}
	}