Java學習lesson 14
*數據結構
*棧結構（先進後出，後進先出）
特點：進棧的方式叫壓棧
出棧的方式叫彈棧
*隊列（先進先出）
*數組（查詢快，增刪慢）
*鏈表結構
有很多鏈子將多個節點連接起來
每一個節點（數據）：數據域（值）和指針域
對於列表來說都是從第一個元素對應的指針域依次進行查詢（從頭開始找)
*查詢慢，增刪快
*List集合的子實現類的一些特點
*ArrayList集合
*底層數據結構是數組；滿足查詢快，增刪慢的特點
*從線程考慮是線程不安全的，不同步，執行效率高
*由於ArrayList集合是List集合的子類那麽他的元素是可以重復的，並且存儲和取出是一致的
package arraylist;
//下面代碼會出現黃色警告，是由於沒有使用泛型
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListDemo {
public static void main(String[] args) {
//創建一個集合對象;註意導包
ArrayList al=new ArrayList();
al.add("hello");
al.add("world");
al.add("JavaSE");
al.add("hello");//可以出現重復的元素
//獲取叠代器對象，遍歷元素
Iterator it=al.iterator();
//判斷是否有下一個要遍歷的元素
while(it.hasNext()){
String str=(String)it.next();
System.out.println(str);
}
}
} 
//沒有使用泛型：有可能會出現ClassCastException（類型轉換異常）
*Vector集合
*底層數據結構是數組形式可以實現可增長的對象數組，與數組一樣，包含可以用整形索引進行訪 問的組件
*線程安全，同步執行效率低
package vector;
import java.util.Enumeration;
import java.util.Vector;
public class VectorDemo {
public static void main(String[] args) {
//創建Vactor對象
Vector v=new Vector();
//public void addElements(E obj);向集合中添加元素
v.addElement("hello");
v.addElement("worlde");
v.addElement("hello");
v.addElement("Java");
//獲取叠代器對象
Enumeration en=v.elements();
//遍歷輸出
while(en.hasMoreElements()){
String str=(String)en.nextElement();
System.out.println(str);
}
}
} 
*LinkedList集合
*底層數據結構是鏈表；（增刪快，查詢慢）
*此實現類是不同步的：線程不安全
*如果使用多線程程序，一般要是安全的類：
StringBuffer，Vector<E>,hashtable<K,V>
synchronized(同步鎖對象){
代碼；
}
*特有功能：
*public void addElement(E obj)//相當於:add(Object e)
*public Enumeration<E> elements()//相當於：INterator iterator()
*Enumeration<E>
是一個接口：向量的組件枚舉
boolean hasMoreElements()://相當於獲取叠代器裏面的hasNext（）方法
Object nextElement()://相當於next（）方法
package vector;
import java.util.Enumeration;
import java.util.Vector;
public class VectorDemo {
public static void main(String[] args) {
//創建Vactor對象
Vector v=new Vector();
//public void addElements(E obj);向集合中添加元素
v.addElement("hello");
v.addElement("worlde");
v.addElement("hello");
v.addElement("Java");
//獲取叠代器對象
Enumeration en=v.elements();
//遍歷輸出
while(en.hasMoreElements()){
String str=(String)en.nextElement();
System.out.println(str);
}
}
}
*如果在一般的需求中沒有指明采用是用什麽集合去完成，都默認采用ArrayList集合
如果需求中考慮線程安全，那麽使用Vector集合
*筆試中一般使用ArrayList集合，效率高，速度快
*LinkList集合
底層數據結構是鏈表，特點：查詢慢，增刪快；是一個線程不安全的類
*特有功能
*添加功能：
*public void addFirst(E e)//將指定的元素差插入此列表的開頭
*public void addLast(E e)//將制定元素添加到此列表的末尾
*獲取功能：
*public Object getFirst()//返回此列表的第一個元素
*public Object getLast();//返回此列表的最後一個元素
*刪除功能：
*public Object moveFirst()//刪除此列表第一個元素並返回
*public Object moveLast()//刪除並返回此列表最後一個元素並返回
package linkedlist;
import java.util.LinkedList;
public class LinkedListDemo {
public static void main(String[] agrs){
//創建集合對象
LinkedList lk=new LinkedList();
//向集合中添加元素
lk.add("hello");
lk.add("world");
lk.add("Java");
System.out.println("lk"+lk);
//在開頭添加
lk.addFirst("JavaSe");
//在末尾添加
lk.addLast("JavaWeb");
System.out.println("lk:"+lk);
System.out.println("----------------------------");
//獲取第一個元素並返回
Object obj=lk.getFirst();
//獲取最後一個元素並返回
Object obj1=lk.getLast();
System.out.println("getFirst():"+obj+‘\n‘+"getLast():"+obj1);
System.out.println("lk:"+lk);
System.out.println("----------------------------");
//移除此列表第一個元素並返回
Object obj2=lk.removeFirst();
//移除最後一個元素並返回
Object obj3=lk.removeLast();
System.out.println("removeFirst():"+obj2+‘\n‘+"removeLast():"+obj3);
System.out.println("lk:"+lk);
}
}
//模擬棧結構
package linkedlist;
import java.util.LinkedList;
//自定義棧集合
public class Stack {
private LinkedList link;
//通過無參構造創建LinkedList集合對象
public Stack() {
link=new LinkedList();
}
//向集合的開頭添加元素;相當於壓棧
public void add(Object obj){
link.addFirst(obj) ;
}
//獲取集合第一個元素；相當於彈棧
public Object get(){
//removeFirst():移除第一個元素並返回
return link.removeFirst();
}
//判斷集合是否為空
public boolean isEmpty(){
return link.isEmpty();
}
}
//測試類
package linkedlist;
public class StackDemo {
public static void main(String[] args){
Stack s=new Stack();
s.add("hello");
s.add("world");
s.add("JavaSE");
//這裏做一個非空判斷，否則會出錯
while(!s.isEmpty()){
//獲取集合中的元素；底層調用removeFirst()
System.out.println(s.get());
}
}
}//棧結構特點：先進後出
*泛型
一般的類和方法，只能使用具體的類型：;JavaSE5之後引出了泛型的概念，使代碼可以應用多種類型
（只可以是引用類型，不可以是基本類型）
*好處：
*將運行時起一場提前到了編譯時期
*解決了黃色警告線的問題
*在獲取數據是不需要強制轉換類型
*提高代碼的安全性
泛型一般情況下可以應用在接口、類、方法上，主要在集合中應用
package generic;
public class ObjectTool {
private Object obj;
public Object getObj(){
return obj;
}
public void setObj(Object obj){
//Object obj = new Integer(27) ; //向上轉型
this.obj = obj ;
}
}
package generic;
public class GenericDemo3 {
public static void main(String[] args) {
ObjectTool1<String> ot=new ObjectTool1<String>();
ot.setObj("卡卡西");
//Integer i = ot.getObj(); 由於給類上加入了泛型,在實際測試中,給定了數據類型
//獲取數據的時候就必須應該類型來接收,否則不匹配
String name = ot.getObj() ;
System.out.println("姓名是:" +name);
//創建對象
ObjectTool1<Integer> ot2 = new ObjectTool1<Integer>() ;
//設置數據
ot2.setObj(27) ;
//獲取數據
//String s = ot2.getObj() ;
Integer ig= ot2.getObj() ;
System.out.println("年齡是:"+ig);
}
}
//對於基本類型的泛型
package generic;
import java.util.ArrayList;
import java.util.Iterator;
public class GenericDemo {
public static void main(String[] args) {
//創建集合類；jsk 7.0泛型推斷!:建議:後面永遠給出類型
ArrayList<String> al=new ArrayList<String>();
//向集合中添加元素
al.add("hello");
al.add("world");
al.add("JavaSE");
//獲取叠代器對象;使用泛型
Iterator<String> it=al.iterator();
//遍歷集合，並打印
while(it.hasNext()){
//由於使用了泛型不需要強制轉型
String str=it.next();
System.out.println(str);
}
}
}
//應用泛型對ArrayList集合存儲自定義對象並遍歷
package generic;
public class Student{
private String name;
private int age;
public Student() {
super();
}
public Student(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;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
}
package generic;
import java.util.ArrayList;
import java.util.Iterator;
public class GenericDemo1 {
public static void main(String[] args) {
//創建ArrayList集合對象
ArrayList<Student> al=new ArrayList<Student>();
//創建Student類對象
Student st1=new Student("卡卡西",24);
Student st2=new Student("佐助",17);
Student st3=new Student("鳴人",17);
Student st4=new Student("小櫻",17);
//向集合中添加元素
al.add(st1);
al.add(st2);
al.add(st3);
al.add(st4);
//獲取遍歷器對象
Iterator<Student> it=al.iterator();
System.out.println("在Student中重寫toString方法：");
while(it.hasNext()){
//由於這裏是自定義類型Student，需要在Student裏重寫toString方法
Student st=it.next();
System.out.println(st);
}
System.out.println("用get方法：");
Iterator<Student> it1=al.iterator();
while(it1.hasNext()){
//如果不重寫toString方法，就使用getXX（）來獲取
Student st6=it1.next();
System.out.println(st6.getName()+"-------"+st6.getAge());
}
}
} 
*將泛型定義在方法上
package generic;
public class ObjectTool2 {
//將泛型定義在方法上
public <T> void show(T t){
System.out.println(t);
}
}
package generic;
public class GenericDemo4 {
public static void main(String[] args){
ObjectTool2 obj=new ObjectTool2();
//在工具類中將泛型定義在了方法上
obj.show("hello");
obj.show("world");
obj.show("JavaSE");
}
}
*泛型接口
*接口的子實現類已經知道傳遞的是一個什麽類型的數據
package generic;
//將泛型定義在接口上
public interface Generic<T> {
public abstract void show(T t);
}
package generic;
//子實現類
public class GenericImpl<String> implements Generic<String>{
public void show(String str){
System.out.println(str);
}
}
package generic;
//測試類
public class GenericDemo5 {
public static void main(String[] args){
Generic<String> gl=new GenericImpl<String>();
gl.show("弋痕夕");
gl.show("天凈沙");
gl.show("山鬼謠");
}
} 
*接口的子實現類在實現接口時不知道傳遞的是什麽類型的數據類型，在測試類中才知道
package generic;
//在接口上定義泛型
public interface Generic1<T> {
public abstract void show(T t);
}
package generic;
public class GenericImpl1<T> implements Generic1<T> {
public void show(T t){
System.out.println(t);
}
}
package generic;
public class GenericDemo6{
public static void main(String[] args){
Generic1<Integer> gl=new GenericImpl1<Integer>();
gl.show(17);
gl.show(18);
gl.show(20);
}
}
*泛型可以提供程序的安全性!
* 早期的時候,用Object類型代表任意的類型向上轉型是不會出現問題的,但是向下轉型的時候,由於隱 藏了類型轉換,導致出現錯誤!
* JDK5以後,提供了泛型可以解決程序的安全性
Java學習lesson 14