69期-Java SE-015_集合-1-001-002

### Collection

接口，一个Collection存储一组无序、不唯一的对象，一般不会直接使用该接口。

Collection 常用方法

- int size()                                    获取集合的长度
- boolean isEmpty()                                                       判断集合是否为空
- boolean contains(Object o)                                       判断集合中是否存在某个对象
- Iterator<E> itertor()                                                    实例化Iterator接口，遍历集合
- Object[] toArray()                                                         将集合转换为一个Object类型的数组
- boolean add(Object o)                                                向集合中添加元素
- boolean remove(Object o)                                         从集合中删除元素
- boolean containsAll(Collection c)                              判断集合中是否存在某个集合的所有元素
- boolean addAll(Collection c)                                      向集合中添加某个集合的所有元素
- boolean removeAll(Collection c)                               从集合中移除某个集合的所有元素
- void clear()                                                                    清空集合，删除集合中的所有元素
- boolean equals(Object o)                                           比较两个集合是否相等
- int hashCode()                                                             返回集合的hash值

### Collection 的子接口

- List：存放有序、不唯一的元素。
- Set：存放无序、唯一的元素。
- Queue：队列集合。

#### List接口

List是Collection主要的子接口，一个List可以存储一组有序、不唯一的对象。

List接口在继承Collection接口的基础之上，进行啦了方法扩展。

- Object get(int index)                                            通过下标获取集合中指定位置的元素。
- Object set(int index,Object o)                            向集合中指定位置添加元素，如果该位置已存在某个元素，则直接替换
- int indexOf(Object o)                                           查找某个对象在集合中的具体位置
- ListIterator<E> listIterator()                               实例化ListIterator对象
- List<E> subList(int fromIndex,int toIndex)      根据两个指定的下标获取集合的子元素

#### List接口的实现类

- ArrayList 

ArrayList 的特点是查询元素效率很高，只需要通过寻址地址和下标即可快速定位到目标元素，缺点是添加或删除元素，效率很低，因为要移动兄弟元素的位置。

```java
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("Hello");
        arrayList.add("World");
        arrayList.add("JavaSE");
        arrayList.add("JavaME");
        arrayList.add("JavaEE");
        System.out.println("list:"+arrayList);
        System.out.println("list的长度是："+arrayList.size());
        System.out.println("list是否包含Java："+arrayList.contains("Java"));
        for(int i=0;i<arrayList.size();i++) {
            System.out.println(arrayList.get(i));
        }
        Iterator iterator = arrayList.iterator();
        while(iterator.hasNext()) {
            String item = (String)iterator.next();
            System.out.println(item);
        }
        arrayList.remove("World");
        System.out.println(arrayList);
        arrayList.remove(3);
        System.out.println(arrayList);
        arrayList.add(1, "SQL");
        System.out.println(arrayList);
        int index = arrayList.indexOf("JavaSE");
        System.out.println(index);
        List list = arrayList.subList(1, 3);
        System.out.println(list);
    }
}
```

Vector 是一个早期的List实现类，用法基本与ArrayList一致。Stack 是 Vector 的一个子类，实现了"后进先出"的栈。

```java
import java.util.Vector;

public class Test2 {
    public static void main(String[] args) {
        Vector vector = new Vector();
        vector.addElement("Hello");
        vector.add("World");
        for(int i=0;i<vector.size();i++) {
            System.out.println(vector.get(i));
        }
    }
}
```

```java
import java.util.Stack;

public class Test3 {
    public static void main(String[] args) {
        Stack stack = new Stack();
        stack.push("Hello");
        stack.push("JavaSE");
        stack.push("JavaME");
        stack.push("JavaEE");
        System.out.println(stack);
        for(int i=0;i<stack.size();i++) {
            System.out.println(stack.get(i));
        }
        System.out.println("栈顶元素："+stack.peek());
        System.out.println(stack);
        System.out.println("栈顶元素："+stack.pop());
        System.out.println(stack);
    }
}
```

LinkedList 实现了一个"先进先出"的队列，采用链表的形式存储分散的内存空间，

```java
import java.util.LinkedList;

public class Test4 {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add("Hello");
        list.add("World");
        list.add("Java");
        System.out.println(list);
        list.offer("JavaSE");
        System.out.println(list);
        list.addLast("JavaSE2");
        System.out.println(list);
        list.push("JavaME");
        System.out.println(list);
        list.addFirst("JavaME2");
        System.out.println(list);
        System.out.println("第一个元素是："+list.peek());
        System.out.println(list);
        System.out.println("最后一个元素是："+list.peekLast());
        System.out.println(list);
        System.out.println(list.pop());
        System.out.println(list);
    }
}
```

