Java集合类总结

Java集合类

1.简介：

java集合类包含在java.util包下
集合类存放的是对象的引用，而非对象本身。
集合类型主要分为Set(集)，List(列表)，Map(映射)。

1.1 java集合类图

集合关系图.jpg

从上述类图，自己整理出主要内容是如下：

.jpg

2.集合详解

2.1 HashSet

HashSet是Set接口的一个子类
主要的特点是：

  • 里面不能存放重复元素，元素的插入顺序与输出顺序不一致
  • 采用散列的存储方法，所以没有顺序。

代码实例：HashSetTest

package cn.swum;

import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;

public class HashSetTest {

    public static void main(String[] args) {

        Set set = new HashSet();

        set.add("a");
        set.add("b");
        set.add("c");
        set.add("d");
        set.add("f");
        //插入重复元素，测试set是否可以存放重复元素
        set.add("a");
        set.add(null);
        //插入重复null，看结果是否可以存放两个null
        set.add(null);

        Iterator iter = set.iterator();

        System.out.println("输出的排列顺序为：");

        while (iter.hasNext()){

            System.out.println( iter.next());
        }

    }
}

输出结果：

HashSetTest.jpg

小结：

HashSet存放的值无序切不能重复，可以存放null，但只能存放一个null值

HashSet 继承AbstractSet，有两个重要的方法，其中HashCode()和equals()方法,当对象被存储到HashSet当中时，会调用HashCode()方法，获取对象的存储位置。

HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等，并且两个对象的hashCode()方法返回值相等。

2.2 LinkedHashSet

  • LinkedHashSet是HashSet的一个子类
  • 只是HashSet底层用的HashMap，
    而LinkedHashSet底层用的LinkedHashMap

LinkedHashSet代码实例:

package cn.swum;

import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;

public class LinkedHashSetTest {

    public static void main(String[] args) {

        Set set = new LinkedHashSet();

        set.add("a");
        set.add("b");
        set.add("c");
        set.add("d");
        set.add("e");
        
        System.out.println("LinkedHashSet存储值得排序为：");

        for (Iterator iter = set.iterator();iter.hasNext();){
            System.out.println(iter.next());

        }

    }

}

输出结果：

LinkedHashSetTest.jpg

小结：

此时，LinkedHashSet中的元素是有序的

2.3 SortedSet（接口）

  • SortedSet是一个接口，里面（只有TreeSet这一个实现可用）的元素一定是有序的。
  • 保证迭代器按照元素递增顺序遍历的集合，
    可以按照元素的自然顺序（参见 Comparable）进行排序， 或者按照创建有序集合时提供的 Comparator进行排序

其源码如下：

public interface SortedSet<E> extends Set<E> {

        
    //返回与此有序集合关联的比较器，如果使用元素的自然顺序，则返回 null。

    Comparator<? super E> comparator();

        
    //返回此有序集合的部分元素，元素范围从 fromElement（包括）到 toElement（不包括）。

    SortedSet<E> subSet(E fromElement, E toElement);

        
    //用一个SortedSet, 返回此有序集合中小于end的所有元素。

    SortedSet<E> headSet(E toElement);

    
    //返回此有序集合的部分元素，其元素大于或等于 fromElement。

    SortedSet<E> tailSet(E fromElement);
        
    //返回此有序集合中当前第一个（最小的）元素。

    E first();
        

    //返回此有序集合中最后一个（最大的）元素

    E last();

}

2.4 TreeSet

  • TreeSet类实现Set 接口，该接口由TreeMap 实例支持，此类保证排序后的 set 按照升序排列元素，
    根据使用的构造方法不同，可能会按照元素的自然顺序 进行排序（参见 Comparable或按照在创建 set 时所提供的比较器进行排序。

  • Set 接口根据 equals 操作进行定义，但 TreeSet 实例将使用其 compareTo（或 compare）方法执行所有的键比较

代码实例TreeSetTest：

package cn.swum;

import java.util.Comparator;
import java.util.TreeSet;

public class TreeSetTest {

    static class Person{

        int id;
        String name;
        int age;
        
        public Person(int id, String name, int age){
            this.id = id;
            this.name = name;
            this.age = age;

        }

        public String toString(){
            return "id:"+ this.id + " " + "name:" + this.name +" " + "age:" + this.age;

        }

    }


    static class MyComparator implements Comparator<Person> {
        
        @Override
        public int compare(Person p1, Person p2) {

            if(p1 == p2) {
                return 0;

            }

            if(p1 != null && p2 == null) {
                return 1;

            }else if(p1 == null && p2 != null){
                return -1;

            }

            if(p1.id > p2.id){
                return 1;

            }else if(p1.id < p2.id){
                return -1;

            }
            
            return 0;
            
        }

    }

