【Java基础】(03)Java常用数据结构-CSDN博客

本文链接：https://blog.csdn.net/u011384489/article/details/78228656

【Java基础】(03)Java常用数据结构

Auther: Thomas Shen
E-mail: Thomas.shen3904@qq.com
Date: 2017/10/14
All Copyrights reserved !

- - Java基础03Java常用数据结构

1. 简述：

在进行Java开发时，JDK已经为我们提供了一系列相应的类来实现基本的数据结构。这些类均在java.util包中。JAVA集合主要分为三种类型：Set(集),List(列表),Map(映射)。本文试图通过简单的描述，向读者阐述各个类的作用以及如何正确使用这些类：

Collection
- List
  - LinkedList
  - ArrayList
  - Vector
    - Stack
- Set
Map
- Hashtable
- HashMap
- WeakHashMap
- ConcurrentHashMap

2. Collection接口：

Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。

　　所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。

Collection接口的方法：

boolean add(Object o):  向集合中加入一个对象的引用；
void    clear():        删除集合中所有的对象，即不再持有这些对象的引用；
boolean isEmpty():      判断集合是否为空；
boolean contains(Object o):  判断集合中是否持有特定对象的引用；
boolean remove(Object o):    从集合中删除一个对象的引用；
int     size():         返回集合中元素的数目；
Object[]  toArray():    返回一个数组，该数组中包括集合中的所有元素；
Iterartor iterator():  返回一个Iterator对象，可以用来遍历集合中的元素。

关于：Iterator() 和toArray() 方法都用于集合的所有的元素，前者返回一个Iterator对象，后者返回一个包含集合中所有元素的数组。

如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。

Iterator接口声明了如下方法：

    hasNext(): 判断集合中元素是否遍历完毕，如果没有，就返回true
    next()       :返回下一个元素
    remove():从集合中删除上一个有next()方法返回的元素。

典型的用法如下：

    import java.util.Iterator;
    Iterator it = collection.iterator(); // 获得一个迭代子
    while(it.hasNext()) {
        Object obj = it.next(); // 得到下一个元素
    }

由Collection接口派生的两个接口是List和Set。

2.1 List接口：

List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。

和下面要提到的Set不同，List允许有相同的元素。

除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。

实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。

2.1.1 LinkedList类：

LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。

注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：

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

2.1.2 ArrayList类：

ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。

size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。

每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
　　
和LinkedList一样，ArrayList也是非同步的（unsynchronized）。

使用示例：

import java.util.ArrayList;
import java.util.List;
List<Integer> _list = new ArrayList<Integer>();
_list.add(Integer.valueOf(3));
_list.get(0);   // by id
_list.remove(0);// by id

2.1.3 Vector类：

参考：http://www.cnblogs.com/strivers/archive/2010/12/28/1918877.html

Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList创建的Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。

基础用法：

import java.util.*;

//使用Vector的构造方法进行创建 
Vector v = new Vector(4);

//向Vector中添加元素，使用add方法直接添加元素 
v.add("Test0"); 
v.add("Test1"); 

//从Vector中删除元素 
v.remove("Test0"); //删除指定内容的元素 
v.remove(0); //按照索引号删除元素

//获得Vector中已有元素的个数 
int size = v.size(); 
System.out.println("size:" + size);

//遍历Vector中的元素 
for(int i = 0;i < v.size();i++){ 
    System.out.println(v.get(i)); 
}

2.1.4 Stack 类：

参考：http://www.cnblogs.com/JJCS/p/3480982.html

Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。

import java.util.*;

Stack stack = new Stack(); // 创建堆栈对象
stack.push(new Integer(11111)); //向 栈中 压入整数 11111
stack.push("absdder"); //向 栈中 压入
stack.push(new Double(29999.3)); //向 栈中 压入

String s = new String("absdder");
System.out.println("元素absdder在堆栈的位置"+stack.search(s));     
System.out.println("元素11111在堆栈的位置"+stack.search(11111));

