【黑马】程序员————集合框架（二）泛型、Collections、Array

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

一、泛型<T>

泛型概述

JDK1.5新特性，是一种安全机制：

1.将运行时期出现的ClassCastException转移到了编译时期；

2.避免了强制转换.

泛型举例

public class Test6 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        
        TreeSet<String> ts = new TreeSet<String>();   //泛型限定集合的元素数据类型为字符串
        
        ts.add("alice");
        ts.add("john");
        ts.add("alicia");
        ts.add("vincent");
        
        for(Iterator<String>  it = ts.iterator();it.hasNext();) {  //迭代器泛型定义所要操作的数据类型
            
            
            System.out.println(it.next());
        }
        
    }

}


class MyComparator implements Comparator<String>  {  //比较器
    
    public int compare(String s1,String s2) {
        
        
        return s1.compareTo(s2);
    }
    
}

泛型类和泛型方法：

在泛型出现之前，我们不确定类所要操作的数据类型时，会定义Object这个公共的父类作为成员变量，而具体应用的时候，需要把这个父类对象

进行类型提升，如Person p1 = (Person)obj;泛型类的出现简化了这种情况。示例如下：

泛型类class Fanfan<T>定义以后，Fanfan<String>对象指定数据类型后，该类只能操作String类型数据

举例：

class Animal<T> {
    
    private T t;
    

    public T getT() {
        return t;
    }
    
    public  void show1(T t) {  //泛型类中方法，只能操作类明确的数据
        System.out.println(t);
    }
    
    public <T> void show2(T t) { //泛型方法，不确定
        System.out.println(t);
    }
    
}

静态泛型方法:静态泛型方法无法访问类明确的操作数据类型。

泛型限定

        对于一个范围内的一类事物，可以通过泛型限定的方式定义，有两种方式：

        1）? extends E：可接收E类型或E类型的子类型；称之为上限。

        如：ArrayList<? extends Number>x = new ArrayList<Integer>();

        2）? super E：可接收E类型或E类型的父类型；称之为下限。

        如：ArrayList<? super Integer>x = new ArrayList<Number>();

 

Treeset(Comparater<? super E>)

 TreeSet<Student> ts = new TreeSet<Student>(new Mycomp());

 class Mycomp implements Comparator<Person> {  //student继承Person

 

}

二、集合框架工具类Collections

Collections是java.util包中的一个工具类，其方法均为静态方法，常用于操作集合（List）,

常见方法

max(Collection<? extends T> coll);//根据集合的自然顺序，获取coll集合中的最大元素

max(Collection<? extends T> coll,Comparator<? super T> comp);//根据指定比较器comp的顺序，获取coll集合中的最大元素

binarySearch(Lsit<? extends Comparable<? super T>> list,Tkey);//二分法搜索list集合中的指定对象

fill(List<? super T> list, T obj);//将list集合中的全部元素替换成指定对象obj

replaceAll(List<T> lsit,T oldVal,T newVal);//用newVal替换集合中的oldVal值

swap(Listlist,int i,int j);/在指定列表的指定位置处交换元素

 

shuffle(List<?> list);//使用默认随机源对list集合中的元素进行随机排序，用于洗牌

sort(Lsit<T> list);//根据自然顺序对list集合中的元素进行排序

sort(List<T> lsit,Comparator<? super T> c);//根据指定比较器c的排序方式对list集合进行排序

 

reverse(List<?> list);//反转list集合中元素的顺序

Comparator  reverseOrder();//返回一个比较器，强行逆转了实现Comparable接口的对象的自然顺序

Comparator  reverseOrder(Comparator<T> cmp);//返回一个比较器，强行逆转了指定比较器的顺序

 

synchronizedList(List<T> list);//返回支持的同步（线程安全的）List集合

Map<K,V>synchronizedList(Map<K,V> m);//返回支持的同步（线程安全的）Map集合

 

Collections综合举例

 

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.TreeSet;



public class Test6 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList<Person> al = new ArrayList<Person>() ;
        al.add(new Person("lennon",18));
        al.add(new Person("alice",23));
        al.add(new Person("cannon",19));
        al.add(new Person("cannon",16));
        al.add(new Person("joyce",33));
        
        printList(al);         //第一步，打印方法，记过无序
        Collections.sort(al);   //排序
        printList(al);            //第二部，结果有序
        Collections.reverse(al); //第三部，反转
        printList(al);            //结果逆序
        Collections.shuffle(al); //洗牌
        printList(al);  //结果无序
                
        
    }
    
    public static void printList(List<Person> al) {    //封装打印集合方法
        for(Iterator<Person> it = al.iterator();it.hasNext();) {
            
                System.out.print(it.next()+"\t");
            
        }
        System.out.println();
    }

}



class Person implements Comparable<Person> {  //类Person实现Comparable接口具备比较性
    
    private String name;
    private int age;
    
    Person(String name ,int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return this.name;
    }
    
    public String toString() {     //重写toString方法
        return this.name+"...."+this.age;
    }

    @Override
    public int compareTo(Person p1) {   //重写abstract function比较方法
        // TODO Auto-generated method stub
        
        int num = this.name.compareTo(p1.name);
        if(num == 0) {
            return this.age - p1.age;
        }
        else {
            return num;
        }
            
    }
}

 

 

三、集合框架工具类Arrays

 Arrays是一个工具类，用于操作数组。

集合和数组可以互相转换，把数组转换为集合是为了可以使用集合的思想操作数组元素，

而把集合转换为数组是为了限制对集合元素的操作。

 

常用方法

Lsit<T> asList(T... a);//将数组转换为集合,、将数组转换成集合，不可使用集合的增删方法，因为数组的长度是固定的。如果进行增删操作，则会产生　　UnsupportedOperationException的编译异常,如果数组中的元素都是对象，则变成集合时，数组中的元素就直接转为集合中的元素。

如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

binarySearch() //二分查找方法

fill()：替换方法//

sort()//排序方法

 

Person[] p = new Person[4];
        p[0] = new  Person("lennon",18);
        p[1] = new  Person("lennon",19);
        p[2] = new  Person("joyce",18);
        p[3] = new  Person("vincent",18);
        
        Arrays.sort(p);
        List<Person> ps = Arrays.asList(p);
        printList(ps);