Java十分鐘精通集合的使用與原理下篇

更新時間：2022年03月10日 15:55:55 作者：熱愛飛行的小應(yīng)學(xué)長

這章就對上一章的集合進(jìn)行代碼操作，去學(xué)習(xí)如果創(chuàng)建集合，以及對集合數(shù)據(jù)的處理，下面跟小編一起來看看吧

List集合：

ArrayList：

底層是數(shù)組結(jié)構(gòu)，儲存有序并且可以重復(fù)的對象

package SetTest;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ArrayListTest {
    public static void main(String[] args) {

		//創(chuàng)建ArrayList的對象
        List<Integer> list = new ArrayList<>();  
        //使用add方法就可以添加
        list.add(1);
        list.add(2); //是可以重復(fù)的
        list.add(2);
        list.add(3);
        list.add(4);
        
        //使用集合工具類Collections
        Collections.sort(list); //排序
        Collections.reverse(list); //反轉(zhuǎn)
        System.out.println(list.toString());

    }
}

輸出：

[1, 2, 2, 3, 4]
[4, 3, 2, 2, 1]
//在ArrayList中重復(fù)數(shù)據(jù)是沒問題的

LinkedList：

雙向鏈表式存儲，存儲有序可重復(fù)的對象。LinkedList的實現(xiàn)機(jī)制與ArrayList的不同，ArrayList底層是數(shù)組實現(xiàn)的，每次插入值的時候先擴(kuò)容數(shù) 組的長度，通過下標(biāo)獲取到該數(shù)組的值因此查詢元素的效率很高，但是插入和刪除需要位移效率很低，所以經(jīng) 常對元素插入或者刪除操作建議不要使用ArrayList，而要采用LinkedList。LinkedList采用雙向鏈表式存儲在增加和刪除元素的時候不需要位移，插入和刪除效率高。

LinkedList的儲存結(jié)構(gòu)：

總結(jié)：查詢多的時候用ArrayList，刪除和插入多就用LinkedList

List<Integer> list = new LinkedList<>();//創(chuàng)建LinkedList的對象

其他操作與ArrayList一致

Vector：

Vector和ArrayList集合沒有什么太大的區(qū)別，底層都是數(shù)組實現(xiàn)的，作用也是一致，用來存儲大量的有序的可重復(fù)的對象，一般用于大量數(shù)據(jù)的查詢。唯一的區(qū)別在于Vector是線程安全的，ArrayList是非線程安全的。

 List<Integer> list = new Vector<>();//創(chuàng)建Vector的對象

其他操作與ArrayList一致

Set集合：

HashSet：

是以Hash算法來記錄再內(nèi)存中無序存儲的對象

HashSet源碼：

public HashSet() {
	map = new HashMap<>();
}

說明HashSet底層是依賴于HashMap以鍵值對的形式來存儲的無序的集合，通過鍵來找到值，但是鍵是以hash算法來存儲的無序集合。

TreeSet:

TreetSet是SortSet接口的實現(xiàn)類，TreeSet可以保證元素處于排序狀態(tài)再保存。它采用的是紅黑樹算法數(shù) 據(jù)結(jié)構(gòu)來存儲集合元素。TreeSet支持兩種排序：自然排序和定制排序，默認(rèn)采用自然排序

自然排序：

package SetTest;

import java.util.Set;
import java.util.TreeSet;

public class TreeSetTest {
    public static void main(String[] args) {

        //treeSet是以紅黑樹算法將值先排序再保存
        Set<Integer> tre = new TreeSet<>();
        tre.add(5);
        tre.add(3);
        tre.add(8);
        tre.add(1);
        tre.add(4);
        for (Integer val:tre){
            System.out.println(val);
        }
    }
}

輸出：

1
3
4
5
8

定制排序：

Student類：

package TreeSet;

public class Student implements Comparable<Student> {

    private String name;
    private int age;
    private char sex;

