Java集合总结（一）

1.集合：用于存储对象的容器，长度可变，不可以存储基本数据类型。
2.Collection，顶层集合，实现了Iterable接口。代码示例；

    Collection collectionOne = new ArrayList();
    Collection collectionTwo = new ArrayList();
    // 添加
    System.out.println("add.....");
    collectionOne.add("s");
    collectionOne.add(2);
    collectionOne.add(3.5);
    System.out.println(collectionOne);
    collectionTwo.addAll(collectionOne);
    collectionTwo.add(88);
    System.out.println(collectionTwo);
    // 删除
    System.out.println("remove.....");
    collectionOne.remove(3.5);
    System.out.println(collectionOne);
    collectionOne.add("rt");
    collectionTwo.removeAll(collectionOne);
    System.out.println(collectionOne + "\n" + collectionTwo);
    // 判断
    System.out.println("contains.....");
    System.out.println(collectionOne.contains("jio"));
    collectionTwo.add("s");
    collectionTwo.add("rt");
    collectionTwo.add(2);
    System.out.println(collectionOne + "\t" + collectionTwo);
    System.out.println(collectionTwo.containsAll(
        collectionOne));
    // 获取
    System.out.println("get.....");
    System.out.println(collectionOne.size() + "\t" + collectionTwo.size());
    Iterator it = collectionOne.iterator();
    while (it.hasNext()) {
        System.out.print(it.next() + "\t");
    }
    System.out.println();
    // 其它
    // 转变为数组
    Object[] objArr = collectionTwo.toArray();
    for (int j = 0; j < objArr.length; j++) {
        System.out.print(objArr[j] + "\t");
    }
    System.out.println();
    // 交集判断 去除collectionTwo中包含的非collectionOne中的元素
    // 不更改collectionTwo的元素顺序
    System.out.println(
        collectionTwo.retainAll(collectionOne));
    System.out.println(collectionOne + "\t" + collectionTwo);
    Collection newCollection = new ArrayList();
    newCollection.add("a");
    newCollection.add("s");
    for(Iterator newIt = newCollection.iterator();
        newIt.hasNext();){
        System.out.print(newIt.next()+"\t");
    }       
    System.out.println("\n"+newCollection);
    newCollection.clear();
    System.out.println(newCollection);

3.Iterator变量放在for循环之中比放在while循环里面更加高效，因为for循环结束就会释放Iterator变量占有的内存。
4.
|–Collection
|–List:元素有序，可重复，List集合具有索引角标
|–ArrayList:底层使用数组结构，查询速度快，增删慢。线程不同步
|–LinkedList:底层使用链表，增删速度快，查询很慢。
|–Vector:底层使用数组，线程同步。已被ArrayList取代。
|–Set:元素无序，不可重复（存入的顺序与取出的顺序不同）。
|–HashSet:底层使用hash表，哈希表。
|–HashSet如何在添加对象时保证对象的唯一性？
通过元素的两个方法，hashCode()和equals()实现。
如果hashCode值相同，调用equals判断是否为true。
如果hashCode值不同，则为不同对象。
对于判断元素是否存在，以及删除操作，依次调用hashCode与equals方法判断。
|–TreeSet:底层使用二叉树,存储按照自然顺序，即ASCLL码存储。
|–当添加的对象本身没有实现Comparable接口的ComparaTo()方法,或者实现的方法不具有比较性，或者不是需要的比较性时这是需要让容器本身具有比较性，定义了比较器，调用构造方法,TreeSet(Comparator(Object o1,Object o2))来实现此处的Comparator(Object o1,Object o2)为实现Comparator接口的比较器对象，需要自己写实现，并用这个对象构造TreeSet对象。比较器优先级高于类本身的比较方法。
5.
|–ListIterator与Iterator的区别：并发性的考虑
|–ListIterator有add()方法，可以向当前选中的迭代数据添加新数据，添加到该数据之后。
|–ListIterator可以正向，逆向遍历。
|–ListIterator可以定位当前的索引位置，nextIndex(),previousIndex()。
|–ListIterator可以修改对象，set()。ListIterator和Iterator皆能remove()。
|–由于在集合中只是存储了对象的地址，而并没有存储对象的具体值，所以在调用set()方法时，并不会直接改变该对应对象的值，而是替换对应的地址。
6.|–Comparable:所有实现了此接口的类都对加入的新对新进行排序,需要复写CompareTo()
|–String类的CompareTo()方法默认实现升序排序
|–CompareTo()返回值为0 保证元素唯一性
7.List方法实现：

    List<Integer> list = new LinkedList<Integer>();
    //添加
    list.add(1);        
    list.add(2);
    list.add(3);
    list.add(4);
    list.add(2);
    //从指定位置插入
    list.add(1, 9);
    System.out.println(list);
    //删除
    list.remove(1);
    list.remove(new Integer(1));
    //list.clear();
    //list.removeAll(list);
    System.out.println(list);
    //修改
    list.set(1, 88);
    System.out.println(list);
    //查找
    System.out.println(list.get(1));
    System.out.println(
        list.indexOf(1)+"\t"+list.indexOf(new Integer(2)));
    System.out.println(list.lastIndexOf(2));
    System.out.println(list);
    //截取一部分List作为新的List
    List<Integer> newList = list.subList(0, 3);
    System.out.println(newList);

