数据去重

利用HashSet不能重复元素的特性去重
在hashCode中调用this会造成栈溢出错误,因为this也会去调用hashCode方法,所以会死循环

去重

@Test
    public void demo(){
        List<Integer> list= new ArrayList<Integer>();
        Random random = new Random();
        HashSet hashSet = new HashSet();
        int i1 = 0;
        for (int i = 0; i < 1000; i++) {
            //生成1000个1~10随机数
            i1 = random.nextInt(10) + 1;
            hashSet.add(i1);
        }
        System.out.println(hashSet);
        
    }

HashSet中自定义对象去重

import java.util.Objects;

/**
 * @author nyh
 * @create 2019-01-11  9:48
 **/
public class Student {
    String name;
    String cardNumber;

    public Student(String name, String cardNumber) {
        this.name = name;
        this.cardNumber = cardNumber;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getCardNumber() {
        return cardNumber;
    }

    public void setCardNumber(String cardNumber) {
        this.cardNumber = cardNumber;
    }

    @Override
    public boolean equals(Object o) {
       Student s = null;
       if (o==null){
           return true;
       }
       if (o instanceof Student){
           //向下转型
           s= (Student) o;
       }
       return s==null?true:this.cardNumber.equals(s.cardNumber);
    }

    @Override
    public int hashCode() {


        return cardNumber.hashCode();
    }
}

/**
     * 自定义对象去重
     */
    @Test
    public void demo1(){
        Set<Student> students = new HashSet<>();
        Student student = new Student("b","1");
        Student student2 = new Student("b","1");
        students.add(student);
        students.add(student2);
        System.out.println(students.toString());
    }

TreeSet

也可以去重,去重的同时进行排序

TreeSet实现自定义对象去重排序

自定义对象要实现comparable接口,重写compareTo方法

/**
 * @author nyh
 * @create 2019-01-11  11:56
 **/
public class Animal implements Comparable {
    //
    private int id;
    //
    private String name;

    public Animal(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public int compareTo(Object o) {
        Animal al = (Animal) o;
        return this.id-al.id;//按照id升序排列
    }
}

compareTo方法返回正数放右边,负数放左边,0只会返回一次(就是在第一次和自己比较的时候)
this:新来的
Object:已存在的

LinkedHashSet

链表与哈希表的结合,去重的同时也保证存取的顺序

Iterator()

使用迭代器的同时对set进行修改,这时会抛出ConcurrentModificationException异常(并发修改异常),想要不报异常,可以使用迭代器自身的remove方法