Java-泛型和常見的數據結構

集合

集合的體系結構

• 由於不同的數據結構（數據的組織方式），所以Java爲我們提供了不同的集合
• 不同的集合的功能是相似的，不斷的向上提取，將共性抽取出來，這就是體系結構形成的原因

體系結構：

• 最頂層，包含了所有的共性
• 使用最底層，具體的實現

例如：ArrayList----List-----Collection

package com.it01;

import java.util.ArrayList;


public class CollectionDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayList al = new ArrayList();
		al.add("hello");
		al.add("world");
		al.add("java");
		
		for (int x = 0;x<al.size();x++) {
			System.out.println(al.get(x));
		}

	}

}

Collection的常見功能：

• boolean add(E e)
• void clear()
• boolean contains(Object o)
• boolean isEmpty()
• boolean remove(Object o)
• int size()
• Object[] toArray()

package com.it01;

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


public class CollectionDemo2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Collection c = new ArrayList();// 多態，父類引用指向子類對象

		// boolean add(E e)
		System.out.println(c.add("hello"));
		System.out.println(c.add("world"));

		System.out.println(c);
		
		//void clear()清空集合
		c.clear();
		System.out.println(c);
		
		//boolean contains(Object o)
		c.add("hello");
		c.add("world");
		System.out.println(c.contains("hello"));
		
		//boolean isEmpty() 
		System.out.println(c.isEmpty());
		
		//boolean remove(Object o)
		System.out.println(c.remove("hello"));
		System.out.println(c);
		
		//int size() 
		System.out.println(c.size());
		
		
		//Object[] toArray() ,將集合變成Object類型數組
		Object[] ob = c.toArray();
		System.out.println(ob[0]);
		
	}

}

集合的遍歷方式

• 1-toArray，可以把集合變成數組，遍歷數組
• 2-Iterator返回一個迭代器對象，我們可以通過迭代器對象來迭代集合

Iterator：可以用於遍歷集合
Iterator iterator()

• E next() ：返回下一個元素
• boolean hasNext() :如果迭代具有更多元素，則返回 true

注意：next()獲取下一個元素，如果沒有元素可以獲取，則出現異常

package com.it02;

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


public class IteratorDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		method1();
		
		method2();
		
	}

	private static void method2() {
		Collection c = new ArrayList();
		
		//添加元素
		c.add("hello");
		c.add("world");
		c.add("java");
		
		//獲取迭代器對象
		Iterator it = c.iterator();
		
		//E next()  ：返回下一個元素
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}

	private static void method1() {
		//創建集合
		Collection c = new ArrayList();
		
		//添加元素
		c.add("hello");
		c.add("world");
		c.add("java");
		
		//獲取數組
		Object[] ob = c.toArray();
		//遍歷數組
		for(int x=0;x<ob.length;x++) {
			System.out.println(ob[x]);
		}
	}

}

泛型

由於集合可以存儲任意類型的對象，當我們存儲了不同類型的對象，就有可能在轉換的時候出現類型轉換的異常，所以提供了泛型機制

泛型：把明確數據類型的工作提前到了編譯時期，借鑑了數組的特點
泛型的好處：

• 避免了類型轉換的問題
• 可以減少黃色警告
• 可以簡化代碼的書寫

使用：

• API：當我們看到時可以使用

package com.it03;

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

/*
 * 	使用集合存儲自定義對象並遍歷

 */
public class GenericDemo {

	public static void main(String[] args) {
		//創建集合對象
		Collection<Student> c = new ArrayList<Student>();
		//創建元素對象
		Student s1 = new Student("wangwu", 29);
		Student s2 = new Student("zhangsan", 30);
		//添加元素對象
		c.add(s1);
		c.add(s2);
		//遍歷集合對象
		Iterator<Student> it=c.iterator();	
		while(it.hasNext()) {
			Student str =it.next();
			System.out.println(str.name+"----"+str.age);
			
		}
	}

}

class Student{
	String name;
	int age;
	public Student(String name, int age) {
		//super();
		this.name = name;
		this.age = age;
	}
	
	
}

