集合框架和分析

集合框架可以分为两个部分：Collection和Map，详细的框架图如下：

我们先来分析一下Collection集合框架，Collection包括两大体系List和Set，其中List中的元素存取有序、元素可重复、有索引，可以根据索引获取值，Set的元素存取无序、不能存储重复元素。

List下面有有三个实现类ArrayList、vector、LinkedList，ArrayList和Vector底层是数组，LinkedList底层实现是链表。

ArrayList和Vector底层是数组实现，能够根据索引直接获取值，所以查找快，但是删除和添加操作慢，因为需要向前或向后挪动多个元素。Vector是旧版本的，线程安全，所以如果是单线程进行存取，最好用ArrayList，效率快，如果是多线程我们最好用Vector来进行存储，因为Vector里面的方法是线程安全的。

LinkedList是基于链表实现的，查找必须从头开始，所以查找速度慢，但是删除和添加只需要挪动两个节点，所以删除和添加速度快。链表提供了特殊的方法，所以链表可以实现栈或者队列。

Set接口有三个实现类HashSet、LinkedHashSet、TreeSet

HashSet集合存储不重复，无序，原理是什么？因为HashSet底层实现是哈希表，哈希表通过hashCode()和equals()方法来共同保证元素不重复。首先根据存储的元素算出hashCode值，然后根据算出的hashCode值和数组的长度算出存储的下标；如果下标位置无元素，那么直接存储，如果有元素，那么就要使用存入的元素和已经存在的元素进行equals方法进行比较，如果结果为真就不存储，如果为假就进行存储，以链表方式进行存储。

注意：一般我们自定义的类都需要重新写hashCode()和equals()，必须要重写Object类的这两个方法，因为hash值是根据存储的元素获得的

如：

@Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + age;
    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 != other.age)
        return false;
    if (name == null) {
        if (other.name != null)
            return false;
    } else if (!name.equals(other.name))
        return false;
    return true;
}

LinkedHashSet基于链表和哈希表实现的，所以具有存取有序，元素唯一的特点。

package cn.yqg.day4;

public class Person {
  private int age ;
  private String name;
  public Person(int age,String name) {
      this.age=age;
      this.name=name;
  }
  
@Override
public String toString() {
    return "Person [age=" + age + ", name=" + name + "]";
}

@Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + age;
    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 != other.age)
        return false;
    if (name == null) {
        if (other.name != null)
            return false;
    } else if (!name.equals(other.name))
        return false;
    return true;
}
}

package cn.yqg.day4;


import java.util.Iterator;
import java.util.LinkedHashSet;

public class Test {
    public static void main(String[] args) {
        LinkedHashSet<Person> list=new LinkedHashSet<>();
        list.add(new Person(1,"12"));
        list.add(new Person(1,"12"));
        list.add(new Person(3,"14"));
        list.add(new Person(4,"15"));
        
        Iterator<Person> it=list.iterator();
        while(it.hasNext()) {
            Person p=it.next();
            System.out.println(p);
        }
    }
}

运行结果：

Person [age=1, name=12]
Person [age=3, name=14]
Person [age=4, name=15]

TreeSet：特点存取无序，元素唯一，可以进行排序；TreeSet是基于二叉树实现。

存储过程：如果是第一个元素，直接存入，作为根节点，下一个元素进来就会进行比较，如果大于加点就放在节点右边，如果小于节点就放在节点左边，等于节点就不存储，后面的元素会依次进行比较直到有存储的位置为止。

package cn.yqg.day4;

import java.util.TreeSet;

public class Test2 {
    public static void main(String[] args) {
        TreeSet<String> set=new TreeSet<>();
        set.add("abd");
        set.add("abc");
        set.add("bcd");
        set.add("bce");
        set.add("bce");
        
        for(String str : set) {
            System.out.println(str);
        }
    }
}

运行结果：

abc
abd
bcd
bce

