Day16——ArrayList类&Vector类&LinkedList类&泛型&可变参数&增强for循环&Arrays工具类asList方法

Day16——ArrayList类&Vector类&LinkedList类&泛型&可变参数&增强for循环&Arrays工具类asList方法

ArrayList
Vector
LinkedList
泛型(Generic)
可变参数
增强for循环
Arrays工具类asList方法

ArrayList

概述&快捷键使用

public class Test1 {
    public static void main(String[] args) {
        //Ctrl+H 可以查看一个类的继承关系
        //List接口实现了所有可选列表操作，并允许包括null在内的所有元素
        //ArrayList底层使用数组。查询快，增删慢，线程不安全，但是效率高
        //元素有序的（存取顺序一致），元素编有索引 允许元素重复
        ArrayList arrayList = new ArrayList();
        arrayList.add(100);
        arrayList.add(200);
        arrayList.add(300);
        arrayList.add(400);
        arrayList.add(500);
        arrayList.add(600);
        arrayList.add(null);

        //遍历方式
        //两种迭代器
        Iterator iterator = arrayList.iterator();
        ListIterator listIterator = arrayList.listIterator();
        //for循环
        for (int i = 0; i < arrayList.size(); i++) {
            Object o = arrayList.get(i);
        }
        System.out.println("=========新的迭代方法=========");
        //JDK1.8提供的一种新的迭代方法
        //Ctrl+P 可以看方法要的参数
        //Ctrl+Q 详细看一下，这个方法的介绍
        //void forEach(Consumer<? super E> action)
        //对 Iterable的每个元素执行给定的操作，直到所有元素都被处理或动作引发异常。

        arrayList.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o);
            }
        });
    }
}

遍历方法&ArrayList特有方法

遍历方法

public class Test2 {
    public static void main(String[] args) {

                ArrayList list = new ArrayList();
                list.add(100);
                list.add(100);
                list.add(100);
                list.add(200);
                list.add(300);
                list.add(400);
                list.add(null);
                //迭代器遍历，了解 很少用
                //for for循环遍历
                for (int i = 0; i < list.size(); i++) {
                    System.out.println(list.get(i));
                }
                System.out.println("===========================");
                //JDK1.8 提供了一个方法也可以进行遍历

                list.forEach(new Consumer() {
                    @Override
                    public void accept(Object obj) {
                        //obj 集合中的每一个元素
                        System.out.println(obj);
                    }
                });
    }
}

ArrayList特有方法

public class Test3 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(100);
        list.add(300);
        list.add(100);
        list.add(200);
        list.add(100);
        list.add(400);
        System.out.println("=============替换列表元素=============");
        list.set(3,1000);
        System.out.println(list);
        System.out.println("=============比较器=============");
        /*   void sort (Comparator < ? super E > c)
        分类列表使用提供的 Comparator比较元素。*/
        //排序  Comparator 比较器
        list.sort(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Integer o11 = (Integer) o1;
                Integer o21 = (Integer) o2;
                return o11 - o21;
            }
        });
        System.out.println(list);
        System.out.println("============条件删除============");
        /*  boolean removeIf (Predicate < ? super E > filter)
        删除满足给定谓词的这个集合的所有元素。*/
        list.removeIf(new Predicate() {
            @Override
            public boolean test(Object o) {
                Integer o1 = (Integer) o;
                return o1 > 200;
                //返回true就删除集合中的元素，返回false就不删
            }
        });
        System.out.println(list);

        System.out.println("==========判断集合为空=========");
        /*   System.out.println("======================");
        for (int i = 0; i < list.size(); i++) {
            Integer num = (Integer) list.get(i);
            if(num>100){
                list.remove(num);
            }
        }*/
        boolean empty1 = "java".isEmpty();


        list.clear();
        //判断集合为空的方法 isEmpty()
        boolean empty = list.isEmpty();
        System.out.println(empty);
        if (list.size() == 0) {
            System.out.println("集合为空了");
        }
    }
}

