java-Collection集合，List集合

àì夳堔傛蜴生んèń 2022-01-28 10:13 462阅读 0赞

**集合数组**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDgxOTI0_size_16_color_FFFFFF_t_70][]

**65.集合的由来和集合继承体系图**

**-集合的由来：数组长度是固定,当添加的元素超过了数组的长度时需要对数组重新定义,太麻烦,java内部给我们提供了集合类,能存储任意对象,长度是可以改变的,随着元素的增加而增加,随着元素的减少而减少 **

**-数组和集合的区别：**

**   1：**

**           \*数组既可以存储基本数据类型，也可以存储引用数据类型，基本数据类型存储的是值，引用数据类型存储的是地址值**

**           \*集合只能存储引用数据类型（对象）集合中也可以存储基本数据类型，但在存储的时候会自动装箱为对象，100->new Integer(100)**

**    2:**

**            \*数组的长度是固定的，不能自动增长**

**            \*集合的长度是可变的，可以根据元素的增加而增长**

**-集合和数组什么时候用：**

**\*如果元素个数是固定推荐用数组，因为当使用集合****时，由于集合也有通过数组实现的，所以在赋值时可能会产生大量垃圾，浪费内存**

**            \*如果元素个数不是固定的推荐用集合**

**-集合继承体系图：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDgxOTI0_size_16_color_FFFFFF_t_70 1][]

**66.Collection集合的基本功能**

**-方法：**

**boolean add(E e)              //向集合中添加元素（参数为object的任意对象）**

**注：add方法如果是List集合一直会返回true，因为List集合是可以存储重复元素的，如果是Set集合存储重复元素就会返回false**  
**        boolean remove(Object o)      //删除集合中的元素  
        void clear()                               //清空集合中的元素  
        boolean contains(Object o)    //查看集合中是否包含指定元素，返回一个boolean值  
        boolean isEmpty()                   //判断集合是否为空  
        int size()                                    //获取集合中元素的个数**

**-ArrayList的父类的父类重写toString方法，所以在打印对象引用的时候，输出的结果不是Object类中toString的结果**

package Collection;
    
    import java.util.ArrayList;
    import java.util.Collection;
    
    public class demo1 {
    
    	public static void main(String[] args) {
    		Collection c = new ArrayList();           //父类引用指向子类对象，编译看父类，运行看子类
    		
    		boolean b1 = c.add("abc");  
    		boolean b2 = c.add(true);                 //基本数据类型，会自动装箱，new Boolean(true);
    		boolean b3 = c.add(123);                 //new Integer(123)
    		boolean b4 = c.add(new Student("张三",23));     
    		
    		System.out.println(c);
    	}
    
    }

![20181208172532901.png][]

**67.集合的遍历**

**-遍历：其实就是依次获取集合中的每一个元素**

**-实现：将集合转换为数组，可以实现集合的遍历**

**           方法：toArray();                   //将集合转换为数组**

package Collection;
    
    import java.util.ArrayList;
    import java.util.Collection;
    
    public class demo2 {
    
    	public static void main(String[] args) {
    		demo1();
    		Collection c = new ArrayList();
    		c.add(new Student("张三",23));         //Object obj = new Student("张三",23);  向上转型 ，多态弊端无法使用子类特有的属性和方法
    		c.add(new Student("李四",24));
    		c.add(new Student("王五",25));
    		c.add(new Student("赵六",26));
    		Object[] arr = c.toArray();                  //将集合转换为Object数组
    		for (int i = 0; i < arr.length; i++) {
    			//System.out.println(arr[i]);        //它的作用只是为了显示
    			Student s = (Student)arr[i];          //将obj向下转型为Student对象，这样就可以使用student中特有的属性和方法
    			System.out.println(s.getName()+".."+s.getAge());    //这样不仅可以显示，还可以获取数据做其他操作
    		}
    	}
    
    	private static void demo1() {
    		Collection c = new ArrayList();
    		c.add("a");
    		c.add("b");
    		c.add("c");
    		c.add("d");
    		
    		Object[] arr = c.toArray();
    		for (int i = 0; i < arr.length; i++) {
    			System.out.println(arr[i]);
    		}
    	}
    
    }

![20181208190054304.png][]

**68.Collection集合中带All的方法测试**

**-方法：**

