一、集合的出現
1.1、集合簡述
面向對象語言對事物的體現都是以對象形式，為了方便對多個對象的操作，就對象對象進行存儲，集合就是存儀儲對象最常用的一種試
1.2、數組和集合都是容器
數組也存對象，存儲同一種類型，但數組是固定長度的，集合長度是可變。
數組中可以存儲基本數據類型，集合只能存儲對象
1.3、集合特點
集合只用于存儲對象，集合長度是可變的，集合可以存儲不同類型的對象。
1.4、結構
二、集合共性方法
2.1、Collection接口頂級
Collection 層次結構 中的根接口。Collection 表示一組對象，這些對象也稱為 collection 的元素。一些 collection 允許有重復的元素，而另一些則不允許。一些 collection 是有序的，而另一些則是無序的。JDK 不提供此接口的任何直接 實現：它提供更具體的子接口（如 Set 和 List）實現。此接口通常用來傳遞 collection，并在需要最大普遍性的地方操作這些 collection。
2.2、共性方法
| 方法摘要 | ||
|---|---|---|
boolean | add(E e) 確保此 collection 包含指定的元素（可選操作）。 | |
boolean | addAll(Collection<? extends E> c) 將指定 collection 中的所有元素都添加到此 collection 中（可選操作）。 | |
void | clear() 移除此 collection 中的所有元素（可選操作）。 | |
boolean | contains(Object o) 如果此 collection 包含指定的元素，則返回 true。 | |
boolean | containsAll(Collection<?> c) 如果此 collection 包含指定 collection 中的所有元素，則返回 true。 | |
boolean | equals(Object o) 比較此 collection 與指定對象是否相等。 | |
int | hashCode() 返回此 collection 的哈希碼值。 | |
boolean | isEmpty() 如果此 collection 不包含元素，則返回 true。 | |
Iterator<E> | iterator() 返回在此 collection 的元素上進行迭代的迭代器。 | |
boolean | remove(Object o) 從此 collection 中移除指定元素的單個實例，如果存在的話（可選操作）。 | |
boolean | removeAll(Collection<?> c) 移除此 collection 中那些也包含在指定 collection 中的所有元素（可選操作）。 | |
boolean | retainAll(Collection<?> c) 僅保留此 collection 中那些也包含在指定 collection 的元素（可選操作）。 | |
int | size() 返回此 collection 中的元素數。 | |
Object[] | toArray() 返回包含此 collection 中所有元素的數組。 | |
| toArray(T[] a) 返回包含此 collection 中所有元素的數組；返回數組的運行時類型與指定數組的運行時類型相同。 | |
2.3、ArrayList示例
import java.util.*;class CollectionDemo { public static void main(String[] args) { // 聲明2個集合容器，并添加元素 List<String> ar1 = new ArrayList<String>(); ar1.add("a"); ar1.add("b"); ar1.add("c"); ar1.add("d"); ar1.add("e"); // 遍歷 sop("ar1遍歷:"); getIterator(ar1); List<String> ar2 = new ArrayList<String>(); ar2.add("a"); ar2.add("b"); ar2.add("f"); ar2.add("q"); ar2.add("w"); // 增強for循環遍歷 sop("ar2遍歷:"); getFor(ar2); // 求集合的長度 sop("ar1的長度:" + ar1.size()); sop("ar2的長度:" + ar2.size()); // 比較判斷 sop("ar1中有字符a嗎 : " + ar1.contains("a")); // 整個集合比較 sop("ar1中有字符ar2嗎 : " + ar1.containsAll(ar2)); // 求交集 ar1.retainAll(ar2); sop("求交集"); getFor(ar1); // addALL ar1.addAll(ar2); // 增強for循環遍歷 sop("添加ar2后的ar1:"); getFor(ar1); // 刪除 ar1.remove("c"); sop("ar1刪除指定c后"); getFor(ar1); sop("ar1刪除指定集合"); ar1.removeAll(ar2); getFor(ar1); sop("ar1是空嗎？" + ar1.isEmpty()); // 清空 ar1.clear(); sop(ar1.size()); } // iterator遍歷集合 public static void getIterator(List<String> list) { Iterator<String> iterator = list.iterator(); while (iterator.hasNext()) { String str = iterator.next(); sop(str); } } // forEach遍歷 public static void getFor(List<String> list) { for (String str : list) { sop(str); } } // 打印 public static void sop(Object obj) { System.out.PRintln(obj); }}
結果：
ar1遍歷:abcdear2遍歷:abfqwar1的長度:5ar2的長度:5ar1中有字符a嗎 : truear1中有字符ar2嗎 : false求交集ab添加ar2后的ar1:ababfqwar1刪除指定c后ababfqwar1刪除指定集合ar1是空嗎？true0
2.4、Iterator
| 方法摘要 | |
|---|---|
boolean | hasNext() 如果仍有元素可以迭代，則返回 true。 |
E | next() 返回迭代的下一個元素。 |
void | remove() 從迭代器指向的 collection 中移除迭代器返回的最后一個元素（可選操作）。 |
2.5、ArrayList
import java.util.ArrayList;import java.util.Iterator;import java.util.List;/** * List:元素是有序的，元素可以重復，該集合體系有索引 * Set:元素是無序，元素不可以重復 * List: * 特有方法：可以操作索引的方法都 是特有 * add(index ,element) * addAll(index,Collection); * remove (index) * set(index,element) * get(index); * subList(from,to) * listIterator() * * */public class ListDemo { public static void main(String[] args) { //add(); //remove(); //set(); //getIndex(); indexSub(); } //indexOf和subList public static void indexSub(){ List<String> list=new ArrayList<String>(); //添加元素 list.add("java01"); list.add("java02"); list.add("java03"); list.add("java04"); list.set(2,"hello"); sop(list.indexOf("java04"));//3 sop(list.indexOf("java09"));//-1 sop(list.lastIndexOf("hello"));//2 List<String> subList=list.subList(1, 3); sop(subList);//hello,java03 } //遍歷 public static void getIndex(){ List<String> list=new ArrayList<String>(); //添加元素 list.add("java01"); list.add("java02"); list.add("java03"); list.add("java04"); list.set(2,"hello"); //循環遍歷，通過索引的方式遍歷和數組一樣 for(int x=0;x<list.size();x++){ sop("list["+x+"]="+list.get(x)); } } //修改 public static void set(){ List<String> list=new ArrayList<String>(); //添加元素 list.add("java01"); list.add("java02"); list.add("java03"); list.add("java04"); list.set(2,"hello"); //遍歷 get(list); } //刪除元素 public static void remove(){ List<String> list=new ArrayList<String>(); //添加元素 list.add("java01"); list.add("java02"); list.add("java03"); list.add("java04"); list.remove(2); //遍歷 get(list); } //添加元素 public static void add(){ List<String> list=new ArrayList<String>(); //添加元素 list.add("java01"); list.add("java02"); list.add("java03"); //遍歷 get(list); //在指定位置添加 list.add(1,"java09"); //遍歷 System.out.println("========在指定位置添加后=========="); get(list); } //遍歷 public static void get(List<String> list){ for(Iterator<String> it=list.iterator();it.hasNext();){ sop(it.next()); } } public static void sop(Object obj){ System.out.println(obj); } }
2.6、列表迭代器 listIterator
iterator，只能做判斷、刪除、取出，不能做其它操作
listIterator
public ListIterator<E> listIterator(int index)
返回列表中元素的列表迭代器（按適當順序），從列表的指定位置開始。指定的索引表示 next 的初始調用所返回的第一個元素。previous 方法的初始調用將返回索引比指定索引少 1 的元素。
此實現返回 ListIterator 接口的直接實現，擴展了由 iterator() 方法返回的 Iterator 接口的實現。ListIterator 實現依賴于底層實現列表的 get(int)、set(int, E)、add(int, E) 和 remove(int) 方法。
注意，除非重寫列表的 remove(int)、set(int, E) 和 add(int, E) 方法，否則此實現返回的列表迭代器將拋出 UnsupportedOperationException 來響應其 remove、set 和 add 方法。
根據 (protected) modCount 字段規范中的描述，在面臨并發修改時，可以使此實現拋出運行時異常。
| 方法摘要 | |
|---|---|
void | add(E e) 將指定的元素插入列表（可選操作）。 |
boolean | hasNext() 以正向遍歷列表時，如果列表迭代器有多個元素，則返回 true（換句話說，如果 next 返回一個元素而不是拋出異常，則返回 true）。 |
boolean | hasprevious() 如果以逆向遍歷列表，列表迭代器有多個元素，則返回 true。 |
E | next() 返回列表中的下一個元素。 |
int | nextIndex() 返回對 next 的后續調用所返回元素的索引。 |
E | previous() 返回列表中的前一個元素。 |
int | previousIndex() 返回對 previous 的后續調用所返回元素的索引。 |
void | remove() 從列表中移除由 next 或 previous 返回的最后一個元素（可選操作）。 |
void | set(E e) 用指定元素替換 next 或 previous 返回的最后一個元素（可選操作）。 |
package com.pb.list.demo1;import java.util.ArrayList;import java.util.List;import java.util.*;public class ListIteratorDemo { public static void main(String[] args) { List<String> list=new ArrayList<String>(); //添加元素 list.add("java01"); list.add("java02"); list.add("java03"); list.add("java04"); list.add("java05"); //獲取listIterator迭代器 ListIterator<String> listIterator=list.listIterator(); while(listIterator.hasNext()){ if(listIterator.next().equals("java02")){//判斷 //修改 listIterator.set("java007"); //添加 listIterator.add("hello"); } } sop(list); //倒序輸出遍歷 while(listIterator.hasPrevious()){ sop(listIterator.previous()); } } public static void sop(Object obj){ System.out.println(obj); }}
2.7、Vector
package com.pb.list.demo1;import java.util.ArrayList;import java.util.Enumeration;import java.util.List;import java.util.Vector;public class VectorDemo { public static void main(String[] args) { Vector<String> vector=new Vector<String>(); //添加元素 vector.add("java01"); vector.add("java02"); vector.add("java03"); vector.add("java04"); vector.add("java05"); //獲取枚舉 Enumeration<String> en=vector.elements(); while(en.hasMoreElements()){ System.out.println(en.nextElement()); } }}
2.8、LinkedList
package com.pb.list.demo1;import java.util.LinkedList;/** * LinkedList特有方法： * 添加元素到第一個索引位置 addFirst();* 添加元素到最后一個索引位置 addLast(); * 獲取索引為0的元素 getFirst(); * 獲取索引最后的元素 getLast(); * 刪除索引為0的元素 removeFirst(); * 刪除索引為size()-1的元素 * removeLast(); */public class LinkedListDemo { public static void main(String[] args) { // 聲明一個鏈表集合 LinkedList<String> list = new LinkedList<String>(); // 添加到第一個元素 list.addFirst("1"); list.add("2"); list.add("3"); sop(list);// 3,2,1 // 將元素添加到最后 list.addLast("6"); list.addLast("5"); list.addLast("4");// 3,2,1,6,5,4 sop(list);// 獲取第一個元素 sop(list.getFirst());//3 // 獲取最后一個元素 sop(list.getLast());// 4 // 刪除第一個元素 sop(list.removeFirst()); // 刪除最后一個 sop(list.removeLast()); sop(list);// 2,1,6,5 /* * 獲取集合全部元素，不使用迭代器 */ while (!list.isEmpty()) { list.removeFirst();// list.removeLast(); } } public static void sop(Object obj) { System.out.println(obj); }}
removeFirst或者removeLast
public E removeFirst()
移除并返回此列表的第一個元素。
Deque<E> 中的 removeFirst返回：
此列表的第一個元素
拋出：
NoSuchElementException - 如果此列表為空
JDK 1.6之后提供了新的方法
public E pollFirst()
Deque<E> 中的 pollFirst示例
package com.pb.list.demo1;import java.util.LinkedList;/** * JDK 1.6提供了新的方法 * offerFirst()，添加元素到第個 * offerLast(),添加元素到最后一位 * * peekFirst()獲取第一個元素 * peekLast()獲取最后一個元素 * * pollFirst()刪除第一個元素 * pollLast()刪除最后一個元素 * */public class LinkedListDemo1 { public static void main(String[] args) { // 聲明一個鏈表集合 LinkedList<String> list = new LinkedList<String>(); // 添加到第一個元素 list.offerFirst("1"); list.offerFirst("2"); list.offerFirst("3"); sop(list);// 3,21 // 將元素添加到最后 list.offerLast("6"); list.offerLast("5"); list.offerLast("4");// 3,2,1,6,5,4 sop(list); // 獲取第一個元素 sop(list.peekFirst());// 3 // 獲取最后一個元素 sop(list.peekLast());// 4 // 刪除第一個元素 sop(list.pollFirst()); // 刪除最后一個 sop(list.pollLast()); sop(list);// 2,1,6,5 /* * 獲取集合全部元素，不使用迭代器 */ while (!list.isEmpty()) { list.pollFirst();// list.pollLast() } } public static void sop(Object obj) { System.out.println(obj); }}
示例：
package com.pb.list.demo1;import java.util.LinkedList;/** * 使用LinkedList模擬一個堆棧或者隊列數據結構 * 堆棧：先進后出 * 隊列：先進先出 * * */public class LinkedListDemo2 { public static void main(String[] args) { Que q=new Que(); q.myAdd("java01"); q.myAdd("java02"); q.myAdd("java03"); q.myAdd("java04"); q.myAdd("java05"); while(!q.isNUll()){ //輸出 System.out.println(q.myGet()); } }}class Que{ private LinkedList list=null; public Que(){ list=new LinkedList(); } //判斷是不是NULL public boolean isNUll(){ return list.isEmpty(); } //添加 public void myAdd(Object obj){ list.offerFirst(obj); } //刪除 public Object myGet(){ return list.pollLast(); //先出 // return list.pollFirst(); }}
示例，去除list的重復元素
package com.pb.list.demo1;import java.util.ArrayList;import java.util.Iterator;/** * 去除ArrayList中的重復元素 * @author Administrator * */public class ArrayListDemo1 { public static void main(String[] args) { ArrayList list=new ArrayList(); list.add("java01"); list.add("java01"); list.add("java02"); list.add("java02"); list.add("java03"); list.add("java03"); list.add("java019"); System.out.println(getSingle(list)); } public static ArrayList getSingle(ArrayList list){ ArrayList tempList=new ArrayList(); for(Iterator it=list.iterator();it.hasNext();){ Object obj=it.next(); if(!tempList.contains(obj)){ tempList.add(obj); } } return tempList; }}
示例，去除list的重復對象
package com.pb.list.demo1;public class Person { private String name; private int age; //重寫equals @Override public boolean equals(Object obj) { if(!(obj instanceof Person)){ return false; } Person p=(Person)obj; return this.name.equals(p.name)&&this.age==p.age; } public Person() { super(); // TODO Auto-generated constructor stub } public Person(String name, int age) { super(); 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; } public void show(){ System.out.println(this.name+"........"+this.age); }}
package com.pb.list.demo1;import java.util.ArrayList;import java.util.Iterator;/** * 去除ArrayList中的重復元素 * @author Administrator * */public class ArrayListDemo1 { public static void main(String[] args) { Person p1=new Person("張三",19); Person p2=new Person("張三",19); Person p3=new Person("李四",23); Person p4=new Person("李四",23); Person p5=new Person("王五",33); Person p6=new Person("王五",23); Person p7=new Person("趙六",18); ArrayList<Person> list=new ArrayList<Person>(); list.add(p1); list.add(p2); list.add(p3); list.add(p4); list.add(p5); list.add(p6); //遍歷去掉重復后的 for(Person p:getSingle(list)){ p.show(); } } public static ArrayList<Person> getSingle(ArrayList<Person> list){ ArrayList<Person> tempList=new ArrayList<Person>(); for(Iterator<Person> it=list.iterator();it.hasNext();){ Person p=it.next(); if(!tempList.contains(p)){ //contains也是調用對象equals方法 tempList.add(p); } } return tempList; }}
2.9、三種集合區別
ArrayList：底層的數據結構使用是數組結構,遍歷快，增、刪、改，慢,線程不同步
LinkedList：底層的數據結構使用鏈表數據結構，遍歷慢，增、刪、改，快，
Vector:底層的數據結構使用是數組結構,線程同步的，被ArrayList替代了。
3.1、List和Set區別
List:元素是有序的，元素可以重復，該集合體系有索引
Set:元素是無序，元素不可以重復
一個不包含重復元素的 collection。更確切地講，set 不包含滿足 e1.equals(e2) 的元素對 e1 和 e2，并且最多包含一個 null 元素。
3.2、常見子類
HashSet--哈希表,TreeSet
3.3、功能方法
Set的方法和Collection一樣，使用方式也一樣
package com.pb.list.demo1;public class Person { private String name; private int age; //重寫hashCode @Override public int hashCode() { System.out.println("========hashCode"); return name.hashCode()+age*39; } //重寫equals @Override public boolean equals(Object obj) { if(!(obj instanceof Person)){ return false; } Person p=(Person)obj; System.out.println(p.name+"========equals"+p.age); return this.name.equals(p.name)&&this.age==p.age; } public Person() { super(); // TODO Auto-generated constructor stub } public Person(String name, int age) { super(); 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; } public void show(){ System.out.println(this.name+"........"+this.age); }}
package com.pb.list.demo1;import java.util.HashSet;import java.util.Iterator;public class Demo1 { public static void main(String[] args) { Person p1=new Person("張三",19); Person p2=new Person("李四",20); Person p3=new Person("張三",19); Person p4=new Person("李四",20); Person p5=new Person("五一",19); Person p6=new Person("五一",19); HashSet<Person> set=new HashSet<Person>(); set.add(p6); set.add(p5); set.add(p4); set.add(p3); set.add(p2); set.add(p1); Iterator<Person> iterator=set.iterator(); while(iterator.hasNext()){ Person p=iterator.next(); p.show(); } }}
========hashCode========hashCode五一========equals19========hashCode========hashCode========hashCode李四========equals20========hashCode張三========equals19李四........20張三........19五一........19
ArrayList:判斷元素是否存或者刪除依賴的方法equals()方法
Set:判斷元素是否存或者刪除，依賴的方法hashCode()和equals()方法,先判斷hashCode如果有再判斷equals
新聞熱點
疑難解答
