标签：list集合、泛型
*数据结构
*栈结构（先进后出，后进先出）
特点：进栈的方式叫压栈
出栈的方式叫弹栈
*队列（先进先出）
*数组（查询快，增删慢）
*链表结构
有很多链子将多个节点连接起来
每一个节点（数据）：数据域（值）和指针域
对于列表来说都是从第一个元素对应的指针域依次进行查询（从头开始找)
*查询慢，增删快
*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以后,提供了泛型可以解决程序的安全性
标签：list集合、泛型
原文地址：http://13355940.blog.51cto.com/13345940/1982477
