Java

Collection 以value形式存在
 Set  无序无重复
 1.具体的实现类
  HashSet
  TreeSet
 2.基本的使用
 3.无序   无重复
  无序：我们使用集合存放元素的顺序  集合内取出来的顺序不一致
  集合本身是有自己的算法排布顺序  hash算法

 

一、HashSet---->(HashMap (数组+链表) 散列表 临接连表)
  1.java.util
  2.如何创建对象   无参数  有参数

  3.集合容器的基本使用
   　　增删改查
   　　boolean = add(value)   addAll(collection c)   retainAll   removeAll
   　　boolean = remove(Object)
  　　 没有修改方法

　　　size()
   　　iterator()  获取一个迭代器对象

import java.util.HashSet;
import java.util.Iterator;

public class TestHashSet {
    public static void main(String[] args){

        //无序的
        HashSet<String> hashSet = new HashSet<String>();
        hashSet.add("a");
        hashSet.add("h");
        hashSet.add("d");
        hashSet.add("b");
        hashSet.add("c");
        hashSet.add("a");
        //通过迭代器来遍历
        Iterator<String> it = hashSet.iterator();
        while(it.hasNext()){
            String value = it.next();
            System.out.println(value);
        }
    }

}
输出结果
a
b
c
d
h

  4.无重复的原则
   　　首先通过String类型和Person类型存储
   　　大概猜测  无重复的原则  利用equals方法进行比较

public class Person {
    private String name;

    public Person(String name){
        this.name=name;
    }

    //重写 toString方法  让对象打印输出的时候直接输出对象的属性 而不是hashCode码
    public String toString(){
        StringBuilder builder = new StringBuilder("{");
        builder.append(this.name);
        builder.append("}");
        return new String(builder);
    }
    public String getName(){
        return this.name;
    }
}
import java.util.HashSet;
public class TestHashSet {
    public static void main(String[] args){
        HashSet<String> stringSet = new HashSet<String>();
        stringSet.add(new String("123"));
        stringSet.add(new String("123"));
        stringSet.add(new String("123"));
        stringSet.add(new String("123"));
        stringSet.add(new String("123"));
        System.out.println("string集合的size:"+stringSet.size());//1
        HashSet<Person> personSet = new HashSet<Person>();
        personSet.add(new Person("123"));
        personSet.add(new Person("123"));
        personSet.add(new Person("123"));
        personSet.add(new Person("123"));
        personSet.add(new Person("123"));
        System.out.println("person集合的size:"+personSet.size());//5
        System.out.println(personSet);
    }
}
输出结果
string集合的size:1
person集合的size:5
[{123}, {123}, {123}, {123}, {123}]

   　　如果我们想要让Person对象的name一致 认为是同一个对象

   　　我们可以重写equals方法
   　　重写了equals方法  发现还没有产生无重复的效果，证明可能原则不止equals一个方法这么简单，还有另一个规则同时起着作用 hashCode方法  int

//重写equals方法  将person放入set集合中 去掉重复
    public boolean equals(Object obj) {
        if(this==obj){
            return true;
        }
        if(obj instanceof Person){
            //obj还原回Person类型
            Person anotherPerson = (Person)obj;
            //this  anotherPerson比较对象中的name属性
            if(this.name.equals(anotherPerson.name)){//递归
                return true;
            }
        }
        return false;
    }
    //重写 hashCode方法
    public int hashCode(){
        //两个person对象name属性一致  需要让hashCode返回值一致
        return this.name.hashCode();
    }

　　　五个Person对象只剩一个   第一次存储的?   还是最后一次存储?

   　　set集合是发现重复的元素 拒绝存入  存储的是第一个
  
 二、TreeSet-----(TreeMap 二叉树 利用Node(left item right))
  无序无重复  java.util
  无参数构造方法    带Collection构造方法
  基本常用方法
 　　  add(E e)  iterator()  remove(E e)  没有修改  size()
  无重复的规则是如何实现的
  　　 treeSet集合本身有顺序   我们指的无序存入的和取出来的不一致
   　　compareTo---->String类  按照字母的自然顺序排布(Unicode)
  　　 如果想要把自己写的类型 比如Person对象存入TreeSet集合里
   　　不能随意的存储 需要让自己写的类先实现Comparable接口

