集合是什麼？簡單的說就是一種容器，用來裝載各種封裝後的數據，數組也能裝載數據，他和集合有什麼區別呢？簡單的說，數組是固定的，而集合卻是可以隨時根據需要增加，刪除，改變數據。
集合框架 看圖
這是集合裏面包含的接口和實現類，我可能知道不是那麼多，只能將我學了的記下來
-List接口：存儲有序的，可以重複的元素.—相當於“動態”數組
常用方法 ：刪除remove(int index) 修改set(int index,Object obj) 獲取get(int index)插入add(int index,Object obj)
主要實現類：-ArrayList（主要的實現類）
-LinkedList（更適用於頻繁的插入、刪除操作）
package collectior;
import java.util.ArrayList;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
/**此乃容器也，第一次接觸容器，容器一共有collectior（List、set(Hasset)），map（HasMap）這麼多接口
* ArrayList:底層實現是數組，線程不安全，效率高。所以，查詢快，修改，插入，刪除慢。
* LinkedList：底層實現是鏈表，線程不安全，效率高。所以，查詢慢。修改，插入，刪除快。
* List與順序有關，而且可以重複
* set與順序無關且不可以重複
*/
public class Test01 {
public static void main(String[] args) {
List list=new ArrayList();//父類指向子類的引用
List list0=new LinkedList();//父類指向子類的引用 多態無時不在，面向接口編程
list0.add("imiao");//向list0中添加一個字符串
list0.add(new dog());//向list0中添加一個對象
list0.remove(0);//刪除第0個元素
for(int i=0;i<list0.size();i++){
System.out.println(list0.get(i));
}
list.add("aaa");
list.add(new Date());
list.add(new dog());
list.add(1234);//包裝類的：自動裝箱
System.out.println(list.size());
System.out.println(list.isEmpty());
// list.remove("aaa"); //hasshoode和equals
//System.out.println(list.size());
List list2=new ArrayList();//父類指向子類的引用
list2.add("bbb");
list2.add("ccc");
list.add(list2);
System.out.println(list.size());
//跟順序有關的操作
String str=(String )list.get(0);
System.out.println(str);
list.set(1, "ababab");
list.remove(0);
}
}
class dog{
public dog() {
System.out.println("this is dog");
}
}
顯示結果
this is dog
collectior.dog@77f2fbff
this is dog
4
false
5
aaa
Set接口：存儲無序的，不可重複的元素。—相當於高中的“集合”概念
添加進Set集合中的元素所在的類一定要重寫equals() 和 hashCode()。要求重寫equals() 和 hashCode()方法保持一致。
1.無序性：無序性不等於隨機性。真正的無序性，指的是元素在底層存儲的位置是無序的。
2.不可重複性：當向Set中添加進相同的元素的時候，後面的這個不能添加進去。
HashSet（主要的實現類）
LinkedHashSet(是HashSet的子類，當我們遍歷集合元素時，是按照添加進去的順序實現的；頻繁的遍歷，較少的添加、插入操作建議選擇他)
TreeSet（可以按照添加進集合中的元素的指定屬性進行排序，默認升序）
添加進Set集合中的元素所在的類一定要重寫equals() 和 hashCode()。要求重寫equals() 和 hashCode()方法保持一致
兩個對象equals相等，那麼它的hashcode相等
兩個對象equals不相等，那麼它的hashcode並不要求它不相等，但一般建議不相等
hashcode相等不代表兩個對象相等（採用equals比較）
package collectior;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class TestSet {
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "小明";
p1.age = 8;
Person p2 = new Person();
p2.name = "小紅";
p2.age = 5;
Person p3 = new Person();
p3.name = "小紅";
p3.age = 10;
Set set = new HashSet();
set.add(p1);
set.add(p2);
set.add(p3);
for (Iterator iter=set.iterator(); iter.hasNext();) {
Person p = (Person)iter.next();
System.out.println("name=" + p.name + ", age=" + p.age);
}
System.out.println("p1.hashCode=" + p1.hashCode());
System.out.println("p2.hashCode=" + p2.hashCode());
System.out.println("p3.hashCode=" + p3.hashCode());
Set set0 =new HashSet();
set0.add("aaa");
set0.add("ddd");
set0.add(set);
set0.add(new String ("aaa"));
System.out.println(set0.size());//2，表明是不可以插入重複的數據的
for (Iterator iter=set0.iterator(); iter.hasNext();) {
System.out.println(iter.next());
}
/**
* 3
[(this Collection), aaa, ddd]
aaa
ddds
*
*/
//表明輸出結果是無序的
//set.remove("aaa");
}
}
顯示結果:
name=小明, age=8
name=小紅, age=5
p1.hashCode=756703
p2.hashCode=762995
p3.hashCode=762995
3
[collectior.Person@b8bdf, collectior.Person@ba473]
aaa
ddd
再來看一個treeSet的例子
package collectior;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class TesttreeSet {
public static void main(String[] args) {
Set set0 = new TreeSet();
set0.add(1);
set0.add(8);
set0.add(5);
set0.add(3);
for (Iterator set=set0.iterator(); set.hasNext();) {
int int1 = (int)set.next();//強制類型轉換成int
System.out.print(int1+"\t");
}
}
}
顯示結果
1 3 5 8 按升序排序輸出
繼續排序 實現Comparable接口
package collectior;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class TestSet {
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "小明";
p1.age = 8;
Person p2 = new Person();
p2.name = "小紅";
p2.age = 5;
Set set = new TreeSet();
set.add(p1);
set.add(p2);
for (Iterator iter=set.iterator(); iter.hasNext();) {
Person p = (Person)iter.next();
System.out.println("name=" + p.name + ", age=" + p.age);
}
}
}
package collectior;
public class Person implements Comparable {//實現Comparable接口
String name;
int age;
//重寫hashCode()
public int hashCode() {
return (name==null)?0:name.hashCode();
}
//重寫equals
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof Person) {
Person p = (Person)obj;
return this.name.equals(p.name);
}
return false;
}
public int compareTo(Object o) {//重寫copareTo()方法
if (o instanceof Person) {
Person p = (Person)o;
//降序
return ( p.age-this.age);
}
throw new IllegalArgumentException("非法參數，o=" + o);
}
}
顯示結果：
name=小明, age=8
name=小紅, age=5
繼續排序 實現Comparator接口
package collectior;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class TestSet {
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "小明";
p1.age = 8;
Person p2 = new Person();
p2.name = "小紅";
p2.age = 5;
//內部類實現Coparator方法，所謂內部類就是在new的同時把類給直接寫出來了 不需類名，卻可以訪問外部類的屬性和方法
Set set = new TreeSet(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if (!(o1 instanceof Person)) {//instanceof的意思是檢查傳入的對象與原對象是否一致
throw new IllegalArgumentException("非法參數，o1=" + o1);
}
if (!(o2 instanceof Person)) {
throw new IllegalArgumentException("非法參數，o2=" + o2);
}
Person p1 = (Person)o1;
Person p2 = (Person)o2;
return p2.age - p1.age;
}
});
set.add(p1);
set.add(p2);
for (Iterator iter=set.iterator(); iter.hasNext();) {
Person p = (Person)iter.next();
System.out.println("name=" + p.name + ", age=" + p.age);
}
}
}
顯示結果：
name=小明, age=8
name=小紅, age=5一個類實現了Camparable接口則表明這個類的對象之間是可以相互比較的，這個類對象組成的集合就可以直接使用sort方法排序。
Comparator可以看成一種算法的實現，將算法和數據分離
Map接口：存儲“鍵-值”對的數據 —-相當於高中的
key是不可重複的，使用Set存放。value可以重複的，使用Collection來存放。一個key-value對構成一個entry(Map.Entry)，entry使用Set來存放
常用方法：添加put(Object key,Object value)
刪除remove(Object key)
獲取get(Object key) size() / keySet() values() entrySet()
HashMap：主要的實現類，可以添加null鍵，null值
LinkedHashMap：是HashMap的子類，可以按照添加進Map的順序實現遍歷
TreeMap：需要按照key所在類的指定屬性進行排序。要求key是同一個類的對象。對key考慮使用自然排序 或 定製排序
我不想舉例了。。。。。。
Iterator接口：用來遍歷集合Collection元素，foreach就是Iterator加入泛型後的產品
來了解一下這個類
Collections工具類：操作Collection及Map的工具類，大部分爲static的方法。
泛型 ：這個就是C++中的函數模板，很相似，後面會夾帶出現，但就不單獨作爲一個點來細細記了
這篇好像寫得有點多了哦 ，我會加油的，博客的質量也會越來越好的