Java--Working with Colections--Using the list Interface

1.ArrayList

是一个可改变大小的数组.当更多的元素加入到ArrayList中时,其大小将会动态地增长.内部的元素可以直接通过get与set方法进行访问,因为ArrayList本质上就是一个数组.不同步(就是线程不安全)

      ArrayList是一个动态数组，也是我们最常用的集合。它允许任何符合规则的元素插入甚至包括null。每一个ArrayList都有一个初始容量（10），该容量代表了数组的大小。随着容器中的元素不断增加，容器的大小也会随着增加。在每次向容器中增加元素的同时都会进行容量检查，当快溢出时，就会进行扩容操作。所以如果我们明确所插入元素的多少，最好指定一个初始容量值，避免过多的进行扩容操作而浪费时间、效率。

      size、isEmpty、get、set、iterator 和 listIterator 操作都以固定时间运行。add 操作以分摊的固定时间运行，也就是说，添加 n 个元素需要 O(n) 时间（由于要考虑到扩容，所以这不只是添加元素会带来分摊固定时间开销那样简单）。

      ArrayList擅长于随机访问。同时ArrayList是非同步的。

ArrayList :

package test;
//package com.algorithm.java.Niit2.Learning;

//import com.sun.xml.internal.bind.v2.runtime.reflect.ListIterator;

import java.util.ArrayList;
import java.util.ListIterator;

public class ArrayListDemo {
    public static void main(String[] args){
        ArrayList<String> obj=new ArrayList<String>();
        String sobj1=new String("Element 1");
        String sobj2=new String("Element 2");
        String sobj3=new String("Element 3");
        String sobj4=new String("Element 4");

        System.out.println("Size of ArrayList is :"+obj.size());
        obj.add(sobj1);
        obj.add(sobj2);
        obj.add(sobj3);
        obj.add(sobj4);
        obj.add(sobj1);

        System.out.println("
ArrayList after adding the objects:"+obj);
        System.out.println("
Size of ArrayList after adding object "+obj.size());

        obj.remove(2);
        obj.remove(sobj4);

        System.out.println("
ArrayList after removing the objects"+obj);
        System.out.println("Size of ArrayList after removing objects:"+obj.size());

        System.out.println("
The final ArrayList :");
        ListIterator i= (ListIterator) obj.listIterator();
        while(i.hasNext()){
            System.out.println(i.next());

        }

    }

}

2.LinkedList

是一个双链表,在添加和删除元素时具有比ArrayList更好的性能.但在get与set方面弱于ArrayList.不同步(就是线程不安全)

      同样实现List接口的LinkedList与ArrayList不同，ArrayList是一个动态数组，而LinkedList是一个双向链表。所以它除了有ArrayList的基本操作方法外还额外提供了get，remove，insert方法在LinkedList的首部或尾部。

      由于实现的方式不同，LinkedList不能随机访问，它所有的操作都是要按照双重链表的需要执行。在列表中索引的操作将从开头或结尾遍历列表（从靠近指定索引的一端）。这样做的好处就是可以通过较低的代价在List中进行插入和删除操作。

      与ArrayList一样，LinkedList也是非同步的。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List： 
List list = Collections.synchronizedList(new LinkedList(...));

LinkedList:

package test;
//package com.algorithm.java.Niit2.Learning;

//import com.sun.xml.internal.bind.v2.runtime.reflect.ListIterator;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.ListIterator;

public class LinkedListDemo {
    public static void main(String[] args){
        LinkedList<String> obj=new LinkedList<String>();
        String sobj1=new String("Element 1");
        String sobj2=new String("Element 2");
        String sobj3=new String("Element 3");
        String sobj4=new String("Element 4");

        System.out.println("Size of ArrayList is :"+obj.size());
        obj.add(sobj1);
        obj.add(sobj2);
        obj.add(sobj3);
        obj.add(sobj4);
        obj.add(sobj1);

        System.out.println("
ArrayList after adding the objects:"+obj);
        System.out.println("
Size of ArrayList after adding object "+obj.size());

        obj.remove(2);
        obj.remove(sobj4);

        System.out.println("
ArrayList after removing the objects"+obj);
        System.out.println("Size of ArrayList after removing objects:"+obj.size());

        System.out.println("
The final ArrayList :");
        ListIterator i= (ListIterator) obj.listIterator();
        while(i.hasNext()){
            System.out.println(i.next());

        }

    }

}

3.Vector

和ArrayList类似,但属于强同步类。如果你的程序本身是线程安全的(thread-safe,没有在多个线程之间共享同一个集合/对象),那么使用ArrayList是更好的选择。.同步(线程安全)

有句话叫越安全，效率就越低。

Vector:

package test;
//package com.algorithm.java.Niit2.Learning;

//import com.sun.xml.internal.bind.v2.runtime.reflect.ListIterator;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.Vector;

public class LinkedListDemo {
    public static void main(String[] args){
       Vector<String> obj=new Vector<String>();
        String sobj1=new String("Element 1");
        String sobj2=new String("Element 2");
        String sobj3=new String("Element 3");
        String sobj4=new String("Element 4");

        System.out.println("Size of ArrayList is :"+obj.size());
        obj.add(sobj1);
        obj.add(sobj2);
        obj.add(sobj3);
        obj.add(sobj4);
        obj.add(sobj1);

        System.out.println("
ArrayList after adding the objects:"+obj);
        System.out.println("
Size of ArrayList after adding object "+obj.size());

        obj.remove(2);
        obj.remove(sobj4);

        System.out.println("
ArrayList after removing the objects"+obj);
        System.out.println("Size of ArrayList after removing objects:"+obj.size());

        System.out.println("
The final ArrayList :");
        ListIterator i= (ListIterator) obj.listIterator();
        while(i.hasNext()){
            System.out.println(i.next());

        }

    }

}

Map接口

本词条缺少信息栏、名片图，补充相关内容使词条更完整，还能快速升级，赶紧来编辑吧！

Map接口储存一组成对的键-值对象，提供key（键）到value（值）的映射，Map中的key不要求有序，不允许重复。value同样不要求有序，但可以重复。最常见的Map实现类是HashMap，他的储存方式是哈希表，优点是查询指定元素效率高。

 

Map接口提供了将键映射到集合的对象,一个映射不能包含重复的键.

每个键最多只能映射到一个值.Map接口中同样提供了集合的常用方法,如clear()方法,isEmpty()方法,Size()方法等.

Map接口有三个比较重要的实现类，分别是HashMap、TreeMap和HashTable:

1.HashMap:哈希表：冲突处理为单链表；无序

2.TreeMap:二叉树：有序

3.HashTable:哈希表：冲突处理为单链表

*************Hashtable的方法是同步的，HashMap的方法不是同步的

Hashtable是线程安全的，HashMap不是线程安全的。

HashMap效率较高，Hashtable效率较低。

 =========================================================================================

HashMap:

注：基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。 此实现假定哈希函数将元素适当地分布在各桶之间，可为基本操作（get 和 put）提供稳定的性能。迭代 collection 视图所需的时间与 HashMap 实例的“容量”（桶的数量）及其大小（键-值映射关系数）成比例。所以，如果迭代性能很重要，则不要将初始容量设置得太高（或将加载因子设置得太低）。