Java集合學習（適合新手）

集合框架

由⼀組類和接⼝組成的⼀個體系。

Collection 集合框架

最基本的接⼝，⼀個 Collection 能夠存儲⼀組⽆序、不惟⼀的對象，實際開發中不會直接使⽤ Collection 進⾏開發。

List 是 Collection 的⼀個⼦接⼝，存儲⼀組有序、不惟⼀的對象，集合框架中最常⽤的接⼝之⼀。

List  接口的實現類 ：ArrayList、LinkedList

Set  是 Collection 的⼀個⼦接⼝，存儲⼀組⽆序、惟⼀的對象。

Set 接口的實現類：TreeSet、HashSet、LinkedHashSet

Map 獨⽴於 Collection 的另外⼀個接⼝，存儲⼀組鍵值對象（key-value），經過鍵到值的映射。

Map 接口的實現類：HashMap、TreeMap、Hashtable

Iterator ⽤來輸出集合元素的接⼝，⼀般適⽤於⽆序集合。

//獲取集合的迭代器  將集合內的元素輸出

Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}

 

Enumeration 更能與 Iterator ⼀樣，已經被 Iterator 所取代。

SortedSet Set 的⼦接⼝，能夠對 Set 集合中的元素進⾏排序。

SortedMap Map 的⼦接⼝，能夠對 Map 集合中的元素進⾏排序。

Queue 隊列接⼝，此接⼝能夠實現對列操做。

Map.Entry Map 內部的接⼝，描述 Map 中的⼀個鍵值對元素。

 

Collection 常⽤的⽅法

int size() 返回集合的⻓度

boolean isEmpty() 判斷集合是否爲空

boolean contains(Object o) 判斷集合中是否存在 o

Iterator iterator() 返回迭代器Object[] toArray() 將集合轉爲數組

boolean add(Object o) 向集合中添加元素

boolean remove(Object o) 從集合中刪除 o

boolean remove(int index) 從集合中刪除下標是 index 的元素

System.out.println(list.size());//輸出list集合的長度

        System.out.println(list.isEmpty());//判斷list集合是否爲空

        System.out.println(list.contains(1));//判斷list集合是否包含元素 1

        Object[] array = list.toArray();//將一個集合  轉成一個數組
        System.out.println(array);

        list.remove(1);//刪除下標爲1的元素
        list.remove("java");//刪除集合中的java元素
        System.out.println(list);
        System.out.println("##########################");
       

 

Vector 是⼀個早期的 List 的實現類，⽤法基本與 ArrayList ⼀致。

Stack 是⼀個棧的數據結構的實現，棧的特色是「後進先出」，「先進後出」。

　　♦ push 將數據壓如到棧中。

　　♦ peek 取出棧頂元素，以複製的形式。

　　♦ pop 取出/移除棧頂元素。

LinkedList 實現了⼀個「先進先出」的隊列，不但要保存⾃⼰的數據，同時要保存前驅節點、後繼節點的

位置信息，全部須要更多的內存空間。

 //list 實現的一個先進先出的隊列
        LinkedList list1=new LinkedList();
        list1.add("How");
        list1.add("are");
        list1.add("you");
        System.out.println(list1);

 

ist.offer("JavaSE");
System.out.println(list);
list.add(1,"List");
System.out.println(list);
System.out.println(list.getLast());
System.out.println(list.get(1));

 

棧和隊列的區別

Stack stack = new Stack();
stack.push(1);
stack.push(2);
stack.push(3);
stack.push(4);
stack.push(5);
for(int i=0;i<5;i++){
System.out.println(stack.pop());
}
System.out.println("****************");
LinkedList list = new LinkedList();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
for(int i=0;i<5;i++){
System.out.println(list.pop());
}

 

Queue 隊列，要求存⼊的數據必須是有序的，因此若是要存⼊⾃定義數據類型，則須要實現

Comparable 接⼝，⾃定義的類就具有了排序的功能。

public class User implements Comparable {
private int id;
private String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public User(int id, String name) {
this.id = id;
this.name = name;
}
/**
* 0 表示相等
* 1 表示this⽐o⼤
* -1 表示this⽐o⼩
* @param o
* @return
*/
@Override
public int compareTo(Object o) {
User user = (User) o;
if(this.id<user.id){
return 1;
}
if(this.id>user.id){
return -1;
}
if(this.id == user.id){
return 0;
}
return 0;
}
}Queue queue = new PriorityQueue();
User user = new User(1,"張三");
User user1 = new User(2,"李四");
queue.add(user);
queue.add(user1);
System.out.println(queue);

 

Set 集合框架

Set 是 Collection 另外⼀個常⽤的⼦接⼝，Set 接⼝以散列的形式來存儲數據，元素沒有順序（一、不能

經過下標取出元素，二、遍歷集合，元素的輸出是隨機的）能夠存儲⼀組惟⼀、⽆序的數據。

實際開發中，不能直接實例化 Set。

HashSet、LinkedHashSet、TreeSet

HashSet 存儲⼀組⽆序且惟⼀的數據，⽆序是指存⼊的順序和取出的順序沒有關係。

Set set = new HashSet();
set.add("Java");
set.add("Hello");
set.add("World");
System.out.println(set.size());
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
set.remove("Hello");
iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}

LinkedHashSet 存儲⼀組有序且惟⼀的數據，這⾥的有序不是說能夠經過下標取數據，LinkedHashSet

