DAY14

DAY14

回顾内容:

对象数组:可以存储(引用类型)的数组

集合:

数组和集合的区别?

1:长度的区别

数组长度:固定

集合长度:可变

2:存储数据类型的区别

数组:可以存储基本数据类型,也可以存储引用类型

集合:只能存储引用类型

3:存储元素的区别?

数组:只能存储同一种类型的元素    int[] arr = {“hello”,10,20,30...} ;

集合:可以存储多种类型的元素

获取集合的元素数:size()

获取数组的长度:length属性

获取字符串的长度:length()方法

集合(Colleciton)的高级功能:

   boolean retainAll(Collection c):

     交集功能:A集合对B集合取交集,交集的元素去A集合中,返回值boolean表示的是:A集合中的元素是否改变,如果改变了,返回true,否则,false

集合的遍历:

1)toArray():将集合转换成数组,返回值是一个Object类型

2)集合的专有遍历方式:获取集合的迭代器

Iterator  it =  集合对象.iterator() ;

while(it.hasNext()){//判断是否有下一个可以迭代的元素

   //获取

String s = (String)it.next() ;

}

interface Iterator{

    boolean hasNext();

Object next() ;

}

interface Collection extends Iterable{

}

interface List extends Collection{

}

class ArrayList<> implements List{

return new Itr();

class Itr implements Iterator {

}

}

 

 

List集合:

List集合是Colleciton集合子接口,就可以使用父接口中的迭代器

List特点:

元素是可以重复的,并且有序性(存储和取出一致)

遍历集合:

1)toArray()

2)迭代器功能:Iterator iterator()

3)列表迭代器:ListIterator listIterator(); 里面添加元素的功能

4)普通for循环,用size()和get(int index)相结合

经常可能会出现问题:

ConcurrentModificationException:并发修改异常:                                  

该异常描述的意思:使用迭代器遍历元素,那么就不能使用集合元素

解决方案:

             1:使用集合遍历元素,普通for(size()和get(int index)结合),使用集合添加元素

             2:使用迭代器遍历元素,使用迭代器添加元素(列表迭代器:ListIterator listIterator())

Set集合:

元素唯一,并且不能保证元素的顺序恒久不变

正则表达式:

基础语法:

字符:

\t:制表符

\n:换行符

\r:回车符

边界匹配:

^:以....开头

$:以...结尾

数量词:

X*:当前X字符出现0次或多次

X?:0次或1次

X+:一次或多次

X{n,}:至少n次

X{n}:恰好n次

X{n,m}:至少出现n次但不超过m次

. :可以代表任意字符:----->本身就是表示.---->\.代表.--->正则表达式书写的时候:\\.

                            [a-zA-Z_0-9]------->\w------------>\\w

[0-9]:------------->\d------------->\\d

硬盘上的抽象路径表现形式:

E:\\JavaSE\\day14\\Code

分割功能:

spilt(String regex): “\\\\”

替换功能

replaceAll(String replacement,String regex) ;

 

关于模式和匹配器的顺序的使用:

1)先通过正则表达式编译模式对象

Pattern p = Pattern.compile(a+b) ;

2)在通过模式对象获取匹配器对象

Matcher m = p.matcher(aaaaaaaab) ;

3)调用匹配器中的方法:boolean matchers()

 

DAY14

一 List集合的子实现类的特点:

1 ArrayList:

底层数据结构是数组的形式,满足数组结构的特点:查询快,增删慢

从线程安全问题来看:线程不安全的,不同步,执行效率高        

2 Vector:

底层数据结构是数组的形式,查询快,增删慢

从线程角度看:线程安全的类,同步,执行效率低

3 LinkedList:

底层数据结构是链接列,特点:查询慢,增删快

从线程角度看:线程不安全的一个类,不同步,执行效率高

如果实现多线程程序,一般要是安全的类:

StringBuffer,Vector<E>,hashtable<K,V>

synchronized(同步锁对象){

代码;

}

如果在一般的需求中没有指明使用集合去完成,都默认采用ArrayList

如果需求中要考虑线程安全,那么使用Vector集合!

笔试过程中,一些需求用到集合:就是用ArrayList

 

二 ArrayList:

底层数据结构是数组的形式,满足数组结构的特点:查询快,增删慢

从线程安全问题来看:线程不安全的,不同步,执行效率高

由于ArrayList是List集合的自实现类,它元素可以重复,并且存储和取出一致

