黑马程序员——Java基础---泛型、集合框架工具类：collections和Arrays

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

一、泛型

JDK1.5版本以后出现的新特性，用于解决安全问题,是一个类型安全机制。
(1) 好处：
<1>将运行时期出现的问题ClassCastException，转移到了编译时期，
            方便于程序员解决问题，让运行时期问题减少，安全。

<2>避免了强制转换。
(2) 泛型格式：通过<>来定义要操作的引用数据类型。
(3) 在使用java提供的对象时，什么时候写泛型呢？
        通常在集合框架中常见，只要见到<>就要定义泛型。
               其实<>就是用来接收类型的。
               当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

import java.util.*;class GenericDemo{public static void main(String [] args){ArrayList<String> al = new ArrayList<String>();al.add("abc01");al.add("abc0991");al.add("abc014");//al.add(4);Iterator<String> it = al.iterator();while(it.hasNext()){String s =it.next();System.out.println(s+":"+s.length());}}}

泛型练习

import java.util.*;class GenericDemo2{public static void main(String [] args){TreeSet<String> ts = new TreeSet<String>();ts.add("abcd");ts.add("cc");ts.add("cba");ts.add("aaa");ts.add("z");ts.add("hahaha");Iterator<String> it =ts.iterator();while(it.hasNext()){String s =it.next();System.out.println(s);}}}class LengthComparator implements Comparator<String>{public int compare(String o1,String o2){int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));if(num==0)return o1.compareTo(o2);return num;}}

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

import java.util.*;class Worker{}class Student{}//泛型前做法。class Tool{private Object obj;public void setWorker(Object obj){this.w = w;}public Object getObject(){ return obj;}}

JDK1.5泛型出现后，用泛型的做法.
泛型类

