Java基础学习笔记16——（List的子类，泛型类，增强for循环，静态导入，可变参数）

1：list的子类（掌握）

(1)List的子类特点
    ArrayList:
        底层数据结构是数组，查询快，增删慢
        线程不安全，效率高
    Vector:
        底层数据结构是数组，查询快，增删慢
        线程安全，效率低
    LinkedList:
        底层数据结构是链表，查询慢，增删快
        线程不安全，效率高
(2)ArrayList    
    A:没有特有功能需要学习
    B:案例

a：ArrayList存储字符串并遍历

package cn.itcast_01;
import java.util.ArrayList;
import java.util.Iterator;

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方法遍历
        for(int x = 0; x < array.size(); x++) {
            String s = (String)array.get(x);
            System.out.println(s);
        }
    }
}

b:ArrayList存储自定义对象并遍历

// 对象类
package cn.itcast_01;

public class Student {
    private String name;
    private int age;
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(String name, int age) {
        super();
        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 cn.itcast_01;
import java.util.ArrayList;
import java.util.Iterator;
/*
 * 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 ++) {
            Student s = (Student) array.get(x);
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}

(3)Vector
    A:有特有功能
        a:添加    
            public void addElement(E obj)  -- add()
        b:获取
            public E elementAt(int index)  -- get()
            public Enumeration<E> elements()  -- iterator()
    B:案例

a:Vector存储字符串并遍历

package cn.itcast_02;
import java.util.Enumeration;
import java.util.Vector;
/*
 * Vector的特有功能：
 * 1：添加功能
 *      public void addElement(Object obj)     -- add()
 * 2:获取功能
 *      public Object elementAt(int index)     -- get()
 *      public Enumeration elements()          -- Iterator iterator()
 *              boolean hasMoreElements()                hasNext()
 *              Object nextElement()                     next()
 * 
 * JDK升级的原因：
 *      A：安全
 *      B：效率
 *      C：简化书写
 */
public class VectorDemo {
    public static void main(String[] args) {
        // 创建集合对象
        Vector v = new Vector();
        // 添加功能
        v.addElement("hello");
        v.addElement("world");
        v.addElement("java");
        // 遍历
        for (int x = 0; x < v.size(); x++) {
            String s = (String) v.elementAt(x);
            System.out.println(s);
        }
        System.out.println("----------------");
        Enumeration en = v.elements();  // 返回的是实现类的对象  -- Iterator it = v.iterator();
        while(en.hasMoreElements()) {
            String s = (String) en.nextElement();
            System.out.println(s);
        }
    }
}

b:Vector存储自定义对象并遍历

不展开

(4)LinkedList
    A:有特有功能
        a:添加
            addFirst()
            addLast()
        b:删除
            removeFirst()
            removeLast()
        c:获取
            getFirst()
            getLast()
    B:案例

a:LinkedList存储字符串并遍历

package cn.itcast_03;
import java.util.LinkedList;
/*
 * LinkedList的特有功能：
 *      A：添加功能
 *          public void addFirst(Object e)
 *          public void addLast(Object e)
 *      B：获取功能
 *          public Object getFirst()
 *          public Object getLast()
 *      C：删除功能
 *          public Object removeFirst()
 *          public Object removeLast()
 */
public class LinkedListDemo {
    public static void main(String[] args) {
        // 创建集合对象
        LinkedList link = new LinkedList();
        // 添加元素
        link.add("hello");
        link.add("world");
        link.add("java");   
        // public void addFirst(Object e)
        link.addFirst("javaee");
        // public void addLast(Object e)
        link.addLast("android");
        // public Object getFirst()
        System.out.println("getFirst:" + link.getFirst());
        // public Object getLast()
        System.out.println("getLast:" + link.getLast());
        // 输出对象名
        System.out.println("link:" + link);
        // public Object removeFirst()
        System.out.println("removeFirst:" + link.removeFirst());
        System.out.println("removeLast:" + link.removeLast());
        // 再次输出
        System.out.println("link:" + link);
    }
}

b:LinkedList存储自定义对象并遍历

此处不展开

 (5)案例：

A:去除集合中的多个字符串的重复元素，如果字符串的内容相同，即为重复元素

方式一：

package cn.itcast_04;
import java.util.ArrayList;
import java.util.Iterator;
/*
 * ArrayList去除集合中字符串的重复值（字符串的内容相同）
 * 
 * 分析：
 *      A：创建集合对象
 *      B：添加多个字符串元素（包含内容相同的）
 *      C：创建新集合
 *      D：遍历旧集合，获取得到每一个元素
 *      E：拿这个元素到新集合中去找，看有没有
 *          有：不搭理它
 *          没有：就添加到新集合
 *      F：遍历新集合
 */
public class ArrayListDemo {
    public static void main(String[] args) {
        // 创建集合对象
        ArrayList array = new ArrayList();  
        // 添加多个字符串元素（包含内容相同的）
        array.add("hello");
        array.add("world");
        array.add("java");
        array.add("world");
        array.add("world");
        array.add("world");
        array.add("world");
        array.add("java");
        // 创建新集合
        ArrayList newArray = new ArrayList();
        // 使用迭代器遍历旧集合，获取得到每一个元素
        Iterator it = array.iterator();
        while(it.hasNext()) {
            String s = (String)it.next();
            // 拿这个元素到新集合去找，使用l.contains()，看有没有
            if(!newArray.contains(s)) {
                newArray.add(s);
            }
        }
        // 遍历新集合
        for (int x = 0; x < newArray.size(); x++) {
            String s = (String)newArray.get(x);
            System.out.println(s);
        }
    }
}

方式二：

package cn.itcast_04;
import java.util.ArrayList;
import java.util.Iterator;
/*
 * 需求：ArrayList去除集合中字符串的重复值（字符串的内容相同）
 * 要求：不能创建新的集合，就在以前的集合上做
 */
public class ArrayListDemo2 {
    public static void main(String[] args) {
        // 创建集合对象
        ArrayList array = new ArrayList();
        // 添加多个字符串元素（包含内容相同的）
        array.add("hello");
        array.add("world");
        array.add("java");
        array.add("world");
        array.add("java");
        array.add("world");
        array.add("java");
        array.add("world");
        array.add("hello");
        array.add("hello");
        // 由选择排序思想引入，我们就可以通过这种思想做这个题目
        // 拿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);
        }
    }
}

B:去除集合中的多个自定义对象的重复元素，如果自定义对象的成员变量值都相同，即为重复元素

// 创建对象 
package cn.itcast_04;

public class Student {
    private String name;
    private int age;
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(String name, int age) {
        super();
        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  // 此处重写了equlas()方法,可通过Eclipse实现
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
}           
// 功能实现
package cn.itcast_04;
import java.util.ArrayList;
import java.util.Iterator;
/*
 * 需求：去除集合中自定义对象的重复值（对象的成员变量值都相同）
 * 
 * 我们按照和字符串一样的操作，发现出了问题。
 * 原因：
 *      首先思考哪里会出问题
 *      通过简单分析，我们知道问题出现在判断上
 *      而这个判断功能是集合自己提供的，所以我们如果想很清楚的知道它是如何判断的，就应该去看源码
 * contains()方法的底层依赖的是equals()方法
 * 而我们的学生类没有equals()方法，这个时候，默认使用的是它父亲Object的equals（）方法
 * Object（）的equals()默认比较的是地址值，所以，他们进去了。因为new的东西，地址值都不同。
 * 按照我们自己的需求，比较成员变量的值，需要重写equals（）即可。
 * 自己动手生成即可。
 */
public class ArrayListDemo3 {
    public static void main(String[] args) {
        // 创建集合对象
        ArrayList array = new ArrayList();
        // 创建学生对象
        Student s1 = new Student("林青霞",27);
        Student s2 = new Student("林志玲",40);
        Student s3 = new Student("凤姐",35);
        Student s4 = new Student("芙蓉姐姐",18);
        Student s5 = new Student("翠花",16);
        Student s6 = new Student("张雨绮",32);
        Student s7 = new Student("林青霞",27);
        // 添加学生类
        array.add(s1);
        array.add(s2);
        array.add(s3);
        array.add(s4);
        array.add(s5);
        array.add(s6);
        array.add(s7);
        // 创建新集合
        ArrayList newArray = new ArrayList();
        // 遍历旧集合，获取得到每一个元素
        Iterator it = array.iterator();
        while(it.hasNext()) {
            Student s = (Student) it.next();
            // 拿这个元素到新集合去找，看有没有
            // contains源码中使用的是equals方法，通过重写equals方法实现目的。
            if(!newArray.contains(s)) {
                newArray.add(s);
            }
        }
        // 遍历新集合
        for (int x = 0; x < newArray.size(); x++) {
            Student s = (Student) newArray.get(x);
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}

C:用LinkedList模拟一个栈数据结构的集合类，并测试。你要定义一个集合类，只不过内部可以使用LinkedList来实现。

package cn.itcast_05;
import java.util.Iterator;
import java.util.LinkedList;
/*
 * 请用LinkList模拟栈数据结构的集合，并测试
 * 题意：
 *      你自己定义一个集合类，在这个集合类内部可以使用LinkedList模拟
 */
public class LinkedListDemo {
    public static void main(String[] args) {
        // A:LinkedList的特有添加功能addFirst()
        // B:栈的特点先进后出
        // 创建集合对象
        LinkedList link = new LinkedList();
        // 添加元素
        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);
        }
    }
}   

2:泛型（掌握）

(1)泛型概述
    是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。
(2)格式
    <数据结构>
    注意：该数据类型只能是引用类型。
(3)好处：
    A:把运行时期的问题提前到了编译期间
    B:避免了强制类型转换
    C:优化了程序设计，解决了黄色警告线问题，让程序更安全
(4)泛型的前世今生

A:泛型的由来

