集合

一、 Collection

集合是用來管理多個對象的對象，相對於數組來說，在使用前可以不必確定元素的類型，也不必確定元素數量

Collection是集合框架中的根接口，聲明瞭集合框架中常用的方法

Add

Contains

Remove

iterate

二、 List:元素是有序，可以重複

a) ArrayList,基於數組，底層是使用數組來存儲元素，當存儲的元素數量超過一定的配置時，就會創建一個比原來的容量大新的數組，再將原來數組中的值複製到新數組中

b) 爲什麼要使用Iterator,使用增強for循環就可以對集合元素進行遍歷，但如果要在遍歷的過程中對集合進行結構上的修改，就必須使用Iterator,否則會拋ConcurrentModifyException

c) ArrayList,底層是基於數組的，可以隨機訪問元素，但不方便隨機插入元素，線程不安全

d) Vector:與ArrayList基本相同，但它是線程安全的，效率低

e) LinkedList:基於鏈接列表實現，方便隨機插入元素，不方便隨機訪問元素

三、 Set：元素是無序，不可以重複,只能接收一個null元素，判斷元素是否存在與hashCode方法和equals方法有關係

a) HashSet:

四、 SortedSet:元素是無序，不可以重複，支持排序

a) TreeSet

五、 Map：不是Collection的子接口，以鍵值對的形式存儲元素

a) HashTable:線程安全，效率低

b)HashMap:線程不安全，效率高，

它是鍵值對的形式存儲數據，鍵基於set，不重複，無序。值是可以重複，可以爲null,向set集合中添加數據時，如果數據已經存在，數據添加不進去，但在map中，如果鍵已經存在，會把原來對應的鍵的值覆蓋.鍵和值都可爲null,但不能同時爲null

public class Student /*implements Comparable<Student>*/{
	private Long id;
	private static long count = 0;
	private String name;
	
