黑马程序员——Java基础---泛型、集合框架工具类：Collections和Arrays、JDK 1.5新特性

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

第一部分 泛型
泛型：广泛的类型。就是给对象指定数据类型的安全机制。泛型是JDK1.5 版本以后出现的新特性。用于解决数据的安全问题。是一个安全机制。

好处：

1、将运行时期出现问题 ClassCastException，转移到了编译时期。防便于程序员解决问题。让运行时问题减少，提高安全。

2、避免了强制转换的麻烦。

泛型格式：通过 <> 尖括号来定义要操作的引用数据类型。

泛型又可以细分为：

1、泛型集合

2、泛型类

3、泛型接口

4、高级泛型

一、泛型集合

在使用java提供的对象时，什么时候写泛型呢？通常在集合框架中很常见。只要见到<>就是定义泛型。其实<>就是用来接收数据类型的。当使用集合时，将集合中要存储的数据类型作为参数传递到<>尖括号中即可。

1）Demo：

    ArrayList<String> al = new ArrayList<String>();//加了“ <> ”。就表示泛型结构，为了定义容器的数据类型，减少出错。         al.add("java01");        al.add("java02");        al.add("java04");        al.add(2,"java03");        ListIterator<String> li = al.listIterator();        //指定迭代器的数据类型          while (li.hasNext()){            String str = li.next();//这时候就不需要强转了，避免了强制转换的麻烦            if(obj.equals("java02")){//              li.set("java002");//修改操作//              li.remove();//删除操作            }            System.out.println(str);//        }

二、泛型类，泛型方法和泛型接口

1) 什么时候定义泛型类？当类中需要操作的引用数据类型不确定的时候，早期定义 Object 来完成扩展，现在定义泛型来完成扩展。

2) 泛型类定义的泛型在整个类中有效。如果被方法使用，那么泛型类的对象要明确操作的具体类型后，所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。

3) 特殊之处：

静态不可以访问类上定义的泛型。

如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法中。

4) 定义泛型类：

1、可以定义泛型类：class DemoGe< T>

2、可以定义泛型方法：public < S> void show(S s)

3、可以同时定义泛型类和泛型方法。

5) Demo ：

