Java基础--Collection集合

1.Collection接口

    Collection是java集合框架(collection-frame)中的顶层接口。Collection接口表示一个容器，容器中只能存储引用数据类型，建议存同一类型的引用类型，方便后续遍历等操作。

    容器中的元素可以是有序的、可重复的，称为List接口；也可能是无序的、唯一的，称为Set接口。

    Collection接口的常用方法：

public static void main(String[] args) {
        
        /**
         * 增:add/addAll
         * 删:clear/remove/removeAll/retainAll
         * 改:
         * 查:contains/containsAll/isEmpty/size
         */
        
        Collection c1 = new ArrayList();
        
        // 追加
        c1.add("apple"); // Object object = new String("apple");
        // c1.add(1);         // Object object = new Integer(1); 
        c1.add("banana");
        System.out.println(c1);
        
        // 追加一个集合 
        Collection c2 = new ArrayList();
        c2.add("java");
        c2.add("c++");
        c1.addAll(c2);
        System.out.println(c1);
        
        // clear
        //c1.clear();
        
        // c1.remove("apple");
        // c1.removeAll(c2);
        //c1.retainAll(c2);
        //System.out.println(c1);
        
        System.out.println(c1.contains("apple"));
        c2.add("js");
        System.out.println(c1.containsAll(c2));
        // c1.clear();
        System.out.println(c1.isEmpty());
        // 返回集合元素的个数
        System.out.println(c1.size());
        
        System.out.println(c1.equals(c2));
        
    }

    Collection接口的快速遍历：

// 快速遍历
        // for-each
        // Object 表示元素类型 
        // item表示迭代变量
        // c1表示集合
        for (Object item : c1) {
            System.out.println(item.toString());
        }

    快速遍历的本质：

    Collection继承Iterable接口，表示集合支持快速遍历。Iterable接口定义了一个方法iterator()用于获取集合的迭代器，是一个Iterator接口类型，iterator()内部返回一个实现类实现类Iterator接口。这个实现类一定具有hasNext和next方法用于判断是否有下一个元素和获取下一个元素。快速遍历就是基于迭代器工作的。

public static void main(String[] args) {
        

        Collection c1 = new ArrayList();
        c1.add("apple");
        c1.add("banana");
        c1.add("coco");
        
        
        // 快速遍历
        // for-each
        // Object 表示元素类型 
        // item表示迭代变量
        // c1表示集合
        for (Object item : c1) {
            System.out.println(item.toString());
        }
        
        // 迭代器遍历（国内）
        Iterator it = c1.iterator();
        while(it.hasNext()) {
            Object item = it.next();
            System.out.println(item.toString());
        }
        
        // 国外
        for(Iterator it2=c1.iterator();it2.hasNext();) {
            Object item = it2.next();
            System.out.println(item.toString());
        }    
    }

2.List接口

List 接口中的元素时有序的、可重复的。List接口中的元素通过索引(index)来确定元素的顺序。

有序的 collection（也称为序列）。可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

List接口的常用方法：

public static void main(String[] args) {
        
        /**
         * 增:add/addAll/add(index,el)/addAll(index,collection)
         * 删:clear/remove/removeAll/remove(index)
         * 改:set(index,el)
         * 查:get(index)/indexOf/lastIndexOf()
         * 其他:contains/containsAll/isEmpty/size
         */
        List list1 = new ArrayList();
        // 添加元素
        list1.add("apple");
        list1.add("banana");
        // 在指定位置添加元素
        list1.add(0, "coco");
        
        System.out.println(list1);
        
        List list2 = new ArrayList();
        list2.add("java");
        list2.add("c++");
        
        list1.addAll(1, list2);
        System.out.println(list1);
        
        // 删除
        list1.remove(0);
        System.out.println(list1);
        
        // 修改
        list1.set(0, "javax");
        System.out.println(list1);
        
        // 查
        System.out.println(list1.get(0));
        list1.add("apple");
        list1.add("apple");
        System.out.println(list1);
        System.out.println(list1.indexOf("apple"));
        System.out.println(list1.lastIndexOf("apple"));
    }