System.out.println("元素"+stack.pop()+"出栈");
System.out.println("元素"+stack.pop()+"出栈");

2.1.5 Vector、ArrayList和LinkedList对比：

大多数情况下，从性能上来说ArrayList最好，但是当集合内的元素需要频繁插入、删除时LinkedList会有比较好的表现，但是它们三个性能都比不上数组，另外Vector是线程同步的。所以：

如果能用数组的时候(元素类型固定，数组长度固定)，请尽量使用数组来代替List；
如果没有频繁的删除插入操作，又不用考虑多线程问题，优先选择ArrayList；
如果在多线程条件下使用，可以考虑Vector；
如果需要频繁地删除插入，LinkedList就有了用武之地；
如果你什么都不知道，用ArrayList没错。

2.2 Set接口：

参考：http://blog.csdn.net/lushuaiyin/article/details/7381478/
参考：http://www.cnblogs.com/UniqueColor/p/5707704.html

Set是一种不包含重复的元素的Collection，它不允许出现重复元素，即任意的两个元素e1和e2都有e1.equals(e2)=false；
不保证和政集合中元素的顺序；

允许包含值为null的元素，但最多只能有一个null元素。

请注意：必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。

* Java.util.HashSet类实现了Java.util.Set接口：*

import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;

public class TestHashSet
{
    public static void main(String [] args)
    {
        HashSet h=new HashSet();
        h.add("1st");
        h.add("2nd");
        h.add(new Integer(3));
        h.add(new Double(4.0));
        h.add("2nd");            //重复元素，未被添加
        h.add(new Integer(3));      //重复元素，未被添加
        h.add(new Date());
        System.out.println("开始：size="+h.size());
        Iterator it=h.iterator();
        while(it.hasNext())
        {
            Object o=it.next();
            System.out.println(o);
        }
        h.remove("2nd");
        System.out.println("移除元素后：size="+h.size());
        System.out.println(h);
    }
}

TreeSet（有序存放）:

TreeSet描述的是Set的一种变体——可以实现排序等功能的集合，它在讲对象元素添加到集合中时会自动按照某种比较规则将其插入到有序的对象序列中，并保证该集合元素组成的读uixiangxulie时刻按照“升序”排列。

import java.util.TreeSet;
import java.util.Iterator;
public class TestTreeSet
{
    public static void main(String [] args)
    {
        TreeSet ts=new TreeSet();
        ts.add("orange");
        ts.add("apple");
        ts.add("banana");
        ts.add("grape");
        Iterator it=ts.iterator();
        while(it.hasNext())
        {
            String fruit=(String)it.next();
            System.out.println(fruit);
        }
    }
}

3. Map接口：

参考：Map遍历的四种方式

Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。

3.1 Hashtable类：

参考：http://blog.csdn.net/jinhuoxingkong/article/details/52022999

Hashtable继承Map接口，实现一个key-value映射的哈希表。任何非空（non-null）的对象都可作为key或者value。

Hashtable 是一个散列表，它存储的内容是键值对(key-value)映射。
Hashtable 继承于Dictionary，实现了Map、Cloneable、java.io.Serializable接口。Map是”key-value键值对”接口，Dictionary是声明了操作”键值对”函数接口的抽象类。

java.lang.Object  
   ↳     java.util.Dictionary<K, V>  
         ↳     java.util.Hashtable<K, V>  

public class Hashtable<K,V> extends Dictionary<K,V>  
    implements Map<K,V>, Cloneable, java.io.Serializable { }

Hashtable 的函数都是同步的，这意味着它是线程安全的。它的key、value都不可以为null。

构造函数：
Hashtable中提供了四个构造函数，如下：

// 默认构造函数。  
public Hashtable()   
// 指定“容量大小”的构造函数  
public Hashtable(int initialCapacity)   
// 指定“容量大小”和“加载因子”的构造函数  
public Hashtable(int initialCapacity, float loadFactor)   
// 包含“子Map”的构造函数  
public Hashtable(Map<? extends K, ? extends V> t)

