集合3

1:泛型(掌握)
(1)泛型概述
是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。
(2)格式：
<数据类型>
注意：该数据类型只能是引用类型。
(3)好处：
A:把运行时期的问题提前到了编译期间
B:避免了强制类型转换
C:优化了程序设计，解决了黄色警告线问题，让程序更安全
(4)泛型的前世今生
A:泛型的由来
Object类型作为任意类型的时候，在向下转型的时候，会隐含一个转型问题
B:泛型类
C:泛型方法
D:泛型接口
E:泛型高级通配符
?
? extends E
? super E
(5)我们在哪里使用呢?
一般是在集合中使用。

* * ArrayList存储字符串并遍历。要求加入泛型，并用增强for遍历。 * A:迭代器 * B:普通for * C:增强for */public class ArrayListDemo {    public static void main(String[] args) {        // 创建集合对象        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();            System.out.println(s);        }        System.out.println("------------------");        // 普通for        for (int x = 0; x < array.size(); x++) {            String s = array.get(x);            System.out.println(s);        }        System.out.println("------------------");        // 增强for        for (String s : array) {            System.out.println(s);        }    }}

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

/* * JDK5的新特性：自动拆装箱,泛型,增强for,静态导入,可变参数,枚举 *  * 增强for:是for循环的一种。 *  * 格式： *      for(元素数据类型 变量 : 数组或者Collection集合) { *          使用变量即可，该变量就是元素 *      } *    * 好处：简化了数组和集合的遍历。 *  * 弊端： 增强for的目标不能为null。 * 如何解决呢?对增强for的目标先进行不为null的判断，然后在使用。 */public class ForDemo {    public static void main(String[] args) {        // 定义一个int数组        int[] arr = { 1, 2, 3, 4, 5 };        for (int x = 0; x < arr.length; x++) {            System.out.println(arr[x]);        }        System.out.println("---------------");        // 增强for        for (int x : arr) {            System.out.println(x);        }        System.out.println("---------------");        // 定义一个字符串数组        String[] strArray = { "林青霞", "风清扬", "东方不败", "刘意" };        // 增强for        for (String s : strArray) {            System.out.println(s);        }        System.out.println("---------------");        // 定义一个集合        ArrayList<String> array = new ArrayList<String>();        array.add("hello");        array.add("world");        array.add("java");        // 增强for        for (String s : array) {            System.out.println(s);        }        System.out.println("---------------");        List<String> list = null;        // NullPointerException        // 这个s是我们从list里面获取出来的，在获取前，它肯定还好做一个判断        // 说白了，这就是迭代器的功能        if (list != null) {            for (String s : list) {                System.out.println(s);            }        }        // 增强for其实是用来替代迭代器的        //ConcurrentModificationException        // for (String s : array) {        // if ("world".equals(s)) {        // array.add("javaee");        // }        // }        // System.out.println("array:" + array);    }}

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

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

    注意：        A:该变量其实是一个数组名        B:如果一个方法有多个参数，并且有可变参数，可变参数必须在最后

/* * 可变参数：定义方法的时候不知道该定义多少个参数 * 格式： *      修饰符 返回值类型 方法名(数据类型…  变量名){ *  *      } *  *      注意： *          这里的变量其实是一个数组 *          如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个 */             public class ArgsDemo {    public static void main(String[] args) {        // 2个数据求和        int a = 10;        int b = 20;        int result = sum(a, b);        System.out.println("result:" + result);        // 3个数据的求和        int c = 30;        result = sum(a, b, c);        System.out.println("result:" + result);        // 4个数据的求和        int d = 30;        result = sum(a, b, c, d);        System.out.println("result:" + result);        // 需求：我要写一个求和的功能，到底是几个数据求和呢，我不太清楚，但是我知道在调用的时候我肯定就知道了        // 为了解决这个问题，Java就提供了一个东西：可变参数        result = sum(a, b, c, d, 40);        System.out.println("result:" + result);        result = sum(a, b, c, d, 40, 50);        System.out.println("result:" + result);    }    public static int sum(int... a) {        // System.out.println(a);        //return 0;        int s = 0;        for(int x : a){            s +=x;        }        return s;    }    // public static int sum(int a, int b, int c, int d) {    // return a + b + c + d;    // }    //    // public static int sum(int a, int b, int c) {    // return a + b + c;    // }    //    // public static int sum(int a, int b) {    // return a + b;    // }}

(3)Arrays工具类的一个方法    asList()把数组转成集合。    注意：这个集合的长度不能改变。

/* * 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);        }    }}

5:练习(掌握)
A:集合的嵌套遍历

/* * 集合的嵌套遍历 * 需求： *      我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。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());            }        }    }}

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

/* * 获取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(Integer i : array){            System.out.println(i);        }    }}

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

/* * 键盘录入多个数据，以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;            }        }        // 把集合转成数组        // public <T> T[] toArray(T[] a)        Integer[] i = new Integer[array.size()];        // Integer[] ii = array.toArray(i);        array.toArray(i);        // System.out.println(i);        // System.out.println(ii);        // 对数组排序        // 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();    }}

6:要掌握的代码
集合存储元素，加入泛型，并可以使用增强for遍历。