ArrayList存储自主定义对象

public class Test {
    public static void main(String[] args) {
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student("张三",23));
        students.add(new Student("张三",23));
        students.add(new Student("张四",25));
        students.add(new Student("张三",23));
        students.add(new Student("王五",8));
        students.add(new Student("张三",99));
        students.add(new Student("刘二",23));
        students.add(new Student("胡八一",26));
        /*Iterator<Student> iterator = students.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("================================");
        for (int i = 0; i < students.size(); i++) {
            System.out.println(students.get(i));
        }*/

        //姓名年龄一样的就是重复内容
        System.out.println("=============创建新集合方法=============");
        ArrayList<Student> newStudents = new ArrayList<>();
        for (int i = 0; i < students.size(); i++) {
            Student student = students.get(i);
            if(!newStudents.contains(student)){
                newStudents.add(student);
            }
        }
        for (int i = 0; i < newStudents.size(); i++) {
            System.out.println(newStudents.get(i));
        }

        System.out.println("=============不创建新集合方法=============");
        for (int i = 0; i < students.size(); i++) {
            for (int j = i+1; j < students.size(); j++) {
                if(students.get(i).equals(students.get(j))){
                    students.remove(j);
                    j--;
                }
            }
        }
        System.out.println(students);
    }
}

public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}'+'\n';
    }
}

案例演示去除列表重复值

 /* A:
        案例演示
        需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
        思路：创建新集合方式*/

public class homework {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("aaa");
        strings.add("aaa");
        strings.add("aaa");
        strings.add("bbb");
        strings.add("ccc");
        strings.add("ddd");
        strings.add("aaa");
        ArrayList<String> newStrings = new ArrayList<>();
        //创建新集合的方式，取出旧集合元素进行判断
        //旧集合中没有，就装进新集合
        for (int i = 0; i < strings.size(); i++) {
            String s = strings.get(i);
            //判断元素在新集合中是否重复
            if(!newStrings.contains(s)){
                newStrings.add(s);
            }
        }
        System.out.println(newStrings);
    }
}

/* A:
        案例演示
        需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
        思路：不能创建新集合*/

public class homework2 {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("aaa");
        strings.add("aaa");
        strings.add("aaa");
        strings.add("bbb");
        strings.add("ccc");
        strings.add("ddd");
        strings.add("aaa");
        //每次拿一个元素去跟后面的所有元素进行比较，相等就删除
        for (int i = 0; i < strings.size(); i++) {
            for (int j = i+1; j < strings.size(); j++) {
                if(strings.get(i).equals(strings.get(j))){
                    strings.remove(j);
                    j--;
                }
            }
        }
        System.out.println(strings);
    }
}

Vector

概述

public class Test {
    public static void main(String[] args) {
        Vector vector = new Vector();
        vector.add("aaa");
        vector.add("bbb");
        vector.add("ccc");
        vector.add("ddd");
        vector.add("eee");

        System.out.println("============遍历列表===========");
        vector.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o);
            }
        });

        System.out.println("==========寻找头尾索引=========");
        Object o = vector.firstElement();
        System.out.println(o);
        Object o1 = vector.lastElement();
        System.out.println(o1);

        System.out.println("======根据索引截取一个元素=======");
        Object o2 = vector.elementAt(2);
        System.out.println(o2);
    }
}

public class Test1 {
    public static void main(String[] args) {
        //Vector 集合中自己的一个迭代器，可以遍历集合中的元素
        /*Enumeration<E> elements ()
        返回此向量的组件的枚举。*/
        Vector vector = new Vector();
        vector.addElement(100);
        vector.addElement(200);
        vector.addElement(300);
        vector.addElement(400);
        vector.addElement(500);
        //Enumeration 迭代器
        // hasMoreElements()  判断还有没有下个元素
        // nextElement() 获取下一个元素
        Enumeration elements = vector.elements();
        while(elements.hasMoreElements()){
            System.out.println(elements.nextElement());
        }
    }
}

LinkedList

概述