**boolean addAll(Collection c)                          //将整个集合添加为另一集合的元素中，合并  
        boolean removeAll(Collection c)                    //删除的是交集  
        boolean containsAll(Collection c)                  //判断一集合是否包含另一集合的元素，可以重复，但如果另一集合含有集合中不存在的元素，则返回fasle  
        boolean retainAll(Collection c)                       //获取两个集合的交集，如果调用的集合改变就返回true，如果调用的集合不变就返回false**

package Collection;
    
    import java.util.ArrayList;
    import java.util.Collection;
    
    public class demo3 {
    
    	public static void main(String[] args) {
    		addAll();
    		removeAll();
    		containsAll();
    		Collection c1 = new ArrayList();
    		c1.add("a");
    		c1.add("b");
    		c1.add("c");
    		c1.add("d");
    		Collection c2 = new ArrayList();
    		c2.add("a");
    		c2.add("b");
    		c2.add("b");
    		boolean b = c1.retainAll(c2);
    		Collection c3 = new ArrayList();
    		c3.add("a");
    		c3.add("b");
    		c3.add("c");
    		c3.add("d");
    		c3.add("e");
    		c3.add("f");
    		System.out.println("获取c1,c2中相同的元素，若c1改变，返回true若不变，返回false");
    		System.out.println(b);
    		System.out.println(c1);
    		System.out.println("c3包含c1的全部元素，此时c1不变，返回false");
    		boolean b2 = c1.retainAll(c3);
    		System.out.println(b2);
    		System.out.println(c1);
    	}
    
    	private static void containsAll() {
    		Collection c1 = new ArrayList();
    		c1.add("a");
    		c1.add("b");
    		c1.add("c");
    		c1.add("d");
    		Collection c2 = new ArrayList();
    		c2.add("a");
    		c2.add("b");
    		c2.add("b");
    		boolean b = c1.containsAll(c2);
    		System.out.println("判断c1中是否含有c2中的所有元素，c2中的元素可以重复，但如果含有c1没有的元素，则返回false");
    		System.out.println(b);
    		System.out.println(c1);
    	}
    
    	private static void removeAll() {
    		Collection c1 = new ArrayList();
    		c1.add("a");
    		c1.add("b");
    		c1.add("c");
    		c1.add("d");
    		Collection c2 = new ArrayList();
    		c2.add("a");
    		c2.add("b");
    		c2.add("3");
    		boolean b = c1.removeAll(c2);
    		System.out.println("获取两个集合的交集，若没有交集则返回false");
    		System.out.println(b);
    		System.out.println(c1);
    	}
    
    	private static void addAll() {
    		Collection c1 = new ArrayList();
    		c1.add("a");
    		c1.add("b");
    		c1.add("c");
    		c1.add("d");
    		Collection c2 = new ArrayList();
    		c2.add("a");
    		c2.add("b");
    		c2.add("3");
    		boolean b = c1.addAll(c2);
    		System.out.println("将两个集合合并，并将结果返回给调用的集合");
    		System.out.println(b);
    		System.out.println(c1);
    	}
    
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDgxOTI0_size_16_color_FFFFFF_t_70 2][]

**69.集合的遍历之迭代器遍历**

**-概述：** **集合是用来存储元素,存储的元素需要查看,那么就需要迭代(遍历) **

**-迭代器：Iterator（接口）**

**-迭代器原理：迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取都是不一样,那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合体系过于臃肿,迭代器是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式,这样做的好处有二,第一规定了整个集合体系的遍历方式都是hasNext()和next()方法,第二,代码有底层内部实现,使用者不用管怎么实现的,会用即可 **

**-方法：**

**          \*boolean hasnext()                    //如果仍有元素可以迭代，返回true**

**          \*next()                                         //返回迭代的下一个元素**

**         **

package Collection;
    
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    public class demo4 {
    
    	public static void main(String[] args) {
    		demo1();
    		Collection c = new ArrayList();
    		c.add(new Student("张三",23));         //Object obj = new Student("张三",23);  向上转型 ，多态弊端无法使用子类特有的属性和方法
    		c.add(new Student("李四",24));
    		c.add(new Student("王五",25));
    		c.add(new Student("赵六",26));
    		Iterator it = c.iterator();           //获取迭代器
    		while(it.hasNext()){
    			Student s = (Student)it.next();                  //将集合中的元素向下转型，由object对象转换为Student对象
    			System.out.println(s.getName()+".."+s.getAge());
    		}
    	}
    
    	private static void demo1() {
    		Collection c = new ArrayList();
    		c.add("a");
    		c.add("b");
    		c.add("c");
    		c.add("d");
    		Iterator it = c.iterator();          //获取迭代器
    		while(it.hasNext()){
    			System.out.println(it.next());           //指针会自动向后移动
     		}
    	}
    
    }