TreeSet保证元素唯一有两种方式：

1.自定义对象实现Comparable()接口，重写CompareTo()方法，该方法返回0表示相等，大于0表示存入的元素比被比较的元素大。反之小于0。

2.在创建TreeSet的时候向构造器中传入比较器Comparator接口实现类的对象，实现Comparator接口重写compare方法。

如果向TreeSet中存储自定义类没实现Comparable接口，或者没有传入Comparator比较器时，会出现ClassCastException异常。

下面演示用两种方式存储自定义对象

package cn.yqg.day4;

import java.util.TreeSet;

public class Test4 {
   public static void main(String[] args) {
     TreeSet<Person> treeSet=new TreeSet<>();
     treeSet.add(new Person(4,"1"));
     treeSet.add(new Person(1,"张三"));
     treeSet.add(new Person(1,"李四"));
     treeSet.add(new Person(3,"大王"));
     treeSet.add(new Person(2,"小王"));
     treeSet.add(new Person(3,"大王"));
     treeSet.add(new Person(4,"1"));
     treeSet.add(new Person(4,"1"));
     
     for(Person p : treeSet) {
         System.out.println(p);
     }
}
}

package cn.yqg.day4;

public class Person implements Comparable<Person>{
  private int age ;
  private String name;
  public Person(int age,String name) {
      this.age=age;
      this.name=name;
  }
  
@Override
public String toString() {
    return "Person [age=" + age + ", name=" + name + "]";
}

@Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + age;
    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 != 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 int compareTo(Person o) {
    int rusult=this.age-o.age;
    if(rusult==0) {
        return this.name.compareTo(o.name);
    }
    return rusult;
}

}

另一种方式：使用比较器Comparator

package cn.yqg.day4;

import java.util.Comparator;
import java.util.TreeSet;

public class Test5 {
   public static void main(String[] args) {
    TreeSet<Person2> treeSet2=new TreeSet<>(new Comparator<Person2>() {

        @Override
        public int compare(Person2 o1, Person2 o2) {
            if(o1==o2) {
                return 0;
            }
            int result=o1.getAge()-o2.getAge();
            if(result==0) {
                return o1.getName().compareTo(o2.getName());
            }
            return result;
        }
        
    });
    treeSet2.add(new Person2(1,"张三"));
    treeSet2.add(new Person2(5,"小龙"));
    treeSet2.add(new Person2(4,"3"));
    treeSet2.add(new Person2(5,"小庆"));
    treeSet2.add(new Person2(4,"1"));
    treeSet2.add(new Person2(1,"1"));
    
    for(Person2 p : treeSet2) {
        System.out.println(p);
    }
  }
}

package cn.yqg.day4;

public class Person2 {
    private int age ;
      private String name;
      public Person2(int age,String name) {
          this.age=age;
          this.name=name;
      }
      
    @Override
    public String toString() {
        return "Person [age=" + age + ", name=" + name + "]";
    }

    
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

}

运行结果：

Person [age=1, name=1]
Person [age=1, name=张三]
Person [age=4, name=1]
Person [age=4, name=3]
Person [age=5, name=小庆]
Person [age=5, name=小龙]

-------------------------------------------------------------------------------------------------------------------

Collection体系总结：

List：“特点”，存取有序，可存重复值，元素有索引。

ArrayList：数组结构，查询速度快，增删慢，线程不安全，效率高。

Vector：数组结构，查询快，增删慢，线程安全，效率低。

LinkedList：链表结构，增删快，查询慢，线程不安全，效率高。

Set：“特点”，存取无序，不可存重复值，无索引。

HashSet：哈希表，存储无序，元素不重复，无索引。

LinkedHashSet：链表加哈希表，存储有序，无索引，值不重复。

TreeSet：二叉树，元素不重复，存取无序，但是可以进行排序。

两种排序方式：

1.自然排序：我们的元素必须实现Comparable接口，实现CompareTo()方法。