LinkedList的特有功能

public class Test1 {
    public static void main(String[] args) {
        //LinkedList:底层数据结构是链表，查询慢，增删快.
        //注意，此实现不是同步的。线程不安全，效率高
        LinkedList linkedList = new LinkedList();
        System.out.println("============添加元素===========");
        /*void addFirst(E e)
        在该列表开头插入指定的元素。
        void addLast(E e)
        将指定的元素追加到此列表的末尾。*/
        linkedList.add(200);
        System.out.println(linkedList);
        linkedList.addFirst(100);
        System.out.println(linkedList);
        linkedList.addLast(300);
        System.out.println(linkedList);
        linkedList.addLast(100);
        linkedList.addLast(200);
        linkedList.addLast(300);
        linkedList.addLast(400);
        /*E getFirst ()
        返回此列表的第一个元素。
        E getLast ()
        返回此列表的最后一个元素。*/
        System.out.println(linkedList.getFirst());
        System.out.println(linkedList.getLast());

        System.out.println("============删除元素===========");
        Object remove = linkedList.remove(linkedList.size()-1);
        System.out.println(remove);
        System.out.println(linkedList);
    }
}

public class Test2 {
    public static void main(String[] args) {
        /*E poll ()
        获取并移除此列表的头（第一个元素）
        E pollFirst ()
        获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
        E pollLast ()
        获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。*/
        LinkedList linkedList = new LinkedList();
        linkedList.addLast(100);
        linkedList.addLast(200);
        linkedList.addLast(300);
        linkedList.addLast(400);

        Object poll = linkedList.poll();
        System.out.println(poll);
        System.out.println(linkedList);
        System.out.println("===================");
        poll = linkedList.poll();
        System.out.println(poll);
        System.out.println(linkedList);
        System.out.println("===================");
        poll = linkedList.poll();
        System.out.println(poll);
        System.out.println(linkedList);
        System.out.println("===================");
        poll = linkedList.poll();
        System.out.println(poll);
        System.out.println(linkedList);
        System.out.println("===================");
        poll = linkedList.poll();
        System.out.println(poll);
        System.out.println(linkedList);
    }
}

public class Test3 {
    public static void main(String[] args) {
        /*E pop ()
        从此列表所表示的堆栈处弹出一个元素。
        void push (E e)
        将元素推入此列表所表示的堆栈。*/
        LinkedList linkedList = new LinkedList();
        linkedList.add(100);
        linkedList.add(200);
        linkedList.add(300);
        linkedList.add(400);
        linkedList.push(600);
        linkedList.push(800);
        System.out.println(linkedList);


        Object pop = linkedList.pop();
        System.out.println(linkedList);
        System.out.println("==================");
        pop = linkedList.pop();
        System.out.println(linkedList);
        System.out.println("==================");
        pop = linkedList.pop();
        System.out.println(linkedList);
        System.out.println("==================");
    }
}

LinkedList里面会两个特有的方法，可以模仿堆栈的数据结构存取

堆栈的存取类似于弹夹的存储子弹的方式

案例演示

 /*A:案例演示:
        需求：请用LinkedList模拟栈数据结构的集合，并测试*/

public class homework {
    public static void main(String[] args) {
        //用addFirst方法将数据压入堆栈
        LinkedList<Integer> integers = new LinkedList<>();
        integers.addFirst(100);
        integers.addFirst(200);
        integers.addFirst(300);
        integers.addFirst(400);
        integers.addFirst(500);
        integers.addFirst(600);//在列表的第一个地址
        System.out.println(integers);
        //用getFirst模拟堆栈数据的获取
        for (int i = 0; i < integers.size(); i++) {
            System.out.println(integers.get(i));
        }
    }
}

泛型(Generic)

概述

