ArrayList、Vector、LinkedList、泛型(Generic)

1.ArrayList、Vector、LinkedList

ArrayList存储字符串并遍历

void forEach(Consumer<? super E> action) 执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常

public class ArrayListDemo2 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add('a');
        arrayList.add('b');
        arrayList.add('c');
        //迭代器
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }
            //普通for
            Object[] array = arrayList.toArray();
            for (int i = 0; i < arrayList.size(); i++) {
                System.out.println(array[i]);
            }
    }
}

ArrayList存储自定义对象并遍历

    public static void main(String[] args) {
        Class class1 = new Class("通工");
        Class class2 = new Class("信工");
        Class class3 = new Class("电气");
        ArrayList list = new ArrayList();
        list.add(class1);
        list.add(class2);
        list.add(class3);
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            Class c=(Class)iterator.next();
            System.out.println(c.getName());
        }
        Object[] array = list.toArray();
        for (int i = 0; i <array.length ; i++) {
            Class c=(Class)array[i];
            System.out.println(c.getName());

        }
    }
}

Vector的特有功能

Vector类概述: Vector 类可以实现可增长的对象数组 , Vector 是同步的。
Vector类特有功能
public void addElement(E obj)
public E elementAt(int index)
public Enumeration elements()

    public static void main(String[] args) {
        //Vector:底层数据结构是数组,增删慢,查询快,线程安全,效率低
        //void addElement (E obj)
        //添加指定的组件到这个向量的结束，增加其大小由一个。
        //E elementAt ( int index)
        //返回指定索引处的组件。
        //Enumeration<E> elements ()
        //返回此向量的组件的枚举。
        //boolean equals (Object o)
        //将指定的对象与此向量进行比较，以进行相等性。
        //E firstElement ()
        //返回第一个组件（在指数 0 项目）这个载体。
        //E lastElement ()
        //返回向量的最后一个组件。
        //void removeElementAt ( int index)
        //在指定的索引中删除组件
        Vector vector = new Vector();
        vector.addElement(100);
        vector.addElement(200);
        vector.addElement(300);
        Vector vector2 = new Vector();
        vector2.addElement(100);
        vector2.addElement(200);
        vector2.addElement(300);
        vector2.addElement(500);
        //返回一个迭代器
        Enumeration elements = vector.elements();
        while (elements.hasMoreElements()){
            Object o = elements.nextElement();
            System.out.println(o);

        }
        //对比两个集合当中元素是否一模一样
        boolean equals = vector.equals(vector2);
        System.out.println(equals);
        Object o = vector2.firstElement();
        System.out.println(o);
        vector2.removeElementAt(vector2.size()-1);
        System.out.println(vector2);


    }
}

LinkedList的特有功能

LinkedList类概述: List 接口的链接列表实现 , 此实现不是同步的
LinkedList类特有功能
public void addFirst(E e)及addLast(E e)
public E getFirst()及getLast()
public E removeFirst()及public E removeLast()

2.泛型

泛型是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。
参数化类型，把类型当作参数一样的传递。
泛型的格式 : <数据类型> 注意：这里的数据类型只能是引用数据类型！！！
泛型好处
(1): 把运行时期的问题提前到了编译期间
(2): 避免了强制类型转换
(3):优化了程序设计，解决了黄色警告线
注意：泛型只在编译期有效 但在运行期就擦除了

    public static void main(String[] args) {
//        自定义对象存储到ArrayList集合
//        使用迭代器遍历
        Student student = new Student("金克斯");
        Student student1 = new Student("布里茨");
        Student student2 = new Student("维克托");
        ArrayList<Student> list = new ArrayList<Student>();
        list.add(student);
        list.add(student1);
        list.add(student2);
        Iterator<Student> iterator = list.iterator();
        while (iterator.hasNext()){
            Student stu=iterator.next();
            System.out.println(stu.getName());
        }
	}

泛型的由来
泛型的由来:通过Object转型问题引入，早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。
泛型类概述: 把泛型定义在类上
定义格式: public class 类名<泛型类型1,…>

	
	private K k ;

	public K getK() {
		return k;
	}

	public void setK(K k) {
		this.k = k;
	}

}

泛型方法
泛型方法概述: 把泛型定义在方法上
定义格式: public <泛型类型> 返回类型 方法名(泛型类型 变量名)

	
	/**
	 * 泛型方法
	 */
	public <E> void show(E e){
		System.out.println(e);
	}
}

泛型接口概述: 把泛型定义在接口上
定义格式: public interface 接口名<泛型类型>

	
	public abstract void show(T t) ;

}

泛型高级之通配符

泛型通配符<?> 任意类型，如果没有明确，那么就是Object以及任意的Java类了

<? extends E>： 向下限定，E及其子类 <? super E> ： 向上限定，E及其父类