Java学习之Vector类LinkedList类&&泛型&&泛型通配符&&可变参数

【1】Vector类

A:概述：Vector类可以实现可增长的对象数组，Vector是同步的

B：Vector类特有功能：

                public void addElement(E obj)

                public E elementAt(int index)

                public Enumeration elements()

package Collection;
import java.util.Enumeration;

public class Vector {
    public static void main(String[] args) {
        java.util.Vector vector = new java.util.Vector();
        vector.addElement(100);
        vector.addElement(200);
        vector.addElement(300);
        java.util.Vector vector2 = new java.util.Vector();
        vector2.addElement(100);
        vector2.addElement(200);
        vector2.addElement(300);
        vector2.addElement(500);
        //返回一个迭代器
        Enumeration elements=vector.elements();
        while(elements.hasMoreElements()){
            Object obj=elements.nextElement();
            System.out.println(obj);
        }
        //对比两个集合当中元素是否一模一样
        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);
    }
}

【2】LinkedList类

A：LinkedList类概述：List接口的链接列表实现，此实现不是同步的

B:LinkedList类特有的功能

                                public void addFirst(E e)及addLast(E e)

                                public E getFirst()及getLast()

                                public E removeFirst()及public E removeLast()

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

public class LinkedList {
    public static void main(String[] args) {
        ArrayList arrayList=new ArrayList();
        arrayList.add(400);
        arrayList.add(500);
        arrayList.add(600);
        arrayList.add(100);
        arrayList.add(200);
        arrayList.add(100);
        arrayList.add(200);
        arrayList.add(300);
        int i=arrayList.indexOf(100);
        i=arrayList.lastIndexOf(100);
        System.out.println(i);
        //排序集合中的元素
        arrayList.sort(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Integer a=(Integer)o1;
                Integer b=(Integer)o2;
                return -(a-b);
            }
        });
        System.out.println(arrayList);
        List list=arrayList.subList(0,3);
        System.out.println(list);
        System.out.println(arrayList);
    }
}

【3】泛型

A：泛型概述：是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型

      参数化类型，把类型当做参数一样的传递

     泛型由来：通过Object转型问题引入，早期的Object类可以接收任意对象类型，但是在实际的使用中，会有类型转换的问题，这就存在隐患，所以java提供了泛型来解决此安全问题

B：泛型的格式：  public class 类名  <数据类型>  这里的数据类型只能是引用数据类型

public class ObjectTools<K> {
    
    private K k ;

    public K getK() {
        return k;
    }

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

}

C：泛型的好处：（1）把运行时期的问题提前到了编译期间

                            （2）避免了强制类型转换

                            （3）优化了程序设计，解决了黄色警告线

注意：泛型只在编译期间有效，但在运行期间就擦除了

D：泛型的接口子类：

                 第一种：就是在定义子类的时候我们已经可以明确数据类型了

public class InterImp1 implements Inter<String>{

        @Override
        public void show(String t){
               System.out.println(t);
        }

}

                    第二种：在定义子类的时候我们还不知道到底使用哪种数据类型，这个时候我们就需要将这个子类也定义成泛型

public class InterImpl<T> implements Inter<T>  {

	@Override
	public void show(T t) {
		System.out.println(t);
	}

}

【4】泛型通配符

A:泛型通配符<?>:        任意类型，如果没有明确，那么就是Object以及任意的Java类了
    B:? extends E:            向下限定，E及其子类
    C:? super E:            向上限定，E及其父类
    D:案例演示:            泛型高级之通配符的基本使用
        /**
         * 泛型如果明确了数据类型以后,那么要求左右两边的数据类型必须一致
         */
        Collection<Object> col1 = new ArrayList<Object>() ;
        Collection<Object> col2 = new ArrayList<Animal>() ;//报错

        // ? 表示任意的数据类型
        Collection<?> col5 = new ArrayList<Object>() ;
        Collection<?> col6 = new ArrayList<Animal>() ;

        // ? extends E : 向下限定    , ? 表示的是E或者E的子类
//        Collection<? extends Animal> col9 = new ArrayList<Object>() ;//报错
        Collection<? extends Animal> col10 = new ArrayList<Animal>() ;
        Collection<? extends Animal> col11 = new ArrayList<Dog>() ;

        // ? super E:  向上限定 , ? 表示的是E或者E的父类
        Collection<? super Animal> col13 = new ArrayList<Object>() ;
        Collection<? super Animal> col14 = new ArrayList<Animal>() ;
//        Collection<? super Animal> col15 = new ArrayList<Dog>() ;//报错
【5】可变参数

A：定义方法的时候不知道该定义多少个参数

B：格式：  修饰符 返回值类型 方法名（数据类型…变量名）{}

C：注意事项：a:这里的变量其实是一个数组

                        b:如果一个方法有可变参数，并且有多个参数，那么可变参数是最后一个

public static int add(int... a){
		
		// 定义一个累加变量
		int sum = 0 ;
		
		for(int s : a ){
			sum += s ;
		}
		
		return sum;
	}