public class Test1 {
    public static void main(String[] args) {
        //泛型机制：是一种将数据类型明确工作推迟到创建对象或调用方法时去进行的机制
        //也就是说，你在coding类，接口，方法时，可以先不明确其中的数据类型
        //当调用时，再去通过泛型明确数据类型
        //泛型的好处：增加了程序的扩展性
        //泛型语法：<类型> <类型1,类型2,。。。>类型指的是引用类型
        //基本类型参与泛型机制时使用包装类
        //泛型可以定义在类上，接口上，方法上
        //泛型只在编译时有效，运行时就擦除了

        //创建集合时就会使用泛型
        //没有使用泛型时，集合中可以存储多种数据类型
        ArrayList list = new ArrayList();
        list.add(new Integer(300));
        list.add(new Double(3.01415926));
        list.add("abs");
        list.add(800);
        Object o = list.get(0);
        Object o2 = list.get(1);
        //要想使用Integer的特有方法，需要向下转型
        Integer o1 = (Integer) o;
        int i = o1.intValue();
        System.out.println("i="+i);
        System.out.println("o2=" + o2+"     这是由于自动拆箱才会显示出原来的数值");

        System.out.println("=====================================");
        //创建集合的时候，我们用上泛型
        //用泛型明确集合中只能存储String类型
        ArrayList<String> strings = new ArrayList<>();
       /* strings.add(100);//存储基本数据类型就会报错*/
        strings.add("abcdefgh");
        strings.add("bbbbbbbbbb");
        strings.add("cccccccccc");
        strings.add("dddddddddd");
        strings.add("eeeeeeeeee");

        //使用泛型在使用String特有的方法时不需要向下转型
        //因为泛型在编译时就明确了这个集合中存的数据类型
        //所以取得集合中元素后就可以直接连式编程调用String特有的方法
        System.out.println(strings.get(0).charAt(3));

        System.out.println("=====================================");
        //自定义类
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student("小刘",23));
        students.add(new Student("小王",25));
        students.add(new Student("仙王",55));
        Student student = students.get(0);
        //由于创建集合的时候应用了泛型，所以就可以直接调用Student类的方法
        System.out.println(student.getName() + student.getAge());
        System.out.println(student.toString());
    }
}

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        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 +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

不使用泛型定义类&使用泛型定义类对比

不使用泛型定义类

public class Test1 {
    //在没有泛型之前，为了提高扩展性
    //经常在设计一个类的时候
    //将其成员变量和成员方法的参数设置为Object类
    private Object obj;

    public Object getObj() {
        return obj;
    }

    public void setObj(Object obj) {
        this.obj = obj;
    }
}

public class Test2 {
    public static void main(String[] args) {
        //将所有的成员变量和成员方法的一些参数设置成Object类
        //好处是程序的扩展性很好
        Test1 test1 = new Test1();
        test1.setObj("abcd");
        Test1 test11 = new Test1();
        test11.setObj(100);

        //但是要调用元素的方法或者是一些特定方法就需要向下转型
        Object obj = test1.getObj();
        String string = (String) obj;
        System.out.println(string.charAt(2));
    }
}

使用泛型定义类对比

public class Test1 <T>{
    //设计一个类使用泛型，在调用时，就不需要向下转型
    T obj;

    public T getObj() {
        return obj;
    }

    public void setObj(T obj) {
        this.obj = obj;
    }
}

public class Test2 {
    public static void main(String[] args) {
        //使用泛型调用的类就不需要向下转型，可以直接使用
        Test1<String> stringTest1 = new Test1<>();
        stringTest1.setObj("abcde");
        System.out.println(stringTest1.getObj().charAt(0));
    }
}

泛型接口

public class Test1 {
    public static void main(String[] args) {
        //如若在实现接口的类中没有明确接口泛型的具体类型
        //就需要在创建接口的子类对象时明确
        //可以使用匿名内部类方式实现接口
        new myInterface<Double, String>() {
            @Override
            public Double test(String s) {
                return null;
            }

            @Override
            public String show(Integer num) {
                return null;
            }
        };

        System.out.println("===========================");
        //使用创建该接口子类对象方式实现该接口
        //第一个son在类中明确了接口的泛型类型
        son son = new son();
        son.test("abcd");
        son.show(100);

        //第二个没有明确泛型就需要在创建子类对象时明确
        son2<String, Double> stringDoubleson2 = new son2<>();
        stringDoubleson2.test(799.96);
        stringDoubleson2.show(1000);
    }
}