    public static void main(String[] args) {
        MyComparator myComparator = new MyComparator();

        TreeSet<Person> treeSet = new TreeSet<>(myComparator);

        treeSet.add(new Person(3,"张三",20));
        treeSet.add(new Person(2,"王二",22));
        treeSet.add(new Person(1,"赵一",18));
        treeSet.add(new Person(4,"李四",29));

        //增加null空对象
        treeSet.add(null);

        System.out.println("TreeSet的排序是：");

        for (Person p : treeSet){
            if(p == null){
                System.out.println(p);
            }else {
                System.out.println(p.toString());
            }
        }

    }

}

实例用TreeSet保存对象引用，并且实现Comparator中compare方法进行比较和排序

输出结果：

TreeSetTest.jpg
  • 表明TreeSet是可以按照自定义方法中的比较进行排序的，且可以有空值。

2.5 Vector

  • Vector 类也是基于数组实现的队列，代码与ArrayList非常相似。
  • 线程安全，执行效率低。
  • 动态数组的增长系数
  • 由于效率低，并且线程安全也是相对的，因此不推荐使用vector

2.6 Stack

Stack 是继承了Vector，是一个先进后出的队列

Stack里面主要实现的有一下几个方法：

方法名 返回类型 说明
empty boolean 判断stack是否为空
peek E 返回栈顶端的元素
pop E 弹出栈顶的元素
push E 将元素压入栈
search int 返回最靠近顶端的目标元素到顶端的距离

代码实例StackTest：

package cn.swum;

import java.util.Stack;

public class StackTest {

    static class Person{

        int id;
        String name;
        int age;

        public Person(int id, String name, int age){
            this.id = id;
            this.name = name;
            this.age = age;

        }

        public String toString(){
            return "id:"+ this.id + " " + "name:" + this.name +" " + "age:" + this.age;

        }

    }

    public static void main(String[] args) {

        Stack stack = new Stack();

        stack.push(new Person(1,"赵一",18));
        stack.push(new Person(2,"王二",19));
        stack.push(new Person(3,"张三",20));
        stack.push(new Person(4,"李四",21));

        System.out.println("栈顶元素是:(" + stack.peek() + ")");

        System.out.println("目标元素离栈顶多少距离:" + stack.search(stack.get(0)));

        System.out.println("栈元素从栈顶到栈底的排序是:");

        //此处先用size保存是因为pop时，size会减1，
        // 如果直接stack.size放在循环中比较，只能打印一半对象
        int size = stack.size();

        for (int i = 0; i < size ; i++) {

            Person p = (Person) stack.pop();

            System.out.println(p.toString());

        }

    }

}

输出结果：

StackTest.jpg
  • Stack 是一个有序的栈，遵循先进后出原则。

2.7 ArrayList

ArrayList是List的子类，它和HashSet相反，允许存放重复元素，因此有序。

集合中元素被访问的顺序取决于集合的类型。

如果对ArrayList进行访问，迭代器将从索引0开始，每迭代一次，索引值加1。

然而，如果访问HashSet中的元素，每个元素将会按照某种随机的次序出现。

虽然可以确定在迭代过程中能够遍历到集合中的所有元素，但却无法预知元素被访问的次序。

代码实例：ArrayListTest

package cn.swum;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class ArrayListTest {

    public static void main(String[] args) {

        List<String> arrayList = new ArrayList<String>();


        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("c");
        //添加重复值
        arrayList.add("a");
        arrayList.add("d");
        arrayList.add("e");
        //添加null
        arrayList.add(null);

        System.out.println("arrayList的输出顺序为:");

        for (int i = 0; i < arrayList.size(); i++) {

            System.out.println((i+1) + ":" +arrayList.get(i));

        }

    }

}

输出结果：

ArrayListTest.jpg
  • ArrayList是一个有序且允许重复和空值的列表

2.8 LinkedList

LinkedList是一种可以在任何位置进行高效地插入和删除操作的有序序列。

代码实例：LinkedListTest

package cn.swum;


import java.util.LinkedList;

/**
 * @author long
 * @date 2017/2/28
 */
public class LinkedListTest {

    public static void main(String[] args) {

        LinkedList<String> linkedList = new LinkedList<String>();

        linkedList.add("a");
        linkedList.add("b");
        linkedList.add("c");
        linkedList.add("d");
        linkedList.add("e");

        linkedList.add(2,"2");

        System.out.println("linkedList的输出顺序是:" + linkedList.toString());

        linkedList.push("f");

        System.out.println("push后，linkedList的元素顺序:" + linkedList.toString());

        linkedList.pop();

        System.out.println("pop后，linkedList的所剩元素:" + linkedList.toString());

    }

}

