------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流! -------
一、JDK1.5--->泛型
泛型:JDK1.5版本以后出现的新特性,用于解决安全问题,是一个安全机制。
泛型的优点:
1,将运行时期出现的问题,如ClassCastException,转移到了编译时期,方便程序员解决问题,让运行时期问题减少。
2,避免了强制转换动作。
泛型的格式:通过<>来定义要引用的数据类型。如ArrayList<String> al = new ArrayList<String>();
其中,<>是用来接收类型的。当使用集合时,将集合中药存储的数据类型作为参数传递进去即可。
package 博客7_集合框架二;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class 泛型示例 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
TreeSet<String> ts = new TreeSet<String>(new MyComparator());//添加了String类型的泛型
ts.add("absd");
ts.add("vabssdfd");
ts.add("ggabsfd");
ts.add("erabsd");
ts.add("qwabsddff");
Iterator<String> it = ts.iterator();
while(it.hasNext())
{
String s = it.next();
System.out.println(s);
}
}
}
class MyComparator implements Comparator<String>//按照字符串长度排序
{
public int compare(String s1,String s2)
{
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if(num == 0)
return s1.compareTo(s2);
return num;
}
}
泛型类:加了泛型的类,扩展性强。
当类中要操作的引用数据类型不确定的时候,早期定义Object来完成,现在则通过定义泛型来完成。
package 博客7_集合框架二;
class Work
{
}
class Util<QQ>
{
private QQ q ;
public void setObject(QQ q)
{
this.q= q;
}
public QQ getObject()
{
return q;
}
}
public class 泛型类Demo {
public static void main(String[] args) {
Util<Work> u = new Util<Work>();
u.setObject(new Work());
Work w = u.getObject();
System.out.println(w);
}
泛型方法:泛型类定义的泛型,在整个类中有效,如果被方法使用,那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。为了让不同方法可以操作的类型不同,且不确定,就可以 将泛型定义在方法上。
特殊之处:静态方法不可以访问类上定义的泛型,如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上。
泛型定义在接口上的示例如下:
package 博客7_集合框架二;
interface Inter<T>
{
void show(T t);
}
class MyInter<T> implements Inter<T>
{
public void show(T t)
{
System.out.println(t);
}
}
public class 泛型定义在接口上 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
MyInter<String> mi = new MyInter<String>();
mi.show("lalala");
}
}
泛型限定:在泛型中,<?>代表通配符,也叫占位符。
泛型的限定:
? extends E:可以接收E类型或者E的子类型,上限。
? super E:可以接收E类型或者E的父类型,下限。
package 博客7_集合框架二;
import java.util.*;
public class 泛型限定Demo
{
public static void main(String[] args)
{
TreeSet<Student> ts = new TreeSet<Student>(new Comp());
ts.add(new Student("abc1"));
ts.add(new Student("abc3"));
ts.add(new Student("abc5"));
ts.add(new Student("abc2"));
printColl(ts);
TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());
ts1.add(new Worker("wabc---6"));
ts1.add(new Worker("wabc---2"));
ts1.add(new Worker("wabc---8"));
ts1.add(new Worker("wabc---1"));
printColl(ts1);
}
public static void printColl(TreeSet<? extends Person> ts)//泛型限定为Person或者Person的子类
{
Iterator<? extends Person> it = ts.iterator();
while(it.hasNext())
{
System.out.println(it.next().getName());
}
}
}
class Comp implements Comparator<Person>//泛型限定为person或者person的子类
{
public int compare(Person p1 ,Person p2)
{
return p1.getName().compareTo(p2.getName());
}
}
class Person
{
private String name;
Person(String name)
{
this.name=name;
}
public String getName()
{
return name;
}
}
class Worker extends Person
{
Worker(String name)
{
super(name);
}
}
class Student extends Person
{
Student(String name)
{
super(name);
}
}
二、Map集合
Map<K,V>接口:将键映射到值的对象,一个映射不能包含重复的键,每个键最多只能映射到一个值。
K:此映射所维护的键的类型。同KEY。
V:映射值的类型。同VALUE。
Map的特点:该集合存储键值对,一个一个往里存,且要保持唯一性。
Map
|--Hashtable:底层是哈希表,不可以存入null值,是同步的,但是效率低,已经不怎么使用。
|--Hashmap:底层是哈希表,允许使用null值,是不同步。所以效率高,替代了Hashtable。
|--Treemap:底层是二叉树,可以用于给map集合中的key排序。
Map集合的共性方法演示如下:
package 博客7_集合框架二;
import java.util.*;
public class Map集合共性方法
{
public static void main(String[] args)
{
method();
}
public static void method()
{
Map<String,String> map = new HashMap<String,String>();
//添加元素,如果添加了相同的键,那么后面的值会替换原有的值,并返回被替换的值。
map.put("01","zhangsan1");
map.put("02","zhangsan2");
map.put("03","zhangsan3");
//是否包含元素
//sop("contains:"+map.containsKey("022"));
//删除元素
//sop("remove:"+map.remove("02"));
//删除后集合
//sop("操作后的集合:"+map);
//获取元素
sop("get:"+map.get("02"));//可以通过get方法返回的值是否为空来判断这个值是否存在
//获取集合中所有的值
Collection<String> coll = map.values();
sop(coll);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
Map集合的两种取出方式:
1,keySet方式:将map集合中所有的键存入到Set集合中,因为Set集合具备迭代器,所以可以通过迭代的方式取出所有的键,再根据get方法,获取每一个键所对应的值。
package 博客7_集合框架二;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Hashmap取出方式之keySet {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Map<String,String> map = new HashMap<String,String>();
map.put("01","zhangsan1");
map.put("02","zhangsan2");
map.put("03","zhangsan3");
//先获取map集合所有键的Set集合,通过keySet()方法
Set<String> keyset= map.keySet();
//使用Set集合的迭代器
Iterator<String> it = keyset.iterator();
while(it.hasNext())
{
String key = it.next();
sop("key::"+key);
sop("value----"+map.get(key));
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
2,通过entruSet:将map集合中的映射关系存入到Set集合中,而这个关系的数据类型就是map.Entry。
<pre name="code" class="java">package 博客7_集合框架二;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Map集合的取出方式之entrySet
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
map.put("01","zhangsan1");
map.put("02","zhangsan2");
map.put("03","zhangsan3");
//将map集合中的映射关系取出,存入到Set集合中
Set<Map.Entry<String, String>> entryset = map.entrySet();
Iterator<Map.Entry<String, String>> it = entryset.iterator();
while(it.hasNext())
{
Map.Entry<String, String> me = it.next();
String key = me.getKey();
String value = me.getValue();
sop(key+"::"+value);
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
Map.Entry中Entry也是一个接口,并且是Map接口中的一个内部接口。