![20181209170322669.png][]

**70.List集合的特有功能概述**

**-概述：有序的Collection也称为序列，此接口的用户可以对列表中每个元素的插入位置进行精确的控制，用户可以根据元素的整数索引访问元素，并搜索列表中的元素。**

**-方法：**

**   \* void add(int index,E element)        //在列表的指定位置插入元素  
    \* E remove(int index)                        //删除指定位置的元素  
    \* E get(int index)                               //根据索引获取指定元素  
    \* E set(int index,E element)             //修改指定位置的元素**

package Collection;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    public class demo5_List {
    
    	public static void main(String[] args) {
    		add();
    		remove();
    		get();
    		set();
    	}
    
    	private static void set() {
    		List list = new ArrayList();
    		list.add("a");
    		list.add("b");
    		list.add("c");
    		list.add("d");
    		list.set(1, "x");
    		System.out.println(list);
    	}
    
    	private static void get() {
    		List list = new ArrayList();
    		list.add("a");
    		list.add("b");
    		list.add("c");
    		list.add("d");
    		//利用迭代器遍历List集合
    		Iterator it = list.iterator();
    		while(it.hasNext()){
    			System.out.println(it.next());
    		}	
    		//通过索引遍历List集合
    		for(int i=0;i<list.size();i++){
    			System.out.print(list.get(i) +" ");
    		}
    		System.out.println();
    	}
    
    	private static void remove() {
    		List list = new ArrayList();
    		list.add("a");
    		list.add("b");
    		list.add("c");
    		list.add("d");
    		list.add(111);
    		list.add(222);
    		Object obj = list.remove(1);               //返回删除的元素，根据索引删除指定元素
    		//Object obj1 = list.remove(111);       //参数不能为数字，将数字当成了索引，所以会报错
    		System.out.println(obj);
    		System.out.println(list);
    	}
    
    	private static void add() {
    		List list = new ArrayList();
    		list.add("a");
    		list.add("b");
    		list.add("c");
    		list.add("d");
    		list.add(4, "e");                    //index<=size    ,且index>=0都不会触发异常
    		//list.add(10,"e");               IndexOutOfBoundsException索引越界异常
    		System.out.println(list);
    	}
    
    }

![20181209193218971.png][]

**-List集合的遍历**

package Collection;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    public class demo6 {
    
    	public static void main(String[] args) {
    		List list  = new ArrayList();
    		list.add(new Student("张三",23));
    		list.add(new Student("李四",24));
    		list.add(new Student("王五",25));
    		list.add(new Student("赵六",26));
    		//利用get方法遍历
    		for (int i = 0; i < list.size(); i++) {
    			//System.out.println(list.get(i));
    			Student s = (Student)list.get(i);
    			System.out.println(s.getName()+".."+s.getAge());
    		}
    		System.out.println();
    		//利用迭代器遍历
    		Iterator it = list.iterator();
    		while(it.hasNext()){
    			Student s = (Student)it.next();             //将obj对象向下转型，这样就可以使用student类中特有的属性和方法
    			System.out.println(s.getName()+".."+s.getAge());
    		}
    	}
    
    }

![20181209194310570.png][]

**-并发修改异常产生的原因及解决方案**

**-ListIterator接口：系列表迭代器，允许按任一方法遍历集合，迭代期间修改列表，接口中有add方法，可以在迭代期间向列表添加元素，而不触发并发修改异常（**ConcurrentModificationException**）的错误**

