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

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

[b]一、泛型<T>[/b]

泛型概述

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

}

[b]二、集合框架工具类Collections[/b]

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;
}

}
}

[b]三、集合框架工具类Arrays[/b]

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);