        Object类型作为任意类型的时候，在向下转型的时候，会隐含一个转型问题

B:泛型类

package cn.itcast_04;
/*
 * 泛型类：把泛型定义在类上
 */
public class ObjectTool<T> {
    private T obj;
    public T getObj() {
        return obj;
    }
    public void setObj(T obj) {
        this.obj = obj;
    }
}   
package cn.itcast_04;
/*
 * 泛型类的测试
 */
public class ObjectToolDemo {
    public static void main(String[] args) {
        ObjectTool<String> ot = new ObjectTool<String>();
        // ot.setObj(new Integer(27));  // 这个时候编译就过不去
        ot.setObj(new String("林青霞"));
        String s = ot.getObj();
        System.out.println("姓名是：" + s);
        ObjectTool<Integer> ot2 = new ObjectTool<Integer>();
        // ot2.setObj(new String("风清扬"));  // 这个时候编译就过不去
        ot2.setObj(new Integer(27));
        Integer i = ot2.getObj();
        System.out.println("年龄是：" + i);
    }
}

C:泛型方法

package cn.itcast_05;
/*
 * 泛型方法：把泛型定义在方法上
 */
public class ObjectTool {
    public <T> void show(T t) {
        System.out.println(t);
    }
}
package cn.itcast_05;
public class ObjectToolDemo {
    public static void main(String[] args) {
        // 泛型类是没有问题的
        // 但是，我的方法不一定要和类的类型一致
        // 要是类上没有泛型的话，方法还能不能接受任意类型的参数呢？

        // 定义泛型方法后
        ObjectTool ot = new ObjectTool();
        ot.show("hello");
        ot.show(100);
        ot.show(true);
    }
}

D:泛型接口

package cn.itcast_06;
/*
 * 泛型接口：把泛型定义在接口上
 */
public interface Inter<T> {
    public abstract void show(T t);
}

package cn.itcast_06;
// 实现类在实现接口的时候
// 还不知道是什么类型
public class InterImpl<T> implements Inter<T> {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

package cn.itcast_06;
public class InterDemo {
    public static void main(String[] args) {
        // 测试
        Inter<String> i = new InterImpl<String>();
        i.show("hello");
        Inter<Integer> ii = new InterImpl<Integer>();
        ii.show(100);
    }
}

E:泛型高级通配符

