【JavaSE筆記】集合(一)_Collection

1. 對象數組

a. 數組既可以存儲基本數據類型，也可以存儲引用類型。它存儲引用類型的時候的數組就叫對象數組
b. 現階段學習的容器有哪些?

i. 數組：裏面的長度是固定的

ii. 字符緩衝區：始終返回的是一個字符串

2. 集合(Collection)

a. 集合由來：

Java -- 面向對象 -- 操作很多對象 -- 存儲 -- 容器(數和StringBuffer) -- 數組，而數組的長度固定，所以不適合做變化的需求，Java就提供了集合供我們使用。

b. 集合和數組的區別

i. 長度區別：

1) 數組固定

2) 集合可變

ii. 內容區別：

1) 數組可以是基本類型，也可以是引用類型

2) 集合只能是引用類型

iii. 元素內容

1) 數組只能存儲同一種類型

2) 集合可以存儲不同類型（一般都存儲同一種類型）

c. 集合框架體系圖

由於需求不同，Java就提供了不同的集合類。這多個集合類的數據結構不同，但是它們都是要提供存儲和遍歷功能的。

Collection

|--List

|--ArrayList

|--Vector

|--LinkedList

|--Set

|--HashSet

|--TreeSet

d. Collection的功能

i. 添加功能：

boolean add(Object obj)   添加一個元素

boolean addAll(Collection c)   添加一個集合中的元素

ii. 刪除功能：

boolean remove(Object o)   刪除指定的元素

boolean removeAll(Collection c)   刪除一個集合中的元素

void clear()   刪除一個集合中的所有元素

iii. 判斷功能：

boolean contains(Object o)   判斷該集合中是否包含指定的元素

boolean containsAll(Collection c)   判斷是否包含一個集合中的元素

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

iv. 獲取功能：

Iterator iterator()  表示對集合中的元素進行迭代(遍歷)

v. 長度功能：

int size()   返回此 collection 中的元素數。

vi. 交集功能：

boolean retainAll(Collection c)  僅保留此 collection 中那些也包含在指定 collection 的元素（可選操作）。

vii. 集合轉換成數組：

Object[ ] toArray() 

public class Collection類的添加功能 {
	public static void main(String[] args) {
		//創建兩個集合對象
		Collection c1 = new ArrayList();
		
		c1.add("yang1");
		c1.add("yang2");
		c1.add("yang3");
		
		Collection c2 = new ArrayList();
		
		c2.add("yang2");
		c2.add("yang3");
		c2.add("yang4");
		Collection c3 = new ArrayList();
		c3.addAll(c2);
		System.out.println(c1);//[yang1, yang2, yang3]
		System.out.println(c2);//[yang2, yang3, yang4]
		System.out.println(c3);//[yang2, yang3, yang4]
	}
}

public class Collection類的判斷功能 {
	public static void main(String[] args) {
		//創建兩個集合對象
		Collection c1 = new ArrayList();		
		c1.add("yang1");
		c1.add("yang2");
		c1.add("yang3");
				
		Collection c2 = new ArrayList();		
		c2.add("yang2");
		c2.add("yang3");
		c2.add("yang4");
		
		Collection c3 = new ArrayList();
		c3.add("yang2");
		c3.add("yang3");
		c3.add("yang4");
//		boolean contains(Object o)   如果此 collection 包含指定的元素，則返回 true。
		System.out.println(c1.contains("yang3"));//true
		System.out.println("————————");
		
//		boolean containsAll(Collection c)   如果此 collection 包含指定 collection 中的所有元素，則返回 true。
		System.out.println(c1.contains(c2));//false
		System.out.println("————————");
		
//		boolean equals(Object o)  比較此 collection 與指定對象是否相等。
		System.out.println(c2.equals(c3));//true
		System.out.println("————————");
		
//		boolean isEmpty()  如果此 collection 不包含元素，則返回 true。
		System.out.println(c1.isEmpty());//false
	}
}

public class Collection類的刪除功能 {
	public static void main(String[] args) {
		Collection c1 = new ArrayList();
		
		c1.add("yang1");
		c1.add("yang2");
		c1.add("yang3");
		System.out.println("c:"+c1);//c:[yang1, yang2, yang3]
		
		c1.remove("yang2");
		System.out.println(c1);//[yang1, yang3]
		
		c1.removeAll(c1);
		System.out.println(c1);//[]
		
//		c1.clear();
//		System.out.println(c1);
	}
}

e. Collection集合的遍歷

i. 把集合轉成數組

ii. 迭代器（集合專用）

