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

最新推荐文章于 2020-05-29 16:47:33 发布

Cathy_ndi杯中有羽￥雨

最新推荐文章于 2020-05-29 16:47:33 发布

阅读量666

点赞数

本文链接：https://blog.csdn.net/Cathy_ndi/article/details/47438977

版权

(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();          
     }    
}