黑马程序员——java基础——集合框架

(1)对象数组概述：

代码注意事项：A:自己的类名不要和我们学习的要使用的API的类名相同。

              B:复制代码的时候，很容易把那个类所在的包也导入过来，容易出现不能理解的问题。

数组既可以存储基本数据类型，也可以存储引用类型。它存储引用类型的时候的数组就叫对象数组。

2:集合(Collection)

      (1)集合的由来?

              我们学习的是Java -- 面向对象 -- 操作很多对象 -- 存储 -- 容器(数组和StringBuffer)-- 数组

              而数组的长度固定，所以不适合做变化的需求，Java就提供了集合供我们使用。

(2)集合和数组的区别?

              A:长度区别

                     数组固定

                     集合可变

              B:内容区别

                     数组可以是基本类型，也可以是引用类型

                     集合只能是引用类型

            集合只能存储对象。

              C:元素内容

                     数组只能存储同一种类型

                     集合可以存储不同类型(其实集合一般存储的也是同一种类型)

(3)集合的继承体系结构?

              由于需求不同，Java就提供了不同的集合类。这多个集合类的数据结构不同，但是它们都是要提供存储和遍历功能的，

              我们把它们的共性不断的向上提取，最终就形成了集合的继承体系结构图。

              Collection

                     |--List

                            |--ArrayList

                            |--Vector

                            |--LinkedList

                     |--Set

                            |--HashSet

                            |--TreeSet

(4)Collection的功能概述

              A:添加功能

                     add(Objectobj)

         Boolean  addAll(Collection c) :添加一个集合的元素。

              B:删除功能

                      Void clear( ): 移除所有元素。

remove(Object obj)

              C:判断功能

                     boolean   contains(Object obj):  判断集合中是否包含指定的元素。

           Boolean containsAll( Collection c) : 判读集合中是否包含指定的集合元素。

           Boolean  isEmpty() : 判断集合是否为空。

              D:获取功能

                     Iterator iterator() ：迭代器，集合的专用遍历方式。

      Object   next() : 获取元素，并移动到下一个位置。

              NoSuchElementException: 报错，没有这样的元素，因为已经到最后了。

       Boolean  hasNext(): 如果仍有元素可以迭代，则放回true（）。

              E:长度功能

                     size()

          包含功能：

          Boolean  containsAll( Collectionc)：判断集合中是否包含指定的集合元素。

               （只有包含所有的元素，才叫包含）。

              F:交集(了解)

         Boolean  retainAll（Collection c）: 两个集合都有的元素。（元素去哪了，返回的boolean又是什么意思？）。

Boolean ： A对B做交集，最终的结果保存在A中，B不变。

          返回值表示的是A是否发生过改变。A集合发生改变返回Ture；

              G:把集合转数组(了解)

          Object[ ]  toArray( )： 把集合转换成数组。

       (5)Collection集合的遍历

              A:把集合转数组(了解)

  

   //创建对象；         Collection c = new ArrayList();                  //添加元素：        c.add("hello"); //Object obj = "hello";向上转型。        c.add( "world");        c.add("java");        //遍历        //Object[] toArray():把集合转成数组，可以实现集合的遍历。        Object[] objs= c.toArray();        for(int x =0; x<objs.length; x++){           //向下转型；       // System.out.println(objs[x]+"----"+objs[x].length);       // objs[x].length:  此方法实现不了。因为是oject类型。                      String s = (String) objs[x];           System.out.println(s+ s.length());                   }              }

              B:while和 for迭代器(集合专用方式)

    

//创建集合对象；     Collection  c = new ArrayList();         c.add("hello");     c.add("woeld");     c.add("java");         //Iterator itrator(); 迭代器，集合的专用遍历     Iterator  it = c.iterator(); //实际返回的肯定是子类对象，这里是多态。        while(it.hasNext()){       String s =(String) it.next();       System.out.println(it.next()); for(Iteratorit1 = c.iterator();it1.hasNext();){        String s = (String)  it1.next();        System.out.println(s);     }

       (6)迭代器

