【Java总结-集合】Java集合的Collection接口，ArrayList，LinkedList，HashSet，TreeSet

Java集合

1. Collection接口
2. Map接口：具有映射关系的“key-Value对”，类似于函数，一个key对象一个Value

Java的Collection接口

Collection接口关系图：

1. Set接口：元素没有顺序，不可以重复的结合类似高中的集合
2. List接口：元素有顺序，但是可以重复动态数组

结合元素的遍历

使用Itertor接口

适用于所有的Collection对象，包括其子接口实现类的对象

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

使用增强for循环

for(Person p : persons) {//persons为集合
    System.out.println(p.getName());
}

List接口

特点：元素有顺序，可以重复

ArrayList

ArrayList类是List的一个实现类，线程不安全的，底层是使用的变长数组

LinkedList

LinkedList是List的一个实现类，对于频繁的插入删除操作，建议使用LinkedLIst,底层使用的链表

Vector

线程安全的，太老了，不建议使用

Set接口

特点：元素没顺序，不可以重复

HashSet

HashSet是Set接口的一个典型实现，大多数使用Set的时候都是使用这个类的

特点：

1. 不能保证元素的排列顺序，遍历是打印出来的不一定是插入的顺序
2. HashSet不是线程安全的
3. 集合元素可以是null

关于存储顺序
当想HashSet集合中存放一个元素的时候，HashSet会调用该对象的HashCode()方法来得到该对象那个的hashcode值决定这个对象存储的位置。

判断两个元素相等：
两个对象通过HashCode()方法比较相等，并且两个对象的equals()方法返回也要相等
所以Set集合要求重写对象的equals()方法和HashCode()方法。

LinkedHashSet

• LinkedHashSet是HashSet的子类
• LinkedHashSet根据元素的HashCode值来决定元素的存放位置，但是他使用的是链表，所以遍历的时候，看起来元素还是按照原来插入顺序保存的
• 插入性能低，访问性能高

TreeSet

TreeSet是SortedSet接口的实现类，插入的元素会按照一定的规则排列顺序

1. 往里添加的元素必须是同一个类型的，要么全是integer类型要么我全是String类型的。
2. 可以按照指定的顺序遍历，像String是按照从小到大的顺序遍历的
3. 对于自定义的类遍历，必须实现排序方式,不然TreeSet不知道按照什么方法遍历元素，所以插不进去，
4. 自定义类有两种方法，1，自然排序 2，定制排序 （定制排序）关于这两个排序参考笔记（TreeSet中的自然排序和定制排序）
5. 往TreeSet中添加元素的时候会首先比较compareTo()方法，一旦返回0，虽然两个对象仅仅此属性相同，但是程序还是会认为这两个元素是相同的，所以后面那个元素无法插入集合中！
6. 添加到treeSet中的元素类必须保证compareTo()方法，HashCode()方法还有equals()方法一致

TreeSet有两种排序方式
要想插入TreeSet中，对象必须至少实现了下面两种排的中一种，这样集合才知道怎么排列这些元素，并且插入的这个元素必须是同一种类型
1. 自然排序（默认情况）
2. 定制排序

自然排序

1. 实现Comparable接口
2. 重写compareTo()方法
3. 重写hashCode()，equals()方法
4. 保证compareTo()，hashCode()，equals()方法一致

public class Employee implements Comparable{
    private String name;
    private int age;
    private MyDate birthday;
    //重写compareTo方法
    @Override
    public int compareTo(Object o) {
        if(o instanceof Employee) {
            Employee e = (Employee)o;
            return this.getName().compareTo(e.getName());
        }
        return 0;
    }
    //重写hashCode()方法
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result
                + ((birthday == null) ? 0 : birthday.hashCode());
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    //重写equals()方法
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Employee other = (Employee) obj;
        if (age != 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;
    }   
}

定制排序

TreeSet的自然排序是根据元素大小进行升序排列的，如果想要按照降序排列的话就需要定制排序

1. 构造TreeSet对象的时候，将COmparator接口的实例作为形参，传递给TreeSet的构造器
2. 重写compare方法
3. compare(T t1, T t2);返回0则t1 = t2; 返回1 则t1 > t2

TreeSet set = new TreeSet(new Comparator() {
    //重写compare方法
    @Override
    public int compare(Object o1, Object o2) {
        if(o1 instanceof Employee && o2 instanceof Employee) {
            Employee e1 = (Employee)o1;
            Employee e2 = (Employee)o2;
            return e1.getName().compareTo(e2.getName());
        }
        return 0;
    }

});