集合(Collection接口)

一、集合与数组

1. 集合与数组存储数据概述：

集合、数组都是对多个数据进行存储操作的结构，简称Java容器。 说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储

2. 数组存储的特点：

一旦初始化以后，其长度就确定了。 数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。

3. 数组存储的弊端：

1. 一旦初始化以后，其长度就不可修改。
2. 数组中提供的方法非常限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
3. 获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
4. 数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。

4. 集合存储的优点：解决数组存储数据方面的弊端。

5. 集合的分类：

Java集合可分为Collection和Map两种体系

• Collection接口：单列数据，定义了存取一组对象的方法的集合
  • List：元素有序、可重复的集合
  • Set：元素无序、不可重复的集
• Map接口：双列数据，保存具有映射关系“key-value对”的集合

6. 集合的框架结构

|----Collection接口：单列集合，用来存储一个一个的对象
     |----List接口：存储有序的、可重复的数据。  -->“动态”数组
           |----ArrayList：作为List接口的主要实现类，线程不安全的，效率高;底层采用Object[] elementData数组存储
           |----LinkedList：对于频繁的插入删除操作，使用此类效率比ArrayList效率高底层采用双向链表存储
           |----Vector：作为List的古老实现类，线程安全的，效率低;底层采用Object[]数组存储
           
     |----Set接口：存储无序的、不可重复的数据   -->数学概念上的“集合”
           |----HashSet：作为Set接口主要实现类;线程不安全;可以存null值
           		|----LinkedHashSet：作为HashSet的子类;遍历其内部数据时，可以按照添加顺序遍历;对于频繁的遍历操作，LinkedHashSet效率高于HashSet.
           |----TreeSet：可以按照添加对象的指定属性，进行排序。


|----Map:双列数据，存储key-value对的数据   ---类似于高中的函数：y = f(x)
     |----HashMap:作为Map的主要实现类；线程不安全的，效率高；存储null的key和value
          |----LinkedHashMap:保证在遍历map元素时，可以照添加的顺序实现遍历。
                    原因：在原的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。
                    对于频繁的遍历操作，此类执行效率高于HashMap。
     |----TreeMap:保证照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序
                      底层使用红黑树
     |----Hashtable:作为古老的实现类；线程安全的，效率低；不能存储null的key和value
          |----Properties:常用来处理配置文件。key和value都是String类型

二、Collection接口

• Collection接口是List、Set和Queue接口的父接口，该接口里定义的方法既可用于操作Set集合，也可用于操作List和 Queue集合。
• JDK不提供此接口的任何直接实现，而是提供更具体的子接口（如：Set和List）实现。
• 在JDK 5.0之前，Java集合会丢失容器中所有对象的数据类型，把所有对象都当成 Object类型处理；从JDK 5.0增加了泛型以后，Java集合可以记住容器中对象的数据类型。

1. 单列集合框架结构

2. Collection接口常用方法：

添加
    add(Object obj)
    addAll(Collection coll)
获取有效元素个数
    int size()
清空集合
    void clear()
是否为空集合
    boolean isEmpty()
是否包含某个元素
    boolean contains(Object obj):是通过元素的equals方法来判断是否是同一个对象
    boolean containsAll(Collection c):也是调用元素的equals方法来比较的。用两个两个集合的元素逐一比较
删除
    boolean remove(Object obj):通过元素的equals方法判断是否是要删除的那个元素。只会删除找到的第一个元素
    boolean removeAll(Collection coll):取当前集合的差集
取两个集合的交集
    boolean retainAll(Collection c):把交集的结果存在当前的集合中，不影响c
集合是否相等
    boolean equals(Object obj)
转换成对象数组
    Object [] toArray()
获取集合对象的哈希值
    hashCode()
遍历
    iterator():返回迭代器对象，用于集合遍历

3. Collection集合与数组间的转换(toArray 和 Arrays.asList)

//集合 --->数组：toArray()
Object[] arr = coll.toArray();
for(int i = 0;i < arr.length;i++){
    System.out.println(arr[i]);
}

//数组 --->集合:调用Arrays类的静态方法asList(T ... t)
List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
System.out.println(list);

List arr1 = Arrays.asList(new int[]{123, 456});//注意！！：list存的是整个数组的那个对象
System.out.println(arr1.size());//1

List arr2 = Arrays.asList(new Integer[]{123, 456});
System.out.println(arr2.size());//2

三、Iterator接口与foreach循环

1. 遍历Collection的两种方式：

使用迭代器Iterator

foreach循环（或增强for循环）：只能用来遍历Collection接口

2.迭代器接口：Iterator

java.utils包下定义的，Iterator对象称为迭代器。主要用于遍历 Collection 集合中的元素

3.主要方法：

hasNext():判断是否还下一个元素