import java.util.ArrayList;
import java.util.Collection;
public class 遍歷_數組的方式 {
	public static void main(String[] args) {
		//創建集合對象
		Collection c = new ArrayList();
		//創建學生對象 添加至集合中
		c.add(new Student("Tom",20));
		c.add(new Student("Jack",21));
		c.add(new Student("Lin",23));
		c.add(new Student("Bush",24));
		//將集合轉換成數組:
		Object[] o = c.toArray();
		for (int i = 0; i <o.length ; i++) {
			Student s = (Student) o[i];
			System.out.println(s.getName()+"---"+s.getAge());
		}
	}
}
//out:Tom---20
//Jack---21
//Lin---23
//Bush---24

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class 遍歷_迭代器 {
	public static void main(String[] args) {
		//創建集合對象
				Collection c = new ArrayList();
				//創建學生對象 添加至集合中
				c.add(new Student("Tom",20));
				c.add(new Student("Jack",21));
				c.add(new Student("Lin",23));
				c.add(new Student("Bush",24));
				
				Iterator t = c.iterator();
				while(t.hasNext()){
					Student s = (Student) t.next();
					System.out.println(s.getName()+"---"+s.getName());
				}
	}
}
//out:
//Tom---Tom
//Jack---Jack
//Lin---Lin
//Bush---Bush

f. 迭代器

i. 迭代器是集合獲取元素的方式。

ii. 迭代器是依賴集合而存在的。

iii. 迭代器的原理和源碼碼：

interface Iterator{
	boolean hasNext() ;
	Object next();
}

public interface Iterable {
	Iterator iterator();
}
public interface Collection extends Iterable{
	public Iterator iterator() {
        return new Itr(); //Itr:類
    }
    
    //具體的類:內部類的另一種形式
    private class Itr implements Iterator { //Itr是Iterator接口的子實現類
     	
     	public boolean hasNext() {//重寫了hasNext()
       		return cursor != size;
      	}
     			
     	public Object next() {
     		
     	}
    }
}
	collection c = new ArrayList();
	c.add("hello");
	c.add("world");
	c.add("java");
	Iterator it = c.iterator();//Iterator it = new Itr() ;//接口多態(開發中經常用)
	while(it.hasNext){
		String s = (String)it.next();
		System.out.println(s);
	}

3. List

a. List集合是Collection集合的子接口,接口與接口的關係是繼承關係!

特點：List集合是一個有序（元素存儲和取出是一致的!）的集合,是可以有重複的元素

b. List的特有功能：

i. 添加功能：

void add(int index,Object element)   在指定位置添加指定的元素

ii. 刪除功能：

Object remove(int index)   刪除指定位置的元素,返回的就是刪除的元素

iii. 獲取功能：

Object get(int index)   獲取指定位置的元素

iv. 修改功能：

Object set(int index,object element)   將指定位置的元素用element該元素替代,返回的是需要被替代的元素

v. 迭代器功能：

ListIterator listIterator()   ListIterator繼承自 Collection中的Iterator接口

import java.util.ArrayList;
import java.util.List;
public class List類的常用方法 {
	public static void main(String[] args) {
		//創建List集合對象  ；
		List l = new ArrayList<>();
		//添加元素；
		l.add("I");
		l.add("want");
		l.add("something");
		l.add("just");
		l.add("like");
		l.add("this");
		
		System.out.println("List:"+l);//List:[I, want, something, just, like, this]
//		void add(int index,Object element)    在指定位置添加指定的元素
//		在該索引對應的元素的位置前面添加一個新的元素
		l.add(0, "NEW");
//		l.add(12,"NEW");//IndexOutOfBoundsException:角標越界
		System.out.println("List"+l);//List[NEW, I, want, something, just, like, this]
		System.out.println("——————————————————————————");
//		Object remove(int index)    刪除指定位置的元素
		
		System.out.println(l.remove(5));//like
		System.out.println("List:"+l);//List:[NEW, I, want, something, just, this]
		System.out.println("——————————————————————————");
//		Object get(int index)    獲取指定位置的元素	
		System.out.println(l.get(5));//this
		System.out.println("——————————————————————————");
//		Object set(int index,object element):將指定位置的元素用element該元素替代,返回的是需要被替代的元素
		System.out.println(l.set(2,"TiHuan"));//want
		System.out.println("List:"+l);//List:[NEW, I, TiHuan, something, just, this]
	}
}

c. List集合遍歷方式：

i. 由size()和get()結合。

ii. Iterate iterate();