class Utils<QQ>{private QQ q;public void setObject(QQ q){this.q = q;}public QQ getObject(){return q;}}class GenericDemo3{public static void main(String [] args){/*Tool t = new Tool();t.setObject(new Worker());Worker w =(Worker)t.getObject();*/Utils<Worker> u = new Utils<Worker>();u.setObject(new Worker);Worker w = u.getObject();}

泛型可以让程序员避免强制转换的麻烦，并且把运行时强转问题转化到了编译时期。 

集合框架(泛型方法)泛型类定义的泛型，在整个类中有效，如果被方法是用到泛型，类的对象明确。

操作的具体类型后，所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型，

而且类型还不确定，那么可以将泛型定义在方法上，而不定义在类上。 

public <T> void show(T t){}

//类型已经确定.class GenericTest<T>{public void show(T t){ sop("show:"+t); } public void print(T t){ sop("print:"+t); } public static void sop(Objectobj){ System.out.println(obj); } }//类型不确定，使用泛型方法class GenericTest2{//泛型方法 public <Q>void show(Q q){ sop("show_2:"+q); } public <Q> void print(Q q){ sop("print_2:"+q); } public static void sop(Object obj){ System.out.println(obj); } }public class Test{public static void main(String args[]){ //泛型确定 GenericTest<String> d = new GenericTest<String>(); d.show("黑马程序员"); d.print("csdn社区"); //泛型不确定 GenericTest2 d2 = new GenericDemo_2(); d2.show("黑马程序员"); d2.print(new Integer(4)); d2.print(4); } public static void sop(Objectobj){ System.out.println(obj); } }

泛型定义在方法上

import java.util.*;class Demo{public <T> void show(T t){System.out.println("show:"+t);}public <Q> void print(Q q){System.out.println("print:"+q);}}class GenericDemo5{public static void main(String [] args){Demo d = new Demo();d.show("haha");d.show(new Integer(4));d.print("hehe");}}

泛型定义在接口上

import java.util.*;interface Inter<T>{void show(T t);}class InterImpl implements Inter<String>{public void show(String t){System.out.println("Show:"+t);}}class InterIm implements Inter<T>{public void show(T t){System.out.println("Show:"+t);}}class GenericDemo7{public static void main(String [] args){InterImpl i = new InterImpl();i.show("haha");InterIm<Integer> im = new InterIm<Integer>();i.show(4);}}

泛型高级应用

import java.util.*;class GenericDemo8{public static void main(String [] args){ArrayList<String> al = new ArrayList<String>();al.add("abc1");al.add("abc2");al.add("abc3");ArrayList<Integer> al1 = new ArrayList<Integer>();al1.add(4);al1.add(7);al1.add(1);printColl(al);printColl(al1);}public static void printColl(ArrayList<?> al){Iterator<?> it = al.iterator();while(it.hasNext());{System.out.println(it.next());}}}

(5) 集合框架(静态方法泛型) 
        泛型类中也可以定义泛型方法
特殊之处：静态方法不可以访问类上定义的泛型，因为只有在实例化的时候，才会使用泛型 
如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。 
<T> 泛型写在返回值前。

集合框架(泛型接口)

interface Inter<T>{void show(T t); }class InterImpl implements Inter<String>{void show(Stringt)//这里只能是 String{} } class InterImpl2<T> implements Inter<T>{void show(T t);//这里类型不固定{} } 

(6) 集合框架(泛型通配符)

import java.util.ArrayList; import java.util.List; import java.util.Iterator; public class Test{public static voidmain(String args[]){ List<String> al = new ArrayList<String>(); al.add("黑马程序员"); al.add("CSDN社区"); al.add("黑马程序员论坛"); List<Integer> al1 = newArrayList<Integer>(); al1.add(1); al1.add(2); al1.add(3); printCollection(al); printCollection(al1); } public static void printCollection(List<?> al){ for(Iterator<?> it = al.iterator();it.hasNext();){ System.out.println(it.next()); } } }

(7)集合框架(泛型限定(上限))
? 通配符
? extends E:可以接收 E 类型或者 E 的子类型。上限。
? super E：可以接收E类型或者E的父类型，下限

import java.util.*;class GenericDemo8{public static void main(String [] args){ArrayList<Person> al = new ArrayList<Person>();al.add(new Person("abc1"));al.add(new Person("abc2"));al.add(new Person("abc3"));ArrayList<Student> al1 = new ArrayList<Student>();al1.add(new Student("abc-1"));al1.add(new Student("abc-2"));al1.add(new Student("abc-3"));printColl(al1);//错误：ArrayList<Person> al = new arrayList<Student>();}public static void printColl(ArrayList<? extends Person> al){Iterator<? extends Person> it = al.iterator();while(it.hasNext());{System.out.println(it.next().getName());}}}class Person{private String name;person(String name){this.name = name;}public  String getName(){return name;}}class Student extends Person{Student(String name){super();}}

练习
? super E  可以接收E类型或者E的父类型，下限

import java.util.*;class GenericDemo9{public static void main(String [] args){TreeSet<Student> ts = new TreeSet<Student>(new Comp());ts.add(new Student("abc03"));ts.add(new Student("abc02"));ts.add(new Student("abc06"));ts.add(new Student("abc01"));Iterator<Student> it = ts.iterator();while(it.hasNext());{System.out.println(it.next().getName());}TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());ts1.add(new Worker("wabc---03"));ts1.add(new Worker("wabc---02"));ts1.add(new Worker("wabc---06"));ts1.add(new Worker("wabc---01"));Iterator<Worker> it1 = ts1.iterator();while(it1.hasNext());{System.out.println(it1.next().getName());}}}class Comp implements Comparator<person>{public int compare(person s1,Person s2){return s1.getName().compareTo(s2.getName());}}class Person{private String name;person(String name){this.name = name;}public  String getName(){return name;}public String toString(){return "Person:"+name;}}class Student extends Person{Student(String name){super();}}class Worker extends{Worker(String name){super();}}

使用泛型的实质：
是么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候， 
早期定义的Object来完成扩展。现在定义泛型类来完成扩展 
泛型类定义的泛型，在整个类中有效。如果被方法使用， 
那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
为了让相同方法可以操作不同类型，而且类型还不确定。
那么可以将泛型定义在方法上。 
特殊之处：
静态方法不可以访问类上定义的泛型。因为只有在实例化的时候，才会使用泛型。 
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。 
? 通配符。也可以理解为占位符。
泛型的限定：
？extends E: 可以接收E类型或者E的子类型。上限。 
？ super    E: 可以接收E类型或者E的父类型。下限 

二、集合框架的工具类 Collections

(1) 概述

Collections:集合框架的工具类。里面定义的都是静态方法。

（相信Java的新手们都知道，如果一个类全都是静态方法的话，

  那么这个类肯定不能创建对象，也不需要给你提供对象的获取方法，因为静态都是优先于对象存在的） 
(2) Collections和Collection有什么区别？
Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。 
它有两个常用的子接口， 
List：对元素都有定义索引。有序的。可以重复元素。 
Set：不可以重复元素。无序。 
Collections是集合框架中的一个工具类。该类中的方法都是静态的。
提供的方法中有可以对List集合进行排序，二分查找等方法。
通常常用的集合都是线程不安全的。因为要提高效率。
如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。

     
              
              

                      

<span style="font-size:18px;">import java.util.*;class CollectionsDemo{public static void main(String [] args){sortDemo();maxDemo();binarySearchDemo();}public static void binarySearchDemo(){List<String> list = new ArrayList<String>(); list.add("abcd");list.add("aaa");list.add("z");list.add("kkkkk");list.add("qq");Collections.sort(list);sop(list);//int index =halfSearch(list,"aaa");int index = Collections.binarySearch(list,"aaa");sop("index="+index);}public static int halfSearch(List<String> list,String key){int max,min,mid;max = list.size()-1;min = 0;while(min<=max){mid = (max+min)>>1;//  /2;String str = list.get(mid);int num =str.compareTo(key);if(num>0)max = mid-1;else if(num<0)min = mid +1;elsereturn mid;}return -min-1;}//比较器public static int halfSearch2(List<String> list,String key,Comparator<String> cmp){int max,min,mid;max = list.size()-1;min = 0;while(min<=max){mid = (max+min)>>1;//  /2;String str = list.get(mid);int num =cmp.compare(str,key);if(num>0)max = mid-1;else if(num<0)min = mid +1;elsereturn mid;}return -min-1;}public static void maxDemo(){List<String> list = new ArrayList<String>(); list.add("abcd");list.add("aaa");list.add("z");list.add("kkkkk");list.add("qq");Collections.sort(list);sop(list);String max = Collections.max(list/*,new StringComparator()*/);sop("max="+max);}public static void sortDemo(){List<String> list = new ArrayList<String>(); list.add("abcd");list.add("aaa");list.add("z");list.add("kkkkk");list.add("qq");sop(list);Collections.sort(list);Collections.sort(list,new StrLenComparator());sop(list);}public static void sop(Object obj){System.out.println(obj);}}class StrLenComparator implements Comparator<String>{public int compare(String s1,String s2){if(s1.length()>s2.length())return 1;if(s1.length()>s2.length())return -1;return s1.compareTo(s2);}}</span>

fill方法：
    可以将list集合中所有元素替换成指定元素。

<span style="font-size:18px;">import java.util.*;class CollectionsDemo2{public static void main(String [] args){fillDemo();    }public static void fillDemo(){List<String> list = new ArrayList<String>(); list.add("abcd");list.add("aaa");list.add("z");list.add("kkkkk");list.add("qq");sop(list);Collections.fill(list,"pp");sop(list);}}/*replaceAll(list,oldvalue,newvalue)reverse(0*/import java.util.*;class CollectionsDemo3{public static void main(String [] args){replaceAllDemo();    }public static void replaceAllDemo(){List<String> list = new ArrayList<String>(); list.add("abcd");list.add("aaa");list.add("z");list.add("kkkkk");list.add("qq");sop(list);Collections.replaceAll(list,"aaa","bbb");sop(list);Collections.reverse(list);sop(list);}}</span>

练习

import java.util.*;class StrComparator implements Comparator<String>{public int compare(String s1,String s2){/*int num = s1.compareTo(s2);if(num>0)   return -1;if(num<0)   return 1;return num*/return s2.compareTo(s1);}}class CollectionsDemo4{public static void main(String [] args){orderDemo();    }public static void orderDemo(){TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder()); ts.add("abcd");ts.add("aaa");ts.add("z");ts.add("kkkkk");ts.add("qq");Iterator it = ts.iterator();while(it.hasNext()){System.out.println(it.next());}}}

三、集合框架的工具类Arrays

Arrays:用于操作数组的工具类。里面都是静态方法。

        

asList:将数组变成list集合。

import java.util.*;class ArraysDemo{public static void main(String [] args){//int [] arr ={2,4,5};//sop(Arrays.toString(arr));String [] arr ={"abh","nkj","hhh"};/*把数组变成list集合的好处  可以使用集合的思想和方法来操作数组中的元素。  注意：将数组变成集合，不可以使用集合的增删方法，  因为数组的长度是固定的。  可以用的方法有:  contains  get  indexOf();  subList();  如果增删，那么就会发生UnsupportedOperationException*/List<String> list = Arrays.asList(arr);sop(list);/*如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的一个元素存在。*/int [] nums ={2,4,5};List<int []> li = Arrays.asList(nums);sop(li);//打印结果是数组的地址}public static void sop(Object obj){System.out.println(obj);}}

集合变数组
Collection接口中的toArray方法。

import java.util.*;class ArraysDemo{public static void main(String [] args){ArrayList<String> al = new ArrayList<String>();al.add("abc1");al.add("abc2");al.add("abc3");/*1,指定类型的数组定义多长  当指定类型的数组长度小于了集合的size，  那么该方法内部会创建一个新的数组，长度为集合的size。  当指定类型的数组长度大于了集合的size，就不会创建新的数组，  而是使用传递进来的数组，所以创建一个刚刚好的数组最优。2,为什么要将集合变数组？是为了限定对元素的操作，不需要进行增删。*/String [] arr = al.toArray(new String [al.size()]);sop(Arrays.toString(arr));}public static void sop(Object obj){System.out.println(obj);}}

四、高级for循环
(1) 格式：
for（数据类型 变量名：被遍历的集合(Collection)或者数组）
{}
对集合进行遍历，只能获取元素，但是不能对集合进行操作；
迭代器除了遍历还可以进行remove集合中元素的动作。
如果使用ListIterator，还可以在遍历过程中进行增删改查动作。
(2) 传统for循环和高级for循环的区别：
高级for有个局限性：必须有被遍历的目标。
建议在遍历数组时候，使用传统for，因为传统for可以定义角标。

import java.util.*;class ForEachsDemo{public static void main(String [] args){ArrayList<String> al = new ArrayList<String>();al.add("abc1");al.add("abc2");al.add("abc3");for(String s: al){sop(s);}/*Iterator<String> it = al.iterator();while(it.hasNext()){sop(it.next());}*/int [] arr = {3,5,2,4};for(int i: arr){sop("i:"+i);}HashMap<Integer,String> hm = new HashMap<Integer,String>();hm.put(1,"a");hm.put(2,"b");hm.put(3,"c");Set<Integer> keySet = hm.keySet();for(Integer i : keySet){sop(i+"::"+hm.get(i));}//Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();//for(Map.Entry<Integer,String> me : entrySet)for(Map.Entry<Integer,String> me : hm.entrySet()){sop(me.getKey()+"_____"+me.getValue());}}public static void sop(Object obj){System.out.println(obj);}}

JDK1.5版本出现的新特性。
方法的可变参数
在使用时注意：可变参数一定要定义在参数列表的最后面。

import java.util.*;class NewDemo{public static void main(String [] args){//可变参数。不用每一次都手动的建立数组对象，只要将要操作的元素作为参数传递即可，隐式将这些参数封装成了数组}public static void show(int... arr){System.out.println(arr);}}

 JDK1.5版本出现的新特性。

 Import Static静态导入

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

当方法重名时，需要指定具备所属的对象或者类

import java.util.*;import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。class StaticImport{public static void main(String [] args){int [] arr ={3,1,5};sort(arr);int index = binarySearch(arr,1);System.out.println("Index="+index);System.out.println(Arrays.toString(arr));}}