public interface myInterface <R,P>{
    public abstract R test(P p);
    public abstract String show(Integer num);
}

//接口需要通过一个实现接口的子类来实现
//这个接口上要是有泛型，就可以明确接口上的泛型的具体类型
public class son implements myInterface<Integer,String>{
    @Override
    public Integer test(String s) {
        return null;
    }

    @Override
    public String show(Integer num) {
        return null;
    }
}

//当在接口的实现类中不想明确接口上的泛型
//就需要将此接口也定义成泛型类
public class son2<R,P> implements myInterface<R,P>{
    @Override
    public R test(P p) {
        return null;
    }

    @Override
    public String show(Integer num) {
        return null;
    }
}

泛型方法

public class AA {
    //泛型方法就是将泛型加在方法上
    //这样免去了编写逻辑一样，但是输入的形参不一样的代码，增加了代码的扩展性
    public<T> void show(T s){
        System.out.println(s);
    }
}

public class Test1 {
    public static void main(String[] args) {
        AA aa = new AA();
        //调用泛型方法时，去明确方法上的泛型，是那种具体类型
        aa.show(5.55);
        aa.show("abs");
        aa.show(200);
    }
}

泛型高级之通配符

public class Test1 {
    public static void main(String[] args) {
        //? 泛型通配符
        ArrayList<?> list = new ArrayList<Animal>();
        ArrayList<?> list2 = new ArrayList<Dog>();
        ArrayList<?> list3 = new ArrayList<Cat>();
        System.out.println("=========================");
        //向下限定 <? extends Animal> 是Animal本身 或者说他的子类
        ArrayList<? extends Animal> list4 = new ArrayList<Animal>();
        ArrayList<? extends Animal> list5= new ArrayList<Dog>();
        ArrayList<? extends Animal> list6= new ArrayList<Cat>();
        //报错
        //ArrayList<? extends Animal> list57= new ArrayList<Object>();
        System.out.println("=======================================");
        //向上限定 <? super Animal> 是Animal本身 或者说的他的父类
        ArrayList<? super Animal> list47= new ArrayList<Animal>();
        ArrayList<? super Animal> list48 = new ArrayList<Object>();
        //ArrayList<? super Animal> list49= new ArrayList<Dog>(); //报错
        //ArrayList<? super Animal> list491 = new ArrayList<Cat>(); //报错

        System.out.println("=========================================");
        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(100);

        ArrayList<Object> integers2= new ArrayList<>();
        integers2.add(200);
        /*boolean addAll (Collection < ? extends E > c)
        按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。
        c集合只能是E类型本身或E的子集*/

        //boolean addAll (Collection < ? extends Integer > c)
        // 向下限定,传入方法的集合c只能是Integral本身或Integer的子类
        //integers.addAll(integers2); 报错
        //因为做了向下限定 ，你传进来的这个集合中的元素类型是Object类型,他不是Integer
    }
}
class Animal{

}
class Dog extends Animal{

}

class Cat extends Animal{

}

可变参数

public class Test1 {
    public static void main(String[] args) {

    }

    //可变参数  参数数据类型 ... 参数名  一次可以接受多个参数
    //可变参数其实是个数组，把你传过来的多个参数放到数组中
    private static int add1(int... i){
        System.out.println("方法调用了");
        System.out.println(i.length);
        int sum=0;
        for (int ele : i) {
            sum+=ele;
        }
        return sum;
    }

    //如果一个方法，定义了多个形参，可变参数一定是最后一个
    private static int add3(String num,double... i){
        return 0;
    }
}

增强for循环

增强for循环&普通for循环

