*数据结构

*栈结构（先进后出，后进先出）

特点：进栈的方式叫压栈

出栈的方式叫弹栈

*队列（先进先出）

*数组（查询快，增删慢）

*链表结构

有很多链子将多个节点连接起来

每一个节点（数据）：数据域（值）和指针域

对于列表来说都是从第一个元素对应的指针域依次进行查询（从头开始找)

*查询慢，增删快

*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;}@Overridepublic 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以后,提供了泛型可以解决程序的安全性