集合- set集合不重复的原理

目录

1.集合的好处：

2.集合的框架体系

 3.Set接口和常用方法

3.1 Set接口实现类--HashSet

3.2HashSet 底层机制说明

3.3 Set 接口实现类-LinkedHashSet

1.集合的好处：

之前用数组保存多个数据 ，现在也可以用集合来保存。

1.1 数组：

1）长度开始时必须指定,而且一旦指定,不能更改

2）保存的必须为同一类型的元素

3）使用数组进行增加/删除元素

例如：Person[] s=new Person[1];

  // 增加新的Person对象

Person[] w=new Person[s.length+1];

for(){//拷贝s数组的元素到w}

w[w.length-1] = new Person();//添加新的对象

1.2 集合：

1）可以动态保存任意多个对象,使用比较方便！

2）提供了一系列方便的操作对象的方法：add，remove，set，get等

3）使用集合添加,删除新元素

2.集合的框架体系

主要分为两大类：

2.1 单列集合

2.2 双列集合

 3.Set接口和常用方法

3.1 set接口基本介绍

1）无序(添加和取出的顺序不一致)，没有索引

2）不允许重复元素,所以最多包含一个null

3）JDK API中Set接口的实现类有：

 (3.2) Set接口的常用方法

和List接口一样,Set 接口也是 Collection 的子接口，因此，常用方法和 Collection 接口一样.

(3.3) Set 接口的遍历方式

同Collection的遍历方式一样,因为Set接口是Colleection接口的子接口.

1.可以使用迭代器

2.增强for

 @SuppressWarnings({"all"})
public class SetMethod { 
    public static void main(String[] args) {

//1. 以 Set 接口的实现类 HashSet 来讲解 Set 接口的方法
 //2. set 接口的实现类的对象(Set 接口对象), 不能存放重复的元素, 可以添加一个 null 
//3. set 接口对象存放数据是无序(即添加的顺序和取出的顺序不一致)
 //4. 注意：取出的顺序的顺序虽然不是添加的顺序，但是他的固定
     Set set = new HashSet();
		set.add("john"); 
		set.add("lucy");
		set.add("john");//重复 
		set.add("jack"); 
		set.add("hsp");
		set.add("mary"); 
		set.add(null);//
        set.add(null);//再次添加 null
for(int i = 0; i <10;i ++) { 
System.out.println("set=" + set); 
}
//遍历 
//方式 1： 使用迭代器
System.out.println("=====使用迭代器====");
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
 Object obj = iterator.next(); 
System.out.println("obj=" + obj); 
}
set.remove(null);
//方式 2: 增强 for
 System.out.println("=====增强 for===="); 、
for (Object o : set) { 
    System.out.println("o=" + o); 
}


//set 接口对象，不能通过索引来获取
}
  }

3.不能使用索引的方式来获取

3.1 Set接口实现类--HashSet

1)HashSet实现了Set接口

2）HashSet实际上是HashMap

3）可以存放null值,但是只能有一个null

4）HashSet不保证元素是有序的,取决于hash后,再确定索引的结果(即,不保证存放元素的顺序和取出顺序一致)

5）不能有重复元素/对象 

@SuppressWarnings({"all"}) 
public class HashSet_ { 
	public static void main(String[] args) { 
		//1. 构造器走的源码 
		/*
		public HashSet() { 
			map = new HashMap<>(); 
			}
		2. HashSet 可以存放 null ,但是只能有一个 null,即元素不能重复 
		*/
		Set hashSet = new HashSet(); 
		hashSet.add(null);
		hashSet.add(null); 
		System.out.println("hashSet=" + hashSet);
		} 
		
		}

HashSet案例说明：

import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;

@SuppressWarnings({"all"})
public class HashSet01 { 
	public static void main(String[] args) { 
		HashSet set = new HashSet();
		//说明
		//1. 在执行 add 方法后，会返回一个 boolean 值 
		//2. 如果添加成功，返回 true, 否则返回 false
		//3. 可以通过 remove 指定删除哪个对象
		System.out.println(set.add("john"));//T 
		System.out.println(set.add("lucy"));//T 
		System.out.println(set.add("john"));//F
		System.out.println(set.add("jack"));//T
		System.out.println(set.add("Rose"));//T
		
		set.remove("john"); 
		System.out.println("set=" + set);//3 个
		
		//
		set = new HashSet();
		System.out.println("set=" + set);//0 
		//4 Hashset 不能添加相同的元素/数据?
		set.add("lucy");//添加成功 
		set.add("lucy");//加入不了
		set.add(new Dog("tom"));//OK
		set.add(new Dog("tom"));//Ok 
		System.out.println("set=" + set);
		
		//看源码，做分析， 先给小伙伴留一个坑，以后讲完源码，你就了然
		//去看他的源码，即 add 到底发生了什么?=> 底层机制. 
		set.add(new String("hsp"));//ok
		set.add(new String("hsp"));//加入不了. 
		System.out.println("set=" + set);
	}
}
class Dog { //定义了 Dog 类
	private String name; 
	public Dog(String name) {
		this.name = name;
		}
	@Override
	public String toString() {
		return "Dog [name=" + name + "]";
	}	
}

3.2HashSet 底层机制说明

（1）HashSet底层是HashMap,HashMap底层是(数组+链表+红黑树);

(模拟简单的数组+链表结构)

import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;