iii. ListIterate listiterate();

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class List遍歷 {
	public static void main(String[] args) {
		//創建集合對象
		List list = new ArrayList();
		
		//創建並添加元素
		list.add("hello");
		list.add("world");
		list.add("java");
		
		//遍歷集合
		Iterator it = list.iterator();
		while(it.hasNext()) {
			String s =(String) it.next();
			System.out.println(s);
		}
		System.out.println("----------");
		//for(size()/get()方法)
		for(int x=0; x<list.size(); x++) {
			String s =(String) list.get(x);
			System.out.println(s);
		}	
	}
}
/*out:
	hello
	world
	java
	----------
	hello
	world
	java*/

d. List集合專有迭代遍歷方式

ListIterator listIterator() ;

i. ListIterator接口（extends Iterator）的方法：

1) boolean hasNext()   表示正向遍歷:是否有下一個可以迭代的元素

2) Object next()  獲取下一個元素

3) boolean hasPrevious()  表示逆向遍歷:是否有上一個可以迭代的元素

4) Object previous()  返回列表中的前一個元素

ii. 可以逆向遍歷，但是要先正向遍歷，所以無意義，基本不使用。

e. 併發修改異常（java.util.ConcurrentModificationException）

i. 產生併發修改異常的原因：

當我們給集合中添加了新的字符串,迭代器不知道集合中是否添加了一個新的元素,所以產生這個異常!

ii. 兩種解決方式:

1) 使用迭代器遍歷,迭代器添加,Iterator接口沒有添加功能,所有使用列表迭代器:ListIterator

2) 使用集合遍歷,使用集合添加

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class 併發修改異常 {
	public static void main(String[] args) {
		//創建集合對象
		List a = new ArrayList();
		//添加字符串
		a.add("I");
		a.add("Want");
		a.add("Something");
		a.add("Just");
		a.add("Like");
		a.add("This");
		
		/*//遍歷集合的元素,使用迭代器遍歷
		Iterator i = a.iterator();
		while(i.hasNext()){
			String s = (String) i.next();
			//判斷
			if(s.equals("Just")){
				a.add("YF");
			}
		}
		System.out.println(a);*/
//		java.util.ConcurrentModificationException 併發修改異常
//		兩種解決方式:
//		1.使用迭代器遍歷,迭代器添加,Iterator接口沒有添加功能,所有使用列表迭代器:ListIterator
		ListIterator i = a.listIterator();
		while(i.hasNext()){
			String s = (String) i.next();
			if(s.equals("Just")){
				i.add("YF");
			}
		}
		System.out.println(a);//[I, Want, Something, Just, YF, Like, This]
//		2.使用集合遍歷,使用集合添加
		for(int x =0 ;x<a.size();x++){
			String s = (String) a.get(x);
			//判斷有world,採用集合添加,在末尾添加
			if(s.equals("Want")){
				a.add("Fan");
			}
		}
		System.out.println(a);//[I, Want, Something, Just, YF, Like, This, Fan]
	}
}

f. 常見數據結構

i. 棧：先進後出

ii. 隊列：先進先出

iii. 數組：查詢快，增刪慢

iv. 鏈表：查詢慢，增刪快

g. List的子類特點(面試題)

i. ArrayList

底層數據結構是數組,查詢快,增刪慢,線程不安全,不同步,效率高

ii. Vector

底層數據結構是數組,查詢快,增刪慢,線程安全,同步,效率低

iii. LinkedList

底層數據結構數鏈表,查詢慢,增刪快,線程不安全,不同步,效率高

應用場景:ArrayList:開發中用的非常多!

如果給一個需求,不知道使用誰的時候,都使用ArrayList

h. List集合的練習：

4. ArrayList

a. 底層數據結構是數組,查詢快,增刪慢,線程不安全(多線程中講),效率高
b. List集合的子類遍歷集合中的元素可以使用的任何迭代遍歷方式：普通for循環、itreator()

c. ArrayList相關案例：需求：ArrayList去除集合中字符串的重複值(字符串的內容相同)

import java.util.ArrayList;
import java.util.Iterator;

public class 練習1 {
	public static void main(String[] args) {
		ArrayList a = new ArrayList();
		a.add("I");
		a.add("Want");
		a.add("Something");
		a.add("Just");
		a.add("Just");
		a.add("Like");
		a.add("Want");
		a.add("Just");
		a.add("This");
		System.out.println(a);
		for (int i = 0; i < a.size()-1; i++) {
			for(int j =i+1;j<a.size();j++){
				if(a.get(i).equals(a.get(j))){
					a.remove(j);
					j--;
				}
			}
		}
		System.out.println(a);
		System.out.println("——————————");
//		迭代器方式
		Iterator t = a.iterator();
		while(t.hasNext()){
			String s = (String) t.next();
			System.out.println(s);
		}
	}
}
/*out:
[I, Want, Something, Just, Just, Like, Want, Just, This]
[I, Want, Something, Just, Like, This]
——————————
I
Want
Something
Just
Like
This*/