8.在迭代器Iterator中不要使用集合操作元素，容易出现java.util.ConcurrentModificationException。可以使用ListIterator来完成对元素的更多操作。
9.ListIterator操作集合：

    List<String> list = new LinkedList<String>();
    for (int i = 0; i < 10; i++) {
        list.add(new String(""+i));
    }
    System.out.println(list);
    ListIterator<String> it;
    int num = 0;
    for(it = list.listIterator();it.hasNext();){
        String s =it.next();
        //删除当前指向的那个值
        if(s.equals("1")){
            it.remove();
            num--;
            System.out.println(list);
        }
        if(num == 8)
            System.out.println("888888888888\t"+it.nextIndex());
        //添加到当前指向值的下一位
        if(s.equals("9")){
            System.out.println(list.size()+"\t"+list.get(8));
            it.add("10");               
            System.out.println(list);
        System.out.println(
            "num="+num+"\t"
            +"99999999999999999999"+"\t"
            +list.size()+"\t"+it.nextIndex());
        }
        //中间跳过了9这个索引 是由于添加的缘故
        if(it.nextIndex() == 9)
            System.out.println("------"+list.size()+"\t"+num);
        num++;

    }
    System.out.println(list);

10.LinkedList方法：

    LinkedList<Integer> ld = new LinkedList<Integer>();
    for (int i = 0; i < 10; i++) {
        ld.add(i);
    }
    ld.add(8888);
    //添加
    ld.addFirst(-1);
    ld.addLast(10);
    System.out.println(ld);
    ld.offer(11);
    ld.offerFirst(-2);
    ld.offerLast(12);
    System.out.println(ld);
    //获取
    System.out.println(ld.getFirst()+"----"+ld.peekFirst());
    System.out.println(ld.getLast()+"----"+ld.peekLast());
    System.out.println(ld.get(1)+"\t"+ld.peek());
    //删除
    //ld.remove();
    //ld.remove(1);
    //ld.removeLast();
    ld.poll();
    ld.pollFirst();
    ld.pollLast();
    System.out.println(ld);

11.LinkedList模仿队列：

    public static LinkedList<Integer> ld 
                    = new LinkedList<Integer>();

    public static void addNum(Integer num){
        ld.addLast(num);
    }
    public static Integer getNum(){
        return ld.pollFirst();
    }
    public static boolean isNull(){
        return ld.isEmpty();
    }

    public static void main(String[] args) {
        //LinkedList模仿队列
        addNum(1);
        addNum(2);
        addNum(3);
        addNum(4);
        System.out.println(ld);
        while(!isNull())
            System.out.println(getNum());
        System.out.println(ld);
    }

12.Set集合：

    class HashDemo {
        private String name;
        private int ID;

        public HashDemo(String name, int ID) {
            this.name = name;
            this.ID = ID;
        }

        @Override
        public int hashCode() {
            return this.name.hashCode() + this.ID;
        }

        @Override
        public boolean equals(Object obj) {
            if(obj == this)
                return true;
            if (!(obj instanceof HashDemo))
                throw new ClassCastException("类型错误");
            HashDemo objDemo = (HashDemo) obj;
            return this.name.equals(objDemo.name) 
                            && this.ID == objDemo.ID;
        }

        @Override
        public String toString() {
            return this.name + "\t" 
                    + ID + "\t" 
                    + + this.getClass().getName();
        }
    }

    public class Demo {
        public static void main(String[] args) {
            HashDemo h1 
                = new HashDemo("caizhanqi", 2012241001);
            HashDemo h2 
                = new HashDemo("chenweirong", 2012241002);
            HashDemo h3 = new HashDemo("chenzheng", 2012241003);
            HashDemo h4 = new HashDemo("cuijunbiao", 2012241005);
            Set<HashDemo> set = new HashSet<HashDemo>();
            set.add(h1);
            set.add(h2);
            set.add(h3);
            set.add(h4);
            Iterator<HashDemo> it;
            for (it = set.iterator(); it.hasNext();)
                System.out.println(it.next());
        }

    }

13.定义功能去除ArrayList中的重复元素：

    HashDemo h1 = new HashDemo("caizhanqi", 2012241001);
    HashDemo h2 = new HashDemo("chenweirong", 2012241002);
    HashDemo h3 = new HashDemo("chenzheng", 2012241003);
    HashDemo h4 = new HashDemo("cuijunbiao", 2012241005);
    List<HashDemo> list = new ArrayList<HashDemo>();
    list.add(h1);
    list.add(h1);
    list.add(h1);
    list.add(h2);
    list.add(h2);
    list.add(h2);
    list.add(h3);
    list.add(h3);
    list.add(h3);
    list.add(h4);
    List<HashDemo> newList = new ArrayList<HashDemo>();
    ListIterator<HashDemo> it;
    for (it = list.listIterator(); it.hasNext();){
        HashDemo obj = it.next();
        if(!newList.contains(obj))
            newList.add(obj);
    }
    for(it = newList.listIterator();it.hasNext();)
        System.out.println(it.next());

14.无序变有序，使用LinkedHashSet。