package Collection;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    import java.util.ListIterator;
    
    public class demo7_listIterator {
    	public static void main(String[] args){
    		List list = new ArrayList();
    		list.add("a");
    		list.add("b");
    		list.add("hello");
    		list.add("c");
    		list.add("d");
    		/*Iterator it= list.iterator();     //获取迭代器
    		while (it.hasNext()) {             //判断集合是否有元素
    			String s = (String)it.next();      //向下转型
    			if("hello".equals(s)){             //如果集合中含有"hello"字符串，就向集合中添加world
    				list.add("wolrd");          //遍历的同时再增加元素，不允许在遍历期间修改集合，触发ConcurrentModificationException异常（并发修改异常）
    			}
    		}*/
    		ListIterator lit = list.listIterator();
    		while (lit.hasNext()) {             //判断集合是否有元素
    			String s = (String)lit.next();      //向下转型
    			if("hello".equals(s)){             //如果集合中含有"hello"字符串，就向集合中添加world
    				lit.add("wolrd");               //调用	ListIterator接口中的add方法，允许再遍历期间修改集合
    			}
    		}
    		System.out.println(list);
    	}
    }

![20181210130418767.png][]

**-ListIterator接口功能**

**\* boolean hasNext()         是否有下一个  
      \* boolean hasPrevious()  是否有前一个  
      \* Object next()                  返回下一个元素  
      \* Object previous()           返回上一个元素**

**71.Vector接口的概述**

**-概述：实现了List接口，功能被ArrayList取代**

**-特有功能：**

**未实现List接口时，Vector通过枚举来遍历获取集合中的值**

**          \*void addElement(obj E)           添加元素**

**-Enumeration      枚举对象，实现枚举功能**

**       \*hasMoreElements()             测试此枚举是否包含更多的元素**

**       \*nextElement()                      如果还有下一个对象，返回下一个元素**

package Collection;
    
    import java.util.Enumeration;
    import java.util.Vector;
    
    public class demo8_Vector {
    
    	public static void main(String[] args) {
    		Vector v = new Vector();
    		v.addElement("a");
    		v.addElement("b");
    		v.addElement("c");
    		v.addElement("d");
    		Enumeration en = v.elements();                 //获取枚举
    		while(en.hasMoreElements()){                 //判断是否有元素
    			System.out.println(en.nextElement());      //输出集合中的所有元素
    		}
    	}
    
    }

** 72.List的三个子类**

**-数组与链表的比较:  
    数组：查询快修改也快**

**               增加和删除慢**

**    链表：查询慢修改也慢**

**               增加和删除快**

**-ArrayList，LinkList，Vector的比较：**

** **       **\*ArrayList:  
              底层数据结构是数组，查询快，增删慢。  
              线程不安全，效率高。  
        \*Vector:  
              底层数据结构是数组，查询快，增删慢。  
              线程安全，效率低。  
                 \*1.Vector相对ArrayList查询慢(线程安全的)  
                 \*2.Vector相对LinkedList增删慢(数组结构)  
        \*LinkedList:  
              底层数据结构是链表，查询慢，增删快  
              线程不安全，效率高  
   \*Vector和ArrayList的区别：  
              Vector是线程安全的,效率低  
              ArrayList是线程不安全的,效率高  
        共同点:都是数组实现的  
    \*ArrayList和LinkedList的区别  
              ArrayList底层是数组结果,查询和修改快  
              LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢  
       共同点:都是线程不安全的**

**73.ArrayList去重**

**-思路：1.创建新集合接收老集合中不重复的值**

**            2.获取老集合中的迭代器**

**            3.遍历老集合**

**            4.通过新集合是否包含老集合中的元素，如果包含就不添加，不包含就添加**

package Collection;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    public class demo9_ArrayList去重 {
    
    	public static void main(String[] args) {
    		ArrayList list = new ArrayList();
    		list.add("a");
    		list.add("a");
    		list.add("a");
    		list.add("b");
    		list.add("b");
    		list.add("b");
    		list.add("c");
    		list.add("c");
    		list.add("b");
    		ArrayList li = method(list);
    		System.out.println(li);
    	}
    	public static ArrayList method(ArrayList list){
    		ArrayList al = new ArrayList();                     //创建新集合
    		Iterator it = list.iterator();                            //获取传入集合的迭代器
    		while(it.hasNext()){
    			Object obj = it.next();                                //取得集合中每一个元素
    			if(!al.contains(obj)){                                  //如果新集合不包含obj，就添加
    				al.add(obj);
    			}
    		}
    		return al;
    	}
    }

**-自定义类实现去重**

**-注意点：Contains方法和remove方法底层是通过equals方法实现的，如果自定义类没有重写equals方法的话，就会调用object类的equals方法，此时比较的是对象的地址值。**

