java集合框架
-
概念：物件的容器，定義了對多個物件進行操作的常用方法，可以實作陣列的功能，
-
和陣列的區別：
- 陣列長度固定，集合長度不固定
- 陣列可以存盤基本資料型別和參考資料型別，集合只能存盤參考資料型別（存盤基本資料型別自動裝箱）
Collection類
所有集合類的父介面
集合體系結構：包括List介面和Set介面的區別
Collection特點：代表一組任意型別的物件，無序、無下標
各元素物件之間沒有指定的順序，允許有重復元素和多個Null元素物件，所以不可以排序，也不可以找出第幾個第幾個元素，
方法：
Collection collection = new ArrayList();
//添加
collection.add("蘋果");
collection.add("西瓜");
collection.add("葡萄");
System.out.println(collection.size());
System.out.println(collection);//相當于呼叫toString
// 洗掉
collection.remove("蘋果");
System.out.println(collection);
// 清除
// collection.clear();
// 遍歷
// 方法一,因為collection無下標所以不要用for-i
for (Object o : collection) {
}
// 方法二：迭代器(專門遍歷集合的一種方式),Iterator是一個介面
Iterator it = collection.iterator();
//是否有下一個元素
it.next();
it.remove();//迭代器中只能用這種方法洗掉,不能用本來的洗掉,洗掉的是堆疊存盤的地址，通過equals方法
while (it.hasNext()){
//等于下一個元素
String s =(String) it.next();
System.out.println(s);
}
// 判斷
System.out.println(collection.contains("葡萄"));
System.out.println(collection.isEmpty());
/*
3
[蘋果, 西瓜, 葡萄]
[西瓜, 葡萄]
葡萄
true
false
List類
特點：有序、有下標、元素可以重復
在擁有父類的方法之外，List特有方法
另外List也有特殊的迭代器串列迭代器ListIterator可以向前或者向后遍歷：
List list = new ArrayList();
// 添加
list.add(0,"蘋果");
list.add("西瓜");
// 串列迭代器
ListIterator listIterator = list.listIterator();
while (listIterator.hasNext()){
System.out.println(listIterator.nextIndex()+":"+listIterator.next());
}
System.out.println("------從后往前---------------");
while (listIterator.hasPrevious()){
System.out.println(listIterator.nextIndex()+":"+listIterator.previous());
}
//查詢位置
System.out.println(list.indexOf("蘋果"));
/*
0:蘋果
1:西瓜
------從后往前---------------
2:西瓜
1:蘋果
0
list洗掉數字：
List list = new ArrayList();
list.add(1);
list.add(2);
//直接輸入數字會被認為是下標，又因為集合的基本資料型別經過了裝箱，所以這樣寫
list.remove((Object)1);或者new Integer（1）也可以
System.out.println(list);
//[2]
其他方法不再演示
List的實作類：ArrayList,Vector,LinkedList
ArrayList類
- 以陣列結構實作，查詢快、增刪慢
- 運行效率快、執行緒不安全
- List的實作類
ArrayList arrayList = new ArrayList();
一些原始碼分析：
- 默認容量：DEFAULT_CAPACITY = 10，沒添加如何元素0,大于10就是元素個數;
- 存放元素的陣列：elementData
- 實際元素個數：size
Vector類
- 陣列結構實作，查詢快、增刪慢
- 運行效率慢、執行緒安全
- 用的少
- List的實作類
創建方法同上，方法自己看檔案
LinkedList類
- 鏈表結構（雙向鏈表）實作，增刪快、查詢慢，
增刪改查方法類似上面，不在贅述
至于鏈表結構學了c或者資料結構應該都懂吧
泛型
本質上是引數化型別，把型別當做引數傳遞
常見形式有泛型類、泛型介面和泛型方法
語法：
<T,...>，T是型別占位符，表示一種參考型別,可以寫多個
作用：
提高代碼重用性
防止型別轉換例外，提高安全性
泛型類
public class MyGeneric <T>{
T t;
public void show(T t){
// T t1 = new T(); 這是不合法，不能new因為不確定型別
System.out.println(t);
}
public T getT(){
return t;
}
public static void main(String[] args) {
//泛型類中必須是參考資料型別，基本資料型別就用包裝類，右邊的String可寫可不寫
MyGeneric<String> myGeneric = new MyGeneric<String>();
myGeneric.t="hello";
System.out.println(myGeneric.t);
myGeneric.show("大家好");
}
}
/*
hello
大家好
泛型介面
泛型介面基本和泛型類類似，只不過其他類實作它時傳入參考型別但是當實作泛型介面時也不確定如下，后面宣告類的時候再傳
public class Student implements MyGeneric<String>{}
public class Student<T> implements MyGeneric<T>{}
泛型方法
public class MyGeneric {
//先宣告泛型方法，之后可以回傳型別或者在引數使用泛型
public <T> T show(T t){
return t;
}
public static void main(String[] args) {
MyGeneric myGeneric = new MyGeneric();
// 泛型型別由傳入的資料型別決定
myGeneric.show("大家好");
myGeneric.show(1);
}
}
泛型好處
-
提高重用性
-
防止型別轉換例外
泛型集合
引數化型別、型別安全的集合，強制集合元素的型別必須一致
ArrayList<String> list = new ArrayList<String>();
//不寫泛型默認是Object
當不使用泛型時
ArrayList list = new ArrayList();
list.add("aa");
list.add(1);
for (Object o : list) {
String s= (String) o;
}
/*
Exception in thread "main" java.lang.ClassCastException: class java.lang.Integer cannot be cast to class java.lang.String (java.lang.Integer and java.lang.String are in module java.base of loader 'bootstrap')
Set類
特點：無序、無下標、元素不可重復
各元素物件之間沒有指定的順序，不允許有重復元素，最多允許有一個Null元素物件
一個不包含重復元素的Collection，方法和Collection完全一樣
繼承Collection，是介面
Set<String> set = new HashSet<>();
// 增刪改查同Collection
Set的實作類：HashSet，TreeSet
HashSet類
- 基于HashCode計算元素的存放位置
- 存盤結構：哈希表（陣列+鏈表+紅黑樹）
- 當存入的一個元素時如果對應哈希碼陣列位置為空直接存入，如果已有元素會呼叫equals進行確認，如果為true，則拒絕存入；為false，存盤在陣列同一個位置與已有元素形成鏈表（回傳哈希值，有方法hashCode）(另外洗掉等其他方法時同理也是通過hashCode和equals方法)
HashSet<String> hashSet = new HashSet<>();
TreeSet類
- 基于排序順序實作元素不重復
- 實作了SortedSet介面，對集合元素自動排序
- 元素物件的型別必須實作Comparable介面，指定排序規則
- 通過Comparable的一個compareTo方法確定是否為重復元素
- 存盤結構：紅黑樹結構（二叉查找樹的一種）
TreeSet<String> treeSet = new TreeSet<>();
treeSet.add("b");
treeSet.add("a");
treeSet.add("c");
treeSet.add("c");
System.out.println(treeSet);
//根據字典序排序，重復的不添加
//out:[a, b, c]
洗掉等操作類似
要求：TreeSet如果要裝入物件，物件必須實作Comparable(泛型介面)重寫compareTo方法
public class Student implements Comparable<Student>{
String name="11";
int age=11;
//先按姓名再按照年齡比,相同回傳0
@Override
public int compareTo(Student o) {
//String的compareTo：相同回傳0
int n1 = this.name.compareTo(o.name);
int n2 = this.age-o.age;
//如果name相同n2否則回傳n1
return n1==0 ? n2:n1;
}
public static void main(String[] args) {
TreeSet<Student> treeSet = new TreeSet<>();
Student s1 = new Student();
treeSet.add(s1);
}
}
//洗掉等其他操作同理
Comparator和Comparable
上文提到如果TreeSet要裝入自定義的類的話需要實作Comparable類，事實上也可以通過實作Comparator裝入
- Comparable：可比較的
- Comparator：實作定制比較（比較器）
TreeSet<Student> treeSet = new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
//比較方法:自己根據專案要求寫,相同回傳0，上面Comparable的compareTo也是同理
return 0;
}
});
Student s1 = new Student();
treeSet.add(s1);
Map集合
特點：
- 用來存盤鍵值對
- 鍵：無序、無下標、不允許重復
- 值：無序、無下標、運行重復
- 是介面
常用方法：
Map<String,String> map = new HashMap<>();
map.put("CHA","中國");
map.put("USA","美國");
map.put("UK","英國");
//替換掉鍵值對上一個值
map.put("UK","聯合王國");
System.out.println(map.size());
System.out.println(map.toString());
//洗掉
map.remove("UK");
System.out.println(map.toString());
//使用KeySet（）遍歷：得到一個存盤了鍵的Set
System.out.println("keySet遍歷-----------------");
Set<String> keySet = map.keySet();
for (String s : keySet) {
//get通過鍵得到值
System.out.println(s+":"+map.get(s));
}
//使用entrySet方法遍歷：得到一個存盤鍵值對的Map.Entry:效率更高
System.out.println("entrySet方法遍歷-------------");
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> entry : entries) {
System.out.println(entry.getKey()+":"+entry.getValue());
}
//判斷
System.out.println(map.containsKey("USA"));
System.out.println(map.containsValue("英國"));
/*
3
{USA=美國, UK=聯合王國, CHA=中國}
{USA=美國, CHA=中國}
keySet遍歷-----------------
USA:美國
CHA:中國
entrySet方法遍歷-------------
USA:美國
CHA:中國
true
false
Map集合的實作類：HashMap，Hashtable，TreeMap
HashMap類
- 運行效率高，執行緒不安全；運行使用null作為key或者value
- 實作Map
- 存盤結構：哈希表
- 區別于hashset（默認容量10，但是元素個數<0時為空Hashmap一樣）默認容量16，加載因子（元素大于容量的0.75（閾yu值）開始擴容，擴容為閾值兩倍）0.75，鏈表長度或者陣列長度大于一定數目時鏈表可能變成紅黑樹，jdk1.8之前是頭插入，之后是尾插入
HashMap<String,String> hashMap = new HashMap<>();
方法和Map方法一樣,
存盤方式看hashSet，完全類似，使用key的hashcode和equals比較
另外HashSet原始碼實際上用的就是HashMap
Hashtable類
- 執行緒安全，運行效率慢，不允許null作為key或者value
- 用的少
- 存盤結構是哈希表
- 子類Properties
方法類似不在贅述
Proeryies類
要求key和value都是String，通常用于組態檔讀取
是Hashtable的子類
這里暫且忽略
TreeMap類
- 實作了SortedMap介面（一個Map的子介面），可以對key自動排序
- 存盤結構：紅黑樹
- 類似TreeSet存盤類需要實作Comparable泛型介面（或者Comparable），重寫相應方法
TreeMap<Student,String> treeMap = new TreeMap<>();
public class Student implements Comparable<Student>{}
Collections工具類
集合工具類，定義了除了存取以外的集合常用方法
全是靜態方法
List<Integer> list = new ArrayList<>();
list.add(20);
list.add(5);
list.add(12);
//sort排序:默認升序，可以直接通過Comparator自定義比較方法
Collections.sort(list);
// Collections.sort(list, new Comparator<Integer>() {
// @Override
// public int compare(Integer o1, Integer o2) {
// return 0;
// }
// });
System.out.println(list);
// binarySearch查找:找到回傳下標否則回傳負值
int i=Collections.binarySearch(list,12);
System.out.println(i);
// copy復制:必須要集合一樣大，直接這樣是不行的，需要如下
List<Integer> list1 = new ArrayList<>();
//大小添加到3
for (int j = 0; j < 3; j++) {
list1.add(0);
}
Collections.copy(list1,list);
System.out.println(list1);
// reverse反轉
Collections.reverse(list1);
System.out.println(list1);
// shuffle打亂
Collections.shuffle(list);
System.out.println(list);
/*
[5, 12, 20]
1
[5, 12, 20]
[20, 12, 5]
[5, 20, 12]
list和陣列之間的相互轉換
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
// list轉陣列:右邊括號內Integer個數小于或等于list個數左邊得到就是list個數
// 大于list個數在list個數基礎上補null到該個數
Integer[] arr = list.toArray(new Integer[0]);
//陣列需要這種方式，不能直接列印
System.out.println(Arrays.toString(arr));
// 陣列轉集合
String[] name = {"張三","李四"};
//受限集合不能添加或洗掉
List<String> list1 = Arrays.asList(name);
System.out.println(list1);
//基本型別陣列轉的時候需要封裝類
Integer[] a = {1,2,3};
List<Integer> list2 = Arrays.asList(a);
/*
[1, 2]
[張三, 李四]
[1, 2, 3]
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/552972.html
標籤：其他
上一篇：【重學C++】01| C++ 如何進行記憶體資源管理？
下一篇：返回列表