存储字符串并遍历

public class ArrayListDemo {

public static void main(String[] args) {

//创建一个ArrayList集合对象

ArrayList array = new ArrayList() ;

//添加元素

array.add("hello") ;

array.add("hello") ;

array.add("world") ;

array.add("world") ;

array.add("java") ;

array.add("java") ;

//遍历元素:

//1)获取迭代器对象

Iterator it = array.iterator() ;

while(it.hasNext()){

String s = (String)it.next() ;

System.out.println(s);

}

}

}

ArrayList集合来存储自定义对象并遍历

public class ArrayListDemo2 {

public static void main(String[] args) {

//创建ArrayList集合对象

ArrayList array = new ArrayList() ;

//创建几个学生对象

Student s1 = new Student("高圆圆", 27) ;

Student s2 = new Student("唐嫣", 25) ;

Student s3 = new Student("邓超", 29) ;

Student s4 = new Student("黄晓明", 28) ;

//给集合添加元素

array.add(s1) ;

array.add(s2) ;

array.add(s3) ;

array.add(s4) ;

//获取迭代器并遍历

Iterator it = array.iterator() ;

while(it.hasNext()){

//java.lang.ClassCastException: org.westos_01.Student cannot be cast to java.lang.String

// String s = (String)it.next() ;

Student s = (Student) it.next() ;

System.out.println(s);

}

}

}

 

import java.util.Enumeration;

import java.util.Vector;

 

 2  Vector:

底层数据结构是数组的形式,查询快,增删慢

从线程角度看:线程安全的类,同步,执行效率低

特有功能:

public void addElement(E obj)------->相当于:add(Object e)

public Enumeration<E> elements()----->相当于:Iterator iterator() ;

Enumeration<E>接口:向量的组件枚举有两个方法

boolean hasMoreElements():------>相当于:hasNext()

Object nextElement():----------->相当于:next();

源码:

 synchronized:同步锁(多线程中讲):它就可以保证线程安全!

 public synchronized void addElement(E obj) {//由同步代码块演变过来的同步方法

   modCount++;

         ensureCapacityHelper(elementCount + 1);

         elementData[elementCount++] = obj;

   }

public class VectorDemo {

public static void main(String[] args) {

//创建一个Vector集合对象

Vector v = new Vector() ;

//添加元素

//public void addElement(E obj)

v.addElement("hello")

v.addElement("hello");

v.addElement("world");

v.addElement("Java");

//public Enumeration<E> elements()----->相当于:Iterator iterator() ;

Enumeration en = v.elements() ;

//遍历元素

 boolean hasMoreElements():------>相当于:hasNext()

Object nextElement():----------->相当于:next();

while(en.hasMoreElements()){

//获取元素

String s = (String)en.nextElement() ;

System.out.println(s);

}

}

} .

 

3  LinkedList:

底层数据结构是链接列表,特点:查询慢,增删快

从线程角度看:线程不安全的一个类,不同步,执行效率高

特有功能:

添加功能:

public void addFirst(E e)将指定元素插入此列表的开头。

public void addLast(E e)将指定元素添加到此列表的结尾。

获取功能:

public Object getFirst()返回此列表的第一个元素

public Object getLast()返回此列表的最后一个元素。

删除功能:

public Object removeFirst()移除并返回此列表的第一个元素。

public Object removeLast()移除并返回此列表的最后一个元素。

public class LinkedListDemo {

public static void main(String[] args) {

//创建LinkedList集合

LinkedList link = new LinkedList() ;

//添加元素

link.addFirst("hello") ;

link.addFirst("world") ;

link.addFirst("Java") ;

//public void addFirst(E e)将指定元素插入此列表的开头

/*link.addFirst("android") ;

link.addLast("JavaWeb") ;*/

/**

 * public Object getFirst()返回此列表的第一个元素

public Object getLast()返回此列表的最后一个元素。

 */

/*

Object obj = link.getFirst() ;

System.out.println(obj);

Object obj2 = link.getLast() ;

System.out.println(obj2);*/

/**

 * public Object removeFirst()移除并返回此列表的第一个元素。

  public Object removeLast()移除并返回此列表的最后一个元素。

 */

/*System.out.println("removeFirst:"+link.removeFirst());

System.out.println("removeLast:"+link.removeLast());*/

//输出集合

System.out.println("link:"+link);

}

}

 

4

import java.util.ArrayList;

