黑马程序员——————泛型的使用与Map的初步学习

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

第一部分：

在学习ArrayList ,linkedList,HashSe,TreeSet等集合时，在编译时(刚学时) 我们总能看到注意的安全提示，说程序不安全，那么怎么才能安全的变异呢？

那么我们来看看泛型怎么解决这个问题的！

什么是泛型？

泛型 （Generic type 或者 generics）是对 Java 语言的类型系统的一种扩展，以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数
4000
化类型时指定的类型的一个占位符，就像方法的形式参数是运行时传递的值的占位符一样。

可以在集合框架（Collection framework）中看到泛型的动机。例如，Map 类允许您向一个 Map 添加任意类的对象，即使最常见的情况是在给定映射（map）中保存某个特定类型（比如 String）的对象。

泛型的好处：

Java 语言中引入泛型是一个较大的功能增强。不仅语言、类型系统和编译器有了较大的变化，以支持泛型，而且类库也进行了大翻修，所以许多重要的类，比如集合框架，都已经成为泛型化的了。这带来了很多好处：

类型安全。 泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设。没有泛型，这些假设就只存在于程序员的头脑中（或者如果幸运的话，还存在于代码注释中）。
举例一:

/*
泛型类 创建，
什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候，
早期定义object来完成扩展。
现在定义泛型来完成扩展。

*/

import java.util.*;

class Worker
{

}

class Utils<QQ>
{
private QQ q;

public void setObject(QQ q)
{
this.q=q;

}

public QQ getObject(){

return q;
}

}

class GenericDemo3
{
public static void main(String[] args)
{
Utils<Worker> u = new Utils<Worker>();
u.setObject(new Worker());
Worker w = u.getObject();

System.out.println(q);
}
}


  举例二：泛型的使用技巧（同时也记下了自己的疑问）。
/*
泛型使用

特殊点；
静态方法不可以访问类上定义的泛型；
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

public static <w> void method(w t)

*/

class Demo<T> //在类上使用泛型
//局限性较大：必须定义同种基本类型。
{
public void show(T t){
System.out.println("show:"+t);
}

public void print(T t){

System.out.println("print:"+t);
}
}

class GenericDemo5
{
public static void main(String[] args)
{
/*
Demo<String> d=new Demo<String>();
d.show("ss");
d.print("asd");

Demo<Integer> d1= new Demo<Integer>();
d1.show(4);
*/

Demo2 d2=new Demo2();
d2.show("fsd");
d2.show(1);
d2.print(4);
}
}

class Demo2 // 泛型定义在方法上：具有更大的方便性！
// 不明白为什么没有不安全提示
{
public <T> void show (T t){

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

}

public<Q> void print(Q q){

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

举例三：泛型在接口

//泛型定义在接口

interface Inter<T>
{
void show(T t);
}

/*
class InterImpl implements Inter<String>
{
public void show(String t )
{
System.out.println("show:"+t);
}
}
*/

class InterImpl <T> implements Inter<T>
{
public void show(T t){
System.out.println(t);
}
}

class GenericDemo6
{
public static void main(String[] args)
{
/*
InterImpl ii= new InterImpl();

ii.show("xsa");
*/

InterImpl<String> ii=new InterImpl<String>();

ii.show("dasfsd");
}
}


第二部分：集合Map

集合 Map：的概括功能一览。

1  增
put(K key, V value）
putAll(Map<? extends K,? extends V> m)

2  删除
clear() 
 
remove(Object key)

3  判断
containsKey(Object key) 
containsValue(Object value) 
equals(Object o)
isEmpty() 

4  获取
entrySet()
keySet()
get(Object key
hashCode()
size()
values() 

Map |---Hashtable  底层就是哈希数据结构，不可以存入null键null值。该集合线程同步，效率低
|---HashMap
  底层就是哈希数据结构，允许存入null键null值。该集合不同步    效率高
|---TreeMap    底层是二叉树数据结构，线程不同步，具有排列键功能。

和Set很像。Set底层就是使用了Map集合。

下面为学习笔记：

/*
集合 Map：

1 增
put(K key, V value）
putAll(Map<? extends K,? extends V> m)

2 删除
clear()

remove(Object key)

3 判断
containsKey(Object key)
containsValue(Object value)
equals(Object o)
isEmpty()

4 获取
entrySet()
keySet()

get(Object key
hashCode()
size()
values()

Map |---Hashtable 底层就是哈希数据结构，不可以存入null键null值。该集合线程同步，效率低
|---HashMap 底层就是哈希数据结构，允许存入null键null值。该集合不同步 效率高
|---TreeMap 底层是二叉树数据结构，线程不同步，具有排列键功能。

和Set很像。Set底层就是使用了Map集合。
*/

import java.util.*;

class MapDemo
{
public static void main(String[] args)
{
Map<String,String> d= new HashMap<String,String>();
//添加元素 put方法
d.put("1","dasd1");
d.put("2","dasd2");
d.put("3","dasd3");
d.put("4","dasd4");

//d.remove("1");
//d.put("4","dasd4");
//d.clear();
System.out.println(d.values());
//System.out.println(d);
//System.out.println(d.size());

if (!d.isEmpty())
{
System.out.println("you are right");
}

}
}


为了更好的深入了解Map，又学习了下面的代码：

/*
Map集合的两种取出方式：
1.set<key> keySet:将map中所有的键存到Set集合，因为Set具有迭代器’
可以迭代方式取出所有的键，再根据get方法，获取每个键对应的值2。

Map集合取出原理：将Map集合转化成Set集合，再通过迭代器取出。

2.Set <> entrySet

Map.Entry 其实Entry也是个接口，它是Map接口的一个内部类。
*/

import java.util.*;

class MapDemo2
{
public static void main(String[] args)
{
Map<String,String> d= new HashMap<String,String>();
//添加元素 put方法
d.put("1","dasd1");
d.put("2","dasd2");
d.put("3","dasd3");
d.put("4","dasd4");

Set<Map.Entry<String,String>> entrySet=d.entrySet();
//将Map集合的映射关系取出，存入Set集合中。
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();
System.out.println(key+"__"+value);
}

}
}

/*
Set<String> keySet= d.keySet();
然后迭代器
*/