依然沒有下標概念，這⾥的有序是指存⼊的順序和取出的順序⼀致。Set set = new LinkedHashSet();

set.add("Java");
set.add("Hello");
set.add("World");
set.add("JavaSE");
set.add("JavaME");
set.add("JavaEE");
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}

 

LinkedHashSet 判斷兩個對象是否相等：

一、判斷 hashcode 是否相等，若是不相等，就認爲是兩個對象不相等。

若是 hashcode 相等，再來執⾏判斷 2。

二、經過 equals ⽅法判斷是否相等。

TreeSet 保存⼀組有序且惟⼀的數據，這⾥的有序是指集合內部會⾃動給全部的元素進⾏升序排列，⽆

論按照什麼樣的順序存⼊數據，輸出的時候⼀定是按照升序進⾏輸出。

HashSet：存⼊的順序和輸出順序沒有關聯，輸出是隨機的。

LinkedHashSet：存⼊順序和輸出順序⼀致。

TreeSet：⽆論什麼順序存⼊，輸出⼀定是升序。

Set set = new TreeSet();
People people = new People(1,"張三");
People people1 = new People(2,"李四");
People people2 = new People(3,"王五");
set.add(people);
set.add(people1);
set.add(people2);
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
public class People implements Comparable {
private int id;
private String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public People(int id, String name) {
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "People{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
@Overridepublic int compareTo(Object o) {
People people = (People) o;
int num = 0;
if(this.id>people.id){
num = 1;
}
if(this.id<people.id){
num = -1;
}
return num;
}
}

Map集合框架

Map 是徹底獨⽴於 Collection 的另外⼀套體系，Set、List、Collection 只能操做單個元素，每⼀次的存

取操做只能針對⼀個元素，Map 能夠操做⼀對元素，key-value 的映射。

K：key

V：value

常⽤⽅法：

int size() 獲取集合的⻓度

boolean isEmpty() 判斷集合是否爲空

boolean containsKey(Object key) 判斷集合中是否存在某個 key 值

boolean containsValue(Object value) 判斷集合是否存在某個 value

V get(Object key) 取出集合中 key 對應的 value

V put(Object key,Object value) 向集合存儲⼀組 key-value 值

V remove(Object key) 刪除集合中 key 對應的 value

void clear() 清空集合

Set keySet() 取出集合中全部的 key，組成⼀個 Set 返回

Collection values() 取出集合中全部的 value，組成⼀個 Collection 返回

HashMap：存儲⼀組⽆序，key 不可重複，value 可重複的元素。

Hashtable：存儲⼀組⽆序，key 不可重複，value 可重複的元素。

TreeMap：存儲⼀組有序（key），key 不可重複，value 可重複的元素。

Map map = new HashMap();
map.put("h","Hello");
map.put("w","World");
map.put("j","Java");
map.put("s","JavaSE");
map.put("m","JavaME");
map.put("e","JavaEE");
System.out.println(map);
map.remove("m");
System.out.println(map);
map.put("jj","Java");
System.out.println(map);
System.out.println(map.containsKey("jj"));
System.out.println(map.containsValue("Java"));
Set keys = map.keySet();
System.out.println(keys);
//遍歷
Iterator iterator = keys.iterator();
while(iterator.hasNext()){
String key = (String) iterator.next();
System.out.println(key+"-"+map.get(key));
}
Collection values = map.values();
for(Object value:values){
System.out.println(value);
}

 

HashMap 和 Hashtable ⽤法⼀樣，Hashtable 較早推出的⼀個 API(Application Interface) 應⽤程序接

⼝，Hashtable 是線程安全的，可是性能較低，HashMap 線程不安全，可是性能更⾼。

Map map = new Hashtable();
map.put("h","Hello");
map.put("w","World");
map.put("j","Java");
map.put("s","JavaSE");
map.put("m","JavaME");
map.put("e","JavaEE");
System.out.println(map);
map.remove("m");
System.out.println(map);
map.put("jj","Java");
System.out.println(map);
System.out.println(map.containsKey("jj"));
System.out.println(map.containsValue("Java"));
Set keys = map.keySet();
System.out.println(keys);
//遍歷Iterator iterator = keys.iterator();
while(iterator.hasNext()){
String key = (String) iterator.next();
System.out.println(key+"-"+map.get(key));
}
Collection values = map.values();
for(Object value:values){
System.out.println(value);
}

 

TreeMap 能夠按照 key 值對數據進⾏排序。

public class Pet implements Comparable {
private int age;
public Pet(int age) {
this.age = age;
}
@Override
public int compareTo(Object o) {
Pet pet = (Pet) o;
if(this.age>pet.age){
return 1;
}
if(this.age<pet.age){
return -1;
}
return 0;
}
@Override
public String toString() {
return "Pet{" +
"age=" + age +
'}';
}
}
Map map = new TreeMap();
Pet pet1 = new Pet(1);
map.put(pet1,"Hello");
Pet pet2 = new Pet(2);map.put(pet2,"World");
Pet pet3 = new Pet(3);
map.put(pet3,"Java");
Pet pet4 = new Pet(4);
map.put(pet4,"JavaSE");
Pet pet5 = new Pet(5);
map.put(pet5,"JavaME");
Pet pet6 = new Pet(6);
map.put(pet6,"JavaEE");
System.out.println(map);

 

♦