import java.util.Iterator;

  需求:ArrayList去除集合中字符串的重复元素

  1)首先创建一个集合

   2)给集合中添加很多重复元素

  3)再次创建一个新集合

  4)获取迭代器遍历

  5)获取到该集合中的每一个元素

判断新集合中是否包含这些有素

   有,不搭理它

       没有.说明不重复,添加进来

   6)遍历新集合

public class ArrayListTest {

public static void main(String[] args) {

//1)创建一个集合

ArrayList array = new ArrayList() ;

//2)给集合中添加多个重复元素

array.add("hello") ;

array.add("hello") ;

array.add("hello") ;

array.add("world") ;

array.add("world") ;

array.add("world") ;

array.add("Java") ;

array.add("Java") ;

array.add("hello") ;

array.add("Javaweb") ;

array.add("JavaEE") ;

array.add("JavaEE") ;

//3)创建一个新的集合

ArrayList newArray = new ArrayList() ;

//4)遍历旧集合,获取当前迭代器对象

Iterator it = array.iterator() ;

while(it.hasNext()){

String s = (String) it.next()

//拿到了每一个字符串元素

//判断新集合是否包含旧集合中的元素

if(!newArray.contains(s)){

//不包含,就将元素直接添加到新集合中

newArray.add(s) ;

}

}

//遍历新集合

Iterator it2 = newArray.iterator() ;

while(it2.hasNext()){

String s = (String) it2.next() ;

System.out.println(s);

}

}

}

 

 

 由选择排序的逻辑想到:

 拿0索引对应的元素依次和后面索引对应的元素进行比较

 同理,1索引对应的元素和后面.....

 前面的索引对应的元素如果和后面索引对应的元素重复了,从集合移出后面索引的对应的元素

  for(int x = 0 ;x <array.size() -1 ; x ++){

for(int y= x +1 ; y <array.size() ;y++){

//判断

if(array.get(x).equals(array.get(y))){

array.remove(y) ;

y -- ;

}

}

}

//遍历集合

Iterator it = array.iterator() ;

while(it.hasNext()){

String s = (String) it.next() ;

System.out.println(s);

}

}

}

5

//需求:使用LinkedList模拟一个栈结构的特点

//表达的意思:自定义栈集合类,然后使用LinkedList的一些特有功能模拟栈结构特点

public class LinkedListDemo {

public static void main(String[] args) {

//创建LinkedList集合的对象

LinkedList link = new LinkedList() ;

//LinkedList集合的特有功能:addFirst(Object e)

//栈结构的特点:先进后出

link.addFirst("hello") ;

link.addFirst("world") ;

link.addFirst("java") ;

Iterator it = link.iterator() ;

while(it.hasNext()){

String s = (String)it.next() ;

System.out.println(s);

}

}

}

 

import java.util.LinkedList;

  自定义的栈集合类

public class MyStack {

//成员变量

private LinkedList link ;

//无参构造

//通过无参进行LinkedList集合对象 的创建

public MyStack(){

link = new LinkedList() ;

}

//添加功能

public void add(Object obj){

link.addFirst(obj) ;//向集合中列表插入到第一个元素

}

//获取功能

public Object get(){

return link.removeFirst() ;//删除集合列表中的第一个元素,返回值是被删除的元素

}

//定义判断集合是否为空

public boolean isEmpty(){

return link.isEmpty() ;

}

}

 

 

 

二 泛型

 使用ArrayList存储元素给ArrayList集合存储了一些元素,String类型的元素,Integer类型的元素但是通过迭代器遍历元素,由于,系统不知道集合中存储了哪些元素,所有使用String类型接收,就会出现ClassCastException:类转换异常

定义一个数组:字符串数组

// String[] str = new String[3] ;

// str[0] = "hello" ;

// str[1] = "world" ;

// str[2] = 100 ;

数组设计这样好处:提前告诉了开发者,这里只能装String类型的元素,Java根据数组特点---->引出:泛型

泛型:把数据类型的明确工作提供提前到了创建对象或者是调用方法的时期明确的一种特殊类型.参数化类型,可以像参数一样进行传递

格式:

<引用类型>:泛型只能放引用类型

泛型好处:

1)将运行时期异常提前到了编译时期

2)解决了黄色警告线问题

3)获取数据的时候,不用强制类型转换了

import java.util.ArrayList;

import java.util.Iterator;