package Collection;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    
    public class demo9_ArrayLIst2 {
    
    	public static void main(String[] args) {
    		ArrayList list = new ArrayList();
    		list.add(new Student("张三",23));
    		list.add(new Student("张三",23));
    		list.add(new Student("张三",25));
    		list.add(new Student("李四",24));
    		list.add(new Student("李四",24));
    		ArrayList al = method(list);
    		System.out.println(al);
    	}
    	public static ArrayList method(ArrayList list){
    		ArrayList aList = new ArrayList();                //创建新集合
    		Iterator it = list.iterator();
    		while(it.hasNext()){
    			Object obj = it.next();
    			if(!aList.contains(obj)){                            //Contains底层是通过equals实现的，如果自定义类没有重写equals方法，就会自动调用object类的equals方法，此时比较的是地址值
    				aList.add(obj);
    			}
    		}
    		return aList;
    	}
    }
    
    
    Student类：
    @Override           //重写equals方法
    	public boolean equals(Object obj) {
    		Student s = (Student)obj;
    		return this.name.equals(s.name) && this.age == s.age;
    	}

![20181211133136865.png][]

**75.LinkedList的概述及使用**

**-概述：List接口的链表形式实现**

**-链表：查询和修改慢，增加和删除快，因为链表的每一个元素（除开头和结尾外）都保留着它前一个元素和后一个元素的地址，这样就可以以链的形式连接，但查询时，只能从头或从尾依次查找，直至找到，所以查询慢，而删除时只要将两个元素之间的链去掉即可。**

**-方法：**

**   \* public void addFirst(E e)及addLast(E e)           //在链的头部或尾部添加元素  
    \* public E getFirst()及getLast()                             //获取链的头部或尾部的元素  
    \* public E removeFirst()及public E removeLast()       //删除链的头部或尾部的元素  
    \* public E get(int index)             //获取指定索引的元素，由（index和size/2）比较，判断应从头部还是尾部开始查找**

**-用LinkedList模拟栈数据结构**

package Collection;
    
    import java.util.LinkedList;
    
    public class demo11_stack {
    	private LinkedList list = new LinkedList();
    	
    	public static void main(String[] args) {
    		demo11_stack d = new demo11_stack();
    		d.inStack("a");
    		d.inStack("b");
    		d.inStack("c");
    		d.inStack("d");
    		while(!d.isEmpty()){
    			System.out.println(d.outStack());
    		}
    	}
    	public void inStack(Object obj){
    		 list.addFirst(obj);
    	}
    	public Object outStack(){
    		return list.removeFirst();
    	}
    	public boolean isEmpty(){
    		return list.isEmpty();
    	}
    }

**77.增强for****概述及其使用**

**-概述：简化数组及Collection集合的遍历（底层用迭代器实现）**

**-格式：**

**for(元素数据类型 变量 : 数组或者Collection集合) \{  
                  使用变量即可，该变量就是元素  
            \}**

package generic;
    
    import java.util.ArrayList;
    
    public class demo5_foreach {
    
    	public static void main(String[] args) {
    		int arr[]  = {11,22,33,44,55};
    		for (int i : arr) {
    			System.out.println(i);
    		}
    		ArrayList< String > list = new ArrayList<>();
    		list.add("a");
    		list.add("b");
    		list.add("c");
    		list.add("d");
    		for (String string : list) {
    			System.out.println(string);
    		}
    	}
    
    }

**78.三种迭代的能否删除**

package generic;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    
    public class demo6 {
    
    	public static void main(String[] args) {
    		ArrayList<String> list = new ArrayList<>();
    		list.add("a");
    		list.add("b");
    		list.add("b");
    		list.add("c");
    		list.add("d");
    		//for 循环遍历删除指定元素
    		/*for (int i = 0; i < list.size(); i++) {       
    			if("b".equals(list.get(i))){            //找到"b"
    				list.remove(i--);                          //删除"b"，并使索引回退一位，因为当删除一个元素时，list的size会减少一位，此时如果i的索引不减一的话，就会跳过删去元素的下一位元素
    			}*/
    		//迭代器循环遍历删除指定元素
    		/*Iterator<String> it = list.iterator();
    		while (it.hasNext()) {
    			if("b".equals(it.next())){
    				it.remove();
    				//list.remove("b");                不能用集合的修改方法，因为会出现并发修改异常
    		}
    		}*/
    		//foreach循环遍历删除（不可以）因为foreach底层依赖迭代器实现
    		/*for (String string : list) {
    			if("b".equals(string)){
    				list.remove("b");                //并发修改异常，不能删除指定元素
    			}
    		}*/
    	}
    }

