----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------
泛型
定义:泛型：jdk1.5版本以后出现新特性，用于解决安全问题，是一个类型安全机制
好处:
1，将运行时期出现问题classcastexception，转移到了编译时期，方便于程序员解决问题，让运行事情问题减少，安全。
2，避免了强制转换麻烦
格式:
通过<>来定义要操作的引用数据类型
在集合框架中,只要见到<>就要定义泛型，其实<>就是用来接收类型的。当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
范例:
public class GenericDemo3 {
public static void main(String[] args) {
Utils<Worker> u=new Utils<Worker>();
u.setObject(new Worker());
Worker w=u.getObject();
/*Tool t=new Tool();
t.setObject(new Worker());
Worker w=(Worker)t.getObject();
*/
}
}
class Worker
{
}
class Student3
{
}
//泛型前做法
//什么时候定义泛型类？
//当类中要操作的引用数据类型不确定的时候，早期定义object来完成扩展
//现在定义泛型来完成扩展
class Tool
{ private Object obj;
public void setObject(Object obj)
{
this.obj=obj;
}
public Object getObject()
{
return obj;
}
}
//泛型类。
class Utils<QQ>
{
private QQ q;
public void setObject(QQ q)
{
this.q=q;
}
public QQ getObject()
{
return q;
}
}
/**
class Tool
{ private worker w;
public void setWorker(worker w)
{
this.w=w;
}
public worker getWorker()
{
return w;
}
}
*/ 特殊之处：静态方法不可以访问类上定义的泛型，如果静态方法操作的 引用数据类型不确定，可以将泛型定义在方法上
泛型定在接口上的范例:
public class genericDemo5 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
InterImpl<Integer> i=new InterImpl<Integer>();
// InterImpl i=new InterImpl();
i.show(4);
}
}
class InterImpl<T> implements Inter<T>//泛型定义在接口上
{
public void show(T t)
{
System.out.println("show:"+t);
}
}
/*class InterImpl implements Inter<String>
{public void show(String t)
{
System.out.println("show:"+t);
}
}
*/
interface Inter<T>
{
void show(T t);
} ? extends E ：可以接受E类型或者E的子类型，上限
? super E:可以接受E类型或E的父类型，下限。
import java.util.*;
class generademo6 {
public static void main(String[] args)
{
/* ArrayList<String> a1=new ArrayList<String>();
a1.add("abc1");
a1.add("abc2");
a1.add("abc3");
ArrayList<Integer> a11=new ArrayList<Integer>();
a11.add(4);//有自动装箱。
a11.add(2);
a11.add(5);
printColl(a1);
printColl(a11);*/
ArrayList<Person> a1=new ArrayList<Person>();
a1.add(new Person("abc1"));
a1.add(new Person("abc2"));
//printColl(a1);
ArrayList<student11> a11=new ArrayList<student11>();
a1.add(new student11("abc1"));
a1.add(new student11("abc2"));
printColl1(a11);//Arraylist<Person>a1=new Arraylist<Student>();是不允许的。error。两边一致
}
public static void printColl1(ArrayList<? extends Person/*泛型限定*/> a1)
{
Iterator<? extends Person> it=a1.iterator();
while(it.hasNext())
{
System.out.println(it.next().getName());
}
}
/*public static void printColl(ArrayList<?String>a1) //ArrayList<String>a1=new ArrayList<Integer>();不允许的。
{
Iterator<String? > it=a1.iterator();
while(it.hasNext())
{
System.out.println(it.next());
// System.out.println(it.next().length());//这不不能使用具体方法。
}
}*/
}
class Person
{
private String name;
Person(String name)
{
this.name=name;
}
public String getName()
{
return name;
}
}
class student11 extends Person
{
student11(String name)
{
super(name);
}
}
class student11 implements Comparable<Person>//<? super e>
{
public int compareTo(Person s)
{
this.getName();
}
}
class comp implements Comparator<Person>
{
public int compare(Person s1,Person s2)
{
return s1.getName().compareTo(s2.getName());
}
}
TreeSet<student11> ts=new TreeSet<student11>(new comp());
ts.add(new student11("abc11")); Comparable 接口强行对实现它的每个类的对象进行整体排序，这种排序被称为自然排序。
Comparable只有comparableTo()
TreeSet内集合要具有比较性。
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Map集合
Map
|-----Hashtable此类实现一个哈希表，该哈希表将键映射到相应的值，任何非null对象都可以用作键或值。
用作键的对象必须实现hashCode方法和equals方法。底层是哈希表数据结构，不可以存入null键null值，jdk1.0 效率低。该集合是线程同步的
|-----HashMap：基于哈希表的map接口的实现，并允许使用null键，null值。底层是哈希表数据结构，jdk1.2 效率高。该集合是非同步的。
|-----TreeMap:底层是二叉树数据结构，线程不同步，可以用于给map集合中的键进行排序
定义:public interface Map<K,V>将键映射到值的对象，一个映射不能包含重复的键，每个键最多只能映射到一个值，collection单例集合，
Map集合：该集合存储键值对，一对一对往里存，而且保证键的唯一性。双列集合。
方法:
1，添加
put(k key,v value)将指定的值与此映射中的指定键关联
putAll(Map<? extends k,? extends v> m)从指定映射中将所有映射关系复制到此映射中
2，删除
void clear();从此映射中移除所有映射关系。即清空
value remove(Object key);如果存在一个键的映射关系，则将其从此映射中移除，删除指定键
3，判断
boolean containsKey(object key);如果此映射包含指定键的映射关系，则返回true, 是否包含key.
boolean containsValue(object value);如果此映射将一个或多个键映射到指定值，则返回true。是否包含value.
boolean isEmpty();如果此映射未包含键值映射关系，则返回true。
4，获取
value get(Object key)返回指定键所映射的值，如果此映射不包含该键的映射关系，则返回null
int size();返回此映射中的键值映射关系数。
Collection values();返回此映射中包含的值的collection视图。获取map集合中的所有的值。
entrySet();返回此映射中包含的映射关系的set视图。
keySet();返回此映射中包含的键的set视图。
5，想要获取map中的所有元素：
原理：map中是没有迭代器的，collection具备迭代器，只要将map集合转成Set集合，可以使用迭代器了。之所以转成set，是因为map集合具备着键的唯一性，其实set集合就来自于map，set集合底层其实用的就是map的方法。
Map集合存储和Collection的区别：
Collection一次存一个元素；Map一次存一对元素。
Collection是单列集合；Map是双列集合。
Map中的存储的一对元素：一个是键，一个是值，键与值之间有对应(映射)关系。
import java.util.*;
public class MapDemo {
public static void main(String[] args) {
Map<String,String>map=new HashMap<String,String>();
//添加元素,添加元素如果出现添加时，相同的键，那么后添加的值会覆盖原有键对应值，并put
//方法会返回被覆盖的值。
map.put("01","zhangs");
map.put("02", "jav12");
map.put("03","jv23");
System.out.print("cont"+map.containsKey("023"));
System.out.println("remove"+map.remove("02"));
System.out.println("get:"+map.get("023"));
map.put("04", null);
System.out.println("get:"+map.get("04"));
//可以通过get方法的返回值来判断一个键是否存在,通过返回null来判断
//获取map集合中所有的值
Collection<String> coll=map.values();
System.out.println(coll);
System.out.println(map); 取出map集合中所有元素的方式一：keySet()方法。
可以将map集合中的键都取出存放到set集合中。对set集合进行迭代。迭代完成，再通过get方法对获取到的键进行值的获取。
Set keySet = map.keySet();
Iterator it = keySet.iterator();
while(it.hasNext()) {
Object key = it.next();
Object value = map.get(key);
System.out.println(key+":"+value);
}set<Map.Entry<k,v>>entryset:将map集合中的映射关系存入到了set集合中，而这个集合的数据类型就是：Map.Entry
Set entrySet = map.entrySet();
Iterator it = entrySet.iterator();
while(it.hasNext()) {
Map.Entry me = (Map.Entry)it.next();
System.out.println(me.getKey()+"::::"+me.getValue());
} interface Map
{ public static interface Entry
{
public abstract Object getKey();
public abstract Object getValue();
}
}
class HashMap implements Map
{
class Hash implements Map.Entry
{
public Object getKey();
public Object getValue();
}
}import java.util.*;
public class mapdemo2 {
public static void main(String[] args) {
Map<String,String> map=new HashMap<String,String>();
map.put("01","zhangs");
map.put("02", "jav12");
map.put("03","jv23");
//将map集合中的映射关系取出，存入到set集合中，
Set<Map.Entry<String, String>>entrySet=map.entrySet();
Iterator <Map.Entry<String, String>>it1=entrySet.iterator();
while(it1.hasNext())
{
Map.Entry<String, String>me=it1.next();
String key=me.getKey();
String value=me.getValue();
System.out.print(key+":::"+value);
}
//先获取map集合的所有键的set集合，keyset();
Set<String> keyset=map.keySet();
//有了set集合，就可以获取其迭代器
Iterator<String> it=keyset.iterator();
while(it.hasNext())
{
String key=it.next();
//有了键可以通过map集合的get方法获取其键对应的值
String value=map.get(key);
System.out.println("key:"+key+"value"+value);
}
}
} 范例:map与映射有关,因为map就是键值对的映射
范例:
import java.util.*;
public class mapdemo31 {
public static void demo()
{
HashMap<String,List<sstudent>>czbk=new HashMap<String,List<sstudent>>();
List<sstudent> reyu=new ArrayList<sstudent>();
List<sstudent> jiuye=new ArrayList<sstudent>();
czbk.put("yureban", reyu);
czbk.put("jiuyeban", jiuye);
reyu.add(new sstudent("01","zhangshan"));
reyu.add(new sstudent("02","zhangshan1"));
jiuye.add(new sstudent("01","zhangshan2"));
jiuye.add(new sstudent("02","zhangshan3"));
//遍历czbk集合，获取所有的教室
Iterator<String>it= czbk.keySet().iterator();
while(it.hasNext())
{
String roomName=it.next();
List<sstudent> room=czbk.get(roomName);
System.out.println(roomName);
getInfos(room);
}
}
public static void getInfos(List<sstudent> list)
{
Iterator<sstudent>it=list.iterator();
while(it.hasNext())
{
sstudent s=it.next();
System.out.println(s);
}
}
public static void main(String[] args) {
demo();
/** HashMap<String,HashMap<String,String>>czbk=new HashMap<String,HashMap<String,String>>();
HashMap<String,String> yure=new HashMap<String,String>();
HashMap<String,String> jiuye=new HashMap<String,String>();
jiuye.put("01","zhaoli");
jiuye.put("02","sdfs");
czbk.put("yureban", yure);
czbk.put("jiuyeban", jiuye);
yure.put("01","zhaoli");
yure.put("02","sdfs");
//遍历czbk集合，获取所有的教室
Iterator<String>it= czbk.keySet().iterator();
while(it.hasNext())
{
String roomName=it.next();
HashMap<String,String> room=czbk.get(roomName);
System.out.println(roomName);
getStudentInfo(room);
}
*/
//getStudentInfo(jiuye);
}
public static void getStudentInfo(HashMap<String,String> roomMap)
{Iterator<String>it=roomMap.keySet().iterator();
while(it.hasNext())
{
String id=it.next();
String name=roomMap.get(id);
System.out.println(id+"::"+name);
}
}
}
class sstudent
{
private String id;
private String name;
sstudent(String id,String name)
{
this.id=id;
this.name=name;
}
public String toString()
{
return id+"::"+name;
}
} ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
使用集合的技巧：
看到Array就是数组结构，有角标，查询速度很快。看到link就是链表结构：增删速度快，而且有特有方法。addFirst； addLast； removeFirst()； removeLast()； getFirst()；getLast()；
看到hash就是哈希表，就要想要哈希值，就要想到唯一性，就要想到存入到该结构的中的元素必须覆盖hashCode，equals方法。
看到tree就是二叉树，就要想到排序，就想要用到比较。
比较的两种方式：
一个是Comparable：覆盖compareTo方法；
一个是Comparator：覆盖compare方法。
LinkedHashSet，LinkedHashMap:这两个集合可以保证哈希表有存入顺序和取出顺序一致，保证哈希表有序。
集合什么时候用？
当存储的是一个元素时，就用Collection。当存储对象之间存在着映射关系时，就使用Map集合。
保证唯一，就用Set。不保证唯一，就用List。
----------------------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------------------
扫一扫
3941
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