public class GenericDemo {

public static void main(String[] args) {

//创建ArrayList集合对象

ArrayList array = new ArrayList() ;

//添加元素

array.add("hello") ;

array.add("world") ;

array.add("Java");

// array.add(new Integer(100)) ;

// array.add(10) ;

//相当于:array.add(Integer.valueOf(10)) ;

//遍历集合中的元素,获取迭代器对象

/*Iterator it = array.iterator() ;

while(it.hasNext()){

//java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

String s = (String) it.next() ;

System.out.println(s);

}*/

 

 

 

2 泛型的应用:

一般情况:泛型可以应用在接口,类,或者方法上;主要用在集合中比较多!

public class GenericDemo2 {

public static void main(String[] args) {

//创建一个ArrayList集合对象

ArrayList<String> array = new ArrayList<String>() ;//jdk7特性:泛型推断!:建议:后面永远给出类型

 

//给集合中添加元素

array.add("hello") ;

array.add("world") ;

array.add("java") ;

// array.add(10) ;

//获取迭代器对象并遍历

Iterator<String> it = array.iterator() ;

//遍历

while(it.hasNext()){

//不用强制类型转换了

String s = it.next() ;

System.out.println(s);

}

}

}

 

 

使用ArrayList集合存储自定义对象并遍历

public class GenericDemo3 {

public static void main(String[] args) {

//创建一个ArrayList集合对象

ArrayList<Student> array = new ArrayList<Student>() ;

//创建学生对象

Student s1 = new Student("RNG",666) ;

Student s2 = new Student("EDG",233 ;

Student s3 = new Student("LGD", 292) ;

Student s4 = new Student("WE", 886) ;

//添加元素

array.add(s1) ;

array.add(s2) ;

array.add(s3) ;

array.add(s4) ;

//获取迭代器

Iterator<Student> it = array.iterator() ;

while(it.hasNext()){

Student s = it.next() ;

System.out.println(s.getName()+"---"+s.getAge());

}

}

}

 泛型可以提供程序的安全性

 早期的时候,用Object类型代表任意的类型

 向上转型是不会出现问题的,但是向下转型的时候,由于隐藏了类型转换,导致出现错误

 JDK5以后,提供了泛型可以解决程序的安全性

public class ObjectToolDemo {

public static void main(String[] args) {

//创建ObjectTool对象

ObjectTool ot = new ObjectTool() ;

//设置数据

ot.setObj(27) ;//Object obj = new Integer(27):向上转型

//获取

Integer i = (Integer) ot.getObj() ;//向下转型

System.out.println("年龄是:"+i);

ObjectTool ot2 = new ObjectTool() ;

//设置

ot2.setObj("高圆圆") ;//Object obj = new String("高圆圆") ;

//获取

String str = (String) ot2.getObj() ;//类型转换了:向下转型:隐藏了类型转换

System.out.println("姓名是:"+str);

System.out.println("-------------------------------");

ObjectTool ot3 = new ObjectTool() ;

ot3.setObj("邓超") ;

//java.lang.ClassCastException

Integer ii = (Integer) ot3.getObj() ;//强制类型转换的接收类型不匹配:程序不安全

System.out.println("姓名是:"+ii);

}

}

 

 

3工具类

使用泛型:将泛型定义在类上:解决刚才可能出现错误

实际开发中根据具体类型在测试中书写

public class ObjectTool<T> {

private T obj;

//获取

public T getObj(){

return obj ;

}

//设置

public void setObj(T obj){

this.obj = obj ;

}

}

 

 

//测试类

public class ObjectToolDemo {

public static void main(String[] args) {

//创建ObjectTool<T>对象

ObjectTool<String> ot = new ObjectTool<String>() ;

//设置数据

ot.setObj("高圆圆") ;

//获取数据

//编译都通过不了

// Integer i = ot.getObj() ; 由于给类上加入了泛型,在实际测试中,给定了数据类型,获取数据的时候就必须应该类型来接收,否则不匹配

String name = ot.getObj() ;

System.out.println("姓名是:" +name);

//创建对象

ObjectTool<Integer> ot2 = new ObjectTool<Integer>() ;

//设置数据

ot2.setObj(27) ;

//获取数据

// String s = ot2.getObj() ;

Integer i = ot2.getObj() ;

System.out.println("年龄是:"+i);

}

}

 

4 将泛型定义在类型 方法上 接口上

//在工具类中定义几个成员方法

/*public class ObjectTool<T> {

//形式参数是String

public void show(String s){

System.out.println(s);

}

//形式参数是Integer类型

public void show(Integer i){

System.out.println(i);

}

public void show(Boolean b){

System.out.println(b);

}

public void show(T t){

System.out.println(t);

}

}*/

public class ObjectTool{

//将泛型定义在方法上

public <T> void show(T t){

System.out.println(t);

}

}

/把泛型定义在接口上

public interface Inter<T> {

 

public abstract void show(T t) ;

}

//测试类

public class InterDemo {

public static void main(String[] args) {

//创建接口对象

//第一种情况的测试

Inter<String> i = new InterImpl<String>() ;

i.show("hello") ;

System.out.println("-----------------------------");

//第二种情况:

Inter<Integer> i2 = new InterImpl<Integer>() ;

i2.show(27) ;

Inter<String> i3 = new InterImpl<String>() ;

i3.show("高圆圆") ;

}

}

//接口加入了泛型:

//第一种情况:接口的子实现类已经知道传递的是什么数据类型

/*public class InterImpl<String> implements Inter<String> {

public void show(String t) {

System.out.println(t);

}

}*/

//第二种情况:接口的子实现类在实现接口的时候,不知道具体的数据类型是什么

//在测试类的时候,传入具体数据类型

//面向接口编程

//JavaEE:Sping框架 :AOP:面向切面编程

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

public void show(T t) {

System.out.println(t);

}

}

 

6

泛型的高级:通配符

<?> :可以是任意类型,包括Object类型以及任意的Java类

<? extends E>:向下限定,E类型以及E类型的子类

<? super E>:向上限定,E类型以及E类型的父类

import java.util.ArrayList;

import java.util.Collection;

public class GenericDemo {

public static void main(String[] args) {

//创建Collection集合的对象

//最起码:前后的数据类型保持一致

// Collection<Object> c1 = new ArrayList<Animal>() ;

// Collection<Object> c2 = new ArrayList<Cat>() ;

// Collection<Object> c3 = new ArrayList<Dog>() ;

Collection<Object> c3 = new ArrayList<Object>() ;

// <?> :可以是任意类型,包括Object类型以及任意的Java类

Collection<?> c4 = new ArrayList<Object>() ;

Collection<?> c5 = new ArrayList<Animal>() ;

Collection<?> c6 = new ArrayList<Cat>() ;

Collection<?> c7 = new ArrayList<Dog>() ;

//<? extends E>:向下限定,E类型以及E类型的子类

Collection<? extends Object> c8 = new ArrayList<Object>() ;

Collection<? extends Animal> c9 = new ArrayList<Animal>() ;

// Collection<? extends Animal> c10 = new ArrayList<Object>() ;

Collection<? extends Object> c11 = new ArrayList<Cat>() ;

//<? super E>:向上限定,E类型以及E类型的父类

Collection<? super Animal> c12 = new ArrayList<Object>() ;

Collection<? super Animal> c13 = new ArrayList<Animal>() ;

// Collection<? super Animal> c14 = new ArrayList<Dog>() ;

}

}

//自定义两个类

class Animal{

}

class Cat extends Animal{

}

class Dog extends Animal{

}

 

 

三 增强for

 1 DK5以后提供了很多特性:

泛型,增强for循环,可变参数,静态导入,自动拆装箱,枚举等的呢过

增强for循环

书写格式:

for(集合或者数组中的数据类型 变量名:集合或者数组的对象名){

输出变量名;

}

 增强for循环的弊端:

遍历数组或者集合的时候,数组对象或者集合对象不能为null

如果对象为空,一般加上非空判断

 增强for循环的出现就是为了替代迭代器遍历集合的,以后开发中就是用增强for遍历元素

import java.util.ArrayList;

import java.util.Iterator;

public class ForDemo {

public static void main(String[] args) {

//定义一个数组,静态初始化

int[] arr = {11,22,33,44,55} ;

//普通for循环的遍历

for(int x = 0 ; x < arr.length ; x ++){

System.out.println(arr[x]);

}

System.out.println("---------------------");

//使用增强for遍历

for(int i :arr){

System.out.println(i);

}

System.out.println("-------------------");

//定义一个字符串数组,并遍历

String[] strArray = {"hello","world","java"};

//直接使用增强for循环

for(String s : strArray){

System.out.println(s);

}

System.out.println("-------------------");

//创建ArrayList集合对象,添加并遍历元素

ArrayList<String> array = new ArrayList<String>() ;

//添加元素

array.add("hello") ;

array.add("world") ;

array.add("java") ;

//之前:迭代器遍历

/*Iterator<String> it = array.iterator() ;

while(it.hasNext()){

String s = it.next() ;

//判断当前集合中是否有"world",如果有就添加元素

//java.util.ConcurrentModificationException

if("world".equals(s)){

//使用集合添加元素

array.add("javaee") ;

}

}*/

//使用增强for遍历该集合

for(String s :array){

//获取到每一个元素

//java.util.ConcurrentModificationException

判断当前集合中是否有"world",如果有就添加元素

if("world".equals(s)){

array.add("javaee") ;

}

}

System.out.println("-------------------");

/* array = null ;

//java.lang.NullPointerException:空指针异常

if(array!=null){

//增强for循环

for(String s:array){

System.out.println(s);

}

}*/

}

}

 

2  使用ArrayList集合存储自定义对象并遍历

   1)toArray()