	public Student(String name) {
		count++;
		id = count;
		this.name = name;
	}
	@Override
	public String toString() {
		return id+"\t"+name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public Long getId() {
		return id;
	}
	
	@Override
	public boolean equals(Object obj) {
		if(obj == this)
			return true;
		if(obj==null)
			return false;
		if(obj instanceof Student){
			Student t = (Student)obj;
			if(t.name!=null&&t.name.equals(this.name)){
				return true; 
			}else{
				return false;
			}
		}else{
			return false;
		}
	}
	
	@Override
	public int hashCode() {
		return name.hashCode();
	}
//	public int compareTo(Student o) {
//		return this.name.compareTo(o.name);
//	}
	
	public String getName() {
		return name;
	}
}

Collection常用的一些方法

@Test
	public void test(){
		//創建一個集合
		Collection c = new ArrayList();
		//給集合添加元素
		c.add(1);
		c.add("ab");
		c.add(new Student("zs"));
		//查看集合中元素的數量
		System.out.println(c.size());
		System.out.println(c);
		//遍歷元素:增強for循環
		for (Object o : c) {
			System.out.println(o);
		}
		//遍歷元素：Iterator
		System.out.println("=================");
		Iterator ite = c.iterator();
		while(ite.hasNext()){
			Object o = ite.next();
			System.out.println(o);
		}
	}

快速失敗

@Test
	public void test2(){
		List<String> names = new ArrayList<String>();
		names.add("aa");
		names.add("bb");
		names.add("cc");
		names.add("dd");
		//使用For循環時，不能刪除元素
//		for (String name : names) {
//			if("bb".equals(name))
//				names.remove(name);
//			else
//				System.out.println(name);
//		}
		//只有使用Iterator纔可以在遍歷時修改集合的結構
		Iterator<String> ite = names.iterator();
		while(ite.hasNext()){
			String name = ite.next();
			if("bb".equals(name))
				ite.remove();
			else
				System.out.println(name);
		}
	}

ArrayList的一些操作

@Test
	public void test3(){
		List<String> names = new ArrayList<String>();
		names.add("aa");
		names.add("bb");
		names.add(1,"cc");
		names.add("dd");
		System.out.println(names);//aa,cc,bb,dd
		names.set(2, "ee");
		System.out.println(names);//aa,cc,ee,dd
		
		//獲取索引爲2的元素
		System.out.println(names.get(2));
	}
	//可以添加null
@Test
	public void test4(){
		List<Integer> is = new ArrayList<Integer>();
		System.out.println(is.size());//0
		is.add(12);
		is.add(null);//可以添加null
		is.add(null);//元素可以重複
		System.out.println(is.size());//3
		
	}

集合中元素本質是一個對象

@Test
	public void test5(){
		List<Student> stus = new ArrayList<Student>();//泛型，限定集合接收的類型
		Student s = new Student("張三");
		//集合中的元素其實是一個變量
		stus.add(s);//只不過是在集合中添加了一個Student類型的變量而已
		stus.add(s);
		stus.add(s);//到這個時候，有4個變量在引用Student對象
		System.out.println(stus.size());
		stus.get(2).setName("李四");
		System.out.println(stus.get(0));//李四
		System.out.println("====================");
		System.out.println(stus);//[1	李四, 1	李四, 1	李四]
	}

測試ArrayList與LinkedList性能異同

@Test
	public void test6(){
		Random r = new Random();
		//基於鏈表的list隨機插入效率高，隨機訪問效率低
		List<String> names = new LinkedList<String>();
		names.add("aa");
		names.add("bb");
		long b = System.currentTimeMillis();//系統當前時間
		for(int i=0;i<1000000;i++){
			names.add(1,"cc"+i);
		}
		System.out.println(System.currentTimeMillis()-b);
		b = System.currentTimeMillis();
		for(int i=0;i<1000;i++)
			names.get(r.nextInt(1000000));
		System.out.println(System.currentTimeMillis()-b);
		List<String> names2 = new ArrayList<String>();
		names2.add("aa");
		names2.add("bb");
		b = System.currentTimeMillis();
		for(int i=0;i<1000000;i++){
			names2.add(1,"cc"+i);
		}
		System.out.println(System.currentTimeMillis()-b);
		b = System.currentTimeMillis();
		for(int i=0;i<1000;i++)
			names.get(r.nextInt(1000000));
		System.out.println(System.currentTimeMillis()-b);
	}

集合有序不同於集合排序

@Test
	public void test7(){
		//
		List<String> names = new ArrayList<String>();
		//list集合是有序的
		names.add("ba");
		names.add("ab");
		names.add("aa");
		names.add(2,"bd");
		names.add("bc");
		System.out.println(names);
		//對集合進行排序
		names.sort(new Comparator<String>() {
			public int compare(String o1, String o2) {
				return o1.compareTo(o2);
			}
		});
		System.out.println(names);
	}

Set(不能重複)的一些方法

@Test
	public void test(){
		Set<Double> sd = new HashSet<Double>();
		sd.add(1.2);//true
		sd.add(2.3);//true
		sd.add(1.2);//false,在這個集合中已經存在值爲1.2的元素，重複，添加不成功
		System.out.println(sd.size());
	}
@Test
	public void test2(){
		Set<Student> st = new HashSet<Student>();
		Student s = new Student("zs");
		st.add(s);
		st.add(s);
		System.out.println(st.size());//1
		s = new Student("zs");
		st.add(s);//添加一個新對象，新對象與原來的對象的地址不同，當student沒有重寫equals方法，按
		//Object類中的equals方法的邏輯來比較
		System.out.println(st.size());//2
	}

添加到Treeset中的元素要麼實現Compareable接口，或是提供Comparator接口的實現

@Test
	public void test5(){
		//實現Compareable接口，
		Set<Student> stus = new TreeSet<Student>();
		stus.add(new Student("aa"));
		stus.add(new Student("ba"));
		stus.add(new Student("ab"));
		System.out.println(stus);
	}
implements Comparable<Student>
重寫compareTo方法
Public int compareTo(Student o){
Return this.name.compareTo(o.name);
}

//Comparator接口的實現
Set<Student> stus = new TreeSet<Student>(new Comparator<Student>(){
Public int compare(student o1,Student o2){
Return o1.getName.compareTo(o2.getName)
}

})

獲得List集合中所有不重複的元素

@Test
	public void test3(){
		List<String> names = new ArrayList<String>();
		names.add("aa");
		names.add("bb");
		names.add("aa");
		names.add("aa");
		names.add("aa");
		System.out.println(names);
		Set<String> ns = new HashSet<String>();
		ns.addAll(names);
		System.out.println(ns);
	}

@Test
	public void test4(){
		Set<Integer> a = new HashSet<Integer>();
		a.add(23);
		a.add(12);
		a.add(7);
		a.add(72);
		System.out.println(a);
		SortedSet<Integer> names = new TreeSet<Integer>();
		names.add(23);
		names.add(12);
		names.add(7);
		names.add(72);
		System.out.println(names);
		SortedSet<String> ss = new TreeSet<String>();
		ss.add("aa");
		ss.add("cc");
		ss.add("kk");
		ss.add("ee");
		System.out.println(ss);
		
	}

Toarray

@Test
	public void testToArray(){
		Set<Integer >  is = new HashSet<Integer>();
		is.add(23);
		is.add(12);
		is.add(45);
		is.add(26);
		
		//將is轉換成數組
		Integer[] ia = is.toArray(new Integer[0]);
		for(int i=0;i<ia.length;i++){
			System.out.println(ia[i]);
		}
	}

Set判斷對象是否相等時通過equals和hashcode

@Override
	public boolean equals(Object obj) {
		if(obj == this)
			return true;
		if(obj==null)
			return false;
		if(obj instanceof Student){
			Student t = (Student)obj;
			if(t.name!=null&&t.name.equals(this.name)){
				return true; 
			}else{
				return false;
			}
		}else{
			return false;
		}
	}
	
	@Override
	public int hashCode() {
		return name.hashCode();
	}