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

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

第一部分：

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

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

什么是泛型？

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


可以在集合框架（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();
然后迭代器
*/