Java-集合的总结

 Collection：接口

只有通过Collection接口中toString（）进行重写，才能够System.out.print(coll)显示Collection集合中元素 

     |-----Set：元素无序，不可重复的集合

        |---hashSet（主要实现类） +LinkedHashSet（添加顺序遍历集合中元素）+TreeSet 

      Set 使用的方法基本上Collection接口下定义;  

      无序：元素底层存储的位置无序的，不重复性：添加相同元素无法添加进去

      HashSet（自定义类的重复性重写 hashCode和equals方法）：原理：向Set集合中添加元素，首先hashCode方法计算hash值，决定此对象存取的位置

 在此位置有对象，在比较equals方法----注意：重写HashCode方法：对象属性值一样保证HashCode一样，对象属性值不一样保证HashCode不一样，不要相同hashcode值但是有不同的属性值。

    Treeset:(对加入元素进行排序处理)存储对象按照ComparaTo方法进行排序 

           1.TreeSet添加元素属于同一个类型，HashSet属于不同类型

           2.两种排序： 1.自然排序 自定义类实现的是 Comparable 接口 重写ComparaTo（按照某种属性排序，属性相同按照其他属性相同） +hashCode+equals方法

                              2.定制排序：1.创建一个Comparator接口的对象（采用匿名内部类方法）     2.在此对象中重写Compare的方法在此compare方法指明按照某个属性进行排序，3.将对象作为形参 传入TreeSet构造器中。

 要求重写 comparaTo 和Compare方法 与equals和HashCode方法表持一致---hashCode和equals用于对元素的储存

---

     |--------List：元素有序，可重复：相当于动态的数组

        |----ArrayList(主要的实现类) + LinkedList(适用于频繁的插入和删除)

 　　对于Collection的contains（）方法判断依据 元素所在类的equals方法，如果元素使用自定义类的 重写自定义类中equals方法

Map 接口：具有映射关系 存放的键-值对

Key 使用set存储，不能重复；value用Collection存放，key-value 对构成entry，entry（Map.entrySet）使用Set存放

    |---HashMap：线程不安全存放null 值

    |---HashTable；线程安全的  

              |---Properties处理属性文件        ConcurrentHashMap：CAS的积极锁的操作

   |----TreeMap：按照可以所在类指定属性排序 Key必须要是同一个类型

Collections是集合的工作类，大部分static 的方法

package com.testCollection;

public class Empolyee implements Comparable{

    private String name ;
    private Integer age;
    private MyData birthday;
    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;
    }
    public MyData getBirthday() {
        return birthday;
    }
    public void setBirthday(MyData birthday) {
        this.birthday = birthday;
    }
    // 遍历的时候直接打印输出
    @Override
    public String toString() {
        return "Empolyee [name=" + name + ", age=" + age + ", birthday=" + birthday + "]";
    }
    public Empolyee(String name, Integer age, MyData birthday) {
        super();
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((age == null) ? 0 : age.hashCode());
        result = prime * result + ((birthday == null) ? 0 : birthday.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;
        Empolyee other = (Empolyee) obj;
        if (age == null) {
            if (other.age != null)
                return false;
        } else if (!age.equals(other.age))
            return false;
        if (birthday == null) {
            if (other.birthday != null)
                return false;
        } else if (!birthday.equals(other.birthday))
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    @Override
    public int compareTo(Object o) {
        if(o instanceof Empolyee)
        {
            Empolyee e1=(Empolyee) o;
            // 本对象Name与输入名字进行标胶
            int i=this.name.compareTo(e1.getName());
             if(i==0)
                 return this.age.compareTo(e1.getAge());
             else
                 return i;
            }
        return 0;
    }
    
}

@Test
    public void test2()
    {
        // 创建一个实现Comparator类 的对象 自定义类防止混淆，创建新的类，有相同的属性
        Comparator com=new Comparator(){

            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof Employee1 && o2 instanceof Employee1)
                {
                    Employee1 e1=(Employee1) o1;
                    Employee1 e2=(Employee1) o2;
                    
                    // 按照年月日比较
                    MyData birth1=e1.getBirthday();
                    MyData birth2=e2.getBirthday();
                    
                    boolean birthequals=false;
                    if(birth1.getYear()!=birth2.getYear())
                    {    return birth1.getYear()-(birth2.getYear());}
                    else
                    {
                        if(birth1.getMonth()!=birth2.getMonth())
                            return birth1.getMonth().compareTo(birth2.getMonth());
                        else
                        {
                            if(birth1.getDay()!=birth2.getDay())
                                {return birth1.getDay().compareTo(birth2.getDay());}
                            else
                                birthequals=true;
                        }
                    }
                    // 按照名字进行排序
                    
                }
                return 0;
            }
        };
            // 自定义时候传入Comparator类的对象
            TreeSet set=new TreeSet(com);
            Employee1 e11=new Employee1("刘德华",55,new MyData(4,12,1966));
            Employee1 e2=new Employee1("刘德",55,new MyData(4,12,1956));
            
            set.add(e11);
            set.add(e2);
            
            for(Object str:set)
                System.out.println(str);
            
    }