System.out.println((Student)it.next()).getName() +”----------“+(Student) it.next()).getAge());

  注意：此拿的是第一个学生的名字和第二个学生的年龄。

              A:是集合的获取元素的方式。

              B:是依赖于集合而存在的。

              C:迭代器的原理和源码。

                     a:为什么定义为了一个接口而不是实现类?

                     b:看了看迭代器的内部类实现。

       (7)Collection集合的案例(遍历方式迭代器)

              集合的操作步骤：

                     A:创建集合对象

                     B:创建元素对象

                     C:把元素添加到集合

                     D:遍历集合

              A:存储字符串并遍历

                    

 importjava.util.Collection;                     importjava.util.ArrayList;                     importjava.util.Iterator;                                         publicclass CollectionDemo {                            publicstatic void main(String[] args) {                                   //创建集合对象                                   Collectionc = new ArrayList();                                                                     //创建并添加元素                                   c.add("hello");                                   c.add("world");                                   c.add("java");                                                                     //遍历集合                                   Iteratorit = c.iterator();                                   while(it.hasNext()){                                          Strings =(String) it.next();                                          System.out.println(s);                                   }                            }                     }        

              B:存储自定义对象并遍历

                   

  publicclass Student {                            privateString name;                            privateint age;                                                       publicStudent(){}                                                       publicStudent(String name,int age) {                                   this.name= name;                                   this.age= age;                            }                                                       //getXxx()/setXxx()                     }                                         importjava.util.Collection;                     importjava.util.ArrayList;                     importjava.util.Iterator;                                         publicclass StudentDemo {                            publicstatic void main(String[] args) {                                   //创建集合对象                                   Collectionc = new ArrayList();                                                                     //创建学生对象                                   Students1 = new Student("林青霞",27);                                   Students2 = new Student("风清扬",30);                                   Students3 = new Student("刘意",30);                                   Students4 = new Student("武鑫",25);                                   Students5 = new Student("刘晓曲",16);                                                                     //添加元素                                   c.add(s1);                                   c.add(s2);                                   c.add(s3);                                   c.add(s4);                                   c.add(s5);                                                                     //遍历集合                                   Iteratorit = c.iterator();                                   while(it.hasNext()){                                          Students = (Student)it.next();                                          System.out.println(s.getName()+"---"+s.getAge());                                   }                            }                     }

 

3:集合(List)(掌握)

       (1)List是Collection的子接口

           特点：有序(存储顺序和取出顺序一致)，可重复

有序的Collection（也成为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

       (2)List的特有功能：(自己补齐)

              A:添加功能

              Void  add(int index,Object obj)：在指定位置添加元素。

              B:删除功能

              Object  remove(intindex)：根绝索引删除元素，返回被删除的元素。

              C:获取功能

                Object     get(int index) : 获取指定位置的元素

              D:迭代器功能

                     ListIteratorlistIterator()： List集合特有的迭代器。

              E:修改功能

               Object   set(intindex,Object obj) ：根据索引修改元素，返回被修改的元素。

       G：元素索引功能：

           Int  indexOf(Object o)：

           返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回—1；

       (3)List集合的特有遍历功能

              A:由size()和get()结合。

              B:代码演示

                           

        //创建集合对象                                   Listlist = new ArrayList();                                                                     //创建并添加元素                                   list.add("hello");                                   list.add("world");                                   list.add("java");                                                                     //遍历集合                                   Iteratorit = list.iterator();                                   while(it.hasNext()){                                          Strings =(String) it.next();                                          System.out.println(s);                                   }                                   System.out.println("----------");                                                                     for(intx=0; x<list.size(); x++) {                                          Strings =(String) list.get(x);                                          System.out.println(s);                                   }

       (4)列表迭代器的特有功能；

              可以逆向遍历，但是要先正向遍历，所以无意义，基本不使用。

          Object   previous():   获取上一个元素。

           Boolean  hasprevious（） 判断是否有元素。

       (5)并发修改异常

  /**    * @param args    *ConcurrentModificationException:当方法检测到对象的并发修改，但不允许这种修改时，抛出异常。    * 产生原因：    *     迭代器是依赖于集合而存在的，在判断成功后，集合的中新添加了元素，而迭代器却不知道，所以就报错了，这个错    *     叫并发修改异常。    *     其实这个问题描述的是：迭代器遍历元素的时候，通过集合是不能修改元素的。    * 图和解决？：    *     A: 迭代器迭代元素，迭代器修改元素    *            元素是跟在刚才迭代的元素后面的。    *     B: 集合遍历元素，集合修改元素（普通for）    *            元素在最后添加的。    */   public static void main(String[] args) {      // TODOAuto-generated method stub     //创建list 集合对象；      List list = new ArrayList();      //添加元素；      list.add("hello");      list.add("world");      list.add("java");           //迭代器的遍历：//    Iterator it = list.iterator();//    while(it.hasNext()){//      //       String s = (String) it.next();//       if("world".equals(s))//       {//          list.add("javaee");//       }//       //System.out.println("list"+list);//      //    }//    ////    方式1：迭代器迭代元素，迭代器修改元素。      //而iterator迭代器却没有添加功能，所以我们使用其子接口ListItetator      ListIterator  lit = list.listIterator();      while(lit.hasNext()){         String s = (String) lit.next();         if("world".equals(s)){          lit.add("javaee");         }                 }      //方式2: 集合遍历元素；      for(int x = 0; x<list.size(); x++){              String s = (String) list.get(x);               if("world".equals(s)){                  list.add("javaeee");               }          System.out.println("---------------");           }      System.out.println("list:"+ list);        }

              A:出现的现象

                     迭代器遍历集合，集合修改集合元素

              B:原因

                     迭代器是依赖于集合的，而集合的改变迭代器并不知道。

              C:解决方案

                     a:迭代器遍历，迭代器修改(ListIterator)

                            元素添加在刚才迭代的位置

                     b:集合遍历，集合修改(size()和get())

                            元素添加在集合的末尾

       (6)常见数据结构 

              A:栈 先进后出

              B:队列 先进先出

              C:数组 查询快，增删慢    存储同一种类型的多个元素的容器。有索引，方便我们的获取。    

              D:链表 查询慢，增删快

       (7)List的子类特点(面试题)

              ArrayList

                     底层数据结构是数组，查询快，增删慢。

                     线程不安全，效率高。

              Vector

                     底层数据结构是数组，查询快，增删慢。

                     线程安全，效率低。

              LinkedList

                     底层数据结构是链表，查询慢，增删快。

                     线程不安全，效率高。

                    

              到底使用谁呢?看需求?

              分析：

                     要安全吗?

                            要：Vector(即使要，也不使用这个，后面再说)

                            不要：ArrayList或者LinkedList

                                   查询多；ArrayList

                                   增删多：LinkedList

                                  

              什么都不知道，就用ArrayList。

ArraryList的使用：

1.ArrayList类概述:        

      底层数据结构是数组，查询快，增删慢；

     数据不安全，效率高。

2.ArrayList案例：

ArrayList遍历：

public class ArrayListDemo {    public static void main(String[] args) {        // 创建集合对象        ArrayList array = new ArrayList();         // 创建元素对象，并添加元素        array.add("hello");        array.add("world");        array.add("java");         // 遍历        Iterator it = array.iterator();        while (it.hasNext()) {            String s = (String) it.next();            System.out.println(s);        }         System.out.println("-----------");         for (int x = 0; x < array.size(); x++) {            String s = (String) array.get(x);            System.out.println(s);        }}

ArrayList存储自定义对象并遍历：

/* * ArrayList存储自定义对象并遍历 */public class ArrayListDemo2 {    public static void main(String[] args) {        // 创建集合对象        ArrayList array = new ArrayList();         // 创建学生对象        Student s1 = new Student("武松", 30);        Student s2 = new Student("鲁智深", 40);        Student s3 = new Student("林冲", 36);        Student s4 = new Student("杨志", 38);         // 添加元素        array.add(s1);        array.add(s2);        array.add(s3);        array.add(s4);         // 遍历        Iterator it = array.iterator();        while (it.hasNext()) {            Student s = (Student) it.next();            System.out.println(s.getName() + "---" + s.getAge());        }         System.out.println("----------------")

    for (int x = 0; x < array.size(); x++) {            // ClassCastException 注意，千万要搞清楚类型            // String s = (String) array.get(x);            // System.out.println(s);             Student s = (Student) array.get(x);            System.out.println(s.getName() + "---" + s.getAge());        }    }}

Vector集合使用：

Vector的特有功能：

1：添加功能：

    Public void addElement(Object obj)     --- add()

2:获取功能：

    Public Object  elementAt( int index)    --- get()        

    Public Enumeration elements()        ---Iterator()  iterator()

         Booleann   hasMoreElements()           hasNext()

             Object     nextElement()                next()

JDK升级的原因：

     A:安全

    B：效率

    C：简化书写

LinkedList的使用：

LinkedList的特有功能;

1.       添加功能：

Public voidaddFirst(Object e)

     Publicvoid addLast(Object e)

2.       获取功能：

Public ObjectgerFirst()

Public ObjectgetLast()

3.       删除功能;

     Public Object  removeFirst()  

      Public Object  RemoveLast()

List集合练习：

ArrayList

去除集合中字符串的重复值（字符串的内容相同）

/* * 去除集合中字符串的重复值（字符串的内容相同） * * 分析：1.创建结合对象 *     2.添加多个字符串元素（包含内容相同） *     3.创建新集合 *     4.遍历旧集合，获取得到每一个元素 *     5.拿这个元素到新集合去找，看有没有 *       有：不搭理它 *       没有:就添加到新集合。 *     6.遍历集合 **/public class ArrayListDemo {    public static void main(String[] args) {      // 创建集合对象       ArrayListarray = new ArrayList();       //添加多个字符串与元素       array.add("hello");       array.add("world");       array.add("java");       array.add("hello");       array.add("java");       array.add("simin");       array.add("4mouth");       //创建新的集合       ArrayListnewArray = new ArrayList();             // 4.遍历旧集合，获取得到每一个元素       Iteratorit = array.iterator();       while(it.hasNext()){          String  s = (String) it.next();          //拿到这个元素到新集合去找，看有没有；          if(!newArray.contains(s)){             newArray.add(s);          }       }       System.out.println(array);       //遍历集合：       for(int x=0; x<newArray.size(); x++){             String s=(String)    newArray.get(x);                  System.out.println(s);        }   } }

 

去除集合中字符串的重复值（字符串的内容相同）不创建新的集合

public class ArrayListDemo2 {  public static void main(String[] args) {      // 创建集合对象  ArrayListarray = new ArrayList();  //添加多个字符串与元素  array.add("hello");  array.add("world");  array.add("java");  array.add("hello");  array.add("java");  array.add("simin");  array.add("4mouth");  array.add("world");  array.add("world");  //   array.remove(2);  System.out.println(array);   //有选择排序的思想引入，我们可以通过这种思想做这个题目；  //拿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--;   //注意：有替位的的现象，有漏网之鱼，要y--；      }     }  }   //遍历结合  Iterator  it= array.iterator();  while(it.hasNext()){      Strings = (String) it.next();      System.out.println(s);  } }}

去除集合中自定义对象的重复值（对象的成员变量值都相同）

import java.util.ArrayList;import java.util.Iterator; /* * 需求：去除集合中自定义对象的重复值(对象的成员变量值都相同) * * 我们按照和字符串一样的操作，发现出问题了。 * 为什么呢? *          我们必须思考哪里会出问题? *          通过简单的分析，我们知道问题出现在了判断上。 *          而这个判断功能是集合自己提供的，所以我们如果想很清楚的知道它是如何判断的，就应该去看源码。 * contains()方法的底层依赖的是equals()方法。 * 而我们的学生类中没有equals()方法，这个时候，默认使用的是它父亲Object的equals()方法 * Object()的equals()默认比较的是地址值，所以，它们进去了。因为new的东西，地址值都不同。 * 按照我们自己的需求，比较成员变量的值，重写equals()即可。 * 自动生成即可。 */public class ArrayListDemo3 {       publicstatic void main(String[] args) {              //创建集合对象              ArrayListarray = new ArrayList();               //创建学生对象              Students1 = new Student("林青霞", 27);              Students2 = new Student("林志玲", 40);              Students3 = new Student("凤姐", 35);              Students4 = new Student("芙蓉姐姐", 18);              Students5 = new Student("翠花", 16);              Students6 = new Student("林青霞", 27);              Students7 = new Student("林青霞", 18);               //添加元素              array.add(s1);              array.add(s2);              array.add(s3);              array.add(s4);              array.add(s5);              array.add(s6);              array.add(s7);               //创建新集合              ArrayListnewArray = new ArrayList();               //遍历旧集合,获取得到每一个元素              Iteratorit = array.iterator();              while(it.hasNext()) {                     Students = (Student) it.next();                      //拿这个元素到新集合去找，看有没有                     if(!newArray.contains(s)) {                            newArray.add(s);                     }              }               //遍历新集合              for(int x = 0; x < newArray.size(); x++) {                     Students = (Student) newArray.get(x);                     System.out.println(s.getName()+ "---" + s.getAge());              }       }}

LinkedList实现栈结构的集合代码：

 /** * 自定义的栈集合 * * @author simi * @version  V1.0 * */public class MyStack {    private LinkedList link;       public MyStack(){       link = new LinkedList();    }    public void add(Object obj){       link.addFirst(obj);    }    public Object get(){       //return  link.getFirst();        return   link.getFirst();    }    public boolean isEmpty(){       return link.isEmpty();    }}

泛型概述：

 泛型简介和使用

 * ArrayList存储字符串并遍历； * * 我们按照正常的写法，结果错了， * 为什么了？ *  因为我们开始存储的时候，存储了String 和 Integer两种类型。 *   而在遍历的时候，我们把他们都当作string类型处理的，做了转换，所以就报错。 *   但是呢，在编译期间却没有告诉我们。 *  集合模仿数组的这种做法，在创建对象的时候明确元素的数据类型，这样就不会再有问题。 *  *  泛型：是一种把类型明确的工作 *  推迟到创建对象或者调用方法的时候才去明确的特殊类型。参数化类型，把类型当作参数一样的传递。 *  格式; *         <数据类型 >  *          此处的数据类型只能是引用类型； *   好处： *       a:把运行期间的问题提前到了编译期间； *       b：避免了强制类型转换 *       c:优化程序设计，解决了黄色警告线。 *                 */importjava.util.Iterator; public class GenericDemo {public static void main(String[] args) {   //看下面这个代码：    String[]  strArray = new String[3];    strArray[0] = "hello";    strArray[1] = "world";   // strArray[2] = 10;                     ArrayList<String>  array = new ArrayList<String>();     array.add("hello");   array.add("world");   array.add("java");   //array. add(new Integer(100));//// array.add(10);//报错，集合只能存储引用类型，但这是基本类型，jdk5 以后的自动装箱   //等价于： array.add(Integer.valueOf(10));   Iterator<String>    it = array.iterator();   while(it.hasNext()){      //ClassCastException;       String  s = it.next();                 System.out.println(s);   }      }

 * ArrayList存储字符串并遍历； * * 我们按照正常的写法，结果错了， * 为什么了？ *  因为我们开始存储的时候，存储了String 和 Integer两种类型。 *   而在遍历的时候，我们把他们都当作string类型处理的，做了转换，所以就报错。 *   但是呢，在编译期间却没有告诉我们。 *  集合模仿数组的这种做法，在创建对象的时候明确元素的数据类型，这样就不会再有问题。 *  *  泛型：是一种把类型明确的工作 *  推迟到创建对象或者调用方法的时候才去明确的特殊类型。参数化类型，把类型当作参数一样的传递。 *  格式; *         <数据类型 >  *          此处的数据类型只能是引用类型； *   好处： *       a:把运行期间的问题提前到了编译期间； *       b：避免了强制类型转换 *       c:优化程序设计，解决了黄色警告线。 *                 */importjava.util.Iterator; public class GenericDemo {public static void main(String[] args) {   //看下面这个代码：    String[]  strArray = new String[3];    strArray[0] = "hello";    strArray[1] = "world";   // strArray[2] = 10;       ArrayList<String>  array = new ArrayList<String>();     array.add("hello");   array.add("world");   array.add("java");   //array. add(new Integer(100));//// array.add(10);//报错，集合只能存储引用类型，但这是基本类型，jdk5 以后的自动装箱   //等价于： array.add(Integer.valueOf(10));   Iterator<String>    it = array.iterator();   while(it.hasNext()){      //ClassCastException;       String  s = it.next();                 System.out.println(s);   }  }

2.泛型在那些地方使用：

     看API，如果类，接口，抽象类后面跟的有< E> 就说要使用泛型。

   一般来说在集合中使用。

 

泛型提高

早期的时候，我们使用Object来代表任意类型。

向上转型是没有任何问题的，但是在向下转型的时候其实隐含了类型的转换的问题。

也就是说这样的程序其实并不是安全的。所以java在JDK5后引入了泛型，提高程序的安全性。

1.      泛型类：把泛型定义在类上

格式： public  class 类名<泛型类型1，……>

注意：泛型类型必须是引用类型

public class ObjecdtTool<T>{      private T  obj;    //public T getObj() {//    return obj;   //}   //   //public void setObj(T obj) {//    this.obj = obj;   //}   //          public void  show(T t){        System.out.println(t);   }

public class ObjecdtTool<T>{      private T  obj;    //public T getObj() {//    return obj;   //}   //   //public void setObj(T obj) {//    this.obj = obj;   //}   //          public void  show(T t){        System.out.println(t);   }

2.      泛型方法

把泛型定义在方法上

格式：

  Public <泛型类型> 返回类型  方法名（泛型类型）

public class ObjecdtTool{           public<T> void show(T t){        System.out.println(t);      }  }

public class ObjecdtTool{           public<T> void show(T t){        System.out.println(t);      }  }

3.      泛型接口

把泛型定义在接口上

格式：public  interface 接口名<泛型类型1……>

泛型明确的写的时候，前后必须一致。

泛型高级（通配符）

1.      泛型通配符<?>

任意类型，如果没有明确，那么就是Object以及任意的java类了

2.？extends E

 向下限定，E及其子类

3.？Super E

 向上限定，E及其父类

 

JDK5的新特性：自动拆装箱，泛型，增强for，静态导入，可变参数，枚举；

1.增强for;

增强for：for循环的一种

格式：

     For(元素数据类型变量； 数组或者Collection集合){

                 使用变量即可，该变量就是元素。}

好处：简化了编程；

坏处：增强for的目标不能为null；

    如何解决呢？对增强for的目标先进行不为null的判断，然后使用。

     增强for其实是用来替代迭代器的

  ConcurrentModificationException If(list != null){ List<String> list = null;      For(String s  :  list){ NullPointerException         System.out.println(s);} } /* * ArrayList存储字符串并遍历。要求加入泛型，并用for遍历。 * a：迭代器 * b:普通for * C：增强for * * */  public class ArrayListDemo {public static void main(String[] args) {   //创建结合独享   ArrayList<String>  array = new ArrayList<String>();   //创建并添加元素   array.add("2015");   array.add("2yue");   array.add("14");     //遍历集合   //迭代器：   Iterator<String> it = array.iterator();   while(it.hasNext()){      String s= it.next();      System.out.println(s);   }   //普通for循环   for( int x = 0; x<array.size(); x++){      String s = array.get(x);      System.out.println(s);   }   //增强for   for(String s : array){      System.out.println(s);   }       }}

2.   静态导入：

静态导入：

格式; import static 包名……类名.方法名；

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

静态导入的注意事项：

A:方法必须是静态的

B：如果有多个同名的静态方法，容易不知道使用谁？这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不用。

3.   可变参数：定义方法的时候不知道该定义多少个参数

格式：

      修饰符  返回值类型( 数据类型…  变量名){

             }

注意：

     这里的变量其实是一个数组

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

Arrays工具类中的一个方法：

public static <T> List<T> asList(T... a)

把数组转成集合；

注意事项;

     虽然可以把数组转成集合，但是集合的长度不能改变。

public class ArraysDemo {  public static void main(String[] args) {   //定义一个数字；     String[] strArray= {"hello","world", "java"};    // List<String> list =Arrays.asList(strArray);   List<String> list = Arrays.asList("hello","world");   //UnsupportedOperationException   list.add("javaee");   for(String s: list){      System.out.println(s);   }   }}

List集合练习：

集合的嵌套遍历：

/ 创建大集合       ArrayList<ArrayList<Student>>bigArrayList = new ArrayList<ArrayList<Student>>();// 把第三个班级存储到学生系统中bigArrayList.add(thirdArrayList);// 遍历集合for (ArrayList<Student> array :bigArrayList) {for(Student s : array) {     System.out.println(s.getName() + "---" + s.getAge()); 

获取10个1—20之间的随机数，要求不能重复

public class test {  public static void main(String[] args) {    //创建产生随机数的对象    Random r = new Random();     // 创建一个存储随机数的集合；    ArrayList<Integer>  array = new ArrayList<Integer>();     //定义一个统计变量，从0 开始。     int count = 0 ;     // 判断统计遍历是否小于10     while(count< 10){        //先产生一个随机数        int number = r.nextInt(20)+1;            //判断该随机数在集合中是否存在。          if(!array.contains(number)){                //如果不存在，统计变量++。             array.add(number);             count++;         }     }     //遍历集合     for(Integer i : array){       System.out.println(i);     }    }}

键盘录入多个数据，以0结束，要求在控制台输出这多个数据中的最大值。

public class test2 {     public static void main(String[] args) {      //创建键盘录入数据对象；       Scanner   sc = new Scanner(System.in);       //键盘录入多个数据，我们不知道多少个，所以用集合存储       ArrayList<Integer>  array = new ArrayList<Integer>();       //以0结束，只要录入的数据是0，我就不继续录入数据了。            while(true){           System.out.println("请输入数据：");           int number = sc.nextInt();           if( number!=0){              array.add(number);           }else{              break;           }        }        //把集合装成数组       // public <T> T[]toArray(T[] a)  //i与ii的地址值一样；        Integer[] i = new Integer[array.size()];        array.toArray(i);                //Integer[]  ii = array.toArray(i);        System.out.println(i);        //System.out.println(ii);        //对数组排序：        //public satic void sort(Object[] a)        Arrays.sort(i);        //获取该数组中的最大索引值        System.out.println("数组是："+arrayToString(i)+"最大值是："+i[i.length-1]);              }     public static String arrayToString(Integer[]  i){        StringBuilder sb =  new StringBuilder();        sb.append("[");        for(int x= 0; x<i.length; x++){           if(x==i.length-1){              sb.append(i[x]);           }else{              sb.append(i[x]).append(",");           }        }        sb.append("]");          return  sb.toString();               }    }