集合1.0

Collection

Collection接口是Java单列集合中的根接口，它定义了各种具体单列集合的共性，其他的集合大多直接或间接继承该接口，
Collection接口中的常用方法：

boolean add(Object o);                          //向当前集合中添加一个元素
boolean addAll(Collection c);                   //将指定集合c中的所有元素添加到当前集合中
void clear();                                  //删除当前集合所有的元素
boolean remmove(Object o);                     //删除当前集合中的指定元素o
boolean removeAll(Collection c);              //删除当前集合中包含集合c中的所有元素
boolean isEmpty();                           //判断集合是否为空
boolean contains(Object o);                  //判断当前集合中是否包含o所代表的元素
boolean containsAll(Collection c);           //判断当前集合中是否包含指定集合c中的所有元素
Iterator iterator();                        //返回当前集合的迭代器。迭代器用于遍历集合中的所有元素
int size();                                 //获取当前集合元素个数

但是在平时使用中不经常使用Collection接口，常常使用的是它的子接口：List、Set、Queue、SortedSet。

List接口：

List接口中储存的元素是有序的，这里的有序说的是元素的存入数据和取出数据的顺序是一致的。
在List接口中的常用方法：

void add(int index,Object element);                     //将元素element插入到List集合的index处
boolean addAll(int intdex,Collection c);                //将集合c中的全部元素加入的List集合的索引index处
Object get(int index);                                  //返回index处的元素
Object remove(int index);                               //删除索引index处的元素
Object set(int index,Object element);                   //将索引index处的元素替换成element对象，并返回替换后的元素
int indexOf(Object o);                                  //返回对象o在List中第一次出现的位置的索引
int lastIndex(Object o);                                //返回对象o在List中最后一次出现的位置的索引
List subList(int fromIndex,int toIndex);               //返回从索引fromIndex(包括)到toIndex(不包括)的所有元素组成的子集合

ArrayList集合

ArrayList内部是封装了一个长度可变的数组对象，当存入的元素超过数组元素时，ArrayList就会在内存中分配一个更大的数组来储存这些元素，所以可以将ArrayList看作是一个长度可变的数组。方法基本都是继承的父类Collection和List继承的。但是这个集合由于可以类似肯成数组，所以在查找的时候效率是很高的，但是在增删上面效率是比较低的（删除时，把对应索引处的元素删掉后需要后面的所有元素都向前移；增加时，需要对应索引处之后的所有元素都向后移动，再把这个元素插入到指定位置），这个是相对于下面一个集合来说的，
举例：

package ti;

import java.util.ArrayList;

public class Ti7 {
    public static void main(String[] args){
        //这个<String>是泛型的应用，就是把这个集合设为String类型，只能储存String类型的元素
        ArrayList<String> a1=new ArrayList<String>();
        
        //这几个都是在集合末尾插入元素
        a1.add("张三");
        a1.add("李四");
        a1.add("王二");

        //在输出的时候集合会自动将集合中的所有元素按照一定的格式输出
        System.out.println(a1);
        System.out.println("----------------");

        //在指定位置插入元素,因为可以看成是任意大小的数组,所以索引是从0开始的
        a1.add(0,"麻子");
        System.out.println(a1);
        System.out.println("----------------");

        //在指定位置查询元素
        System.out.println(a1.get(2));
        System.out.println("----------------");

        //在指定位置删除相应元素和根据输入的内容删除对应的元素
        System.out.println(a1.remove(2));      //会返回被删除的元素
        System.out.println(a1.remove("麻子"));    //返回的是是否删除成功即true or false
        System.out.println("----------------");
        
        //更改相应位置的元素
        System.out.println(a1.set(0,"啊吧啊吧"));//返回的是被替换的元素
        System.out.println("----------------");

        //删除所有的元素
        a1.clear();
        System.out.println(a1);

    }
}

LinkedList集合

