黑马程序员_java1.5新特性泛型集合

---------------------- android培训、java培训、期待与您交流！ ----------------------

泛型：JDK1.5版本一户出现新特性。用于解决安全问题，是一个类型安全机制。

好处：

1.将运行时期出现问题ClassCastException,转换到了编译时期。

方便于程序员解决问题，让运行事情问题减少，安全。

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

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

在使用java提供的对象时，什么时候写泛型呢？

通常在集合框架中很常见。

只要见到<>就要定义泛型。

其实<>就是用来接收类型的

当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

用一个简单的安利说明一下。

import java.util.*;

public class GenericDemo {

public static void main(String[] args) {

ArrayList<String> al = new ArrayList<String>();

al.add("abc01");

al.add("abc02");

al.add("abc04");

al.add("abc00");

al.add(Integer(1)); //这个是编译不通过的

Iterator<String> it = al.iterator();

while(it.hasNext()){

String s = it.next();

System.out.println(s);

}

}

}

泛型使用

通过TreeSet集合 定义一个实现Comparator<T>接口的比较器。

import java.util.Comparator;

import java.util.Iterator;

import java.util.TreeSet;

public class GenericDemo2 {

public static void main(String[] args) {

TreeSet<String> ts = new TreeSet<String>(new LenComparator());

ts.add("adcd");

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 LenComparator implements Comparator<String>{

//覆盖compare方法。

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;

}

}

泛型方法

public class GenericDemo4 {

public static void main(String[] args) {

Demo<String> d = new Demo<String>();

d.show("dfd");

d.print(44);

Demo.method("dfd");

Demo.method(99);

Demo1 dd = new Demo1();

dd.show("dsfd");

dd.show(new Integer(4));

dd.pirnt("dfa");

dd.pirnt(new Integer(3));

}

}

//特殊之处：静态方法不可以访问类上定义的泛型

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

class Demo<T>{

public void show(T t){

System.out.println("show:" +t);

}

public <Q> void print(Q q){

System.out.println("print:" + q);

}

public static <W> void method(W w){

System.out.println("method:" + w);

}

}

//泛型类定义的泛型，在整个类中有效。如果被方法是用，

//那么泛型类的对象明确要操作的具体类型后，所有操作的类型就已经固定了

//为了让不同方法可以操作不同类型，而且类型还不确定。

//那么可以将泛型定义在方法上。

class Demo1{

public <T> void show(T t){

System.out.println("show:" +t);

}

public <T> void pirnt(T t){

System.out.println("pirnt:" +t);

}

}

多态可以提高扩展性，但是还是有弊端。不能预先使用子类中的特有方法。

?通配符。也可以理解为占位符。

泛型的限定

？ extends E：可以接受E类型或者E的子类型，上限

？super E：可以接受E类型或者E的父类型，下限。

import java.util.*;

public class GenericDemo6 {

public static void main(String[] args) {

TreeSet<Student3> ts = new TreeSet<Student3>(new Comp());

ts.add(new Student3("abc08"));

ts.add(new Student3("abc03"));

ts.add(new Student3("abc09"));

ts.add(new Student3("abc04"));

Iterator<Student3> it = ts.iterator();

while(it.hasNext()){

System.out.println(it.next().getName());

}

TreeSet<Worker3> ts1 = new TreeSet<Worker3>(new Comp());

ts1.add(new Worker3("wabc08"));

ts1.add(new Worker3("wabc03"));

ts1.add(new Worker3("wabc09"));

ts1.add(new Worker3("wabc04"));

Iterator<Worker3> it1 = ts1.iterator();

while(it1.hasNext()){

System.out.println(it1.next().getName());

}

}

}

class StuComp implements Comparator<Student3>{

public int compare(Student3 o1, Student3 o2) {

return o1.getName().compareTo(o2.getName());

}

}

class WorkerComp implements Comparator<Worker3>{

public int compare(Worker3 o1, Worker3 o2) {

return o1.getName().compareTo(o2.getName());

}

}

class Comp implements Comparator<Person3>{

public int compare(Person3 o1, Person3 o2) {

return o2.getName().compareTo(o1.getName());

}

}

class Person3{

private String name;

public Person3(String name){

this.name = name;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

}

class Student3 extends Person3{

public Student3(String name) {

super(name);

}

}

class Worker3 extends Person3{

public Worker3(String name) {

super(name);

}

}

Map 集合 该集合存储键值对。一对一对往里存。而且要保证键的唯一性。

1.添加

put(K key,V value);

putAll(Map<? extends K,? extends V> m);

2.删除

clear();

remove(Object key);

3.判断

containsValue(Object value);

containsKey(Object key);

isEmply();

4.获取

get(Object key);

size();

values();

entrySet();

keySet();

Set<k> keySet(); 将Map中所有的键存入到Set集合，因为set具备迭代器。

所有可以迭代方式取出所有的键，在根据get方法，取出每一个键对应的值。

Map集合的取出原理：将map集合转成set集合，在通过迭代器取出。

Set<Map.Entry<k,v>> entrySet();将map集合中的映射关系存入到了set集合中，

而这个关系的数据类型就是：Map.Entry

Map.Entry 其实Entry也是一个借口，它是是Map借口中的内部借口

interface Map{

public static interface Entry{

public abstract Object getKey();

public abstract Object getValue();

}

}

Map:Hashtable:底层是哈希表数据结构。不可以存入null键null值。该集合是线程同步的。jdk1.0,效率低。

hashMap：底层是哈希表数据结构。允许使用null值和null键，该集合是不同步的，jdk1.2,效率高。

TreeMap：底层是二叉树数据结构。可以用于Map集合中的键进行排序，线程不同步。

和Set很像。

其实Set底层就是使用了Map集合。

import java.util.*;

public class MapDemo {

public static void main(String[] args) {

Map<String, String> m = new HashMap<String, String>();

//添加元素,添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原有键对应的值。并put方法会返回覆盖的值。

m.put("01", "zhangsan1");

m.put("02", "zhangsan2");

m.put("03", "zhangsan3");

m.put("04", "zhangsan4");

//System.out.println("contairnsKey:"+ m.containsKey("02"));

//System.out.println("remove:"+m.remove("02"));

//System.out.println("get:"+m.get("02"));

m.put(null, "haha");

//可以通过get方法的返回值来判断一个键是不存在。通过返回null来判断。

//System.out.println("get:"+m.get(null));

//获取Map集合中所有的值。

Collection<String> coll = m.values();

System.out.println(coll);

}

}

用一个例子说一下keySet() 和 EntrySet()

package com.hm.map;

import java.util.*;

public class MapTest {

public static void main(String[] args) {

Map<Per, String> map = new HashMap<Per, String>();

map.put(new Per("zs01",23), "北京");

map.put(new Per("zs02",23), "天津");

map.put(new Per("zs04",23), "上海");

map.put(new Per("zs03",23), "南京");

//第一种获取方式 get();keySet();

Set<Per> p = map.keySet();

Iterator<Per> it = p.iterator();

while(it.hasNext()){

Per po = it.next();

String person = map.get(po);

System.out.println(po +"..."+person);

}

System.out.println();

//第二种方式EntrySet();

Set<Map.Entry<Per, String>> entry = map.entrySet();

Iterator<Map.Entry<Per, String>> iter = entry.iterator();

while(iter.hasNext()){

Map.Entry<Per, String> me = iter.next();

Per key = me.getKey();

String value = me.getValue();

System.out.println(key +"::" + value);

}

}

}

class Per implements Comparable<Per> {

private String name;

private int age;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public Per(String name,int age){

this.name = name;

this.age = age;

}

public int hashCode(){

return this.name.hashCode()+age*37;

}

public boolean equals(Object obj){

if(!(obj instanceof Per)) {

throw new ClassCastException("类型不匹配");

}

Per p = (Per) obj;

return this.name.equals(p.name) && this.age==p.age;

}

public String toString(){

return name+":"+age;

}

public int compareTo(Per o) {

int num = new Integer(this.age).compareTo(new Integer(o.age));

if(num==0)

return this.name.compareTo(o.name);

return num;

}

}

---------------------- android培训、java培训、期待与您交流！ ---------------------

-详细请查看：http://edu.csdn.net/heima