溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇文章主要介紹了Java集合是什么，具有一定借鑒價值，感興趣的朋友可以參考下，希望大家閱讀完這篇文章之后大有收獲，下面讓小編帶著大家一起了解一下。
概念：集合是存放對象的容器，并定義了對多個對象進行操作的常用方法，可實現數組的功能。
和數組的區別：
（1）數組長度固定，集合長度不固定；
（2）數組可以存儲基本類型和引用類型，集合只能存儲引用類型。
位置：java.util.*;
Collection接口通過頂層設計定義了許多針對集合的操作，大致可以分為增、刪、遍歷、判斷等幾個方面的方法。
增
boolean add(E e) 確保此集合包含指定的元素（可選操作）。 boolean addAll(Collection<? extends E> c) 將指定集合中的所有元素添加到這個集合（可選操作）。
刪
void clear() 從這個集合中移除所有的元素（可選操作）。 boolean remove(Object o) 從這個集合中移除指定元素的一個實例，如果它是存在的（可選操作）。 boolean removeAll(Collection<?> c) 刪除此集合中包含的所有元素（可選操作）的所有元素（可選操作）。 default boolean removeIf(Predicate<? super E> filter) 刪除滿足給定謂詞的這個集合的所有元素。 boolean retainAll(Collection<?> c) 僅保留包含在指定集合中的這個集合中的元素（可選操作）。
遍歷
Iterator<E> iterator() 返回此集合中的元素的迭代器。 Object[] toArray() 返回包含此集合中所有元素的數組。 <T> T[] toArray(T[] a) 返回包含此集合中所有元素的數組；返回數組的運行時類型是指定的數組的運行時類型。
判斷
boolean contains(Object o) 返回 true如果集合包含指定元素。 boolean containsAll(Collection<?> c) 返回 true如果這個集合包含指定集合的所有元素。 boolean isEmpty() 返回 true如果集合不包含任何元素。
其它
int size() 返回此集合中的元素的數目。 boolean equals(Object o) 將指定的對象與此集合進行比較，以進行相等性。 int hashCode() 返回此集合的哈希代碼值。
遍歷常用的兩種方法：forEach和Iterator
public class Demo1 {
public static void main(String[] args) {
Collection collection = new ArrayList();
collection.add("蘋果");
collection.add("香蕉");
collection.add("西瓜");
//1.foreach
for(Object object : collection) {
System.out.println(object);
}
/**
* 2.使用Iterator，其包含三個方法：
* hasnext()：判斷是否有下一個元素
* next()：獲取下一個元素
* remove()：刪除迭代器返回的最后一個元素
*/
Iterator it = collection.iterator();
while(it.hasNext()) {
String object = (String)it.next();
// collection.remove(object); 不能使用被遍歷集合的刪除方法，會報并發修改異常
it.remove();
System.out.println(object);
}
System.out.println(collection.size());
}
}特點：有序、有下標、元素可以重復。
List在父接口Collection的基礎上新增了許多方法。
增
void add(int index, E element) 在列表中指定的位置上插入指定的元素（可選操作）。 boolean addAll(Collection<? extends E> c) 追加指定集合的所有元素到這個列表的末尾，按他們的指定集合的迭代器返回（可選操作）。
刪
E remove(int index) 移除此列表中指定位置的元素（可選操作）。
遍歷
ListIterator<E> listIterator() 返回列表元素的列表迭代器（在適當的順序）。 ListIterator<E> listIterator(int index) 在列表中的元素上返回列表迭代器（在適當的順序），從列表中的指定位置開始。
其它
Object get(int index) 根據下標返回指定位置元素 int indexOf(Object o) 返回此列表中指定元素的第一個出現的索引，或-如果此列表不包含元素，或- 1。 List subList(int fromIndex, int toIndex) 返回指定索引之間的集合元素 E set(int index, E element) 用指定元素替換此列表中指定位置的元素（可選操作）。 default void sort(Comparator<? super E> c) 分類列表使用提供的 Comparator比較元素。
1.for、foreach、Collection提供的迭代器接口
public class Demo2 {
public static void main(String[] args) {
List list = new ArrayList();
list.add("華為");
list.add("蘋果");
list.add("小米");
//1.for
for(int i=0; i<list.size(); i++) {
System.out.println(list.get(i));
}
//2.forEach
for(Object str : list) {
System.out.println(str);
}
//3.迭代器
Iterator it = list.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}2、使用ListIterator
//順序遍歷
ListIterator lit = list.listIterator();
while(lit.hasNext()) {
System.out.println(lit.next());
}
//逆序遍歷
while (lit.hasPrevious()) {
System.out.println(lit.previous());
}ListIterator常用方法
boolean hasNext() 返回 true如果列表迭代器具有更多的元素時，正向遍歷列表。 boolean hasPrevious() 返回 true如果列表迭代器具有更多的元素時，逆向遍歷列表。 E next() 返回列表中的下一個元素，并推進光標位置。 E previous() 返回列表中的前一個元素，并向后移動光標位置。 void remove() 從列表中刪除最后一個元素是由 next()或 previous()返回（可選操作）。
ArrayList【重點】
數組結構實現，查詢快、增刪慢；
運行效率快、線程不安全。
LinkedList
雙向鏈表實現，增刪快，查詢慢。
Vector（很少使用）
數組結構實現；
運行效率慢、線程安全
當要刪除List中的指定對象時，需要比較兩個對象是否相同，如果要實現不根據同一引用刪除屬性相同的對象，此時需要在該對象類中重寫equals方法，如下為經典的重寫方法，記下來。
@Override
public boolean equals(Object obj) {
//是否為同一對象
if (this == obj) {
return true;
}
//是否為空
if (this == null) {
return false;
}
//是否為同類對象
if (obj instanceof Student) {
Student s = (Student) obj;
//比較屬性是否相等
if(this.name = s.name && this.age == s.age){
return true;
}
}
return false;
}重要參數：
int size：元素數目；
Object[] elementData：保存元素的數組；
add()方法源碼解析
public boolean add(E e) {
modCount++;
add(e, elementData, size);
return true;
}
private void add(E e, Object[] elementData, int s) {
//數組存放滿了，擴容
if (s == elementData.length)
elementData = grow();
elementData[s] = e;
size = s + 1;
}
//擴容
private Object[] grow() {
return grow(size + 1);
}
//將舊數組擴容
private Object[] grow(int minCapacity) {
return elementData = Arrays.copyOf(elementData,
newCapacity(minCapacity));
}
private int newCapacity(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity <= 0) {
//數組為空
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
return Math.max(DEFAULT_CAPACITY, minCapacity);
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return minCapacity;
}
return (newCapacity - MAX_ARRAY_SIZE <= 0)
? newCapacity
: hugeCapacity(minCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE)
? Integer.MAX_VALUE
: MAX_ARRAY_SIZE;
}相關參數：
int size：集合的大小
Node first：鏈表頭節點
Node last：鏈表尾節點
add方法源碼
public boolean add(E e) {
linkLast(e);
return true;
}
/**
* Links e as last element.
*/
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}Java泛型的本質是參數化類型，把類型作為參數傳遞；
常見形式有泛型類、泛型接口、泛型方法；
語法：
<T,...> T稱為類型占位符，表示一種引用類型；
好處：
（1）提高代碼的重用性；
（2）防止類型轉換異常，提高代碼的安全性。
1.定義泛型類及泛型的用途
/**
* 泛型類
* 語法：類名<T>
* T 是類型占位符，表示一種引用類型，如果編寫多個則使用逗號隔開
* @param <T>
*/
public class MyGeneric<T> {
//使用泛型
//1.創建變量
T t;
//2.泛型作為方法的參數
public void show(T t) {
System.out.println(t);
}
//3.泛型作為方法的返回值
public T getT() {
return t;
}
}2.使用泛型
注意：
（1）泛型只能使用引用類型；
（2）不同泛型類型對象之間不能相互賦值。
public class TestGeneric {
public static void main(String[] args) {
MyGeneric<String> myGeneric = new MyGeneric<>();
myGeneric.t = "蘋果";
myGeneric.show("吃蘋果");
MyGeneric<Integer> myGeneric1 = new MyGeneric<>();
myGeneric.t = "100";
myGeneric.show("打100分");
}
}（1）定義泛型
/**
* 泛型接口
* 語法：接口名<T>
* 注意：不能使用泛型創建靜態常量
*/
public interface MyInterface<T> {
String name = "apple";
T server(T t);
}（2）使用泛型
//1.寫實現類時指定類型
public class MyInterfaceImpl implements MyInterface<String>{
@Override
public String server(String s) {
return s;
}
}
//2.創建對象時再指定類型
public class MyInterfaceImpl1<T> implements MyInterface<T> {
@Override
public T server(T t) {
return t;
}
}
public class TestGeneric {
public static void main(String[] args) {
MyInterfaceImpl1<String> myInterfaceImpl1 = new MyInterfaceImpl1<>();
System.out.println(myInterfaceImpl1.server("apple1"));
}
}（1）定義
/**
* 泛型方法
* 語法：<T> 返回值類型
*/
public class GenericMethod {
//泛型方法, 泛型T可以作為方法的參數或返回值
public <T> void show(T t) {
System.out.println(t);
}
}（2）使用
在使用時傳入具體類型的值。
public class TestGeneric {
public static void main(String[] args) {
GenericMethod genericMethod = new GenericMethod();
genericMethod.show("apple");
genericMethod.show(200);
genericMethod.show(3.14);
}
}概念：參數化類型、類型安全的集合，強制集合元素的類型必須一致。
特點：
編譯時即可檢查，而非運行時拋出異常；
訪問時，不必類型轉換（拆箱）；
不同泛型之間引用不能相互賦值，泛型不存在多態。
public class TestGeneric {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add("apple");
arrayList.add("banana");
arrayList.add(100);
arrayList.add(3.14);
for (Object object : arrayList) {
System.out.println(object);
}
//使用泛型限定傳入的元素類型
ArrayList<String> arrayList1 = new ArrayList<>();
arrayList1.add("apple");
arrayList1.add(100); //添加其它類型時會報錯
}
}特點：無序、無下標、元素不可重復；
方法：全部繼承自Collection中的方法。
HashSet【重點】
基于HashCode實現元素不重復和確認元素存放位置；
當存入元素的哈希碼相同時，會調用equals進行確認，如結果為true，則拒絕后者存入。
TreeSet
基于排列順序實現元素不重復。
使用foreach和Iterator。
public class Demo7 {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
set.add("Jack"); set.add("Lucy"); set.add("Micheal");
//1.foreach
for(String string : set)
System.out.println(string);
//2.Iterator
Iterator it = set.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}存儲結構：哈希表（數組+鏈表+紅黑樹）；
存儲過程：
（1）根據元素的hashcode計算保存的位置，如果該位置為空，則直接保存，否則指定第（2）步；
（2）再執行equals方法，如果equals返回true，則認為存在重復元素，不添加，如果為false，則在保存位置形成鏈表，當鏈表中元素數量超過指定值時，形成紅黑樹。
重寫hashcode()與equals()方法
@Override
public int hashCode() {
return Objects.hash(age, name);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
//getClass()返回對象的hashcode
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
Objects.equals(name, person.name);
}基于排列順序實現元素不重復；
實現了SortedSet接口，對集合元素自動排序；
元素對象的類型必須實現Comparable接口，指定順序規則；
通過CompareTo方法確定是否為重復元素。
存儲結構：紅黑樹
并重寫其中的compareTo方法，否則元素之間無法比較大小，不能排序，會報類型轉換錯誤。
compareTo()返回為0，表示元素重復。
foreach與迭代器方式
package collectionTest;
import java.util.Objects;
public class Person implements Comparable{
//TODO
@Override
public int compareTo(Object o1) {
Person o = (Person)o1;
int n1 = this.getName().compareTo(o.getName());
int n2 = this.getAge() - o.getAge();
return n1 == 0 ? n2 : n1;
}
}（2）Comparator
實現定制的比較器，并在創建TreeSet時傳入該比較器指定比較規則，如此存儲的元素對象便不用實現Comparable接口。
public class Demo3 {
public static void main(String[] args) {
//使用匿名內部類
TreeSet<Person> hashSet = new TreeSet<>(new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
int n2 = o1.getName().compareTo(o2.getName());
int n1 = o1.getAge() - o2.getAge();
return n1 == 0 ? n2 : n1;
}
});
}
}
特點：存儲鍵值對，無序、無下標，鍵不可重復，值可重復。
方法：
V put(K key, V value) 將指定的值與該映射中的指定鍵相關聯（可選操作）。 V get(Object key) 返回到指定鍵所映射的值，或 null如果此映射包含該鍵的映射。 Set<K> keySet() 返回此集合中包含的鍵的Set集合。 Collection<V> values() 返回此集合中包含的值的Collection集合。 Set<Map.Entry<K,V>> entrySet() 返回此集合中包含的映射的Set集合。
（1）使用keySet()
（2）使用entrySet()
entryset()的效率較高，因為一次性獲取到了映射對的key和value值。
public class Demo5 {
public static void main(String[] args) {
HashMap<Integer, String> hashMap = new HashMap<>();
hashMap.put(1, "Jack");
hashMap.put(2, "Lucy");
hashMap.put(3, "asdfaJack");
hashMap.put(4, "DLucy");
//1.keySet()
// Set<Integer> keySet = hashMap.keySet();
for(Integer key : hashMap.keySet()) {
System.out.println(key + " : " + hashMap.get(key));
}
//2.entrySet()
// Set<Map.Entry<Integer, String>> entries = hashMap.entrySet();
for(Map.Entry<Integer, String> entry : hashMap.entrySet()) {
System.out.println(entry.getKey() + " : " + entry.getValue());
}
}
}HashMap：線程不安全，運行效率快；允許使用null作為key或value;
Hashtable：線程安全，運行效率慢，不允許null作為key或value。
Properties：Hashtable的子類，要求key和value都是String，通常用于配置文件的讀取。
TreeMap：實現了SortedMap接口（是Map的子接口），可以對key自動排序。
相關參數
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // hashmap初始容量大小 static final int MAXIMUM_CAPACITY = 1 << 30; //hashmap數組最大容量 static final float DEFAULT_LOAD_FACTOR = 0.75f; //默認裝載因子 static final int TREEIFY_THRESHOLD = 8; //jdk1.8 當鏈表長度大于8時，調整成紅黑樹 static final int UNTREEIFY_THRESHOLD = 6; //鏈表長度小于6，調整成鏈表 static final int MIN_TREEIFY_CAPACITY = 64; //jdk1.8 當鏈表長度大于8且集合元素個數大于等于64時，調整成紅黑樹。 transient Node<K,V>[] table; //哈希表中的數組 transient size; //元素個數
構造函數
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//剛創建的hashmap沒有添加元素，table=null，size=0
HashMap<Integer, String> hashMap = new HashMap<>();put() 方法解析，待深入了解。
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}TreeMap與TreeSet一樣，底層都是由紅黑樹實現，是有序的，因此元素之間必須是可比較的，可以通過讓元素繼承Comparable或者在調用TreeMap的構造方法時傳入自制比較器實現。
遍歷方式
（1）使用keySet() （2）使用entrySet()
public class Demo6 {
public static void main(String[] args) {
TreeMap<Student, String> treeMap = new TreeMap<>();
Student s1 = new Student(11, "Jack");
Student s2 = new Student(17, "adfJack");
Student s3 = new Student(14, "dafJack");
Student s4 = new Student(12, "fJdack");
treeMap.put(s1, "nihao");
treeMap.put(s2, "nihao");
treeMap.put(s3, "nihao");
treeMap.put(s4, "nihao");
for(Student key : treeMap.keySet()) {
System.out.println(key + " : " + treeMap.get(key));
}
for(Map.Entry<Student, String> entry : treeMap.entrySet()) {
System.out.println(entry.getKey() + " : " + entry.getValue());
}
}
}
class Student implements Comparable{
private int age;
private String name;
//TODO
}概念：集合工具類，定義了出了存取以外的集合常用方法。
方法
void sort(List<T> list) 指定列表為升序排序，根據其元素的 natural ordering。 void sort(List<T> list, Comparator<? super T> c) 根據指定的比較器指定的順序對指定的列表進行排序。 static void reverse(List<?> list) 反轉指定列表中元素的順序。 static void shuffle(List<?> list) 隨機置換指定列表使用隨機默認源。 static void swap(List<?> list, int i, int j) 在指定的列表中的指定位置上交換元素。 static <T> void copy(List<? super T> dest, List<? extends T> src) 將所有的元素從一個列表復制到另一個列表中。
copy函數，必須保證dst的長度與src一致。
public class Demo7 {
public static void main(String[] args) {
List<Integer> src = new ArrayList<>();
src.add(1);src.add(2);src.add(100);src.add(89);
List<Integer> dst = new ArrayList<>();
//讓dst的長度與src一致
for(int i=0; i<src.size(); i++)
dst.add(0);
Collections.copy(dst, src);
System.out.println(dst);
}
}方法
static <T> List<T> asList(T... a) 返回由指定數組支持的一個固定大小的列表。
List轉數組
public class Demo7 {
public static void main(String[] args) {
List<Integer> src = new ArrayList<>();
src.add(1);src.add(2);src.add(100);src.add(89);
//傳入數組類型作為參數
Integer[] integers = src.toArray(new Integer[0]);
System.out.println(Arrays.toString(integers));
}
}數組轉集合
public class Demo7 {
public static void main(String[] args) {
Integer[] integers = new Integer[] {1, 2, 3, 4, 5};
List<Integer> list = Arrays.asList(integers);
System.out.println(list);
}
}感謝你能夠認真閱讀完這篇文章，希望小編分享的“Java集合是什么”這篇文章對大家有幫助，同時也希望大家多多支持億速云，關注億速云行業資訊頻道，更多相關知識等著你來學習!
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