输出结果：

LinkedListTest.jpg
  • LinkedList是有序的双向链表，可以在任意时刻进行元素的插入与删除，读取效率低于ArrayList，插入效率高
  • pop和push操作都是在队头开始

2.9 HashMap

  • HashMap的数据结构:

数组的特点是：寻址容易，插入和删除困难；

而链表的特点是：寻址困难，插入和删除容易。

哈希表结合了两者的优点。

哈希表有多种不同的实现方法，可以理解将此理解为“链表的数组”

2012051414243547.png

  • 从上图我们可以发现哈希表是由数组+链表组成的，一个长度为16的数组中，每个元素存储的是一个链表的头结点。那么这些元素是按照什么样的规则存储到数组中呢。一般情况是通过hash(key)%len获得，也就是元素的key的哈希值对数组长度取模得到。比如上述哈希表中:
    12%16=12,28%16=12,108%16=12,140%16=12。所以12、28、108以及140都存储在数组下标为12的位置。然后每个线性的数组下存储一个链表，链接起来。

  • 首先HashMap里面实现一个静态内部类Entry，其重要的属性有 key , value, next，从属性key,value我们就能很明显的看出来Entry就是HashMap键值对实现的一个基础bean.我们上面说到HashMap的基础就是一个线性数组，这个数组就是Entry[]，Map里面的内容都保存在Entry[]里面。

  • HashMap的存取实现:

//存储时:
int hash = key.hashCode();// 这个hashCode方法这里不详述,只要理解每个key的hash是一个固定的int值
int index = hash % Entry[].length;
Entry[index] = value;

//取值时:
int hash = key.hashCode();
int index = hash % Entry[].length;
return Entry[index];
  • 疑问：如果两个key通过hash%Entry[].length得到的index相同，会不会有覆盖的危险？

这里HashMap里面用到链式数据结构的一个概念。上面我们提到过Entry类里面有一个next属性，作用是指向下一个Entry。打个比方，第一个键值对A进来，通过计算其key的hash得到的index=0，记做:Entry[0] = A。一会后又进来一个键值对B，通过计算其index也等于0，现在怎么办？

HashMap会这样做:B.next = A,Entry[0] = B,如果又进来C,index也等于0,那么C.next = B,Entry[0] = C；这样我们发现index=0的地方其实存取了A,B,C三个键值对,他们通过next这个属性链接在一起。所以疑问不用担心。也就是说数组中存储的是最后插入的元素。

HashMapTest代码实例，自我实现HashMap:

Entry.java

package cn.swum.cn.swun.hash;

/**
 * @author long
 * @date 2017/2/28
 */
public class Entry <K,V>{

    final K key;
    V value;
    Entry<K,V> next;//下一个结点

    //构造函数
    public Entry(K k, V v, Entry<K,V> n) {
        key = k;
        value = v;
        next = n;
    }

    public final K getKey() {
        return key;
    }

    public final V getValue() {
        return value;
    }

    public final V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }

    public final boolean equals(Object o) {
        if (!(o instanceof Entry))
            return false;
        Entry e = (Entry)o;
        Object k1 = getKey();
        Object k2 = e.getKey();
        if (k1 == k2 || (k1 != null && k1.equals(k2))) {
            Object v1 = getValue();
            Object v2 = e.getValue();
            if (v1 == v2 || (v1 != null && v1.equals(v2)))
                return true;
        }
        return false;
    }

    public final int hashCode() {
        return (key==null   ? 0 : key.hashCode()) ^ (value==null ? 0 : value.hashCode());
    }

    public final String toString() {
        return getKey() + "=" + getValue();
    }

}

MyHashMap.java

package cn.swum.cn.swun.hash;

/**
 * @author long
 * @date 2017/2/28
 */
public class MyHashMap<K,V>{

    private Entry[] table;//Entry数组表
    static final int DEFAULT_INITIAL_CAPACITY = 16;//默认数组长度
    private int size;

    // 构造函数
    public MyHashMap() {
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        size = DEFAULT_INITIAL_CAPACITY;
    }

    //获取数组长度
    public int getSize() {
        return size;
    }

    // 求index
    static int indexFor(int h, int length) {
        return h % (length - 1);
    }

    //获取元素
    public V get(Object key) {
        if (key == null)
            return null;
        int hash = key.hashCode();// key的哈希值
        int index = indexFor(hash, table.length);// 求key在数组中的下标
        for (Entry<K, V> e = table[index]; e != null; e = e.next) {
            Object k = e.key;
            if (e.key.hashCode() == hash && (k == key || key.equals(k)))
                return e.value;
        }
        return null;
    }