package fuxi1;/** *  *@author XiaLei */public class Day15Test3 {    public static void main(String[] args) {    }}class FanXin<T>{//定义泛型类    public void show(T t){        System.out.println("show");    }    public void run(T t){        System.out.println("run");    }    /*     * 如果不定义泛型类，那么就需要在每一个方法后面传入具体参数，较为麻烦。例如     * public void show(String s){}     * public void run(String s){}     * 简化书写的同时，也出现了弊端，即泛型类一旦明确了类型，则所有的方法都要使用该类型。     */    public <W> void print(W w){//泛型类中也可以定义泛型方法。    }    public static <W> void speak(){//静态方法不可以访问类上定义的泛型，因为类上的泛型必须要通过创建对象后才能实现，而静态加载出现在对象之前。        //另外注意泛型放在返回值类型前面。    }}class FanXinDemo{    public <T> void show(T t){//为了避免泛型类的以上弊端，我们可以定义泛型方法。        System.out.println("show");    }    public <T> void run(T t){        System.out.println("run");    }}

三、高级泛型
当传入的类型不确定时，可以使用通配符？。也可以理解为占位符。使用通配符的好处是可以不用明确传入的类型，这样在使用泛型类或者泛型方法时，提高了扩展性。

Demo:

package fuxi1;import java.util.Comparator;import java.util.Iterator;import java.util.TreeSet;/** * 泛型限定：用于泛型拓展。 * ？ 通配符，也可以理解为占位符。 * ？extends E:可以接受E或者E的子类。上限。 * ？super E：可以接受E或者E的父类。下限。 *@author XiaLei */public class Day15Test4 {    public static void main(String[] args) {        TreeSet<Student> ts = new TreeSet<Student>(new MyLock());        ts.add(new Student("java01"));        ts.add(new Student("java08"));        ts.add(new Student("java00"));        ts.add(new Student("java05"));        TreeSet<GoodStudent> ts1 = new TreeSet<GoodStudent>(new MyLock());        ts1.add(new GoodStudent("java--01"));        ts1.add(new GoodStudent("java--08"));        ts1.add(new GoodStudent("java--00"));        ts1.add(new GoodStudent("java--05"));//      for(Iterator<Student> it = ts.iterator();it.hasNext();){//          System.out.println(it.next().getName());//      }//      for(Iterator<GoodStudent> it = ts1.iterator();it.hasNext();){//书写很麻烦//          System.out.println(it.next().getName());//      }        print(ts);        print(ts1);//定义一个打印方法    }    public static void print(TreeSet<? extends Student> ts){//利用泛型限定简化了书写，利于程序后期扩展。        for(Iterator<? extends Student> it = ts.iterator();it.hasNext();){            System.out.println(it.next().getName());        }    }}class Student{    String name;    public Student(String name) {        super();        this.name = name;    }    public String getName(){        return name;    }}class GoodStudent extends Student{    public GoodStudent(String name) {        super(name);    }    public String getName(){        return name;    }}class MyLock implements Comparator<Student>{//<? super >    public int compare(Student s1,Student s2){        return s1.getName().compareTo(s2.getName());    }}

第二部分 Collections和Arrays

一、Collections

1）常用方法：

1、sort 方法：给 list 集合排序，用 sort 方法。

2、max 方法：取 list 集合中的最大值。用 max 方法。

demo:

package fuxi1;import java.util.ArrayList;import java.util.Collections;import java.util.Comparator;import java.util.List;/** * 集合框架工具类 * 需求：利用Collections工具类给List集合排序，以及求最大值等等。 * 思路：Collections的sort方法就是专门给List集合排序的，如果需要指定比较方法可以创建比较器。 * max方法则是给出最大值，同样也可以加比较器。 *@author XiaLei */public class Day17Test1 {    public static void main(String[] args) {        List<String> list = new ArrayList<String>();        list.add("fdsa");        list.add("fda");        list.add("s");        list.add("ss");        list.add("adfss");//      Collections.sort(list);//按照字符串自然顺序排序。//      System.out.println(list);        Collections.sort(list,new StrLenthCom());//创建比较器，按照字符串长度排序。        System.out.println(list);//      String max = Collections.max(list,new StrLenthCom());//创建比较器，按照字符串长度求最大值。//      System.out.println(max);        int index = Collections.binarySearch(list, "s",new StrLenthCom());//二分查找，如果元素不在则返回-（应插入位置角标）-1；        System.out.println(index);    }}class StrLenthCom implements Comparator<String>{    public int compare(String s1,String s2){        if(s1.length()>s2.length())            return 1;        if(s1.length()<s2.length())            return -1;        else            return s1.compareTo(s2);    }}

3、binarySearch：查询的字符串在集合中是否存在。返回 -1 ，表示不存在；返回 0 ，则存在。

4、fill ：将list集合所有元素替换成指定元素。

fill练习：

package fuxi1;import java.util.ArrayList;import java.util.Collections;import java.util.List;/** * 需求：利用集合框架工具类的fill方法给集合中部分元素替换成指定元素。 * 思路：利用List集合subList方法，查询集合部分元素并替换。 *@author XiaLei */public class Day17Test2 {    public static void main(String[] args) {        List<String> list = new ArrayList<String>();        list.add("fdsa");        list.add("fda");        list.add("s");        list.add("ss");        list.add("adfss");//      Collections.fill(list, "hah");//      System.out.println(list);        myFill(list,1,2);//改变部分元素。        System.out.println(list);        Collections.replaceAll(list, "s", "x");//替换        System.out.println(list);        Collections.reverse(list);//反转        System.out.println(list);    }    public static List<String> myFill(List<String> list,int start,int end){        List<String> list1 =list.subList(start, end);        Collections.fill(list1, "haha");         return list;    }}

打印结果：

5、reverseOrder :强行逆转比较器。
demo:

package fuxi1;import java.util.Collections;import java.util.Iterator;import java.util.TreeSet;/** *  *@author XiaLei */public class Day17Test3 {    public static void main(String[] args) {        TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenthCom()));//强行逆转比较器，可以实现自然排序的反转，也可以实现自定义比较器的反转。        //这种功能一定要记住~        ts.add("aaaa");        ts.add("bb");        ts.add("c");        ts.add("dxaio");        for (Iterator<String> it = ts.iterator(); it.hasNext();){            System.out.println(it.next());        }    }}/*之前定义过的比较器，拿来演示class StrLenthCom implements Comparator<String>{    public int compare(String s1,String s2){        if(s1.length()>s2.length())            return 1;        if(s1.length()<s2.length())            return -1;        else            return s1.compareTo(s2);    }}*/

6、shuffle ：随机排序。

7、swap ：交换位置。
demo:

package fuxi1;import java.util.ArrayList;import java.util.Collections;import java.util.List;/** *  *@author XiaLei */public class Day17Test4 {    public static void main(String[] args) {        List<String> list = new ArrayList<String>();        list.add("fdsa");        list.add("fda");        list.add("s");        list.add("ss");        list.add("adfss");        Collections.swap(list, 1, 4);//换位。        System.out.println(list);        Collections.shuffle(list);//随机排序。        System.out.println(list);    }}

二、Arrays

Arrays是用于操作数组的工具类。
1）将数组转换为集合
注意：
a、将数组转换成集合，不可使用集合的增删方法，因为数组的长度是固定的。如果进行增删操作，则会产生UnsupportedOperationException的编译异常。
b、如果数组中的元素都是对象，则变成集合时，数组中的元素就直接转为集合中的元素。
c、如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

好处：可以使用集合的思想和方法来操作数组中的元素。

2）集合变数组
指定类型的数组到底要定义多长呢？
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。
所以创建一个刚刚好的数组最优。

好处： 可以限定对元素的操作，不可以进行增删了。

第三部分 JDK 1.5的新特性

一、静态导入

1、当类名重名时。需要指定具体的包名

2、当方法重名时。指定具备所属的对象或者类。

二、方法的可变参数

1) 使用注意：可变参数，一定要定义在参数列表的后面。

2) 可变参数传递的使用方式：其实就是上一种数组的参数简写形式，不用每次都动手的建立数组对象，只要将操作的元素作为参数传递即可，隐式的将这些参数封装成了数组。

3) 可变参数的写法：public static void show2(String s,int…arr){}

三、高级 for 循环

1）格式：

for(数据类型 变量名：被遍历的集合(collection) 或者数组){

}

2）for 对集合的遍历，只能获取元素，但是不能对集合进行操作。迭代器除了对集合进行遍历，还能进行 remove 集合中元素的动作。如果是用 ListIterator，还可以在遍历过程中对集合进行增删改查的动作。

3）高级 for 循环的局限性：高级 for 有一个局限性，必须有被遍历的目标。

4）建议：在遍历数组的时候，还是希望使用传统的 for ，因为传统 for 可以定义脚标。高级for：只能对集合中的数据取出，不能做到修改集合中的元素，即使是赋值也没办法。

Demo:

package fuxi1;import java.util.Map;import java.util.Set;import java.util.TreeMap;/** * 演示高级for循环。 * 反思：事实上在写博客的时候，我已经是在复习了。高级for也已经用过很多次了，然而在前面的复习中，尤其是集合框架这章， * 用了很多的迭代器进行打印，完全忘了用高级for循环，这就说明了之前学习的不认真，希望自己能够更加努力！ *@author XiaLei */public class Day17Test5 {    public static void main(String[] args) {        TreeMap<Integer,String> tm = new TreeMap<Integer,String>();        tm.put(1, "java01");        tm.put(2, "java02");        tm.put(3, "java03");        tm.put(4, "java04");        //KaySet方式的高级for循环        Set<Integer> s = tm.keySet();        for(Integer i : s){            System.out.println(i+":"+tm.get(i));        }        //entrySet方式的高级for循环        for(Map.Entry<Integer,String> me : tm.entrySet()){            System.out.println(me.getKey()+"="+me.getValue());        }    }}

四、JDK 1.5 自动装箱与拆箱

1)Integer i = 5;//自动装箱new Integer(5);

2)i = i+2; //i进行自动拆箱，变成了 int 类型，再和 2 相加，再进行装箱赋值给 i 。

3)byte范围是-128~127之间，所以Integer m,n = 128;已经超出byte范围，所以虽然看似相同，其实他们指向了两个不同的 Integer 对象。

总结
本章知识比较零碎，很多内容容易忽视，比如Collections里的reverseOrder强行逆转比较器方法，这些内容方法都是非常实用的方法，掌握它们有时候会让代码精简很多。所以任何的知识点都要引起重视，一次记不住争取第二次就能记住。