PriorityQueue 在使用的时候需要注意，添加到该队列中的数据必须有序，即对象具备排序的功能。

```java
import java.util.PriorityQueue;

public class Test5 {
    public static void main(String[] args) {
        PriorityQueue queue = new PriorityQueue();
        queue.add(new A(2));
        queue.add(new A(1));
        System.out.println(queue);
    }
}

class A implements Comparable{
    private int num;
    public A(int num) {
        this.num = num;
    }
    /**
     * A.compareTo(B)
     * 1表示A大于B
     * 0表示A等于B
     * -1表示A小于B
     */
    @Override
    public int compareTo(Object o) {
        // TODO Auto-generated method stub
        A a = (A)o;
        if(this.num > a.num) {
            return 1;
        }else if(this.num == a.num) {
            return 0;
        }else {
            return -1;
        }
    }
    @Override
    public String toString() {
        return "A [num=" + num + "]";
    }
}
```

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("Hello");
        arrayList.add("World");
        arrayList.add("JavaSE");
        arrayList.add("JavaME");
        arrayList.add("JavaEE");
        arrayList.add(null);
        System.out.println("list:"+arrayList);
        System.out.println("list的长度是："+arrayList.size());
        System.out.println("list是否包含Java："+arrayList.contains("Java"));
        for(int i=0;i<arrayList.size();i++) {
            System.out.println(arrayList.get(i));
        }
        Iterator iterator = arrayList.iterator();
        while(iterator.hasNext()) {
            String item = (String)iterator.next();
            System.out.println(item);
        }
        arrayList.remove("World");
        System.out.println(arrayList);
        arrayList.remove(3);
        System.out.println(arrayList);
        arrayList.add(1, "SQL");
        System.out.println(arrayList);
        int index = arrayList.indexOf("JavaSE");
        System.out.println(index);
        List list = arrayList.subList(1, 3);
        System.out.println(list);
    }
}

import java.util.Vector;

public class Test2 {
    public static void main(String[] args) {
        Vector vector = new Vector();
        vector.addElement("Hello");
        vector.add("World");
        for(int i=0;i<vector.size();i++) {
            System.out.println(vector.get(i));
        }
    }
}

import java.util.Stack;

public class Test3 {
    public static void main(String[] args) {
        Stack stack = new Stack();
        stack.push("Hello");
        stack.push("JavaSE");
        stack.push("JavaME");
        stack.push("JavaEE");
        System.out.println(stack);
        for(int i=0;i<stack.size();i++) {
            System.out.println(stack.get(i));
        }
        System.out.println("栈顶元素："+stack.peek());
        System.out.println(stack);
        System.out.println("栈顶元素："+stack.pop());
        System.out.println(stack);
    }
}

import java.util.LinkedList;

public class Test4 {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add("Hello");
        list.add("World");
        list.add("Java");
        System.out.println(list);
        list.offer("JavaSE");
        System.out.println(list);
        list.addLast("JavaSE2");
        System.out.println(list);
        list.push("JavaME");
        System.out.println(list);
        list.addFirst("JavaME2");
        System.out.println(list);
        System.out.println("第一个元素是："+list.peek());
        System.out.println(list);
        System.out.println("最后一个元素是："+list.peekLast());
        System.out.println(list);
        System.out.println(list.pop());
        System.out.println(list);
        
    }
}

import java.util.PriorityQueue;

public class Test5 {
    public static void main(String[] args) {
        PriorityQueue queue = new PriorityQueue();
        queue.add(new A(2));
        queue.add(new A(1));
        System.out.println(queue);
    }
}

class A implements Comparable{
    private int num;
    public A(int num) {
        this.num = num;
    }
    /**
     * A.compareTo(B)
     * 1表示A大于B
     * 0表示A等于B
     * -1表示A小于B
     */
    @Override
    public int compareTo(Object o) {
        // TODO Auto-generated method stub
        A a = (A)o;
        if(this.num > a.num) {
            return 1;
        }else if(this.num == a.num) {
            return 0;
        }else {
            return -1;
        }
    }
    @Override
    public String toString() {
        return "A [num=" + num + "]";
    }
}