List接口的遍历：

ListIterator 继承于Iterator，在Iterator的基础上提供了以正向遍历集合，也可以以逆序遍历集合。

hasNext/next 以正向遍历

hasPrevious/previous 以逆序遍历

public static void main(String[] args) {
        
        
        List list1 = new ArrayList();
        list1.add("apple");
        list1.add("banana");
        list1.add("coco");
        
        // 【1】快速遍历
        System.out.println("--for each--");
        for (Object item : list1) {
            System.out.println(item.toString());
        }
        
        // 【2】普通for
        System.out.println("--for--");
        for(int i=0;i<list1.size();i++) {
            System.out.println(list1.get(i));
        }
        
        // 【3】集合迭代器
        System.out.println("--iterator--");
        Iterator it = list1.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
        
        System.out.println("--list iterator--");
        // 正向遍历
        ListIterator it2 = list1.listIterator();
        while(it2.hasNext()) {
            System.out.println(it2.next());
        }
        
        // 逆序遍历
        while(it2.hasPrevious()) {
            System.out.println(it2.previous());
        }
        
        System.out.println("--list iterator with index--");
        ListIterator it3 = list1.listIterator(1);
        while(it3.hasNext()) {
            System.out.println(it3.next());
        }
    }

3.LinkedList接口

LinkedList是List接口的实现类，底层数据结构是链表。

LinekList常用方法和遍历方法参照List接口。

LinkedList 线程不安全。

除了实现List接口， 还实现栈接口。

push入栈操作 / pop出栈操作：

public class Test01 {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.push("apple");
        list.push("banana");
        list.push("coco");
        
        
        System.out.println(list.pop());
        System.out.println(list.pop());
        System.out.println(list.pop());
        
        // java.util.NoSuchElementException
        System.out.println(list.pop());
    }
}

队列(Queue)接口：

add/remove/element() 可能会出现NoSuchElementException异常

public static void main(String[] args) {
        
        LinkedList queue = new LinkedList();
        // 入队
        /**
         * 队列头                          队列尾
         *<-----          <-----
         * [apple, banana, coco]
         */
        queue.add("apple");
        queue.add("banana");
        queue.add("coco");
        System.out.println(queue);
        
        // 出队
        System.out.println(queue.remove());
        System.out.println(queue.remove());
        System.out.println(queue.remove());        
        System.out.println(queue);
        
        // java.util.NoSuchElementException
        System.out.println(queue.remove());
        
        
        // 获取表头元素
        System.out.println(queue.element());
    }

offer/poll/peek 可能会返回特殊值(null)：

public static void main(String[] args) {
        
        LinkedList queue = new LinkedList();
        // 入队
        /**
         * 队列头                          队列尾
         *<-----          <-----
         * [apple, banana, coco]
         */
        queue.offer("apple");
        queue.offer("banana");
        queue.offer("coco");
        
        // 出队列
        //System.out.println(queue.poll());
        //System.out.println(queue.poll());
        //System.out.println(queue.poll());
        System.out.println(queue);

        //System.out.println(queue.poll());
        
        // 获取表头元素
        System.out.println(queue.peek());
    
    }

双向队列(Deque)接口：

/**
 * 以双向队列形式操作LinkedList
 */
public class Test04 {
    public static void main(String[] args) {
        
        LinkedList queue = new LinkedList();
        // 入队
        /**
         *<-----          <-----
         * [apple, banana, coco]
         * ---->          ----->
         */
        
        queue.addFirst("apple");
        queue.addFirst("banana");
        queue.addFirst("coco");
        System.out.println(queue);
        
        System.out.println(queue.removeLast());
        System.out.println(queue.removeFirst());
        System.out.println(queue.removeFirst());
        System.out.println(queue);
        
        // 获取头元素
        System.out.println(queue.getFirst());
    
    }
}