    // 添加元素
    public V put(K key, V value) {
        if (key == null)
            return null;
        int hash = key.hashCode();
        int index = indexFor(hash, table.length);

        // 如果添加的key已经存在，那么只需要修改value值即可
        for (Entry<K, V> e = table[index]; e != null; e = e.next) {
            Object k = e.key;
            if (e.key.hashCode() == hash && (k == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                return oldValue;// 原来的value值
            }
        }
        // 如果key值不存在，那么需要添加
        Entry<K, V> e = table[index];// 获取当前数组中的e
        table[index] = new Entry<K, V>(key, value, e);// 新建一个Entry，并将其指向原先的e
        return null;
    }

}

MyHashMapTest.java

package cn.swum.cn.swun.hash;

/**
 * @author long
 * @date 2017/2/28
 */
public class MyHashMapTest {

    public static void main(String[] args) {

        MyHashMap<Integer, Integer> map = new MyHashMap<Integer, Integer>();
        map.put(1, 90);
        map.put(2, 95);
        map.put(17, 85);

        System.out.println(map.get(1));
        System.out.println(map.get(2));
        System.out.println(map.get(17));
        System.out.println(map.get(null));
    }

}

输出结果：

HashMapTest.jpg

2.10 WeekHashMapTest

package cn.swum.cn.swun.hash;

import java.util.WeakHashMap;

/**
 * @author long
 * @date 2017/2/28
 */
public class WeekHashMapTest {

    public static void main(String[] args) {
        int size = 10;

        if (args.length > 0) {
            size = Integer.parseInt(args[0]);
        }

        Key[] keys = new Key[size];
        WeakHashMap<Key, Value> whm = new WeakHashMap<Key, Value>();

        for (int i = 0; i < size; i++) {
            Key k = new Key(Integer.toString(i));
            Value v = new Value(Integer.toString(i));
            if (i % 3 == 0) {
                keys[i] = k;//强引用
            }
            whm.put(k, v);//所有键值放入WeakHashMap中
        }

        System.out.println(whm);
        System.out.println(whm.size());
        System.gc();

        try {
            // 把处理器的时间让给垃圾回收器进行垃圾回收
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(whm);
        System.out.println(whm.size());
    }
}

class Key {
    String id;

    public Key(String id) {
        this.id = id;
    }

    public String toString() {
        return id;
    }

    public int hashCode() {
        return id.hashCode();
    }

    public boolean equals(Object r) {
        return (r instanceof Key) && id.equals(((Key) r).id);
    }

    public void finalize() {
        System.out.println("Finalizing Key " + id);
    }
}

class Value {
    String id;

    public Value(String id) {
        this.id = id;
    }

    public String toString() {
        return id;
    }

    public void finalize() {
        System.out.println("Finalizing Value " + id);
    }

}

输出结果：

WeakHashMapTest.jpg

2.11 HashTable与HashMap的区别

  • HashTable和HashMap存在很多的相同点，但是他们还是有几个比较重要的不同点。

  1. 我们从他们的定义就可以看出他们的不同，HashTable基于Dictionary类，而HashMap是基于AbstractMap。Dictionary是什么？它是任何可将键映射到相应值的类的抽象父类，而AbstractMap是基于Map接口的骨干实现，它以最大限度地减少实现此接口所需的工作。

  2. HashMap可以允许存在一个为null的key和任意个为null的value，但是HashTable中的key和value都不允许为null。如下：当HashMap遇到为null的key时，它会调用putForNullKey方法来进行处理。对于value没有进行任何处理，只要是对象都可以。

  3. Hashtable的方法是同步的，而HashMap的方法不是。所以有人一般都建议如果是涉及到多线程同步时采用HashTable，没有涉及就采用HashMap，但是在Collections类中存在一个静态方法：synchronizedMap()，该方法创建了一个线程安全的Map对象，并把它作为一个封装的对象来返回，所以通过Collections类的synchronizedMap方法是可以我们你同步访问潜在的HashMap。

  4. 遍历不同：HashMap仅支持Iterator的遍历方式，Hashtable支持Iterator和Enumeration两种遍历方式。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 158,736评论 4赞 362
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 67,167评论 1赞 291
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 108,442评论 0赞 243
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 43,902评论 0赞 204
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 52,302评论 3赞 287
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,573评论 1赞 216
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 31,847评论 2赞 312
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,562评论 0赞 197
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,260评论 1赞 241
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,531评论 2赞 245
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 32,021评论 1赞 258
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,367评论 2赞 253
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 33,016评论 3赞 235
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,068评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,827评论 0赞 194
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,610评论 2赞 274
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,514评论 2赞 269

推荐阅读更多精彩内容