    ？
    ？extends E
    ？super E

package cn.itcast_07;
import java.util.ArrayList;
import java.util.Collection;
/*
 * 泛型高级（通配符）
 * ？：任意类型，如果没有明确，那么就是Object以及任意的Java类
 * ？ extends E：向下限定，E及其子类
 * ？super E:向上限定，E及其父类
 */
public class GenericDemo {
    public static void main(String[] args) {
        // 泛型如果明确写的时候，前后必须一致
        Collection<Object> c1 = new ArrayList<Object>();
//      Collection<Object> c2 = new ArrayList<Animal>();
//      Collection<Object> c3 = new ArrayList<Dog>();
//      Collection<Object> c4 = new ArrayList<Cat>();   
        // ?表示任意的类型都是可以的
        Collection<?> c5 = new ArrayList<Object>();
        Collection<?> c6 = new ArrayList<Animal>();
        Collection<?> c7 = new ArrayList<Dog>();
        Collection<?> c8 = new ArrayList<Cat>();
        // ?extends E:向下限定，E及其子类
//      Collection<? extends Animal> c9 = new ArrayList<Object>();
        Collection<? extends Animal> c10 = new ArrayList<Animal>();
        Collection<? extends Animal> c11 = new ArrayList<Dog>();
        Collection<? extends Animal> c12 = new ArrayList<Cat>();
        // ? super E:向上限定,E极其父类
        Collection<? super Animal> c13 = new ArrayList<Object>();
//      Collection<? super Animal> c13 = new ArrayList<Animal>();
//      Collection<? super Animal> c13 = new ArrayList<Dog>();
//      Collection<? super Animal> c13 = new ArrayList<Cat>();
    }
}

class Animal {
}

class Dog extends Animal {
}

class Cat extends Animal {
}

(5)我们在哪里使用它
    一般是在集合中使用。

3：增强for循环（掌握）

(1)是for循环的一种
(2)格式：  
    for(元素的数据类型 变量名：数组或者Collection集合的对象){
        使用该变量即可，该变量其实就是数组或者集合中的元素。
    }
(3)好处：
    简化了数组和集合的遍历
(4)弊端
    增强for循环的目标不能为null。建议在使用前，先判断是否为null。

4：静态导入（了解）

(1)可以导入到方法级别的导入
(2)格式：
    import static 包名....类名.方法名;
(3)注意事项：
    A:方法必须是静态的
    B:如果多个类下有同名的方法，就不好区分了，还得加上前缀。
        所以一般我们并不使用静态导入，但是一定要能够看懂。

5：可变参数（掌握）

(1)如果我们在写方法时，参数个数不明确，就应该定义可变参数。
(2)格式：  
    修饰符 返回值类型 方法名(数据类型... 变量){}