next():①指针下移 ②将下移以后集合位置上的元素返回

remove()：移除当前指针指向的元素

4.注意：

如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法，再调用remove都会报IllegalStateException。此方法不同于集合直接调用remove()

5.foreach循环（JDK 5.0新特性）

方式：for(集合元素的类型 局部变量 : 集合对象)

for(Object obj : coll){
    System.out.println(obj);
}

也可以用来遍历数组：

public void test2(){
    int[] arr = new int[]{1,2,3,4,5,6};
    //for(数组元素的类型 局部变量 : 数组对象)
    for(int i : arr){
        System.out.println(i);
    }
}

注意:foreach不能用来赋值，使用的是局部变量。

@Test
public void test(){
    int[] arr = new int[]{1,2,3,4,5};
    for (int i = 0; i < arr.length; i++) {
        arr[i] = 6;
    }
    for (int i : arr) {
        i = 7;
    }
}

四、Collection子接口：List接口

1. 存储的数据特点：有序集合，集合中的元素可以重复。

• 鉴于Java中数组用来存储数据的局限性，我们通常使用List替代数组。
• List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。
• List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
• List接口的实现类常用的有：ArrayList、LinkedList和 Vector（Stack继承自Vector）。

2.常用方法：List除了从 Collection集合继承的方法外，List集合里添加了一些根据索引来操作集合元素的方法。

void add(int index, Object ele):在index位置插入ele元素
boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
Object get(int index):获取指定index位置的元素
int indexOf(Object obj):返回obj在集合中首次出现的位置
int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
Object remove(int index):移除指定index位置的元素，并返回此元素
Object remove(Object obj)：删除obj这个元素，如果元素是数字，要new Integer(number)
Object set(int index, Object ele):设置指定index位置的元素为ele
List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合

3.ArrayList

ArrayList是List接口的典型实现类、主要实现类

本质上，ArrayList是对象引用的一个”变长”数组

Arrays.asList（...）方法返回的List集合，既不是 ArrayList实例，也不是Vector实例。Arrays.asList（...）返回值是一个固定长度的List集合

4.ArrayList的源码分析：

JDK 1.7情况下

ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData
list.add(123);//elementData[0] = new Integer(123);
...
list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容。

• 默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。

• 结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)

JDK 1.8中ArrayList的变化：

ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}.并没创建长度为10的数组
list.add(123);//第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]
...

后续的添加和扩容操作与JDK 1.7 无异。

总结：

JDK 1.7 中的ArrayList的对象的创建类似于单例的饿汉式，而JDK 1.8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。

5.linkedList

对与对于频繁的插入和删除元素操作，建议使用LinkedList类，效率更高

底层使用双向链表实现。

新增方法：

void addFirst(Object obj)
void addLast(Object obj)
Object getFirst()
Object getlast()
Object removeFirst()
Object removeLast()

6.ArrayList/LinkedList/Vector的异同

• ArrayList和 Linkedlist的异同：

  二者都线程不安全，相比线程安全的 Vector，ArrayList执行效率高。 此外，ArrayList是实现了基于动态数组的数据结构，Linkedlist基于链表的数据结构。对于随机访问get和set，ArrayList觉得优于Linkedlist，因为Linkedlist要移动指针。对于新增和删除操作add（特指插入）和 remove，Linkedlist比较占优势，因为 ArrayList要移动数据。

• ArrayList和 Vector的区别：

  Vector和ArrayList几乎是完全相同的，唯一的区别在于Vector是线程安全的，访问要慢。正常情况下，大多数的Java程序员使用ArrayList而不是Vector，因为线程安全可以由程序员自己来控制。Vector每次扩容请求其大小的2倍空间，而ArrayList是1.5倍。

五、Collection子接口：Set接口

• Set接口是Collection的子接口，set接口没有提供额外的方法
• Set集合不允许包含相同的元素，如果试把两个相同的元素加入同一个Set集合中，则添加操作失败。（多用于过滤操作，去掉重复数据）
• Set判断两个对象是否相同不是使用==运算符，而是根据equals()方法

1、Set数据存储特点

用于存放无序的、不可重复的元素

以HashSet为例说明：

1. 无序性：不等于随机性。存储的数据在底层数组中并非照数组索引的顺序添加，而是根据数据的哈希值决定的。
2. 不可重复性：保证添加的元素照equals()判断时，不能返回true.即：相同的元素只能添加一个。

2、元素添加过程（HashSet为例）

我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断

数组此位置上是否已经有元素：

