java -- 泛型简单介绍

泛型
1.增强了代码的安全性
2.省去了强制转化的麻烦(向下转型)
泛型的好处:
在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。

/**
 * 创建两个集合  一个存Person 一个存Student类型
 * Person, Student各存两人 把Student元素全部添加到Person中  
 *      将子类元素添加到父类  向下限定 只允许是子类或者孙子类
 * 
 * 向上限定(? super E): 允许将父类中的元素添加到子类中
 */
public static void fun3() {
    ArrayList<Person> persons = new ArrayList<>();
    persons.add(new Person("科比", 19));
    persons.add(new Person("詹姆斯", 18));
    ArrayList<Students> students = new ArrayList<>();
    students.add(new Students("麦迪", 15));
    students.add(new Students("艾弗森", 16));

    persons.addAll(students);
    Iterator<Person> iterator = persons.iterator();
    while (iterator.hasNext()) {
        System.out.println(iterator.next());
    }
}

/**
 * 需求:集合中存了 3个对象 迭代器遍历
 * 菱形泛型  ---  后边的泛型可以不写 如果不写默认声明时泛型一致
 * 如果你前后泛型都写 必须保持一致
 */
public static void fun2() {
    ArrayList<Students> list = new ArrayList<>();
    list.add(new Students("科比",22));
    list.add(new Students("詹姆斯",25));
    list.add(new Students("伍兹",30));

    Iterator<Students> iterator = list.iterator();
    while (iterator.hasNext()){
        System.out.println(iterator.next());
    }
}

/**
 * 正向遍历及反向遍历
 */
public static void fun1() {
    ArrayList<String> list = new ArrayList<>();
    list.add("a");
    list.add("b");
    list.add("c");
    list.add("d");
    ListIterator<String> listIterator = list.listIterator();
    while (listIterator.hasNext()) {
        System.out.println(listIterator.next());
    }

    while (listIterator.hasPrevious()) {
        System.out.println(listIterator.previous());
    }
}

(int … num)的用法

/**
 * 参数(int ... num)  相当于传入的是一个数组
 * 如果有多个参数, 必须在int ... num 的前边定义
 */
public static void fun4() {
    int[] array = new int[] {1,2,3,44,5,6};
    print(4, array);
}
public static void print(int a,int ... num) {
    for (int i = 0; i < a; i++) {
        System.out.println(num[i]);
    }
}

Arrays中的asList方法用法

/**
 * Arrays中asList方法,将数组转换成数组
 * 在转换数组的时候,集合只保存对象的类型,而基本数据类型并不是一个对象类型
 * 所以要包装类定义数组,这样的数组就可以实用asList方法转换
 */
public static void fun5() {
    Integer[] array = new Integer[] {12,3,45,6};
    List<Integer> asList = Arrays.asList(array);
    System.out.println(asList);
}

集合中的删除方式

/**
 * 使用迭代器删除元素,  注意的是 next()只可以出现一次,要让迭代器删除 
 * 要添加的时候才用到List中特有的迭代器
 */
public static void fun7() {
    ArrayList<String> strings = new ArrayList<>();
    strings.add("a");
    strings.add("b");
    strings.add("c");
    strings.add("d");
    Iterator<String> iterator = strings.iterator();
    while (iterator.hasNext()) {
        String next = iterator.next();
        if (next.equals("b")) {
            iterator.remove();
        }

    }
    System.out.println(strings);
}

/**
 * 不使用迭代器遍历删除集合中的元素
 * ArrayList的底层实层实现是数组实现的,数组的添加和删除在内存中的表现
 * 数组在删除的之后,后面的元素会向向前移动一个位置
 * 在循环的时候,按照下标循环,再删除第一个的时候, 两个挨着的"b"就会在"i++"
 * 的时候错过,所以要用到"i--"
 */
public static void fun6() {
    ArrayList<String> strings = new ArrayList<>();
    strings.add("a");
    strings.add("b");
    strings.add("b");
    strings.add("c");
    strings.add("d");


    for (int i = 0; i < strings.size(); i++) {
        if (strings.get(i).equals("b")) {
            strings.remove(i--);
        }
    }
    System.out.println(strings);
}

按对象的属性排序 例如 学生类中的年龄(或姓名)排序

//按对象属性排序  学生类中的年龄(姓名)排序
/**
 * 用系统方法collections.sort 排序
 *  步骤  
 *      1.让集合中被排序对象的类 去实现comperable接口
 *      2.实现接口中抽象方法(排序是什么规则的方法)
 *      3.编写排序规则
 *      4.调用collections.sert测试 
 */
public static void fun10() {
    ArrayList<Students> students = new ArrayList<>();
    students.add(new Students("e", 17));
    students.add(new Students("b", 18));
    students.add(new Students("c", 16));
    students.add(new Students("f", 20));
    students.add(new Students("d", 50));
    students.add(new Students("a", 22));
    Collections.sort(students);
    System.out.println(students);
}
/**
 * 创建学生类集合 按姓名排序
 */
public static void fun9() {
    ArrayList<Students> students = new ArrayList<>();
    students.add(new Students("e", 17));
    students.add(new Students("b", 18));
    students.add(new Students("c", 16));
    students.add(new Students("f", 20));
    students.add(new Students("d", 50));
    students.add(new Students("a", 22));

    for (int i = 0; i < students.size(); i++) {
        for (int j = 0; j < students.size() - 1 - i; j++) {
            Students s1 = students.get(j);
            Students s2 = students.get(j + 1);
            if(s1.getName().compareTo(s2.getName()) > 0) {
                Collections.swap(students, j + 1, j);
        }
    }
}
System.out.println(students);
}

集合的嵌套

/**
 * 
 * 需求: 一个java学科 有两个班 每个班里有两个学生
 * 
 */
public static void fun11() {
    ArrayList<ArrayList<Students>> list = new ArrayList<>();

    ArrayList<Students> classs1 = new ArrayList<>();
    classs1.add(new Students("费舍尔", 18));
    classs1.add(new Students("科比", 19));
    ArrayList<Students> classs2 = new ArrayList<>();
    classs2.add(new Students("库里", 18));
    classs2.add(new Students("汤普森", 18));
    list.add(classs1);
    list.add(classs2);
    //System.out.print(list);
    //第一层循环把班级找出来
    for (ArrayList<Students> classs : list) {
        //第二层循环把学生找出来
        for (Students students : classs) {
            System.out.print(students);
        }
        System.out.println();
    }
}