**79.静态导入**

**-概述：静态导入类方法**

**-格式：import static 包名... 类名.方法名**

**            可以直接导入到方法的级别**

**-注意事项：方法必须是静态的，但如果有多个同名的静态方法，容易不知道使用谁？这个时候要使用，必须加前缀。**

**80.可变参数**

**-概述：当定义方法的时候不知道应该定义多少个参数**

**-格式：**

**       \*修饰符 返回值类型 方法名（数据类型 ... 变量名）\{\}**

**-注意事项：**

**        \*这里的可变参数其实是一个数组**

**        \*如果一个方法有可变参数，并且还有多个参数，可变参数肯定是最后一个**

package generic;
    
    public class demo7_changeableargs {
    
    	public static void main(String[] args) {
    		String[] arr = {"a","b","c","d"};
    		method("s1","z","x","y");
    	}
    	public static void method(String s1,String ... arr1){
    		for (String string : arr1) {
    			System.out.println(string);
    		}
    	}
    }

**81.asList方法**

**-功能：将数组转换成集合**

**-注意：**

**          \*数组转换成集合后不能增加或删除元素，但是可以用集合的思想来操作数组，也就是说可以使用其他集合里的方法**

\***基本数据类型转数组，会将整个数组转化为一个对象**

**          \*将数组转化为集合，数组必须是引用数据类型**

package Arrays;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    public class demo2_asList {
    
    	public static void main(String[] args) {
    		Integer[] arr = {11,11,22,33,33,44,44,55};
    		List<Integer> list = Arrays.asList(arr);
    		System.out.println(list);               //数组转集合只能是引用数据类型
    		listtoarray();
    	}
    
    	private static void listtoarray() {
    		ArrayList<String> list = new ArrayList<>();
    		list.add("a");
    		list.add("b");
    		list.add("c");
    		list.add("d");
    		String[] arr = list.toArray(new String[5]); //当集合转数组时，数组的长度如果<=size，转换后的数组长度等于集合的size，如果>size，那么数组的长度就和你指定的长度一样
    		for (String string : arr) {
    			System.out.println(string);
    		}
    	}
    }

**82.集合中嵌套集合**

package Collection;
    
    import java.util.ArrayList;
    
    public class demo12 {
    
    	public static void main(String[] args) {
    		ArrayList<ArrayList<Student>> list = new ArrayList<>();
    		ArrayList<Student> First = new ArrayList<>();
    		First.add(new Student("张三",23));
    		First.add(new Student("李四",24));
    		First.add(new Student("王五",25));
    		ArrayList<Student> Second = new ArrayList<>();
    		Second.add(new Student("赵六",26));
    		Second.add(new Student("周七",27));
    		Second.add(new Student("潘八",28));
    		list.add(First);
    		list.add(Second);
    		for (ArrayList<Student> as :list ) {
    			System.out.println(as);
    			for (Student s : as) {
    				System.out.println(s);
    			}
    		}
     	}
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDgxOTI0_size_16_color_FFFFFF_t_70]: /images/20220128/666ae27cb218414e93d10866c2e9be6f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDgxOTI0_size_16_color_FFFFFF_t_70 1]: /images/20220128/355a114117ab4812b6f51d4c193ed3f1.png
[20181208172532901.png]: /images/20220128/2b83105134474eda944ea56af9d555c7.png
[20181208190054304.png]: /images/20220128/1c37e71bdf6e4ea788c287e2bdeb5866.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDgxOTI0_size_16_color_FFFFFF_t_70 2]: /images/20220128/fe45cb7c1d164b17b266af0bdc95e0ff.png
[20181209170322669.png]: /images/20220128/37657f314504415491422d1f42157f2e.png
[20181209193218971.png]: /images/20220128/c71cb3ff2eb642f3b9b315776d65f114.png
[20181209194310570.png]: /images/20220128/482d8e2bb00040ba856b7facc1f72463.png
[20181210130418767.png]: /images/20220128/34d2589ffeaa4ccbbaa6410844d9f57c.png
[20181211133136865.png]: /images/20220128/98b3bad1cadb4921878869f9c475af82.png