添加数据使用put(key, value)，取出数据使用get(key)，这两个基本操作的时间开销为常数。

使用Hashtable的简单示例如下，将1，2，3放到Hashtable中，他们的key分别是”one”，”two”，”three”：

import java.util.Map; 
import java.util.Hashtable;

Hashtable numbers = new Hashtable();
numbers.put(“one”, new Integer(1));
numbers.put(“two”, new Integer(2));
numbers.put(“three”, new Integer(3));
// 要取出一个数，比如2，用相应的key：
Integer n = (Integer)numbers.get(“two”);
System.out.println(“two = ” + n);

由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置，因此任何作为key的对象都必须实现hashCode和equals方法。hashCode和equals方法继承自根类Object，如果你用自定义的类当作key的话，要相当小心，按照散列函数的定义，如果两个对象相同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，但如果两个对象不同，则它们的hashCode不一定不同，如果两个不同对象的hashCode相同，这种现象称为冲突，冲突会导致操作哈希表的时间开销增大，所以尽量定义好的hashCode()方法，能加快哈希表的操作。

如果相同的对象有不同的hashCode，对哈希表的操作会出现意想不到的结果（期待的get方法返回null），要避免这种问题，只需要牢记一条：要同时复写equals方法和hashCode方法，而不要只写其中一个。

Hashtable是同步的。
参考：http://blog.csdn.net/woshisap/article/details/6887417

Hashtable通过initial capacity和load factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor可以节省空间但相应的查找时间将增大，这会影响像get和put这样的操作。

3.2 HashMap类：

HashMap和Hashtable类似，不同之处在于:

HashMap是非同步的;
HashMap允许null，即null value和null key。

但是将HashMap视为Collection时（values()方法可返回Collection），其迭代子操作时间开销和HashMap的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。

使用HashMap的一个简单例子:

import java.util.HashMap;  
import java.util.Iterator;  
import java.util.Set;  
import java.util.Map.Entry;  

public class HashMapDemo {  
    public static void main(String[] args) {        
        HashMap<String, String> hashMap = new HashMap<String, String>();  
        hashMap.put("cn", "中国");  
        hashMap.put("jp", "日本");  
        hashMap.put("fr", "法国");  

        System.out.println(hashMap);  
        System.out.println("cn:" + hashMap.get("cn"));  
        System.out.println(hashMap.containsKey("cn"));  
        System.out.println(hashMap.keySet());  
        System.out.println(hashMap.isEmpty());  
        hashMap.remove("cn");  
        System.out.println(hashMap.containsKey("cn"));  

        //采用Iterator遍历HashMap  
        Iterator it = hashMap.keySet().iterator();  
        while(it.hasNext()) {  
            String key = (String)it.next();  
            System.out.println("key:" + key);  
            System.out.println("value:" + hashMap.get(key));  
        }

        //遍历HashMap的另一个方法  
        Set<Entry<String, String>> sets = hashMap.entrySet();  
        for(Entry<String, String> entry : sets) {  
            System.out.print(entry.getKey() + ", ");  
            System.out.println(entry.getValue());  
        }
    }
}

一个结合List和HashMap实现的例子:

import java.util.Iterator;  
import java.util.List;  
import java.util.HashMap;  
import java.util.ArrayList;  
import java.util.Map;  
import java.util.Scanner;  
import java.util.Set;  
import java.util.Map.Entry;  
/** 
 * 在不创建学生类的情况下，从键盘输入n个学生信息(学号，姓名，年龄）， 
 * 输入完成后，打印出各个学生信息 
 */  
