Java十分鐘精通集合的使用與原理下篇
List集合：
ArrayList：
底層是數組結構，儲存有序並且可以重復的對象
package SetTest;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class ArrayListTest {
public static void main(String[] args) {
//創建ArrayList的對象
List<Integer> list = new ArrayList<>();
//使用add方法就可以添加
list.add(1);
list.add(2); //是可以重復的
list.add(2);
list.add(3);
list.add(4);
//使用集合工具類Collections
Collections.sort(list); //排序
Collections.reverse(list); //反轉
System.out.println(list.toString());
}
}
輸出：
[1, 2, 2, 3, 4]
[4, 3, 2, 2, 1]
//在ArrayList中重復數據是沒問題的
LinkedList：
雙向鏈表式存儲，存儲有序可重復的對象。LinkedList的實現機制與ArrayList的不同，ArrayList底層是數組實現的，每次插入值的時候先擴容數 組的長度，通過下標獲取到該數組的值因此查詢元素的效率很高，但是插入和刪除需要位移效率很低，所以經 常對元素插入或者刪除操作建議不要使用ArrayList，而要采用LinkedList。LinkedList采用雙向鏈表 式存儲在增加和刪除元素的時候不需要位移，插入和刪除效率高。
LinkedList的儲存結構：
總結：查詢多的時候用ArrayList，刪除和插入多就用LinkedList
List<Integer> list = new LinkedList<>();//創建LinkedList的對象
其他操作與ArrayList一致
Vector：
Vector和ArrayList集合沒有什麼太大的區別，底層都是數組實現的，作用也是一致，用來存儲大量的有序 的可重復的對象，一般用於大量數據的查詢。唯一的區別在於Vector是線程安全的，ArrayList是非線程安全的。
List<Integer> list = new Vector<>();//創建Vector的對象
其他操作與ArrayList一致
Set集合：
HashSet：
是以Hash算法來記錄再內存中無序存儲的對象
HashSet源碼：
public HashSet() {
map = new HashMap<>();
}
說明HashSet底層是依賴於HashMap以鍵值對的形式來存儲的無序的集合，通過鍵來找到值，但是鍵是 以hash算法來存儲的無序集合。
TreeSet:
TreetSet是SortSet接口的實現類，TreeSet可以保證元素處於排序狀態再保存。它采用的是紅黑樹算法數 據結構來存儲集合元素。TreeSet支持兩種排序：自然排序和定制排序，默認采用自然排序
自然排序：
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 "學生的信息是{"+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());
}
}
}
輸出結果：
結果就是按照年齡的大小來進行排序：（這個就是TreeSet的定制排序）
學生的信息是{王五25男}
學生的信息是{李四32男}
學生的信息是{張三40男}
LinkedHashSet：
內部是一個雙向鏈表式結構，所以它插入的值式有序的。因為它插入的時候是使用鏈表式維護插入的順 序，所以獲取元素的時候應該和插入的順序一致。但是LinedHashSet性能上低於HashSet，因為除瞭維護值 以外還需要維護他們的順序：
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遍歷所有的鍵，根據鍵來獲取到值（接上部分代碼即可）
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());
}
輸出：
紅色
綠色
黃色
註意：如果是存儲大量的數據，我們一般是不會用Map去存儲。Map一般用於存儲小量並且可以無序的 鍵值對存儲的數據。比如登錄頁面的用戶名、密碼等等。
LinkedHashMap：
LinkedHashMap是以鏈表式存儲的HashMap，並且是以Hash算法來獲取hashcode的值來獲取內存中的數 據，存儲的順序和讀取的順序一致：
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是采用給當前線程加鎖實現線程安全， ConcurrentHashMap是采用分段鎖機制來實現線程安全：
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);
}
}
集合和數組之間的轉換：
import com.sun.corba.se.spi.ior.ObjectKey;
import java.util.Arrays;
import java.util.List;
/**
* 集合和數組之間的轉換
*/
public class SetToArr {
public static void main(String[] args) {
String name [] = new String[]{"張三","李四","王五","趙六"};
//將各種數據轉換成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轉數組
Object [] newArr = list2.toArray();
String newStr = list2.toString();
System.out.println("數組："+newStr);
}
}
輸出：
list集合：[aa, bb, cc]
數組：[aa, bb, cc]
這些就是常用的集合代碼舉例，大傢可以結合上一章的理論知識來看，在這裡寫的都是一些很簡潔的例子，大傢多看看就可以理解。
到此這篇關於Java十分鐘精通集合的使用與原理下篇的文章就介紹到這瞭,更多相關Java 集合內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！
推薦閱讀：
- 帶你入門Java的集合
- Java集合類之TreeSet的用法詳解
- 深入解讀Java三大集合之map list set的用法
- HashMap實現保存兩個key相同的數據
- Java List的sort()方法改寫compare()實現升序,降序,倒序的案例