• 如果此位置上没有其他元素，则元素a添加成功。 --->情况1
• 如果此位置上有其他元素b(或以链表形式存在的多个元素），则比较元素a与元素b的hash值：
  • 如果hash值不相同，则元素a添加成功。--->情况2
  • 如果hash值相同，进而需要调用元素a所在类的equals()方法：
    • equals()返回true,元素a添加失败
    • equals()返回false,则元素a添加成功。--->情况3

对于添加成功的情况2和情况3而言：元素a 与已经存在指定索引位置上数据以链表的方式存储。

无序集合，集合中的元素不可以重复，访问集合中的元素只能根据元素本身来访问（也是集合里元素不允许重复的原因）

3、注意：向Set中添加的数据，其所在的类一定要重写hashCode()和equals()方法。

4.HashSet

• Hashset是Set接口的典型实现，大多数时候使用Set集合时都使用这个实现类。
• 底层采用HashMap进行存储。key的位置上存值，value上是个不变的对象。
• 无序性指：元素插入的顺序与输出的顺序不一致。
• HashSet按Hash算法来存储集合中的元素，因此具有很好的存取、查找、删除性能。
• HashSet具有以下特点：
  • 不能保证元素的排列顺序
  • HashSet不是线程安全的
  • 集合元素可以是null，且只能有一个
• HashSet集合判断两个元素相等的标准：两个对象通过hashCode()方法比较相等，并且两个对象的equals()方法返回值也相等。
• 对于存放在Set容器中的对象，对应的类一定要重写equals()和hashCode(Object obj)方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码”
• 添加的时候，先比较hash值，再equals方法

public void test(){
    Set set = new HashSet();
    set.add(1);
    set.add("abc");
    set.add(new Person("Tom"));
    for (Object o : set) {
        System.out.println(o);
    }
}

5、LinkedHashSet

• LinkedhashSet是HashSet的子类

• LinkedhashSet根据元素的hashCode值来决定元素的存储位置但它同时使用双向链表维护元素的次序，这使得元素看起来是以插入顺序保存的。

• LinkedhashSet插入性能略低于HashSet，但在迭代访问Set里的全部元素时有很好的性能。

• LinkedhashSet不允许集合元素重复。

• 对于频繁的遍历LinkedhashSet效率高于HashSet

6、TreeSet

• Treeset是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态。

• TreeSet底层使用红黑树结构存储数据

• TreeSet两种排序方法：自然排序（实现Comparable接口 ）和定制排序（Comparator）。

• 向TreeSet中添加的数据，要求是相同类的对象

• TreeSet集合不是通过hashcode和equals函数来比较元素的.它是通过compare或者comparaeTo函数来判断元素是否相等.compare函数通过判断两个对象是否相同。（若比较器只比较一个对象(有多个属性)的id属性，若id相同，同样也被认为相同）

自然排序：

@Override
    public int compareTo(Object o) {
        if(o instanceof Person){
            Person u = (Person)o;
            if(this.getAge() != u.getAge()){
                return this.getAge() - u.getAge();
            }else{
                return this.getName().compareTo(u.getName());
            }
        }else{
            throw new RuntimeException("输入的数据类型不匹配");
        }
    }

定制排序:

TreeSet set = new TreeSet(new Comparator() {
            //照年龄从小到大排列,如果年龄相同，用姓氏排序
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof Person && o2 instanceof Person){
                    Person u1 = (Person)o1;
                    Person u2 = (Person)o2;
                    if(u1.getAge() != u2.getAge()){
                        return u1.getAge() - u2.getAge();
                    }else{
                        return u1.getName().compareTo(u2.getName());
                    }
                }else{
                    throw new RuntimeException("输入的数据类型不匹配");
                }
            }
        });

7、练习

1. 在List中去掉重复的元素，尽量简洁

public class Main{
    public static void main(String[] args) {
        List list1 = new ArrayList();
        list1.add(1);
        list1.add(1);
        list1.add(2);
        list1.add(2);
        List list2 = f(list1);
        for (Object o : list2) {
            System.out.println(o);
        }
    }

    private static List f(List list1) {
        HashSet set = new HashSet();//利用set来去重
        set.addAll(list1);
        return new ArrayList(set);
    }
}

1. set的添加问题

public class Main{
    public static void main(String[] args) {
        HashSet set = new HashSet();
        Person p1 = new Person(1001, "AA");
        Person p2 = new Person(1002, "BB");
        set.add(p1);
        set.add(p2);
        p1.setName("CC");//名字改变之后但是它的hash值不会变
        set.remove(p1);//会通过p1的hash值去找，因为名字改变过后，hash值改变了，所以找不到原来的p1
        System.out.println(set);//依然还是有两个对象

        set.add(new Person(1001, "CC"));//CC的hash值，位置上不是p1，可以加
        System.out.println(set);
        set.add(new Person(1001, "AA"));//位置上是原来的AA后来改为CC了，但是调用equals方法的时候，发现两个不一样，所有可以加
        System.out.println(set);
    }
}
class Person{
    int id;
    String name;

    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return id == person.id &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name);
    }
}