歌唱与自由

Collection

　　Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。使程序员操作成批的数据或对象元素极为方便。
　　Collection 层次结构 中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。
　　这些接口和类有很多对抽象数据类型操作的API，而这是我们常用的且在数据结构中熟知的。例如Map，Set，List等。并且Java用面向对象的设计对这些数据结构和算法进行了封装，这就极大的减化了程序员编程时的负担。
　　程序员也可以以这个集合框架为基础，定义更高级别的数据抽象，比如栈、队列和线程安全的集合等，从而满足自己的需要。

Java集合主要分为三种类型：

• Set(集)
• List(列表)
• Map(映射)

注意，这里的 Collection、List、Set和Map都是接口，不是具体的类实现。

常用集合类的继承结构如下：

Collection<--List<--Vector
Collection<--List<--ArrayList
Collection<--List<--LinkedList
Collection<--Set<--HashSet
Collection<--Set<--HashSet<--LinkedHashSet
Collection<--Set<--SortedSet<--TreeSet
Map<--SortedMap<--TreeMap
Map<--HashMap 

public interface List<E> extends Collection<E>

public interface Collection<E> extends Iterable<E>

public interface Iterable<T>

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

１List接口

　　有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
　　
　　与 set 不同，列表通常允许重复的元素。更确切地讲，列表通常允许满足 e1.equals(e2) 的元素对 e1 和 e2，并且如果列表本身允许 null 元素的话，通常它们允许多个 null 元素。难免有人希望通过在用户尝试插入重复元素时抛出运行时异常的方法来禁止重复的列表，但我们希望这种用法越少越好。
　　
　　List 接口提供了特殊的迭代器，称为 ListIterator，除了允许 Iterator 接口提供的正常操作外，该迭代器还允许元素插入和替换，以及双向访问。

List list = new ArrayList(); 

这是我们平常经常使用的创建一个新的List的语句， List是接口，ArrayList才是具体的类。

２Set

３Map

List * ArrayList

public class ArrayList<E> 
    extends AbstractList<E> 
    implements List<E>, RandomAccess, Cloneable, Serializable

底层用数组实现的List ，查询效率高，增删效率低、 轻量级、 线程不安全。

　　 List 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于 Vector 类，除了此类是不同步的。）

　　size、isEmpty、get、set、iterator 和 listIterator 操作都以固定时间运行。add 操作以分摊的固定时间 运行，也就是说，添加 n 个元素需要 O(n) 时间。其他所有操作都以线性时间运行（大体上讲）。与用于 LinkedList 实现的常数因子相比，此实现的常数因子较低。

　　每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单。
　　
　　在添加大量元素前，应用程序可以使用 ensureCapacity 操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。
　　
　　注意，此实现不是同步的。如果多个线程同时访问一个 ArrayList 实例，而其中至少一个线程从结构上修改了列表，那么它必须 保持外部同步。（结构上的修改是指任何添加或删除一个或多个元素的操作，或者显式调整底层数组的大小；仅仅设置元素的值不是结构上的修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方法将该列表“包装”起来。这最好在创建时完成，以防止意外对列表进行不同步的访问：

 List list = Collections.synchronizedList(new ArrayList(...)); 

　　此类的 iterator 和 listIterator 方法返回的迭代器是快速失败(faill-fast)的：在创建迭代器之后，除非通过迭代器自身的 remove 或 add 方法从结构上对列表进行修改，否则在任何时间以任何方式对列表进行修改，迭代器都会抛出 ConcurrentModificationException。

ArrayList 常用方法

增

import java.util.ArrayList;

public class Arraylist2 {
    public static void main(String[] args) {

        ArrayList<String> list = new ArrayList<>();
        /**
         *  依次添加数据
         */
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");      
        System.out.println("顺序添加list：" + list);
        // [a, b, c, d]

        /**
         * 在第X个元素后面添加数据
         * list必须要有足够多的数据，才能在某个元素下添加
         * IndexOutOfBoundsException 数组越界
         */
        list.add(1,"list1");
        System.out.println("在第X个元素后面添加数据list：" + list);
        // [a, list1, b, c, d]

        /**
         * 把一个链表复制到另一个
         */
        ArrayList<String> list2 = new ArrayList<>();
        list2.addAll(list);
        System.out.println("复制整个链表："+list2);
        // [a, list1, b, c, d]

        /**
         * 把一个链表中的数据添加到另一个链表的第某个元素后
         * IndexOutOfBoundsException 数组越界
         */
        ArrayList<String> list3 = new ArrayList<>();
        list3.add("list3");
        list3.addAll(1,list);
        System.out.println("复制整个链表给特定区域："+list3);
        // [list3, a, list1, b, c, d]

    }
}

删

import java.util.ArrayList;

public class Arraylist {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");

        /**
         * 删除某个数据
         */
        list.remove(2);// 把c删除
        System.out.println(list);
        // [a, b, d, e, f]

        /**
         * 按内容删除
         */
        list.remove("d");
        System.out.println(list);
        // [a, b, e, f]

        /**
         * 按照某个链表删除
         * 
         */
        ArrayList<String> list2 = new ArrayList<>();

        list2.add("a");
        list2.add("b");
        list.removeAll(list2);
        System.out.println(list);
        // [e, f]

        /**
         * 清空链表
         */
        list.clear();
        System.out.println(list);
        // []
    }
}

改,查

import java.util.ArrayList;
/**
 * 改,查
 * Title: Arraylist3
 * Description: 
 * Company: 
 * @author Peng
 * @date 下午4:55:55
 */
public class Arraylist3 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");

        /**
         * 修改指定位置的元素
         * 位置从0开始计算(0、1、2、3...)
         */
        list.set(1, "修改2");
        System.out.println(list);
        // [a, 修改2, c, d, e, f]

        /**
         * 获取指定位置的元素
         */     
        String num = list.get(2);
        System.out.println("第二个元素:"+num);
        // c

    }
}

遍历

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
/**
 * 遍历
 * Title: Arraylist4
 * Description: 
 * Company: 
 * @author Peng
 * @date 上午10:30:17
 */
public class Arraylist4 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");

        /**
         * ArrayList与数组转换
         */
        Object [] obj = (Object[]) list.toArray();

        for(Object c:obj){
            System.out.printf("%2s",c);
        }

        /**
         * 迭代器遍历ArrayList
         */
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String str = (String) it.next();
            System.out.println(str);
        }
        /**
         *  Arrays遍历ArrayList
         */
        System.out.println(Arrays.toString(obj));
        /**
         * foreach遍历ArrayList
         *  
         */
        for(String s:list){
            System.out.println(s);
        }
    }
}

List -LinkedList

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

底层用双向循环链表链式结构实现的List ,查询效率低，增删效率高
每个节点含有一个数据和下一个节点的引用

　　List 接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括 null）。除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列
　　此类实现 Deque 接口，为 add、poll 提供先进先出队列操作，以及其他堆栈和双端队列操作。
　　注意，此实现不是同步的。
　　
LinkedList笔记：http://blog.csdn.net/peng_hong_fu/article/details/52637143#t10