    public Student(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    @Override
    public String toString(){
        return "學(xué)生的信息是{"+name+age+sex+"}";
    }

    @Override
    public int compareTo(Student obj) {
        //這里使用年齡來比較排序
        int num = this.age-obj.age;
        return num;
    }
}

測試類：

package TreeSet;

import java.util.Set;
import java.util.TreeSet;

public class test {
    public static void main(String[] args) {
		
		//這里生成對象的年齡不按照大小來生成
        Student stu1 = new Student("張三",40,'男');
        Student stu2 = new Student("李四",32,'男');
        Student stu3 = new Student("王五",25,'男');

        Set<Student> treeSet = new TreeSet<>();
        treeSet.add(stu1);
        treeSet.add(stu2);
        treeSet.add(stu3);

        for (Student stu:treeSet
             ) {
            System.out.println(stu.toString());

        }
    }
}

輸出結(jié)果：

結(jié)果就是按照年齡的大小來進(jìn)行排序：（這個就是TreeSet的定制排序）

學(xué)生的信息是{王五25男}
學(xué)生的信息是{李四32男}
學(xué)生的信息是{張三40男}

LinkedHashSet：

內(nèi)部是一個雙向鏈表式結(jié)構(gòu)，所以它插入的值式有序的。因為它插入的時候是使用鏈表式維護(hù)插入的順序，所以獲取元素的時候應(yīng)該和插入的順序一致。但是LinedHashSet性能上低于HashSet，因為除了維護(hù)值以外還需要維護(hù)他們的順序：

package SetTest;

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

public class LinkedHashSetTest {
    public static void main(String[] args) {

        //LinkedHashSet 按照插入的順序讀取值
        Set<Integer> set = new LinkedHashSet<>();
        set.add(40);
        set.add(20);
        set.add(10);
        set.add(30);
        
        for (Integer val:set){
            System.out.println(val);
        }
    }
}

輸出：（會按照輸入的順序去讀值）

40
20
10
30

Map集合：

HashMap：

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

public class MapTest {
    public static void main(String[] args) {
    
        Map<String,String> map = new HashMap<>();
        map.put("red","紅色");
        map.put("yellow","黃色");
        map.put("green","綠色");
        
        System.out.println(map);
        
        System.out.println(map.get("yellow"));//通過get鍵去獲取值

	}
}

輸出：

{red=紅色, green=綠色, yellow=黃色}
黃色 // System.out.println(map.get("yellow"));

HashMap的兩種遍歷方法：

通過for遍歷所有的鍵，根據(jù)鍵來獲取到值（接上部分代碼即可）

   for (String stu:map.values()
             )
            System.out.println(stu.toString());{
        }

輸出：

紅色
綠色
黃色

用迭代器的方式：（接上部分代碼即可）

        Set<String> keys = map.keySet();
        Iterator<String> it = keys.iterator();
        while(it.hasNext()){
            String key = it.next();
            String stu = map.get(key);
            System.out.println(stu.toString());
}

輸出：

紅色
綠色
黃色

注意：如果是存儲大量的數(shù)據(jù)，我們一般是不會用Map去存儲。Map一般用于存儲小量并且可以無序的鍵值對存儲的數(shù)據(jù)。比如登錄頁面的用戶名、密碼等等。

LinkedHashMap：

LinkedHashMap是以鏈表式存儲的HashMap，并且是以Hash算法來獲取hashcode的值來獲取內(nèi)存中的數(shù) 據(jù)，存儲的順序和讀取的順序一致：

import java.util.LinkedHashMap;
import java.util.Map;
public class LinkHashMap {

    public static void main(String[] args) {

		//在HashMap里面，添加使用put方法！！        
        Map<String,String> map = new LinkedHashMap<>();
        map.put("yellow","黃色");
        map.put("green","綠色");
        map.put("red","紅色");
        System.out.println(map);
    }
}

輸出：

{yellow=黃色, green=綠色, red=紅色}

HashTable：

Map<String,String> map = new Hashtable<>();

HashMap和HashTable的作用一樣，都是無序的鍵值對形式存儲，HashTable考慮線程安全，HashMap不考慮線程安全，其他操作一致。

ConcurrentHashMap: 也是和HashMap線程一樣，但是它考慮線程安全。HashTable是采用給當(dāng)前線程加鎖實現(xiàn)線程安全， ConcurrentHashMap是采用分段鎖機(jī)制來實現(xiàn)線程安全：

Map<String,String> map = new ConcurrentHashMap<>();

EnumMap：

專門用來存儲枚舉的Map集合：

package SetTest;
import java.util.Map;
public class EnumMap {

    //枚舉
    public enum color{
        RED,GREEN,YELLOW
    }
    public static void main(String[] args) {

        //枚舉map
        Map<color,String> map = new java.util.EnumMap<color, String>(color.class);
        map.put(color.RED,"紅燈");
        map.put(color.GREEN,"綠燈");
        map.put(color.YELLOW,"黃燈");
        System.out.println(color.RED);
        String info = map.get(color.RED);
        System.out.println("信號信息是："+info);

    }
}

集合和數(shù)組之間的轉(zhuǎn)換：

import com.sun.corba.se.spi.ior.ObjectKey;
import java.util.Arrays;
import java.util.List;

/**
 * 集合和數(shù)組之間的轉(zhuǎn)換
 */

public class SetToArr {
    public static void main(String[] args) {
        String name [] =  new String[]{"張三","李四","王五","趙六"};

        //將各種數(shù)據(jù)轉(zhuǎn)換成list集合
        List<String> list1 = Arrays.asList(name);
        List<String> list2 = Arrays.asList("aa","bb","cc");
        List<Integer> list3 = Arrays.asList(100,200,300);
        System.out.println("list集合："+list2);

        //list轉(zhuǎn)數(shù)組
        Object [] newArr = list2.toArray();
        String newStr = list2.toString();
        System.out.println("數(shù)組："+newStr);



    }
}

輸出：