public class Assignment {  
    public static void main(String[] args) {  
        //定义保存学生信息的List，元素类型为HashMap  
        List<HashMap<String, Object>> list = new ArrayList<HashMap<String, Object>>();  
        Scanner input = new Scanner(System.in);  
        System.out.println("请输入学生的信息,y表示继续，n表示退出");  
        while("y".equals(input.next())) {  
            HashMap<String, Object> map = new HashMap<String, Object>();  
            System.out.println("请输入学号");  
            map.put("studentno", input.next());  
            System.out.println("请输入姓名");  
            map.put("name", input.next());  
            System.out.println("请输入年龄");  
            map.put("age", input.nextInt());  
            list.add(map);  
            System.out.println("请继续输入学生的信息,y表示继续，n表示退出");  
        }  

        System.out.println("输入的学生信息为:");  
        System.out.println("学生数量为:" + list.size());  

        Iterator<HashMap<String, Object>> it = list.iterator();  
        int i = 1;  
        while(it.hasNext()) {  
            HashMap<String, Object> stuMap = it.next();  
            System.out.print("第" + i + "个学生的信息为");  
            System.out.println("学号:" + stuMap.get("studentno") + " ,姓名:" + stuMap.get("name") + " ,年龄:" + stuMap.get("age"));  
        }  
    }  
}

3.3 TreeMap类：

参考：基于红黑树实现的TreeMap具体原理
参考：TreeMap的详细使用

TreeMap 是一个有序的key-value集合，它是通过红黑树实现的。
TreeMap 继承于AbstractMap，所以它是一个Map，即一个key-value集合。
TreeMap 实现了NavigableMap接口，意味着它支持一系列的导航方法。比如返回有序的key集合。
TreeMap 实现了Cloneable接口，意味着它能被克隆。
TreeMap 实现了java.io.Serializable接口，意味着它支持序列化。

TreeMap基于红黑树（Red-Black tree）实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。

TreeMap的基本操作 containsKey、get、put 和 remove 的时间复杂度是 log(n) 。另外，TreeMap是非同步的。它的iterator 方法返回的迭代器是fail-fastl的。

TreeMap与HashMap相比较：

HashMap里面存入的键值对在取出的时候是随机的，它根据键的HashCode值存储数据,根据键可以直接获取它的值，具有很快的访问速度。在Map 中插入、删除和定位元素，HashMap是最好的选择。
TreeMap取出来的是排序后的键值对。插入、删除需要维护平衡会牺牲一些效率。但如果要按自然顺序或自定义顺序遍历键，那么TreeMap会更好。

3.4 WeakHashMap类：

WeakHashMap是一种改进的HashMap，它对key实行“弱引用”，如果一个key不再被外部所引用，那么该key可以被GC回收。

3.5 ConcurrentHashMap类：

参考：ConcurrentHashMap类原理
参考：ConcurrentHashMap的使用实例

ConcurrentHashMap是Java 5中支持高并发、高吞吐量的线程安全HashMap实现。ConcurrentHashMap允许多个修改操作并发进行，其关键在于使用了锁分离技术。它使用了多个锁来控制对hash表的不同部分进行的修改。

锁分段技术：
HashTable容器在竞争激烈的并发环境下表现出效率低下的原因，是因为所有访问HashTable的线程都必须竞争同一把锁，那假如容器里有多把锁，每一把锁用于锁容器其中一部分数据，那么当多线程访问容器里不同数据段的数据时，线程间就不会存在锁竞争，从而可以有效的提高并发访问效率，这就是ConcurrentHashMap所使用的锁分段技术，首先将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。

有些方法需要跨段，比如size()和containsValue()，它们可能需要锁定整个表而而不仅仅是某个段，这需要按顺序锁定所有段，操作完毕后，又按顺序释放所有段的锁。这里“按顺序”是很重要的，否则极有可能出现死锁，在ConcurrentHashMap内部，段数组是final的，并且其成员变量实际上也是final的，但是，仅仅是将数组声明为final的并不保证数组成员也是final的，这需要实现上的保证。这可以确保不会出现死锁，因为获得锁的顺序是固定的。

定义方法：

import java.util.HashMap;  
import java.util.Hashtable;  
import java.util.Map;  
import java.util.concurrent.ConcurrentHashMap; 