  2)Collection集合的迭代器:Iterator iterator();

  3)List集合的迭代器:ListIterator listiterator();

4)普通for循环:size()和get(int index)相结合

  5)增强for循环

public class ForDemo2 {

public static void main(String[] args) {

// 创建ArrayList集合

ArrayList<Student> array = new ArrayList<Student>();

// 创建学生对象

Student s1 = new Student("RNG", 27);

Student s2 = new Student("RNG", 20);

Student s3 = new Student("EDG", 29);

Student s4 = new Student("EDG", 25);

 

// 给集合中添加元素

array.add(s1) ;

array.add(s2) ;

array.add(s3) ;

array.add(s4) ;

//普通for循环:size()和get(int index)相结合

for(int x =0 ; x < array.size() ; x ++){

Student s = array.get(x) ;

System.out.println(s.getName()+"---"+s.getAge());

}

System.out.println("-----------------------");

//Collection集合的迭代器:Iterator iterator();

Iterator<Student> it = array.iterator() ;

while(it.hasNext()){

Student s = it.next() ;

System.out.println(s.getName()+"----"+s.getAge());

}

System.out.println("-----------------------");

//增强for遍历

for(Student s : array){

System.out.println(s.getName()+"----"+s.getAge());

}

}

}

课堂练习:

假设有一个Java班,看成一个容器,这个容器里面有很多学生

ArrayList<Student>,但是又不止一个Java班,

大的集合:ArrayList<ArrayList<Student>>

集合的嵌套遍历

public class ArrayListTest {

public static void main(String[] args) {

// 创建一个大集合的对象

ArrayList<ArrayList<Student>> bigArray = new ArrayList<ArrayList<Student>>();

//创建第一个子集合对象ArrayList<Student>

ArrayList<Student> firstArray = new ArrayList<Student>() ;-

//创建学生对象

Student s1 = new Student("LGD", 29) ;

Student s2 = new Student("WE", 22) ;

Student s3 = new Student("WSD", 25;

//给第一个集合中添加元素

firstArray.add(s1) ;

firstArray.add(s2) ;

firstArray.add(s3) ;

//将第一个子集合添加到大集合中

bigArray.add(firstArray) ;

//创建第二个子集合对象

ArrayList<Student> secondArray = new ArrayList<Student>() ;

//创建学生对象

Student s4 = new Student("qg", 28) ;

Student s5 = new Student("omg", 22) ;

Student s6 = new Student("ism", 26) ;

//给第二个子集合中添加元素

secondArray.add(s4) ;

secondArray.add(s5) ;

secondArray.add(s6) ;

//将第二个子集合添加到大集合中

bigArray.add(secondArray) ;

//创建第三个子集合对象

ArrayList<Student> thirdArray = new ArrayList<Student>() ;

//创建学生对象

Student s7 = new Student("微信", 30) ;

Student s8 = new Student("草莓", 22) ;

Student s9 = new Student(”卢本伟", 26) ;

//给第三个子集合中添加元素

thirdArray.add(s7) ;

thirdArray.add(s8) ;

thirdArray.add(s9) ;

//将第二个子集合添加到大集合中

bigArray.add(thirdArray) ;

//遍历大集合

//增强for遍历

//ArrrayList<ArrayList<student>>

for(ArrayList<Student> array :bigArray){

//子集合:ArrayList<Student>

for(Student s : array){

System.out.println(s.getName()+"---"+s.getAge());

}

}

}

}