public class Person implements Comparable<Person>{
    private String name;
    private int age;
    private int testNum;//记录人是谁
    public Person(String name,int age,int testNum){
        this.name=name;
        this.age=age;
        this.testNum=testNum;
    }

    //重写equals方法  将person放入set集合中 去掉重复
    public boolean equals(Object obj) {
        if(this==obj){
            return true;
        }
        if(obj instanceof Person){
            //obj还原回Person类型
            Person anotherPerson = (Person)obj;
            //this  anotherPerson比较对象中的name属性
            if(this.name.equals(anotherPerson.name)){//递归
                return true;
            }
        }
        return false;
    }
    //重写 hashCode方法
    public int hashCode(){
        //两个person对象name属性一致  需要让hashCode返回值一致
        return this.name.hashCode();
    }
    //重写 toString方法  让对象打印输出的时候直接输出对象的属性 而不是hashCode码
    public String toString(){
        StringBuilder builder = new StringBuilder("{");
        builder.append(this.name);
        builder.append(",");
        builder.append(this.age);
        builder.append(",");
        builder.append(this.testNum);
        builder.append("}");
        return new String(builder);
    }

    //如果想要让person对象存入TreeSet集合内  必须实现接口 重写这个方法
    public int compareTo(Person o) {
        int value = this.name.compareTo(o.name);
        if(value!=0){
            return value;//当前对象name和另一个对象name的compateTo结果
        }
        return this.age-o.age;//返回值整数 靠后  返回值负数 靠前
    }

    public String getName(){
        return this.name;
    }
    public int getTestNum(){
        return this.testNum;
    }


}

import java.util.TreeSet;

public class TestTreeSet {
    public static void main(String[] args){
        TreeSet<String> stringSet = new TreeSet<String>();
        stringSet.add(new String("123"));
        stringSet.add(new String("123"));
        stringSet.add(new String("123"));
        stringSet.add(new String("123"));
        stringSet.add(new String("123"));
        System.out.println(stringSet.size());//1    set家族如有相同的对象 拒绝存入

        TreeSet<Person> personSet = new TreeSet<Person>();
        personSet.add(new Person("123",18,1));
        personSet.add(new Person("123",16,2));
        personSet.add(new Person("123",20,3));
        personSet.add(new Person("123",24,4));
        personSet.add(new Person("123",25,5));
        System.out.println(personSet.size());//????  5
        System.out.println(personSet);
        //ClassCastException--->造型异常
    }

}

 总结：

 Set
 特点  无序无重复
 无序: 添加的顺序 获取的顺序不一致 (不是集合本身是否有序 Tree自然有序)
 无重复: 添加的元素不能一致 (如果出现重复元素 只存第一个 不再存入)

 HashSet(HashMap--->数据存储结构 散列表)
 TreeSet(TreeMap--->数据存储结构 二叉树)

 set集合家族的基本使用
  增删改查
  add(E e)   remove(E e)  没有修改  iterator迭代器(增强for)   size();
      hasNext();
      E = next();
 set集合的无重复特性
  HashSet 无重复原则有两个方法同时起作用
   equals hashCode
   默认比较的是两个对象的地址  若第二个对象地址与之前的一致  不再存入
   如果想要改变其比较的规则  可以重写上述两个方法
  TreeSet 无重复原则有一个方法起作用
   compareTo
   上述这个方法不是每一个对象都有的
   若想要将某一个对象存入TreeSet集合中  需要让对象所属的类实现接口Comparable
   实现接口后将compareTo方法重写  返回值int  负数靠前排布 整数排列靠后