    注意： 
        A:该变量其实是一个数组名
        B:如果一个方法有多个参数，并且有可变参数，可变参数必须在最后
(3)Arrays工具类的一个方法
    asList() 把数组转成集合。
    注意：这个集合的长度不能改变。

样例：

package cn.itcast_03;
import java.util.Arrays;
import java.util.List;
/*
 * 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","java");
        // UnsupportedOperationException
//      list.add("javaee");
        // UnsupportedOperationException
//      list.remove(1);
        list.set(1, "javaee");  // 可修改
        for (String s : list) {
            System.out.println(s);
        }
    }
}

输出：

hello
javaee
java

6:练习（掌握）

A：集合的嵌套遍历

// 创建对象类
package cn.itcast_01;
public class Student {
    private String name;
    private int age;
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(String name, int age) {
        super();
        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;
    }   
}
// 对象实现
package cn.itcast_01;
import java.util.ArrayList;
/*
 * 集合的嵌套遍历
 * 需求：
 *      我们班有学生，每个学生是不是一个对象，所有我们可以使用一个集合表示我们班级的学生。ArrayList<Student>
 *      但是，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList<Student>。
 *      而我现在有多个ArrayList<Student>。也要用集合存储，怎么办：
 *      就是用：ArrayList<ArrayList<Student>>
 */
public class ArrayListDemo {
    public static void main(String[] args) {
        // 创建大集合
        ArrayList<ArrayList<Student>> bigArrayList = new ArrayList<ArrayList<Student>>();
        // 创建第一个班级的学生集合
        ArrayList<Student> firstArrayList = new ArrayList<Student>();
        // 创建学生
        Student s1 = new Student("唐僧",30);
        Student s2 = new Student("悟空",29);
        Student s3 = new Student("八戒",28);
        Student s4 = new Student("沙僧",27);
        Student s5 = new Student("白龙马",26);
        // 学生进班
        firstArrayList.add(s1);
        firstArrayList.add(s2);
        firstArrayList.add(s3);
        firstArrayList.add(s4);
        firstArrayList.add(s5);
        // 把第一个班级存储到学生系统中
        bigArrayList.add(firstArrayList);
        // 创建第二个班级的学生集合
        ArrayList<Student> secondArrayList = new ArrayList<Student>();
        // 创建学生
        Student s11 = new Student("诸葛亮",30);
        Student s22 = new Student("司马懿",28);
        Student s33 = new Student("周瑜",26);
        // 学生进班
        secondArrayList.add(s11);
        secondArrayList.add(s22);
        secondArrayList.add(s33);
        // 把第二个班级存储到学生系统中
        bigArrayList.add(secondArrayList);
        // 创建第三个班级的学生集合
        ArrayList<Student> thirdArrayList = new ArrayList<Student>();
        // 创建学生
        Student s111 = new Student("宋江",40);
        Student s222 = new Student("吴用",35);
        Student s333 = new Student("高俅",30);
        Student s444 = new Student("李师师",22);
        // 学生进班
        thirdArrayList.add(s111);
        thirdArrayList.add(s222);
        thirdArrayList.add(s333);
        thirdArrayList.add(s444);
        // 把第三个班级存储到学生系统中
        bigArrayList.add(thirdArrayList);
        // 遍历集合
        for (ArrayList<Student> array : bigArrayList) {
            for (Student s : array) {
                System.out.println(s.getName() + "---" + s.getAge());
            }
        }   
    }
}

输出结果：

唐僧—30
悟空—29
八戒—28
沙僧—27
白龙马—26
诸葛亮—30
司马懿—28
周瑜—26
宋江—40
吴用—35
高俅—30
李师师—22

B:产生10个 1-20 之间的随机数，要求随机数不能重复

package cn.itcast_02;
import java.util.ArrayList;
import java.util.Random;
/*
 * 获取10个1-20之间的随机数，要求不能重复
 * 
 * 用数组实现,但是数组的长度是固定的，长度不好确定。
 * 所以我们使用集合实现。
 * 
 * 分析：
 *      A：创建产生随机数的对象
 *      B：创建一个存储随机数的集合
 *      C：定义一个统计变量。从0开始
 *      D：判断统计变量是否小于10
 *          是：先产生一个随机数，判断该随机数在集合中是否存在。
 *                      如果不存在：就添加，统计变量++。
 *                      如果存在：就不搭理它。
 *          否：不搭理它
 *      E:遍历集合
 */
public class RandomDemo {
    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
        for(Integer i : array) {
            System.out.println(i);
        }
    }
}

输出结果

16
13
14
17
2
3
9
1
12
18

C:键盘录入多个数据，以0结束，并在控制台输出最大值

package cn.itcast_03;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
/*
 * 键盘录入多个数据，以0结束，要求在控制台输出这多个数据中的最大值
 * 
 * 分析：
 *      A：创建键盘录入数据对象
 *      B：键盘录入多个数据，我们不知道多少个，所以用集合存储
 *      C：以0结束，只要键盘录入的数据是0，就不继续录入数据了
 *      D：把集合转成数组
 *      E：对数组排序
 *      F：获取该数组中的最大索引值
 */
public class ArrayListDemo {
    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;
            }
        }
        // 把集合转成数组
        Integer[] i = new Integer[array.size()];
        array.toArray(i);
        // 对数组排序
        // public static 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();
    }
}

输出结果：

请输入数据：
12
请输入数据：
13
请输入数据：
14
请输入数据：
0
数组是：[12,13,14] 最大值是：14

7:必须掌握的代码

集合存储元素，加入泛型，并可以使用增强for遍历。