@SuppressWarnings({"all"})
public class HashSetStructure { 
	public static void main(String[] args) { 
		//模拟一个HashSet的底层（HashMap的底层结构）
		//1.创建一个数组,数组的类型是Node[]
		//2.有些人直接把Node[] 数组称为 表
		Node[] table = new Node[16];
		System.out.println("table="+ table);
		//3.创建结点
		Node xb = new Node("xb",null);
		table[2] = xb;
		Node db = new Node("db",null);
		xb.next = db;//将db结点挂载到xb
		Node nh = new Node("nh", null);
		db.next=nh;//将nh结点挂载到db
		System.out.println("table="+ table);
	}	
}
class Node{//结点,存储数据,可以指向下一个结点,从而形成链表
	Object item;//存放数据
	Node next;//指向下一个结点

	public Node(Object item, Node next) {
		super();
		this.item = item;
		this.next = next;
	}
	
}
		
	
		

（1.2） HashSet的添加元素底层是如何实现(hash())+(equals())

1.执行  HashSet()

 2.执行 add()

;//(static) PRESENT = new Object();

 3.执行 put() , 该方法会执行 hash(key) 得到 key 对应的 hash 值 算法 h = key.hashCode()) ^ (h >>> 16)      //key = "java" value = PRESENT 共享

4. 执行 putVal

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;//定义了辅助变量
   //table 就是 HashMap 的一个数组，类型是 Node[]
   //if 语句表示如果当前 table 是 null, 或者 大小=0 
   //就是第一次扩容，到 16 个空间.
         if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;

//(1)根据 key，得到 hash 去计算该 key 应该存放到 table 表的哪个索引位置 
//并把这个位置的对象，赋给 p
//(2)判断 p 是否为 null
//(2.1) 如果 p 为 null, 表示还没有存放元素, 就创建一个 Node (key="java",value=PRESENT)
//(2.2) 就放在该位置 tab[i] = newNode(hash, key, value, null)
 if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {

                //一个开发技巧提示： 在需要局部变量(辅助变量)时候，在创建
              Node<K,V> e; K k; //
            //如果当前索引位置对应的链表的第一个元素和准备添加的 key 的 hash 值一样
            //并且满足 下面两个条件之一:
               //(1) 准备加入的 key 和 p 指向的 Node 结点的 key 是同一个对象
             //(2) p 指向的 Node 结点的 key 的 equals() 和准备加入的 key 比较后相同 
            //就不能加入

    if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;

            //再判断 p 是不是一颗红黑树, 
           //如果是一颗红黑树，就调用 putTreeVal , 来进行添加

        else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                  //如果 table 对应索引位置，已经是一个链表, 就使用 for 循环比较
                 //(1) 依次和该链表的每一个元素比较后，都不相同, 则加入到该链表的最后
                 // 注意在把元素添加到链表后，立即判断 该链表是否已经达到 8 个结点
         // , 就调用 treeifyBin() 对当前这个链表进行树化(转成红黑树) 
       // 注意，在转成红黑树时，要进行判断, 判断条件 
       // if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY(64))
       // resize(); 
      // 如果上面条件成立，先 table 扩容. 
      // 只有上面条件不成立时，才进行转成红黑树
     
  //(2) 依次和该链表的每一个元素比较过程中，如果有相同情况,就直接 break  
        for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        //size 就是我们每加入一个结点 Node(k,v,h,next), size++
        if (++size > threshold)
            resize();//扩容
        afterNodeInsertion(evict);
        return null;
    }

  

（1.3）HashSet的扩容和转成红黑树机制

import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;

@SuppressWarnings({"all"})
public class HashSetIncrement { 
	public static void main(String[] args) { 
		/*HashSet 底层是 HashMap, 第一次添加时，table 数组扩容到 16，
		 *  临界值(threshold)是 16*加载因子(loadFactor)是 0.75 = 12 
		 *  如果 table 数组使用到了临界值 12,就会扩容到 16 * 2 = 32,
		 *  新的临界值就是 32*0.75 = 24, 依次类推
		 */
		HashSet hashSet = new HashSet(); 
//		 for(int i = 1; i <= 100; i++) { 
//		 hashSet.add(i);//1,2,3,4,5...100
//		 }
		
		/*在 Java8 中, 如果一条链表的元素个数到达 TREEIFY_THRESHOLD(默认是 8 )， 
		 * 并且 table 的大小 >= MIN_TREEIFY_CAPACITY(默认 64),就会进行树化(红黑树), 
		 * 否则仍然采用数组扩容机制 */
//		 for(int i = 1; i <= 12; i++) {
//		 hashSet.add(new A(i));// 
//		 }
		
		/* 当我们向 hashset 增加一个元素，-> Node -> 加入 table , 就算是增加了一个 size++ */
		
		for(int i = 1; i <= 7; i++) {//在 table 的某一条链表上添加了 7 个 A 对象 
			hashSet.add(new A(i));//
		}
		for(int i = 1; i <= 7; i++) {//在 table 的另外一条链表上添加了 7 个 B 对象
			hashSet.add(new B(i));//
			}
		}
	class B { 
		private int n; 
		public B(int n) { 
			this.n = n; 
			}
		@Override
		public int hashCode() {
			return 200; 
			} 
		}
	class A {
		private int n;
		public A(int n) {
			this.n = n; 
			}
		@Override 
		public int hashCode() {
			return 100;
			}
		}
	}
		
	
		

3.3 Set 接口实现类-LinkedHashSet

1）LinkedHashSet是HashSet的子类

2）LinkedHashSet底层是一个LinkedHashMap，底层维护了一个 数组+双向链表

3）LinkedHashSet根据元素的hashCode值来决定元素的存储位置,同时使用链表维护元素的次序,这使得元素看起来是以插入顺序保存的.