public class Test1 {
    public static void main(String[] args) {
        //JDK1.5后提供了一种新的遍历方式，叫做增强for循环
        int[] arr={10,11,12,22,39};
        System.out.println("===========使用普通for循环遍历===========");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("===========使用增强for循环遍历===========");
        //for(容器中的元素数据类型 当前遍历元素的变量名：容器名)
        for (int i : arr) {
            System.out.println(i);
        }

        System.out.println("======================================");
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student("张三", 23));
        students.add(new Student("李四", 24));
        for (Student student : students) {
            System.out.println(student);
        }

        System.out.println("======================================");
        ArrayList<String> strings = new ArrayList<>();
        strings.add("aaaa");
        strings.add("bbbb");
        strings.add("cccc");
        for (String string : strings) {
            System.out.println(string);
        }
    }
}

增强for循环的注意事项

public class Test2 {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("aaaa");
        strings.add("bbbb");
        strings.add("cccc");
        for (String string : strings) {
            System.out.println(string);
        }
        //新式for循环底层使用的是迭代器遍历的
        //所以在使用新式for循环中，更改容器长度,会引起并发修改异常
        //即在增强for循环内不能增删集合中的元素
        //我们一般用新式for循环，你只是为了遍历看，而不是在遍历途中去增删容器中的元素，因为你增删元素，就会报并发修改异常。

        //如果你要在遍历途中增删集合中 的元素，你就使用普通for循环
        for (int i = 0; i < strings.size(); i++) {
            String s = strings.get(i);
            if (s.startsWith("B")) {
                strings.remove(s);
            }
        }

        System.out.println(strings);
    }
}

Arrays工具类asList方法

public class Test1 {
    public static void main(String[] args) {
        /*Arrays工具类的asList（T...t）方法：
        * 将数组转换成集合*/
        //泛型方法：方法上的泛型，是你在调用方法时，就可以明确方法上泛型的具体数据类型
        /*static <T> List <T>
                asList(T...a)
        返回一个受指定数组支持的固定大小的列表。*/
        //将多个参数转换成集合
        List<String> strings = Arrays.asList("aaa", "bbb", "ccc", "ddd");
        List<Integer> integers = Arrays.asList(100, 200, 300, 400, 500);
        System.out.println(strings);
        System.out.println(integers);

        System.out.println("==================================");
        int[] arr={1,2,3,4,5};
        //当传入的是一个基本数据类型的数组，转换成的集合是集合里面放了一个数组
        List<int[]> ints = Arrays.asList(arr);
        //获取集合中的第一个数组的第四个元素
        int i = ints.get(0)[4];
        System.out.println(i);
        System.out.println(ints);

        System.out.println("==================================");
        Integer[] arr1={44,45,36,8,4};
        //当传入的是一个对象数组，就是把数组的元素取出来放入集合中
        List<Integer> integers1 = Arrays.asList(arr1);
        System.out.println(integers1);
        System.out.println(integers1.get(2));

        System.out.println("==================================");
        //当传入的是多个数组，则集合中存储的是多个数组对象
        int[] arr2={1,2,3,4,5};
        int[] arr3={1,2,3,4,5};
        int[] arr4={1,2,3,4,5};
        List<int[]> ints1 = Arrays.asList(arr2, arr3, arr4);
        System.out.println(ints1);

        System.out.println("==================================");
        //当传入的是多个对象数组，就是把对象数组作为整体放入集合中
        Integer[] arr5 = {10, 20, 30};
        Integer[] arr6= {10, 20, 30};
        Integer[] arr7 = {10, 20, 300};
        List<Integer[]> integers2 = Arrays.asList(arr5, arr6, arr7);
        System.out.println(integers2);
        //输出integer2集合中的倒数第二个对象数组中的第三个元素
        System.out.println(integers2.get(integers2.size() - 1)[2]);
        //通过asList()方法转换过来的集合，有一个弊端，这个转换过来的集合，你不能改变这个集合的长度，
        //也就是说，你不能再次增删集合中的元素。
        //list.add(500);  报错
        //list.remove(3); 报错
    }
}

