java中ArrayList，Set，Map区别

转自http://www.cnblogs.com/wangbin2188/p/6518251.html

Java集合框架Collection(1)ArrayList的三种遍历方法

ArrayList是java最重要的数据结构之一，日常工作中经常用到的就是ArrayList的遍历，经过总结，发现大致有三种，上代码：


复制代码

package com.company;


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


/**
 * Created by wangbin10 on 2017/3/1.
 */
public class JavaSort {
    public static void main(String [] args) {
        List<Integer> oldlist=new ArrayList<Integer>();
        for(int i=0;i<=9;i++){
            oldlist.add(i);
        }
//method1
        for(Integer i:oldlist){
            System.out.println(i);
        }
//method2
        for(int i=0;i<oldlist.size();i++){
            System.out.println(oldlist.get(i));
        }
//method3
        Iterator it=oldlist.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

java集合框架collection(2)ArrayList和LinkedList

ArrayList是基于动态数组实现的list，而LinkedList是基于链表实现的list。所以，ArrayList拥有着数组的特性，LinkedList拥有着链表的特性。


优缺点
　　ArrayList


　　优点：因为Array是基于索引(index)的数据结构，适合随机读取数据，读取速度快，可以一步get(index)。


　　缺点：添加删除值很慢，一方面，添加数据在array中间的时候，需要移动后面的数；另一方面，当长度大于初始长度的时候，每添加一个数，都会需要扩容。


　　LinkedList：双向链表


　　优点：添加删除值很快，不需要改变数组的大小，也不需要在数组装满的时候要将所有的数据重新装入一个新的数组，添加在list中间也只需要更改指针；长度不固定，优势只存在于数据插入表头，如果一直往后插入，就没有优势了。


　　实现栈和队列方面，LinkedList要优于ArrayList。


     缺点：LinkedList需要更多的内存，因为ArrayList的每个索引的位置是实际的数据，而LinkedList中的每个节点中存储的是实际的数据和前后节点的位置。


其它
　　LinkedList的remove(int)和remove(Object)的方法的时间复杂度都是O(n),不是O(1).因为会有一个查找的过程。


　　LinkedList的remove(int)要优于remove(Object)，因为remove(int)在查找的时候，会从链表的中间查找，如果int比中间小，找前半部分，否则找后半部分（类似二分查找）。


　　ArrayList的增删比LinkedList的开销更大，因为除了有查找的时间复杂度外，还有数据的移动。


复制代码

package com.company;


import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;


/**
 * Created by wangbin10 on 2017/3/8.
 */
public class ArrayLinkList {
    public static void main(String [] args){
        System.out.println("ArrayList add:"+timeList(new ArrayList()));
        System.out.println("LinkedList add:"+timeList(new LinkedList()));
        List list1=addList(new ArrayList());
        List list2=addList(new LinkedList());
        System.out.println("ArrayList read:"+readList(list1));
        System.out.println("LinkedList read:"+readList(list2));
    }
    static final int N=100000;
    static long timeList(List list){
        long start=System.currentTimeMillis();
        Object o =new Object();
        for(int i=0;i<N;i++){
            list.add(i,o);
        }
    return System.currentTimeMillis()-start;
    }
    static long readList(List list){
        long start=System.currentTimeMillis();
        for(int i=0;i<list.size();i++){
        }
        return System.currentTimeMillis()-start;
    }
    static List addList(List list){
        Object o=new Object();
        for(int i=0;i<N;i++){
            list.add(i,o);
        }
        return list;
    }
}

代码输出：


ArrayList add:3
LinkedList add:7
ArrayList read:1
LinkedList read:1

java集合框架collection(3)Set、ArrayList和HashMap

Set、ArrayList和HashMap是java collection中最常用的三种数据结构。


Set是集合，不允许有重复的元素，ArrayList是动态数组实现的列表，有序可重复，HashMap是key-value的键值对，用于快速存取。


 


Set的常用方法：


add() 插入元素


clear() 清空集合


contains() 是否包含某元素


equals() 是否和某对象完全相同


isEmpty() 是否为空


remove() 删除某元素


 


ArrayList常用方法：


add() 插入元素


clear() 清空集合


contains() 是否包含某元素


equals() 是否和某对象完全相同


isEmpty() 是否为空


remove() 删除某元素


get() 按照索引获取元素值


 


HashMap常用方法：


put(key,value) 增加新对象


containsKey() 是否包含key


containsValue() 是否包含value


keySet() 把key转为Set


Values() 把value转为List

package com.company;

import java.util.*;

/**
 * Created by wangbin10 on 2017/1/5.
 */
public class Collection {
    public static void main(String[] args){
//Set
        Set<Integer> s1 = new HashSet<Integer>();
        for(int i=0;i<10;i++){
            s1.add(i);
        }
        s1.remove(5);
        System.out.println(s1);
        System.out.println(s1.size());
        System.out.println(s1.isEmpty());
//ArrayList
        List<String> s2=new ArrayList<String>();
        s2.add("one");
        s2.add("two");
        s2.add("three");
        s2.add("four");
        s2.remove(0);
        System.out.println(s2.size());
        System.out.println(s2.get(2));
        System.out.println(s2.contains("two"));
        System.out.println(s2.equals(s2));
        Iterator it=s2.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

//HashMap
        Map<String,Integer> s3=new HashMap<String, Integer>();
        s3.put("zhao",1);
        s3.put("qian",2);
        s3.put("sun",3);
        s3.put("li",4);
        System.out.println(s3.get("sun"));
        System.out.println(s3.keySet());
        System.out.println(s3.values());
        System.out.println(s3.containsKey("wang"));
        System.out.println(s3.containsValue(5));
        System.out.println(s3.remove("qian"));
    }
}

java集合框架collection(4)HashMap和Hashtable的区别

HashMap和Hashtable的区别
HashMap和Hashtable都实现了Map接口，但决定用哪一个之前先要弄清楚它们之间的分别。主要的区别有：线程安全性，同步(synchronization)，以及速度。


HashMap几乎可以等价于Hashtable，除了HashMap是非synchronized的，并可以接受null(HashMap可以接受为null的键值(key)和值(value)，而Hashtable则不行)。
HashMap是非synchronized，而Hashtable是synchronized，这意味着Hashtable是线程安全的，多个线程可以共享一个Hashtable；而如果没有正确的同步的话，多个线程是不能共享HashMap的。Java 5提供了ConcurrentHashMap，它是HashTable的替代，比HashTable的扩展性更好。
另一个区别是HashMap的迭代器(Iterator)是fail-fast迭代器，而Hashtable的enumerator迭代器不是fail-fast的。所以当有其它线程改变了HashMap的结构（增加或者移除元素），将会抛出ConcurrentModificationException，但迭代器本身的remove()方法移除元素则不会抛出ConcurrentModificationException异常。但这并不是一个一定发生的行为，要看JVM。这条同样也是Enumeration和Iterator的区别。
由于Hashtable是线程安全的也是synchronized，所以在单线程环境下它比HashMap要慢。如果你不需要同步，只需要单一线程，那么使用HashMap性能要好过Hashtable。
HashMap不能保证随着时间的推移Map中的元素次序是不变的。
hashMap去掉了HashTable 的contains方法，但是加上了containsValue（）和containsKey（）方法。
Hashtable 和 HashMap 都能通过values()方法返回一个 Collection ，然后进行遍历处理：

Collection coll = map.values();  
Iterator it = coll.iterator();  
while (it.hasNext()) {  
String obj = (String) it.next();  
System.out.println(obj);  
}

两者也都可以通过 entrySet() 方法返回一个 Set ， 然后进行遍历处理：

Set set = table.entrySet();  
Iterator it = set.iterator();  
while (it.hasNext()) {  
Entry entry = (Entry) it.next();  
System.out.println(entry.getKey() + " - " + entry.getValue());  
  
}

要注意的一些重要术语：

1) sychronized意味着在一次仅有一个线程能够更改Hashtable。就是说任何线程要更新Hashtable时要首先获得同步锁，其它线程要等到同步锁被释放之后才能再次获得同步锁更新Hashtable。

2) Fail-safe和iterator迭代器相关。如果某个集合对象创建了Iterator或者ListIterator，然后其它的线程试图“结构上”更改集合对象，将会抛出ConcurrentModificationException异常。但其它线程可以通过set()方法更改集合对象是允许的，因为这并没有从“结构上”更改集合。但是假如已经从结构上进行了更改，再调用set()方法，将会抛出IllegalArgumentException异常。

3) 结构上的更改指的是删除或者插入一个元素，这样会影响到map的结构。

我们能否让HashMap同步？

HashMap可以通过下面的语句进行同步：
Map m = Collections.synchronizeMap(hashMap);

结论

Hashtable和HashMap有几个主要的不同：线程安全以及速度。仅在你需要完全的线程安全的时候使用Hashtable，而如果你使用Java 5或以上的话，请使用ConcurrentHashMap吧。

以上转载自：http://www.cnblogs.com/lintong/p/4363533.html

总结：

hashmap	线程不安全	允许有null的键和值	效率高一点、	方法不是Synchronize的要提供外同步	有containsvalue和containsKey方法	HashMap 是Java1.2 引进的Map interface 的一个实现	HashMap是Hashtable的轻量级实现
hashtable	线程安全	不允许有null的键和值	效率稍低、	方法是是Synchronize的	有contains方法方法	、Hashtable 继承于Dictionary 类	Hashtable 比HashMap 要旧

上表转载自：http://www.cnblogs.com/langtianya/archive/2013/03/19/2970273.html