java中的集合類有哪些

java中的集合類有哪些？可能很多人都不太了解，為了讓大家更加了解，小編給大家總結了以下內容，希望大家根據這篇文章可以有所收獲。

1、java集合類圖

上述類圖中，實線邊框的是實現類，比如ArrayList，LinkedList，HashMap等，折線邊框的是抽象類，比如AbstractCollection，AbstractList，AbstractMap等，而點線邊框的是接口，比如Collection，Iterator，List等。

發現一個特點，上述所有的集合類，都實現了Iterator接口，這是一個用于遍歷集合中元素的接口，主要包含hashNext(),next(),remove()三種方法。

它的一個子接口LinkedIterator在它的基礎上又添加了三種方法，分別是add(),previous(),hasPrevious()。也就是說如果是先Iterator接口，那么在遍歷集合中元素的時候，只能往后遍歷，被遍歷后的元素不會在遍歷到，通常無序集合實現的都是這個接口。

比如HashSet，HashMap；而那些元素有序的集合，實現的一般都是LinkedIterator接口，實現這個接口的集合可以雙向遍歷，既可以通過next()訪問下一個元素，又可以通過previous()訪問前一個元素，比如ArrayList。

還有一個特點就是抽象類的使用。如果要自己實現一個集合類，去實現那些抽象的接口會非常麻煩，工作量很大。這個時候就可以使用抽象類，這些抽象類中給我們提供了許多現成的實現，我們只需要根據自己的需求重寫一些方法或者添加一些方法就可以實現自己需要的集合類，工作流大大降低。

2、詳解

2.1HashSet

HashSet是Set接口的一個子類，主要的特點是：里面不能存放重復元素，而且采用散列的存儲方法，所以沒有順序。這里所說的沒有順序是指：元素插入的順序與輸出的順序不一致。

代碼實例：HashSetDemo

package edu.sjtu.erplab.collection;

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

public class HashSetDemo {

    public static void main(String[] args) {
        Set<String> set=new HashSet<String>();
        
        set.add("a");
        set.add("b");
        set.add("c");
        set.add("c");
        set.add("d");
        
        //使用Iterator輸出集合
        Iterator<String> iter=set.iterator();
        while(iter.hasNext())
        {
            System.out.print(iter.next()+" ");
        }
        System.out.println();
        //使用For Each輸出結合
        for(String e:set)
        {
            System.out.print(e+" ");
        }
        System.out.println();
        
        //使用toString輸出集合
        System.out.println(set);
    }
}

代碼實例：SetTest

package edu.sjtu.erplab.collection;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;

public class SetTest {

    public static void main(String[] args) throws FileNotFoundException {
        Set<String> words=new HashSet<String>();

        //通過輸入流代開文獻
        //方法1:這個方法不需要拋出異常
        InputStream inStream=SetTest.class.getResourceAsStream("Alice.txt");
        
        //方法2：這個方法需要拋出異常
        //InputStream inStream = new FileInputStream("D:\\Documents\\workspace\\JAVAStudy\\src\\edu\\sjtu\\erplab\\collection\\Alice.txt");
        Scanner in=new Scanner(inStream);
        while(in.hasNext())
        {
            words.add(in.next());
        }
        
        Iterator<String> iter=words.iterator();
        
        for(int i=0;i<5;i++)
        {
            if(iter.hasNext())
            System.out.println(iter.next());
        }
        
        System.out.println(words.size());

    }
}

2.2ArrayList

ArrayList是List的子類，它和HashSet想法，允許存放重復元素，因此有序。集合中元素被訪問的順序取決于集合的類型。如果對ArrayList進行訪問，迭代器將從索引0開始，每迭代一次，索引值加1。然而，如果訪問HashSet中的元素，每個元素將會按照某種隨機的次序出現。雖然可以確定在迭代過程中能夠遍歷到集合中的所有元素，但卻無法預知元素被訪問的次序。

代碼實例：ArrayListDemo

package edu.sjtu.erplab.collection;

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

public class ArrayListDemo {
    public static void main(String[] args) {
        List<String> arrList=new ArrayList<String>();
        
        arrList.add("a");
        arrList.add("b");
        arrList.add("c");
        arrList.add("c");
        arrList.add("d");

        //使用Iterator輸出集合
        Iterator<String> iter=arrList.iterator();
        while(iter.hasNext())
        {
            System.out.print(iter.next()+" ");
        }
        System.out.println();
        //使用For Each輸出結合
        for(String e:arrList)
        {
            System.out.print(e+" ");
        }
        System.out.println();
        
        //使用toString輸出集合
        System.out.println(arrList);
    }
}

2.3 ListIterator

ListIterator是一種可以在任何位置進行高效地插入和刪除操作的有序序列。

代碼實例：LinkedListTest

package edu.sjtu.erplab.collection;

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

public class LinkedListTest {

    public static void main(String[] args) {

        List<String> a=new ArrayList<String>();
        a.add("a");
        a.add("b");
        a.add("c");
        System.out.println(a);
        
        List<String> b=new ArrayList<String>();
        b.add("d");
        b.add("e");
        b.add("f");
        b.add("g");
        System.out.println(b);
        
        //ListIterator在Iterator基礎上添加了add(),previous()和hasPrevious()方法
        ListIterator<String> aIter=a.listIterator();
        //普通的Iterator只有三個方法，hasNext()，next()和remove()
        Iterator<String> bIter=b.iterator();
        
        //b歸并入a當中，間隔交叉得插入b中的元素
        while(bIter.hasNext())
        {
            if(aIter.hasNext())
                aIter.next();
            aIter.add(bIter.next());
        }
        System.out.println(a);
        
        //在b中每隔兩個元素刪除一個
        bIter=b.iterator();
        
        while(bIter.hasNext())
        {
            bIter.next();
            if(bIter.hasNext())
            {
                bIter.next();//remove跟next是成對出現的，remove總是刪除前序
                bIter.remove();
            }
        }
        System.out.println(b);
        
        //刪除a中所有的b中的元素
        a.removeAll(b);
        System.out.println(a);
    }
}

2.4HashMap

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];

2.5WeekHashMapDemo

package edu.sjtu.erplab.collection;

import java.util.WeakHashMap;

public class WeekHashMapDemo {

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

        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);
    }

}

比較

看完上述內容，你們對java中的集合類有進一步的了解嗎？如果還想了解更多相關內容，歡迎關注億速云行業資訊頻道，感謝各位的閱讀。