public class Test2 {
    public static void main(String[] args) {
        /* static <T> List < T >
                asList(T...a)

        返回一个受指定数组支持的固定大小的列表。*/
        //把多个值，转换成一个集合
        List<Integer> integers = Arrays.asList(10, 20, 20);

        //把数组转换成一个集合
        Integer[] integers1 = new Integer[]{200,300,400};
        List<Integer> integers2 = Arrays.asList(integers1);

        //把集合转换成数组
        Object[] objects = integers.toArray();
    }
}

案例演示（列表嵌套存储学校学生信息）

/* A:
        需求：
        我们班有学生，每一个学生是不是一个对象。
        所以我们可以使用一个集合表示我们班级的学生。ArrayList<Student>*/

public class Test2 {
    public static void main(String[] args) {
        ArrayList<Student> englishClass = new ArrayList<>();
        englishClass.add(new Student("Adair",21));
        englishClass.add(new Student("Tom",23));
        englishClass.add(new Student("Joine",20));

        ArrayList<Student> chineseClass = new ArrayList<>();
        chineseClass.add(new Student("小红", 25));
        chineseClass.add(new Student("小明", 26));

        ArrayList<Student> mathClass = new ArrayList<>();
        mathClass.add(new Student("老李", 25));
        mathClass.add(new Student("老王", 26));

        //再将所有的班级放进一个学校类中
        ArrayList<ArrayList<Student>> westOs = new ArrayList<>();
        westOs.add(englishClass);
        westOs.add(chineseClass);
        westOs.add(mathClass);

        //遍历集合，取出学生信息
        //普通的for循环遍历
        for (int i = 0; i < westOs.size(); i++) {
            //先把每个里面的班级取出来
            ArrayList<Student> aclass = westOs.get(i);
            for (int j = 0; j < aclass.size(); j++) {
                Student student = aclass.get(j);
                System.out.println(student.getName() + "====" + student.getAge());
            }
            System.out.println();
        }

        System.out.println("==================================");
        //使用新式for循环遍历
        for (ArrayList<Student> aclass : westOs) {
            for (Student student : aclass) {
                System.out.println(student.getName() + "===" + student.getAge());
            }
        }

        System.out.println("==================================");
        //使用forEache方法
        westOs.forEach(new Consumer<ArrayList<Student>>() {
            @Override
            public void accept(ArrayList<Student> students) {
                students.forEach(new Consumer<Student>() {
                    @Override
                    public void accept(Student student) {
                        System.out.println(student.getName() + "===" + student.getAge());
                    }
                });
            }
        });
    }
}

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        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 登录注册集合版.beans;

public class User {
    private String userName;
    private String passWord;

    public User() {
    }

    public User(String userName, String passWord) {
        this.userName = userName;
        this.passWord = passWord;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }
}

package 登录注册集合版.door;

import 登录注册集合版.beans.User;

public interface Userdoor {
    //注册
    boolean registerUser(User user);
    //登录
    boolean login(String userName,String passWord);
}

package 登录注册集合版.door;

import 登录注册集合版.beans.User;

import java.util.ArrayList;

public class UserDoorImpl implements Userdoor {
    //我们使用集合来充当数据库
    private static ArrayList<User> list = new ArrayList<>();

    @Override
    public boolean registerUser(User user) {
        //重写注册
        boolean b=list.add(user);
        return b;
    }

    @Override
    public boolean login(String userName, String passWord) {
        //登录
        boolean flag=false;
        for (User user : list) {
            if(userName.equals(user.getUserName())&&passWord.equals(user.getPassWord())){
                flag=true;
                break;
            }
        }
        return flag;
    }
}

package 登录注册集合版.utils;

import java.util.Random;
import java.util.Scanner;