import java.util.ArrayList;
import java.util.Iterator;

//需求：ArrayList去除集合對象的重複的成員信息(成員變量的值是一樣)

//現在集合存儲的是引用類型的對象,而一個類的對象,有一個equals()方法,如果不重寫,默認用Object中的equals()

//默認比較的是地址值;在Student類中重寫equals方法,比較是內容是否相同
class Student{
	private String name;
	private int age;
	
	public Student() {
		super();
	}
	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	//重寫equals方法 比較的是內容
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
}
public class 練習2 {
	public static void main(String[] args) {
		//創建ArrayList集合對象
		ArrayList a = new ArrayList();
		//創建5個學生對象  添加至集合
		a.add(new Student("Tom",21));
		a.add(new Student("Peter",23));
		a.add(new Student("Ber",21));
		a.add(new Student("Peter",23));	
		a.add(new Student("Tom",21));
		a.add(new Student("Peter",23));
		//創建新集合
		ArrayList aa = new ArrayList();
		//遍歷舊集合
		Iterator t = a.iterator();
		while(t.hasNext()){
			Student s = (Student) t.next();
			if(!aa.contains(s)){
				aa.add(s);
			}
		}
		//遍歷新集合
		Iterator tt = aa.iterator();
		while(tt.hasNext()){
			Student s = (Student) tt.next();
			System.out.println(s.getName()+"---"+s.getAge());
		}
		
	}
}

5. Vecotr

a. 底層數據結構是數組,查詢快,增刪慢,線程安全,同步,效率低
b. 特有功能：

i.  public void addElement(Object obj)   給Vector集合中添加元素

ii. public Object elementAt(int index)類似get(int index):獲取指定索引處的元素

iii.public Enumeration elements()       類似Iterator iterator()獲取迭代器對象

iv.boolean hasMoreElements()          類似hasNext():判斷是否有下一個可以迭代的元素

v. Object nextElement()                      類似next()

import java.util.Vector;
import java.util.Enumeration;
public class VectorDemo {
	public static void main(String[] args) {
		//創建Vector集合對象
		Vector v = new Vector();
		//添加元素
		v.addElement("I");
		v.addElement("Want");
		v.addElement("Something");
		v.addElement("Just");
		v.addElement("Like");
		v.addElement("This");
		//遍歷Vector集合：普通的for循環
		for(int i =0 ;i<v.size();i++){
//			public Object elementAt(int index)
			String s = (String) v.elementAt(i);
			System.out.println(s);
		}
		System.out.println("————————————————");
		//獲取迭代器對象:
		Enumeration en = v.elements();
		while(en.hasMoreElements()){
			String s = (String) en.nextElement();
			System.out.println(s);
		}
		
	}
}/*out:
I
Want
Something
Just
Like
This
————————————————
I
Want
Something
Just
Like
This
*/

6. LinkedList

a. 底層數據結構是鏈表,查詢慢,增刪快,線程不安全,效率高!
b. 特有功能

i. 添加相關的方法:

public void addFirst(Object e)

public void addLast(Object e)

ii. 獲取相關的方法:

public Object getFirst()  返回此列表的第一個元素

public Object getLast()  返回此列表的最後一個元素

iii. 刪除相關的方法：

public Object removeFirst() 刪除此列表的第一個元素

public Object removeLast() 刪除此列表的最後一個元素

import java.util.LinkedList;

public class LinkedListDemo  {
	public static void main(String[] args) {
		//創建LinkedList集合對象
		LinkedList link = new LinkedList() ;		
		//給集合中添加元素
		link.add("hello");
		link.add("world");
		link.add("java");
		System.out.println("link:"+link);
//		添加相關的方法:
		link.addFirst("Yang");
		link.addLast("Fan");
		System.out.println(link);
		System.out.println("————————————————————————");
//		獲取相關的方法:
		System.out.println("getFirst:"+link.getFirst());
		System.out.println("getLast:"+link.getLast());
		System.out.println("————————————————————————");
//		刪除相關的方法:
		System.out.println("removeFirst:"+link.removeFirst());
		System.out.println("removeLast:"+link.removeLast());
		System.out.println("link:"+link);
	}
}

/*out:

link:[hello, world, java]
[Yang, hello, world, java, Fan]
————————————————————————
getFirst:Yang
getLast:Fan
————————————————————————
removeFirst:Yang
removeLast:Fan
link:[hello, world, java]*/