集合之Set--java23(13/01/2016)

package com.atguigu.java;

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(古老的实现类、线程安全的)
 *          |------Set接口：存储无序的，不可重复的元素
 *              |------HashSet
                |------LinkedHashSet
                |------TreeSet
 */
public class TestSet {
    
    /*
     * TreeSet的定制排序：
     * 见下面的步骤。
     * 一般使用了Comparator()方法了，就不要再用Comparable接口了
     * >compareTo()与hashCode()以及equals()三者保持一致。
     */
    
    @Test
    public void testTreeSet3(){//这样也可以，一个是有com名的，这个是匿名的。
        
        //2.将此对象作为形参传递给TreeSet的构造器中
        TreeSet set = new TreeSet(new Comparator(){
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof Customer && o2 instanceof Customer) {
                    Customer c1 = (Customer)o1;
                    Customer c2 = (Customer)o2;
                    //return c1.getName().compareTo(c2.getName());同样存在该属性相同则无法添加情况
                    int i = c1.getId().compareTo(c2.getId());
                    if (i == 0) {
                        return c1.getName().compareTo(c2.getName());
                    }else {
                        return i;
                    }
                }
                return 0;
            }   
            
            
        });
        
        //3.向TreeSet中添加Comparator接口中的compare方法中设计的类的对象。
        set.add(new Customer("AA",1003));
        set.add(new Customer("BB",1002));
        set.add(new Customer("GG",1004));
        set.add(new Customer("CC",1001));
        set.add(new Customer("DD",1001));
        
        for(Object str:set){
            System.out.println(str);
        }
    }
    
    
    
    @Test
    public void testTreeSet2(){
        //1.创建一个实现了Comparator接口的类对象
        Comparator com = new Comparator() {
            //向TreeSet中添加Customer类的对象，在此compare()方法中，指明是按照Customer的那个属性排序的

            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof Customer && o2 instanceof Customer) {
                    Customer c1 = (Customer)o1;
                    Customer c2 = (Customer)o2;
                    //return c1.getName().compareTo(c2.getName());同样存在该属性相同则无法添加情况
                    int i = c1.getId().compareTo(c2.getId());
                    if (i == 0) {
                        return c1.getName().compareTo(c2.getName());
                    }else {
                        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("BB",1002));
        set.add(new Customer("GG",1004));
        set.add(new Customer("CC",1001));
        set.add(new Customer("DD",1001));
        
        for(Object str:set){
            System.out.println(str);
        }
    }
    
    /*
     * TreeSet:
     * 1.向TreeSet中添加的元素必须是同一个类的。否则就会报错。
     * 2.可以按照添加进集合中的元素的指定的顺序遍历。像String， 包装类等默认按照从小到大的顺序遍历。
     * 3.当向TreeSet中添加自定义类的对象时，有两种排序方法：①自然排序②定制排序
     * 4.自然排序：要求自定义类实现java.lang.Comparable接口，并重写compareTo(Object obj)
     * 在此方法中，指明按照自定义类的哪个属性进行排序。
     * 
     * 5.向TreeSet中添加元素时，首先按照compareTo()进行比较，一旦返回0，虽然仅是两个对象的此属性值相同，
     * 但是程序会认为这两个对象是相同的，进而后一个对象就不能添加进来。
     * 
     * >compareTo()与hashCode()以及equals()三者保持一致。
     */
    @Test
    public void testTreeSet1(){
        Set set = new TreeSet();
        
//      //情况一：添加的都是String字符串
//      set.add(new String("AA"));//Object类型
//      set.add(new String("AA"));
//      set.add("AA");//不可重复性,与是否写成new没有关系
//      set.add("BB");
//      set.add("JJ");
//      set.add("GG");
        
        //当Person类没有实现Comparable接口时，应当想TreeSet中添加Person对象时，报ClassCastException错误
        //上面的字符串没有报出这个错误，是因为String本身已经重写了这个方法
        set.add(new Person("AA",33));
        set.add(new Person("BB",37));
        set.add(new Person("FF",42));
        set.add(new Person("JJ",14));
        set.add(new Person("DD",28));//在Person中添加以后按名字的大小排列
        set.add(new Person("DD",30));//若判断的第一个属性相同，则只会输出一个，所以需要根据第二个属性进行判断
        //set.add("GG");//属性不一致会出错，但是并不会在编译的时候出错，只会在运行的时候才报出来。
        
        for(Object str:set){
            System.out.println(str);
        }
        
    }
    /*
     * LinkedHashSet:使用链表维护了一个添加进集合中的顺序。
     * 导致当我们遍历LinkedHashSet集合元素时，是按照添加进去的顺序遍历的。(在底层的位置还是无序的)
     * 
     * LinkedHashSet插入性能略低于HashSet，但在迭代访问Set里的全部元素时，有很好的性能。
     */
    @Test
    public void testLinkedHashSet(){
        Set set = new LinkedHashSet();
        set.add(123);
        set.add(456);
        set.add(new String("AA"));
        set.add(new String("AA"));
        set.add("AA");//不可重复性,与是否写成new没有关系
        set.add("BB");
        set.add(null);
        
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());            
        }//123 456 AA BB null
        
    }
    /*
     * Set:存储的元素是无序的，不可重复的！
     * 1.无序性：无序性 ！= 随机性。真正的无序性，指的是元素在底层的位置是无序的。
     * 2.不可重复性：当向Set中添加进相同的元素的时候，后面的这个不能添加进去
     * 
     * 说明：要求添加进Set中的元素所在的类，一定要重写equals()和hashCode()方法。
     *           进而保证Set中元素的不可重复性！
     * 
     * Set中的元素是如何存储的呢？使用了哈希算法。
     * 当向Set中添加对象时，首先调用此对象所在类的hashCode()方法，计算此对象的哈希值，此哈希值
     * 决定了此对象在Set中的存储位置。若此位置之前没有对象存储，则这个对象直接存储到此位置。
     * 若此位置已有对象存储，再通过equals()方法比较这两个对象是否相同。如果相同，后一个对象就不能再添加进来。
     * 万一返回false呢，都存储。(不建议如此)
     * >要求：hashCode()方法要与equals()方法一致。
     */
    @Test
    public void testHashSet(){
        Set set = new HashSet();
        set.add(123);
        set.add(456);
        set.add(new String("AA"));
        set.add(new String("AA"));//只显示一遍
        set.add("AA");//不可重复性,与是否写成new没有关系
        set.add("BB");
        set.add(null);
        Person p1 = new Person("GG",21);
        Person p2 = new Person("GG",21);
        System.out.println(p1.hashCode());
        System.out.println(p2.hashCode());
        set.add(p1);
        set.add(p2);
        System.out.println(set.size());
        System.out.println(set);
    }
}

package com.atguigu.java;

public class Person implements Comparable{

    private String name;
    private Integer age;

    public Person() {
        super();
    }

    public Person(String name, Integer age) {
        super();
        this.name = name;
        this.age = 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 String toString() {
        return "Person [name=" + name + ", 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;
    }

    //当向TreeSet中添加Person类的对象时，依据此方法，确定按照哪个属性排序
    @Override
    public int compareTo(Object o) {
        if (o instanceof Person) {
            Person p = (Person)o;
            //return this.name.compareTo(p.name);
            //return -this.age.compareTo(p.age);一旦出现要判断的属性相同时，只会输出第一个，而后面相同的则
            //不会输出，所以要先进行一下判断,若相同，可以根据第二个属性进行判断
            int i = this.name.compareTo(p.name);
            if (i == 0) {
                return this.age.compareTo(p.age);
            }else {
                return i;
            }
        }
        return 0;
    }
    
    
}

package com.atguigu.java;

public class Customer {
    private String name;
    private Integer 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;
    }
    public Customer(String name, int id) {
        super();
        this.name = name;
        this.id = id;
    }
    public Customer() {
        super();
    }
    @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;
        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 != other.id)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    
    
    
}