public class GussNumGame {
    public static void playGame(){
        Random random = new Random();
        int num = random.nextInt(100) + 1;
        Scanner sc = new Scanner(System.in);
        while(true){
            System.out.println("请输入一个数字 1--------100");
            int gussNumber = sc.nextInt();
            if(gussNumber>num){
                System.out.println("猜大了");
            }else if(gussNumber<num){
                System.out.println("猜小了");
            }else if(gussNumber==num){
                System.out.println("恭喜你猜对了");
                break;
            }
        }
    }
}

package 登录注册集合版.view;

import 登录注册集合版.beans.User;
import 登录注册集合版.door.UserDoorImpl;
import 登录注册集合版.door.Userdoor;
import 登录注册集合版.utils.GussNumGame;

import java.util.Scanner;

public class LoginUI {
    public static void main(String[] args) {
        //作业：你要完善的有一下几点
        //1.用户手误没有输入数字，程序不能报错，提示用户输入数字，直到输入数字为止
        //2.登录机会给三次，三次登录不上，退出系统
        //3.注册时对用户名和密码进行规则的校验，用户名 6-16位大小写字母 密码 6-16位数字。
        //4.注测时判断该用户名是否已被注册
        Scanner sc = new Scanner(System.in);
        System.out.println("====欢迎使用本系统====");
        //创建door对象
        UserDoorImpl userDoor = new UserDoorImpl();
        while(true){
            System.out.println("=== 请选择：1.注册 2.登录 3.退出 ===");
            int i = sc.nextInt();
            switch(i){
                case 1://注册
                    sc = new Scanner(System.in);
                    System.out.println("请输入用户名");
                    String userName = sc.nextLine();
                    System.out.println("请输入密码");
                    String passWord = sc.nextLine();
                    System.out.println("请确认密码");
                    String returnPassWord = sc.nextLine();
                    if(passWord.equals(returnPassWord)){
                        //把用户名和密码封装到User对象中
                        User user = new User(userName, passWord);
                        //调用接口door的方法来注册
                        boolean b = userDoor.registerUser(user);
                        if(b){
                            System.out.println("注册成功");
                        }else{
                            System.out.println("注册失败");
                        }
                    }
                    break;
                case 2://登录
                    sc = new Scanner(System.in);
                    System.out.println("请输入登录用户名");
                    String userName1 = sc.nextLine();
                    System.out.println("请输入登录密码");
                    String passWord1 = sc.nextLine();
                    //调用door进行登录操作
                    boolean flag = userDoor.login(userName1, passWord1);
                    if(flag){
                        System.out.println("登陆成功，开始游戏？y/n");
                        sc = new Scanner(System.in);
                        while(true){
                            String text = sc.nextLine();
                            if("y".equalsIgnoreCase(text)){
                                //调用游戏函数
                                GussNumGame.playGame();
                                System.out.println("还要玩吗？y/n");
                            }else{
                                System.out.println("谢谢使用！Bye Bye!");
                                System.exit(0);//退出线程
                            }
                        }
                    }else{
                        System.out.println("登录失败");
                        System.exit(0);
                    }
                    break;
                case 3://退出
                default:
                    System.out.println("谢谢使用！Bye Bye！");
                    System.exit(0);
                    break;
            }
        }
    }
}
  String userName1 = sc.nextLine();
                    System.out.println("请输入登录密码");
                    String passWord1 = sc.nextLine();
                    //调用door进行登录操作
                    boolean flag = userDoor.login(userName1, passWord1);
                    if(flag){
                        System.out.println("登陆成功，开始游戏？y/n");
                        sc = new Scanner(System.in);
                        while(true){
                            String text = sc.nextLine();
                            if("y".equalsIgnoreCase(text)){
                                //调用游戏函数
                                GussNumGame.playGame();
                                System.out.println("还要玩吗？y/n");
                            }else{
                                System.out.println("谢谢使用！Bye Bye!");
                                System.exit(0);//退出线程
                            }
                        }
                    }else{
                        System.out.println("登录失败");
                        System.exit(0);
                    }
                    break;
                case 3://退出
                default:
                    System.out.println("谢谢使用！Bye Bye！");
                    System.exit(0);
                    break;
            }
        }
    }
}