這篇文章主要介紹了Java集合是什么，具有一定借鑒價值，感興趣的朋友可以參考下，希望大家閱讀完這篇文章之后大有收獲，下面讓小編帶著大家一起了解一下。
站在用戶的角度思考問題，與客戶深入溝通，找到江永網(wǎng)站設(shè)計與江永網(wǎng)站推廣的解決方案，憑借多年的經(jīng)驗，讓設(shè)計與互聯(lián)網(wǎng)技術(shù)結(jié)合，創(chuàng)造個性化、用戶體驗好的作品，建站類型包括：成都網(wǎng)站建設(shè)、網(wǎng)站制作、企業(yè)官網(wǎng)、英文網(wǎng)站、手機端網(wǎng)站、網(wǎng)站推廣、申請域名、雅安服務(wù)器托管、企業(yè)郵箱。業(yè)務(wù)覆蓋江永地區(qū)。
概念：集合是存放對象的容器，并定義了對多個對象進行操作的常用方法，可實現(xiàn)數(shù)組的功能。
和數(shù)組的區(qū)別：
（1）數(shù)組長度固定，集合長度不固定；
（2）數(shù)組可以存儲基本類型和引用類型，集合只能存儲引用類型。
位置：java.util.*;
Collection接口通過頂層設(shè)計定義了許多針對集合的操作，大致可以分為增、刪、遍歷、判斷等幾個方面的方法。
增
boolean add(E e) 確保此集合包含指定的元素（可選操作）。 boolean addAll(Collection c) 將指定集合中的所有元素添加到這個集合（可選操作）。
刪
void clear() 從這個集合中移除所有的元素（可選操作）。 boolean remove(Object o) 從這個集合中移除指定元素的一個實例，如果它是存在的（可選操作）。 boolean removeAll(Collection c) 刪除此集合中包含的所有元素（可選操作）的所有元素（可選操作）。 default boolean removeIf(Predicate filter) 刪除滿足給定謂詞的這個集合的所有元素。 boolean retainAll(Collection c) 僅保留包含在指定集合中的這個集合中的元素（可選操作）。
遍歷
Iteratoriterator() 返回此集合中的元素的迭代器。 Object[] toArray() 返回包含此集合中所有元素的數(shù)組。 T[] toArray(T[] a) 返回包含此集合中所有元素的數(shù)組；返回數(shù)組的運行時類型是指定的數(shù)組的運行時類型。
判斷
boolean contains(Object o) 返回 true如果集合包含指定元素。 boolean containsAll(Collection c) 返回 true如果這個集合包含指定集合的所有元素。 boolean isEmpty() 返回 true如果集合不包含任何元素。
其它
int size() 返回此集合中的元素的數(shù)目。 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); 不能使用被遍歷集合的刪除方法，會報并發(fā)修改異常
it.remove();
System.out.println(object);
}
System.out.println(collection.size());
}
}特點：有序、有下標、元素可以重復(fù)。
List在父接口Collection的基礎(chǔ)上新增了許多方法。
增
void add(int index, E element) 在列表中指定的位置上插入指定的元素（可選操作）。 boolean addAll(Collection c) 追加指定集合的所有元素到這個列表的末尾，按他們的指定集合的迭代器返回（可選操作）。
刪
E remove(int index) 移除此列表中指定位置的元素（可選操作）。
遍歷
ListIteratorlistIterator() 返回列表元素的列表迭代器（在適當?shù)捻樞颍?nbsp; ListIterator listIterator(int index) 在列表中的元素上返回列表迭代器（在適當?shù)捻樞颍?，從列表中的指定位置開始。
其它
Object get(int index) 根據(jù)下標返回指定位置元素 int indexOf(Object o) 返回此列表中指定元素的第一個出現(xiàn)的索引，或-如果此列表不包含元素，或- 1。 List subList(int fromIndex, int toIndex) 返回指定索引之間的集合元素 E set(int index, E element) 用指定元素替換此列表中指定位置的元素（可選操作）。 default void sort(Comparator 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; i2、使用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()返回（可選操作）。
6.List實現(xiàn)類
三種實現(xiàn)類
ArrayList【重點】
數(shù)組結(jié)構(gòu)實現(xiàn)，查詢快、增刪慢；
運行效率快、線程不安全。
LinkedList
雙向鏈表實現(xiàn)，增刪快，查詢慢。
Vector（很少使用）
數(shù)組結(jié)構(gòu)實現(xiàn)；
運行效率慢、線程安全
重寫equals()方法
當要刪除List中的指定對象時，需要比較兩個對象是否相同，如果要實現(xiàn)不根據(jù)同一引用刪除屬性相同的對象，此時需要在該對象類中重寫equals方法，如下為經(jīng)典的重寫方法，記下來。
@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;
}ArraysList源碼解析
重要參數(shù)：
int size：元素數(shù)目；
Object[] elementData：保存元素的數(shù)組；
add()方法源碼解析
public boolean add(E e) {
modCount++;
add(e, elementData, size);
return true;
}
private void add(E e, Object[] elementData, int s) {
//數(shù)組存放滿了，擴容
if (s == elementData.length)
elementData = grow();
elementData[s] = e;
size = s + 1;
}
//擴容
private Object[] grow() {
return grow(size + 1);
}
//將舊數(shù)組擴容
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) {
//數(shù)組為空
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;
}LinkedList源碼解析
相關(guān)參數(shù)：
int size：集合的大小
Node first：鏈表頭節(jié)點
Node last：鏈表尾節(jié)點
add方法源碼
public boolean add(E e) {
linkLast(e);
return true;
}
/**
* Links e as last element.
*/
void linkLast(E e) {
final Node l = last;
final Node newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
private static class Node {
E item;
Node next;
Node prev;
Node(Node prev, E element, Node next) {
this.item = element;
this.next = next;
this.prev = prev;
}
} 7.泛型
泛型概念
Java泛型的本質(zhì)是參數(shù)化類型，把類型作為參數(shù)傳遞；
常見形式有泛型類、泛型接口、泛型方法；
語法：
T稱為類型占位符，表示一種引用類型；
好處：
（1）提高代碼的重用性；
（2）防止類型轉(zhuǎn)換異常，提高代碼的安全性。
泛型類
1.定義泛型類及泛型的用途
/**
* 泛型類
* 語法：類名
* T 是類型占位符，表示一種引用類型，如果編寫多個則使用逗號隔開
* @param
*/
public class MyGeneric {
//使用泛型
//1.創(chuàng)建變量
T t;
//2.泛型作為方法的參數(shù)
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 myGeneric = new MyGeneric<>();
myGeneric.t = "蘋果";
myGeneric.show("吃蘋果");
MyGeneric myGeneric1 = new MyGeneric<>();
myGeneric.t = "100";
myGeneric.show("打100分");
}
} 泛型接口
（1）定義泛型
/**
* 泛型接口
* 語法：接口名
* 注意：不能使用泛型創(chuàng)建靜態(tài)常量
*/
public interface MyInterface {
String name = "apple";
T server(T t);
}
（2）使用泛型
//1.寫實現(xiàn)類時指定類型
public class MyInterfaceImpl implements MyInterface{
@Override
public String server(String s) {
return s;
}
}
//2.創(chuàng)建對象時再指定類型
public class MyInterfaceImpl1 implements MyInterface {
@Override
public T server(T t) {
return t;
}
}
public class TestGeneric {
public static void main(String[] args) {
MyInterfaceImpl1 myInterfaceImpl1 = new MyInterfaceImpl1<>();
System.out.println(myInterfaceImpl1.server("apple1"));
}
}
泛型方法
（1）定義
/**
* 泛型方法
* 語法： 返回值類型
*/
public class GenericMethod {
//泛型方法, 泛型T可以作為方法的參數(shù)或返回值
public 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);
}
}泛型集合
概念：參數(shù)化類型、類型安全的集合，強制集合元素的類型必須一致。
特點：
編譯時即可檢查，而非運行時拋出異常；
訪問時，不必類型轉(zhuǎn)換（拆箱）；
不同泛型之間引用不能相互賦值，泛型不存在多態(tài)。
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 arrayList1 = new ArrayList<>();
arrayList1.add("apple");
arrayList1.add(100); //添加其它類型時會報錯
}
} 8.Set子接口
特點：無序、無下標、元素不可重復(fù)；
方法：全部繼承自Collection中的方法。
1.Set實現(xiàn)類
HashSet【重點】
基于HashCode實現(xiàn)元素不重復(fù)和確認元素存放位置；
當存入元素的哈希碼相同時，會調(diào)用equals進行確認，如結(jié)果為true，則拒絕后者存入。
TreeSet
基于排列順序?qū)崿F(xiàn)元素不重復(fù)。
2.遍歷
使用foreach和Iterator。
public class Demo7 {
public static void main(String[] args) {
Set 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());
}
}
} 3.HashSet
存儲結(jié)構(gòu)：哈希表（數(shù)組+鏈表+紅黑樹）；
存儲過程：
（1）根據(jù)元素的hashcode計算保存的位置，如果該位置為空，則直接保存，否則指定第（2）步；
（2）再執(zhí)行equals方法，如果equals返回true，則認為存在重復(fù)元素，不添加，如果為false，則在保存位置形成鏈表，當鏈表中元素數(shù)量超過指定值時，形成紅黑樹。
重寫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);
}4.TreeSet
基于排列順序?qū)崿F(xiàn)元素不重復(fù)；
實現(xiàn)了SortedSet接口，對集合元素自動排序；
元素對象的類型必須實現(xiàn)Comparable接口，指定順序規(guī)則；
通過CompareTo方法確定是否為重復(fù)元素。
存儲結(jié)構(gòu)：紅黑樹
（1）存儲元素為對象時必須實現(xiàn)Comparable接口
并重寫其中的compareTo方法，否則元素之間無法比較大小，不能排序，會報類型轉(zhuǎn)換錯誤。
compareTo()返回為0，表示元素重復(fù)。
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
實現(xiàn)定制的比較器，并在創(chuàng)建TreeSet時傳入該比較器指定比較規(guī)則，如此存儲的元素對象便不用實現(xiàn)Comparable接口。
public class Demo3 {
public static void main(String[] args) {
//使用匿名內(nèi)部類
TreeSet hashSet = new TreeSet<>(new Comparator() {
@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;
}
});
}
} 9.Map集合
Map父接口
特點：存儲鍵值對，無序、無下標，鍵不可重復(fù)，值可重復(fù)。
方法：
V put(K key, V value) 將指定的值與該映射中的指定鍵相關(guān)聯(lián)（可選操作）。
V get(Object key) 返回到指定鍵所映射的值，或 null如果此映射包含該鍵的映射。
Set keySet() 返回此集合中包含的鍵的Set集合。
Collection values() 返回此集合中包含的值的Collection集合。
Set> entrySet() 返回此集合中包含的映射的Set集合。
遍歷
（1）使用keySet()
（2）使用entrySet()
entryset()的效率較高，因為一次性獲取到了映射對的key和value值。
public class Demo5 {
public static void main(String[] args) {
HashMap hashMap = new HashMap<>();
hashMap.put(1, "Jack");
hashMap.put(2, "Lucy");
hashMap.put(3, "asdfaJack");
hashMap.put(4, "DLucy");
//1.keySet()
// Set keySet = hashMap.keySet();
for(Integer key : hashMap.keySet()) {
System.out.println(key + " : " + hashMap.get(key));
}
//2.entrySet()
// Set> entries = hashMap.entrySet();
for(Map.Entry entry : hashMap.entrySet()) {
System.out.println(entry.getKey() + " : " + entry.getValue());
}
}
} Map集合的實現(xiàn)類
HashMap：線程不安全，運行效率快；允許使用null作為key或value;
Hashtable：線程安全，運行效率慢，不允許null作為key或value。
Properties：Hashtable的子類，要求key和value都是String，通常用于配置文件的讀取。
TreeMap：實現(xiàn)了SortedMap接口（是Map的子接口），可以對key自動排序。
HashMap源碼解析
相關(guān)參數(shù)
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // hashmap初始容量大小
static final int MAXIMUM_CAPACITY = 1 << 30; //hashmap數(shù)組最大容量
static final float DEFAULT_LOAD_FACTOR = 0.75f; //默認裝載因子
static final int TREEIFY_THRESHOLD = 8; //jdk1.8 當鏈表長度大于8時，調(diào)整成紅黑樹
static final int UNTREEIFY_THRESHOLD = 6; //鏈表長度小于6，調(diào)整成鏈表
static final int MIN_TREEIFY_CAPACITY = 64; //jdk1.8 當鏈表長度大于8且集合元素個數(shù)大于等于64時，調(diào)整成紅黑樹。
transient Node[] table; //哈希表中的數(shù)組
transient size; //元素個數(shù)
構(gòu)造函數(shù)
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//剛創(chuàng)建的hashmap沒有添加元素，table=null，size=0
HashMap hashMap = new HashMap<>(); put() 方法解析，待深入了解。
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}TreeMap
TreeMap與TreeSet一樣，底層都是由紅黑樹實現(xiàn)，是有序的，因此元素之間必須是可比較的，可以通過讓元素繼承Comparable或者在調(diào)用TreeMap的構(gòu)造方法時傳入自制比較器實現(xiàn)。
遍歷方式
（1）使用keySet()
（2）使用entrySet()
public class Demo6 {
public static void main(String[] args) {
TreeMap 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 entry : treeMap.entrySet()) {
System.out.println(entry.getKey() + " : " + entry.getValue());
}
}
}
class Student implements Comparable{
private int age;
private String name;
//TODO
} 10.Collections工具類
概念：集合工具類，定義了出了存取以外的集合常用方法。
方法
void sort(List list) 指定列表為升序排序，根據(jù)其元素的 natural ordering。
void sort(List list, Comparator c) 根據(jù)指定的比較器指定的順序?qū)χ付ǖ牧斜磉M行排序。
static void reverse(List list) 反轉(zhuǎn)指定列表中元素的順序。
static void shuffle(List list) 隨機置換指定列表使用隨機默認源。
static void swap(List list, int i, int j) 在指定的列表中的指定位置上交換元素。
static void copy(List dest, List src) 將所有的元素從一個列表復(fù)制到另一個列表中。
copy函數(shù)，必須保證dst的長度與src一致。
public class Demo7 {
public static void main(String[] args) {
List src = new ArrayList<>();
src.add(1);src.add(2);src.add(100);src.add(89);
List dst = new ArrayList<>();
//讓dst的長度與src一致
for(int i=0; i11.Arrays工具類
方法
static List asList(T... a) 返回由指定數(shù)組支持的一個固定大小的列表。
List轉(zhuǎn)數(shù)組
public class Demo7 {
public static void main(String[] args) {
List src = new ArrayList<>();
src.add(1);src.add(2);src.add(100);src.add(89);
//傳入數(shù)組類型作為參數(shù)
Integer[] integers = src.toArray(new Integer[0]);
System.out.println(Arrays.toString(integers));
}
} 數(shù)組轉(zhuǎn)集合
public class Demo7 {
public static void main(String[] args) {
Integer[] integers = new Integer[] {1, 2, 3, 4, 5};
List list = Arrays.asList(integers);
System.out.println(list);
}
} 感謝你能夠認真閱讀完這篇文章，希望小編分享的“Java集合是什么”這篇文章對大家有幫助，同時也希望大家多多支持創(chuàng)新互聯(lián)，關(guān)注創(chuàng)新互聯(lián)行業(yè)資訊頻道，更多相關(guān)知識等著你來學(xué)習!
文章題目：Java集合是什么
鏈接分享：http://weahome.cn/article/gopoic.html
