Java集合总结，泛型机制，可变参数

List实现类的区别及适用场景

	底层实现	优缺点	线程是否安全	效率	适用场景
ArrayList	数组	查询易，增删难	否	高	单线程，多查询，少增删的程序
Vector	数组	查询易，增删难	是	低	多线程，多查询，少增删的程序
LinkdeList	链表	查询难，增删易	否	高	单线程，多增删，少查询的程序

泛型

提问：什么是泛型

回答：所谓泛型就是指是一种把类型的明确放到创建该类对象的时候或者调用该类方法的时候在确定。请看下面这个例子

//定义一个泛型类
public class MyClass<T> {
    //一个T类型的变量
    T t;
}

class test{
    public static void main(String[] args) {
        //创建对象的时候定义该类型为String
        MyClass<String> stringMyClass = new MyClass<>();
        stringMyClass.t="ssss";
    }
}

public class MyClass<T> {
    T t;
    //定义一个泛型方法
    public void test(T t){
    }
}

class test{
    public static void main(String[] args) {
        //创建对象的时候定义该类型为String
        MyClass<Integer> stringMyClass = new MyClass<>();
            stringMyClass.test(Integer.valueOf(100));
    }
}

 提问：可以定义一个泛型接口吗

 回答：当然可以，请看这里

//定义一个泛型接口
public interface MyInterface<M> {
    void test(M m);
}

class Test implements MyInterface<String>{

    @Override
    public void test(String s) {
        System.out.println(s);
    }
}

提问：为什么要使用泛型，直接定义不就好了吗，这样岂不多此一举？

回答：既然不好理解，那我们看一段代码吧

//如果我们预先不知道需要定义的变量是什么类型，我们就可以把它定义成Object类型，可以接收任意类型
public class ObjectDemo {
    private Object object;

    public Object getObject() {
        return object;
    }

    public void setObject(Object object) {
        this.object = object;
    }
}
class test {
    public static void main(String[] args) {
        ObjectDemo objectDemo = new ObjectDemo();
        objectDemo.setObject("object");//将类型设置为String
        //取值
        Object object = objectDemo.getObject();
        String s = (String) object;
        s.length();
    }
}

 继续回答：上面这段代码虽然实现了可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。这样就不是很方便的，所以泛型应运而生。

public class Demo<T> {
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}
class TestDemo{
    public static void main(String[] args) {
        Demo<String> stringDemo = new Demo<>();
        stringDemo.setT("泛型");
        String t = stringDemo.getT();
        t.length();
    }
}

可变参数

基本格式：public void test(数据类...变量名) 

请看这么一段代码：

public class ChangePara {
    public static void main(String[] args) {
        test(1.0);
        test(1.0,2.0);
        test(1.0,2.0,3.0);
    }

    //普通方法重写
    public static void test(double d1) {
        System.out.println(d1);
    }

    public static void test(double d1, double d2) {
        System.out.println(d1 + d2);
    }

    public static void test(double d1, double d2, double d3) {
        System.out.println(d1 + d2 + d3);
    }
}

如果我说可变参数可以一句代码实现上面这一堆，你们会信吗？不信不行，请看 

public class ChangePara {
    public static void main(String[] args) {
        test(1.0);
        test(1.0,2.0);
        test(1.0,2.0,3.0);
    }

    //可变参数
    public static void test(double...d){
        //TODo..
    }

}

提问：这么厉害，究竟如何实现的？

回答：其实他的顶层是将参数存入一个数组当中，这样就可以存下同一个类型的多个参数，成百上千都不是问题的。 

提问：ArrayList集合遍历一共有几种方式？

回答：应该有四种

再问：请分别用四种方式遍历集合

public class ArrayListDemo {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList();
        arrayList.add("三国演义");
        arrayList.add("红楼梦");
        arrayList.add("水浒传");
        arrayList.add("西游记");
        //遍历方式1 普通for循环
        for (int i = 0; i <arrayList.size(); i++) {
            System.out.println(arrayList.get(i));
        }
        //方式2  迭代器遍历
        Iterator iterator = arrayList.iterator(); //获取迭代器对象
        while (iterator.hasNext()){//判断是否存在
            System.out.println(iterator.next()); //获取
        }
        //方式3  列表迭代器遍历
        ListIterator listIterator = arrayList.listIterator();
        while (listIterator.hasNext()){
            System.out.println(listIterator.next());
        }
        //方式4 增强for循环遍历
        for(String s : arrayList){
            System.out.println(s);
        }

    }
}