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