Map<String, Integer> hashmapSync = Collections.synchronizedMap(new HashMap<String, Integer>());  
Map<String, Integer> concurrentHashMap = new ConcurrentHashMap<String, Integer>();  
Map<String, Integer> hashtable = new Hashtable<String, Integer>();

3.6 总结：

如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。

如果程序在单线程环境中，或者访问仅仅在一个线程中进行，考虑非同步的类，其效率较高，如果多个线程可能同时操作一个类，应该使用同步的类。

要特别注意对哈希表的操作，作为key的对象要正确复写equals和hashCode方法。

尽量返回接口而非实际的类型，如返回List而非ArrayList，这样如果以后需要将ArrayList换成LinkedList时，客户端代码不用改变。这就是针对抽象编程。

附：
同步性〉Vector是同步的。这个类中的一些方法保证了Vector中的对象是线程安全的。而ArrayList则是异步的，因此ArrayList中的对象并不是线程安全的。因为同步的要求会影响执行的效率，所以如果你不需要线程安全的集合那么使用ArrayList是一个很好的选择，这样可以避免由于同步带来的不必要的性能开销。

数据增长〉从内部实现机制来讲ArrayList和Vector都是使用数组(Array)来控制集合中的对象。当你向这两种类型中增加元素的时候，如果元素的数目超出了内部数组目前的长度它们都需要扩展内部数组的长度，Vector缺省情况下自动增长原来一倍的数组长度，ArrayList是原来的50%,所以最后你获得的这个集合所占的空间总是比你实际需要的要大。所以如果你要在集合中保存大量的数据那么使用Vector有一些优势，因为你可以通过设置集合的初始化大小来避免不必要的资源开销。

使用模式〉在ArrayList和Vector中，从一个指定的位置（通过索引）查找数据或是在集合的末尾增加、移除一个元素所花费的时间是一样的，这个时间我们用O(1)表示。但是，如果在集合的其他位置增加或移除元素那么花费的时间会呈线形增长：O(n-i)，其中n代表集合中元素的个数，i代表元素增加或移除元素的索引位置。为什么会这样呢？以为在进行上述操作的时候集合中第i和第i个元素之后的所有元素都要执行位移的操作。这一切意味着什么呢？

这意味着，你只是查找特定位置的元素或只在集合的末端增加、移除元素，那么使用Vector或ArrayList都可以。

如果是其他操作，你最好选择其他的集合操作类。比如，LinkList集合类在增加或移除集合中任何位置的元素所花费的时间都是一样的?O(1)，但它在索引一个元素的使用缺比较慢－O(i),其中i是索引的位置. 使用ArrayList也很容易，因为你可以简单的使用索引来代替创建iterator对象的操作。LinkList也会为每个插入的元素创建对象，所有你要明白它也会带来额外的开销。

最后，在《Practical Java》一书中Peter Haggar建议使用一个简单的数组（Array）来代替Vector或ArrayList。尤其是对于执行效率要求高的程序更应如此。因为使用数组(Array)避免了同步、额外的方法调用和不必要的重新分配空间的操作。

几个常用类的区别：
1. ArrayList: 元素单个，效率高，多用于查询
2. Vector: 元素单个，线程安全，多用于查询
3. LinkedList: 元素单个，多用于插入和删除
4. HashMap: 元素成对，元素可为空
5. HashTable: 元素成对，线程安全，元素不可为空

Hashtable和HashMap到底有哪些不同呢:
1. 基类不同：HashTable基于Dictionary类，而HashMap是基于AbstractMap。Dictionary是什么？它是任何可将键映射到相应值的类的抽象父类，而AbstractMap是基于Map接口的骨干实现，它以最大限度地减少实现此接口所需的工作。
2. null不同：HashMap可以允许存在一个为null的key和任意个为null的value，但是HashTable中的key和value都不允许为null。
3. 线程安全：HashMap时单线程安全的，Hashtable是多线程安全的。
4. 遍历不同：HashMap仅支持Iterator的遍历方式，Hashtable支持Iterator和Enumeration两种遍历方式。