foreach：增強for循環，一般用於遍歷集合或者數組

package com.it04;

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

/*
 * 	foreach:增強for循環，一般用於遍歷集合或者數組
 * 	格式：
 * 		for(元素的類型 變量：集合或者數組對象){
 * 				可以直接使用變量
 * 
 * 		}
 * 
 * 	注意：在增強for循環中不能修改集合，否則會出現併發修改異常
 * 
 * 		
 */
public class ForEachDemo {

	public static void main(String[] args) {
		

		
		
		Collection<String> c = new ArrayList<String>();
		
		//添加元素
		c.add("hello");
		c.add("world");
		c.add("java");
		
		//增強for循環，遍歷集合
		for(String str:c) {
			System.out.println(str.toUpperCase());
		}
		

	}
	

}

常見的幾種數據結構

List集合

List：

• 有序的（存儲和讀取的順序是一致的）
• 有整數索引
• 允許重複

幾種常見的方法

• void add(int index, E element) ：將指定的元素插入此列表中的指定位置（可選操作）
• E get(int index) ：返回此列表中指定位置的元素
• E remove(int index) ：刪除該列表中指定位置的元素（可選操作）。
• E set(int index, E element) ：用指定的元素（可選操作）替換此列表中指定位置的元素

package com.it05;

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


public class ListDemo {

	public static void main(String[] args) {
		//創建列表對象
		List l = new ArrayList();
		
		//添加void add(int index, E element)
		l.add(0,"hello");
		l.add(0,"world");
		l.add(0,"java");
		
		//獲取E get(int index)  ：返回此列表中指定位置的元素
		System.out.println(l.get(0));
		
		//E remove(int index) ：刪除該列表中指定位置的元素（可選操作）
		System.out.println(l.remove(0));
		
		//E set(int index, E element)  ：用指定的元素（可選操作）替換此列表中指定位置的元素
		System.out.println(l.set(0, "java"));
		
		System.out.println(l);
		
		
	}

}

List的子類

常見子類：

• ArrayList-底層時數組結構，查詢快，增刪慢
• LinkedList-底層結構是鏈表，查詢慢，增刪快

如何使用集合

•  如果查詢多，增刪少，使用ArrayList
  

•  如果查詢少，增刪多，使用LinkedList
  

LinkedList的特有方法

• void addFirst(E e)：在該列表開頭插入指定的元素
• void addLast(E e)：將指定的元素追加到此列表的末尾
• E getFirst()
• E getLast()
• E removeFirst()
• E removeLast()

package com.it06;

import java.util.LinkedList;


public class LinkedListDemo {

	public static void main(String[] args) {
		LinkedList list = new LinkedList();
		list.add("hello");
		list.add("world");
		

		//void addFirst(E e)：在該列表開頭插入指定的元素
		list.addFirst("java");
		
		//void addLast(E e)：將指定的元素追加到此列表的末尾
		list.addLast("android");
		
		System.out.println(list);
		
		//E getFirst()  
		System.out.println(list.getFirst());
		
		//E getLast()  
		System.out.println(list.getLast());
		
		//E removeFirst()  
		System.out.println(list.removeFirst());
		
		//E removeLast()  
		System.out.println(list.removeLast());
		
		System.out.println(list);

	}

}

List測試

package com.it07;

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

/*
 * 	需求：定義一個方法，返回指定列表中指定元素的索引位置
 * 		判斷元素是否存在
 */
public class ListTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List list = new ArrayList();
		list.add("hello");
		list.add("java");
		list.add("android");
		int index = getIndex(list,"java");
		System.out.println(index);
		
		
		

	}
	public static int getIndex(List list,Object other) {
		for (int x=0;x<list.size();x++) {
			//獲取元素
			Object obj = list.get(x);
			
			if(obj.equals(other)) {
				return x;
			}
		}
		//查找不到
		return -1;
	}
	
	public static boolean contains(List list,Object other) {
		int index = getIndex(list, other);
		if(index>-1) {
			return true;
		}
		return false;
		
	}

}