2.比较器排序：我们自定义的类实现Comparator接口，比较器实现Compare方法。然后创建TreeSet的时候把比较器对象当做参数传递给TreeSet。

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

现在我们来看看Map集合框架

Map是一个双列集合，保存的是键值对，键要求保持唯一性，值可以重复。键值一一对应。Map存储是将键值传入Entry，然后存储Entry对象。

Map接口实现类有三个，分别为HashMap、TreeMap、LinkedHashMap。

HashMap:是基于hash表实现的，所以存储自定义对象作为键时，必须重写hashCode和equals方法。存取无序

package cn.yqg.day4;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;

public class Test6 {
   public static void main(String[] args) {
    HashMap<Person,String> map=new HashMap<Person,String>();
    map.put(new Person(1,"pp"),"java");
    map.put(new Person(2,"kk"),"c");
    map.put(new Person(1,"pp"),"c++");
    map.put(new Person(3,"ll"),"java");
    
    Set<Entry<Person,String>> entrySet=map.entrySet();
    Iterator<Entry<Person,String>> it=entrySet.iterator();
    while(it.hasNext()) {
        Entry<Person,String> entry=it.next();
        System.out.println(entry.getKey()+"-----"+entry.getValue());
    }
}
}

结果：

Person [age=1, name=pp]-----c++
Person [age=3, name=ll]-----java
Person [age=2, name=kk]-----c

我们发现如果键重复，后面的值会覆盖前面的值。存取无序。

LinkedHashMap：用法基本和HashMap一致，基于链表和哈希表来实现的，所以有存取有序，键不重复的特点。

package cn.yqg.day4;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map.Entry;

public class Test7 {
         public static void main(String[] args) {
         LinkedHashMap<Person,String> map=new LinkedHashMap<Person,String>();
            map.put(new Person(1,"pp"),"java");
            map.put(new Person(2,"kk"),"c");
             map.put(new Person(1,"pp"),"c++");
             map.put(new Person(1,"pp"),"R");
             for(Entry<Person,String> entry : map.entrySet()) {
                 System.out.println(entry.getKey()+"-----"+entry.getValue());
             }
        }
}

实现结果：

Person [age=1, name=pp]-----R
Person [age=2, name=kk]-----c

我们注意到键如果相同，值会被后面的覆盖掉。而且存取有序。

TreeMap集合存储自定义对象，自定义对象始终作为TreeMap的key值，由于TreeMap底层实现是二叉树，所有存进去的数据都要进行排序，排序有两种方法，一种自定义类实现Comparable接口，实现CompareTo方法，另一种实现Comparator接口，实现自定义比较器Compare方法。

package cn.yqg.day4;

import java.util.Comparator;
import java.util.TreeMap;
import java.util.Map.Entry;

public class Test8 {
    public static void main(String[] args) {
        TreeMap<Person,String> map=new TreeMap<>(new Comparator<Person>() {

            @Override
            public int compare(Person o1, Person o2) {
                if(o1==o2) {
                    return 0;
                }
                int result=o1.getAge()-o2.getAge();
                if(result==0) {
                    result=o1.getName().compareTo(o2.getName());
                }
                return result;
            }
            
        });
        
        map.put(new Person(1,"pp"),"java");
          map.put(new Person(2,"kk"),"c");
           map.put(new Person(6,"pp"),"c++");
           map.put(new Person(0,"pp"),"R");
        map.put(new Person(-7,"pp"),"jsp");
        map.put(new Person(0,"pp"),"js");
        for(Entry<Person,String> entry : map.entrySet()) {
             System.out.println(entry.getKey()+"-----"+entry.getValue());
         }
    }
}

运行结果：
Person [age=-7, name=pp]-----jsp
Person [age=0, name=pp]-----js
Person [age=1, name=pp]-----java
Person [age=2, name=kk]-----c
Person [age=6, name=pp]-----c++