[Java知识库]Java集合详细讲解 set集合去重原理

集合 Collection 集合的超类
1、add 添加元素
2、clear 清空
3、contains(Object o) 判断集合中是否有指定的元素
4、isEmpty 判断集合是否为空。
其他集合继承Collection集合

集合迭代器 超类调用

 public static void f1(Collection<String> c){    //在不知道传过来的类型 Collection<？> c  使用通配符
        Iterator<String> iterator1=c.iterator();
        while(iterator1.hasNext()){
            //iterator
            //String s1=  iterator1.next();
            System.out.println(iterator1.next());
        }
    }

List:
它是一个有序的集合(元素存与取的顺序相同)
它可以存储重复的元素
Set:
它是一个无序的集合(元素存与取的顺序可能不同)
它不能存储重复的元素
? List集合中的特有方法
? void add(int index, Object element) 将指定的元素，添加到该集合中的指定位置上
? Object get(int index)返回集合中指定位置的元素。
? Object remove(int index) 移除列表中指定位置的元素, 返回的是被移除的元素
? Object set(int index, Object element)用指定元素替换集合中指定位置的元素,返回值的更新前的元素
? ArrayList:
底层数据结构是数组，查询快，增删慢
? LinkedList:
底层数据结构是链表，查询慢，增删快
? HashSet:
元素唯一，不能重复
底层结构是 哈希表结构
元素的存与取的顺序不能保证一致
如何保证元素的唯一的？
重写hashCode() 与 equals()方法
? LinkedHashSet:
元素唯一不能重复
底层结构是 哈希表结构 + 链表结构
元素的存与取的顺序一致

/*
数据存储的结构：
1、链表数据存储结构
查询速度慢，增加，修改数据快 元素和元素之间通过地址来发生关联
2、堆栈数据存储结构
元素先进后出
3、队列数据存储结构
元素先进先出来
4、数组数据存储结构
根据索引查询快
list接口：
特点：
元素允许重复
有序
带索引的，访问
使用普通for循环
数据结构：数组，查询速度快
应用场景：数据大数据的查询中。
set接口：
特点：
元素不允许重复
无序
无索引
访问迭代器，增强for
数据结构：哈希表的结构（ 链表数据存储结构+数组）
应用场景：

LinkedList:常用的方法：
首元素
最后元素

 LinkedList<String> list=new LinkedList<>();
        list.add("abc");
        list.add("def");
        //子类特有的方法不能访问
        list.addFirst("xyz"); //加到头部
        list.addLast("mn");//加到尾部

/
字符串 set应用
/
hashSet的存储数据-哈希表
组成：链表和数组
初始化的数组容量最大是16*0.75=12个.保存的数据
hashset集合依赖什么将关联的数据加载一个桶里面。
哈希值和元素是否是相同的类型。
删除重复元素原理：
依赖哈希码值和 equals.
*/

HashSet<String> hs=new HashSet<String>();
        hs.add("a");
        hs.add("b");
        String str1=new String("abc");
        String str2=new String("abc");//一句哈希吗值和equals
        hs.add(str1);
        hs.add(str2);
        hs.add(new String("def"));//计算哈希吗值  不同，equals false
        System.out.println(str1==str2);//false，字符串的比较 equals 为true 存在常量池   两个new  指向同一地址
        System.out.println(str1.equals(str2));//true
        System.out.println(str1.hashCode());//计算出来 96354
        System.out.println(str2.hashCode());//96354
        System.out.println(hs);//集合中 几个abc 1个

类对象 set 集合应用

Set<Student> s1=new HashSet<>();
s1.add(new Student("a",10));
s1.add(new Student("b",11));
s1.add(new Student("a",10));       //可以加进去 因为equals()和hashcode()返回值不为flase
Student ss1=new Student("a",10);
Student ss2=new Student("a",10);
System.out.println(ss1.equals(ss2));//equals 对象  fasle  比较的是对象的内容  出现了new 对象不同
System.out.println(ss1==ss2);//false  比较的就是地址。
System.out.println(ss1.hashCode());//调用的父类的 hashcode。
     //要求如果学生的姓名，年龄，是一样的不允许加入。
    // 重写学生类的equlas()方法和hashcode()方法   具体在类对象实现时  重写方法
//子类重写父类的hashcode.
    public int hashCode(){

        //return 1;//这里不能写死。缺点是所有的学生哈希码值都一样
        //不同name和年龄生成不同的哈希码值。
        return 31*this.name.hashCode()+this.age*55;
    }
  //重写equals方法,希望姓名和年龄一样的，就是同一个学生。
 public boolean equals(Object obj) {
        //obj的数据类型，Object
        //name 的属性是 student
        Student s=(Student)obj;
        if(this.name==s.name && this.age==s.age){
            return true;
        }
        return false;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }