JAVA集合——Collection接口中的Set接口

TestSet.java

package com.it.study;

import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

import org.junit.Test;

/*Collection接口 ：
 *   |------List接口：
 *      |------ArrayList（主要的实现类）
        |------LinkedList（更适用于频繁的插入、删除操作）
        |------Vector（古老的实现类、线程安全的，但效率要低于ArrayList）
 *   |------Set接口：存储无序的，不可重复的元素。---相当于高中的“集合”概念
        >--Set使用的方法基本上都是Collection接口下定义的。
        >--添加进Set集合中的元素所在的类一定要重写equals() 和 hashCode()。
                 要求重写equals() 和 hashCode()方法保持一致。
        >--1.无序性：无序性！= 随机性。真正的无序性，指的是元素在底层存储的位置是无序的。
        >--2.不可重复性：当向Set中添加进相同的元素的时候，后面的这个不能添加进去。
 *      |------HashSet（主要的实现类）
        |------LinkedHashSet(是HashSet的子类，当我们遍历集合元素时，是按照添加进去的顺序实现的；频繁的遍历，较少的添加、插入操作建议选择此)
        |------TreeSet（可以按照添加进集合中的元素的指定属性进行排序）
        >要求TreeSet添加进的元素必须是同一个类的！
*/
public class TestSet {
    /*
     * TreeSet的定制排序：
     * >--compareTo()与hashCode()以及equals()三者保持一致！*/
    @Test
    public void testTreeSet2() {
        //1.创建一个实现了Comparater接口的类对象
        Comparator com = new Comparator() {
            //向TreeSet中添加Customer类的对象，在此compare()方法中，指明是按照Customerde的哪一个属性排序的
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof Customer && o2 instanceof Customer) {
                    Customer c1 = (Customer)o1;
                    Customer c2 = (Customer)o2;
                    int i = c1.getId().compareTo(c2.getId());
                    if(i==0) {
                        return c1.getName().compareTo(c2.getName());
                    }
                    return i;
                }
                return 0;
            }
        };
        //2.将此对象作为形参传递给TreeSet的构造器中
        TreeSet set = new TreeSet(com);
        //3.向TreeSet构造器中添加Comparator接口中的compare方法中涉及的类的对象
        set.add(new Customer("AA",1003));
        set.add(new Customer("GG",1013));
        set.add(new Customer("BB",1007));
        set.add(new Customer("HH",1001));
        set.add(new Customer("FF",1005));
        set.add(new Customer("PP",1005));

        for(Object o : set) {
            System.out.println(o);
        }

    }
    /*
     * TreeSet:
     * 1.向TreeSet中添加的元素必须同类型
     * 2.可以按照添加进集合中的元素指定的顺序遍历，默认从小到大
     * 3.当向TreeSet中添加自定义类的对象时，有两种排序方法：
     *    |--①自然排序：要求自定义类实现java.lang.Comparble接口并重写其compareTo(Object obj)的抽象方法，
     *                 在此方法中指明按照自定义类中的哪一个属性排序
     *    |--②
     * 4.向TreeSet中添加元素时，首先按照compareTo()进行比较，一旦返回0，虽然仅仅是两个对象的此属性值相同，
     *   但是程序会认为这两个对象是相同的，导致后一个对象就不能添加进去
     * >--compareTo()与hashCode()以及equals()三者保持一致！*/
    @Test
    public void testTreeSet1() {
        Set set = new TreeSet();
//      set.add(123);
//      set.add(456);/String 与Int类型不能同时存在
//      set.add("AA");
//      set.add("AA");
//      set.add("DD");
//      set.add("BB");
//      set.add("CC");
        //当Person类没有实现Comparable接口时，当向TreeSet中添加Preson对象时，报ClassCastException错
        set.add(new Person("CC",23));
        set.add(new Person("AS",24));
        set.add(new Person("AW",25));
        set.add(new Person("CG",12));
        set.add(new Person("FD",43));
        set.add(new Person("WE",22));
        set.add(new Person("TO",22));

        for(Object o:set) {
            System.out.println(o);
        }
    }

    /* 1.LinkedHashSet:使用链表维护了一个添加进集合中的顺序。导致当我们遍历LinkedHasSet集合元素时，是按照添加进去的顺序遍历的
     * 2.LinkedhashSet插入性能略低于HashSet，但在迭代访问Set里的全部元素时有很好的性能。
     * */
    @Test
    public void testLinkedHashSet() {
        Set set = new LinkedHashSet();
        set.add(123);
        set.add(456);
        set.add("AA");
        set.add("BB");
        set.add("AA");
        set.add(null);

        Iterator iterator = set.iterator();
        while(iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

    /*Set:存储的元素是无序的，不可重复的
     * 1.无序性 不等于 随机性！无序性是指元素在底层存储的位置是无序的
     * 2.不可重复性：不能向set中添加相同的元素
     * 3.添加进Set集合中的元素所在的类一定要重写equals() 和 hashCode()。 要求重写equals() 和 hashCode()方法保持一致。
     * 4.Set中元素的存储用到的算法是————哈希算法
     * 5.当向Set中添加对象时，首先调用此对象所在类的hashCoude()方法，计算此对象的哈希值，此哈希值决定了此对象在Set中的存储位置。
     *   若此位置之前没有对象存储，则这个对象直接存储到此位置，若此位置已有对象存储，再通过equals()比较这两个对象是否相同。如果
     *   相同，后一个对象就不能再添加进来。
     * >--要求：hashCode()方法要与equals()方法值一致。
     * */
    @Test
    public void testHashSet() {
        Set set = new HashSet();
        set.add(123);
        set.add(456);
        set.add("AA");
        set.add("BB");
        set.add("AA");
        set.add(null);
        Person p1 = new Person("GG",23);
        Person p2 = new Person("MM",21);
        Person p3 = new Person("MM",21);
        System.out.println(p1.hashCode());
        System.out.println(p2.hashCode());
        System.out.println(p3.hashCode());
        set.add(p1);
        set.add(p2);
        System.out.println(set.size());
        System.out.println(set);
    }

}

Person.java

package com.it.study;

public class Person implements Comparable{
    private String name;
    private Integer age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((age == null) ? 0 : age.hashCode());
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (age == null) {
            if (other.age != null)
                return false;
        } else if (!age.equals(other.age))
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    public Person(String name, Integer age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person() {
        super();
    }
    //当向TreeSet中添加Person类对象时，依据此方法确定按照哪一个属性排列
    @Override
    public int compareTo(Object o) {
        if(o instanceof Person) {
            Person p = (Person)o;
            //return this.age.compareTo(p.age);
            int i = this.age.compareTo(p.age);
            if(i == 0) {
                return this.name.compareTo(p.name);
            }else{
                return 1;
            }
        }
        return 0;
    }

}

Customer.java

package com.it.study;

public class Customer {
   private String name;
   private Integer id;
public Customer() {
    super();
}
public Customer(String name, Integer id) {
    super();
    this.name = name;
    this.id = id;
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public Integer getId() {
    return id;
}
public void setId(Integer id) {
    this.id = id;
}
@Override
public String toString() {
    return "Customer [name=" + name + ", id=" + id + "]";
}
@Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + ((id == null) ? 0 : id.hashCode());
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    return result;
}
@Override
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    Customer other = (Customer) obj;
    if (id == null) {
        if (other.id != null)
            return false;
    } else if (!id.equals(other.id))
        return false;
    if (name == null) {
        if (other.name != null)
            return false;
    } else if (!name.equals(other.name))
        return false;
    return true;
}

}