LinkedList内部维护了一个双向循环链表，链表中的每一个元素都使用引用的方式记录它前一个元素和后一个元素，从而将所有的元素彼此连接起来。当插入一个元素的时候，只需要修改元素之间的引用关系即可；删除一个节点也是类似操作。
LinkedList的常用方法：

void add(int index,E element);           //将当前指定类型的元素添加到指定的索引处
void addFirst(Object o);                //将指定元素o添加到当前集合的开头
void addLast(Object o);                 //将指定元素o添加到当前集合的结尾
Object getFirst();                      //返回当前集合的第一个元素
Object getLast();                       //返回当前集合的最后一个元素
Object removeFirst();                   //移除并返回当前集合的第一个元素
Object RemoveLast();                   //移除并返回当前集合的最后一个元素
boolean offer(Object o);               //将指定元素o添加到当前集合的结尾
boolean offerFirst(Object o);         //将指定元素o添加到当前集合的开头
boolean offerLst(Object o);           //将指定元素o添加到当前集合的结尾
Object peekFirst();                   //获取当前集合的第一个元素
Object peekLast();                   //获取当前集合的最后一个元素
Object pollFirst();                 //移除并返回当前集合的第一个元素
Object pollLast();                  //移除并返回当前集合的最后一个元素
void push(Object o);                //将指定的元素o添加到当前集合的开头

部分方法示例的代码：

package ti;

import java.util.LinkedList;

public class Ti8 {
    public static void main(String[] args){
        //创建集合对象
        LinkedList<String> link=new LinkedList<String>();
        //添加String类型的集合内容
        link.add("张三");
        link.add("李四");
        System.out.println(link);
        System.out.println("---------------");
        //分别在集合的开头和结尾插入两个String类型的元素
        link.addFirst("王二");
        link.addLast("麻子");
        System.out.println(link);
        System.out.println("---------------");

        //在指定索引处插入元素
        link.add(1,"啊吧啊吧");
        System.out.println(link);
        System.out.println("---------------");

        //获取指定索引处的元素
        System.out.println(link.get(3));
        System.out.println(link.getFirst());
        System.out.println(link.getLast());
        System.out.println("---------------");

        //删除指定索引处的元素
        link.remove(2);
        link.remove(3);
        System.out.println(link);
    }
}

集合的遍历

对于集合的遍历是由于我们都在使用集合的过程中可能会使用的到
对于集合的遍历常用的方法就是迭代器和foreach循环，这两个都是不需要使用索引的，因为有的集合不带有索引，是无序的，不常使用for循环，关于迭代器和for-each循环的使用例子如下：

package ti;

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

public class Ti9 {
    public static void main(String[] args) {
        ArrayList<String> a=new ArrayList<String>();
        a.add("张三");
        a.add("李四");
        a.add("王二");
        a.add("麻子");
        Iterator it=a.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println("---------------------");
        for(String s:a){
            System.out.println(s);
        }
    }
}

运行结果如下：

这个迭代器和foreach循环时一样的效果，只是迭代器太繁琐，还是foreach简单、好用。另外，在使用迭代器遍历的同时去调用集合对象的remove()方法去删除某些特定的元素就会产生并发性异常，
例如：

package ti;

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

public class Ti9 {
    public static void main(String[] args) {
        ArrayList<String> a=new ArrayList<String>();
        a.add("张三");
        a.add("李四");
        a.add("王二");
        a.add("麻子");
        Iterator it=a.iterator();
        while(it.hasNext()){
            if(it.next().equals("王二"))
                a.remove(it.next());
            System.out.println(it.next());
        }
    }
}

Iterator会抛出下列异常：

这个时候，如果说就删除这一个元素的话那么就可以用break去跳出循环，这样就不会再使用Iterator对集合中的元素进行遍历，那么Iterator就不会抛出异常。如果说有多个想要删除的元素的话，那可以用Iterator自己本身的删除方法，it.remove(),去删除该元素。
所以总的来说还是foreach循环好用。