黑马程序员_java基础_集合（泛型、Map）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

泛型

一.泛型概述

1. JDK1.5版本以后出现的新特性。用于解决安全问题，是一个类型安全机制。

2.泛型的好处：

（1）将运行时期出现问题ClassCastException，转移到了编译时期。方便于程序员解决问题。让运行时问题减少，安全。
（2）避免了强制转换麻烦。

二.泛型使用

1.在使用java提供的对象时，什么时候写泛型？

 通常在集合框架中很常见，只要见到<>就要定义泛型。

 其实<>就是用来接收类型的。当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

2. 泛型格式：

通过<>来定义要操作的引用数据类型。

例如：TreeSet<String> tr=new TreeSet<String>;建立一个字符串类型的TreeSet集合。

3.泛型定义在比较器中的例子：

<span style="font-size:14px;">import java.util.*;
public class GenericTest
{
	public static void main(String[] args)
	{	//建立指定String类型的TreeSet集合
		TreeSet<String> t = new TreeSet<String>(new MyComparator());
        t.add("gdgd");
        t.add("eyg");
        t.add("dghhds");
        t.add("kg");
        t.add("ht");
        Iterator<String> it = t.iterator();//迭代器接收加泛型
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
	}
}
//比较器接口加泛型
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;
    }
}
</span>

三.泛型类

1.、什么时候定义泛型类

（1）当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展。现在定义泛型来完成扩展。

（2）泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型，所以要操作的类型就已经固定了。

2.定义泛型类的例子：

class Utils<AA>//AA可以代表任意的引用数据类型
{
    private AA a;
    public void setObject(AA a)
    {
        this.a = a;
    }
    public AA getObject()
    {
        return a;
    }
}

四.泛型方法

1.泛型为什么定义在方法上

（1）泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。 
（2）为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。

泛型定义在方法上的例子：

<span style="font-size:14px;">class Demo
{
    public <T> void show(T t){}
    public <Q> void print(Q q){} 
    public  static <W> void method(W t){}
}
</span>

泛型在类和方法上都定义的例子：

class Demo<T>
{
    public  void show(T t){}
    public <Q> void print(Q q){} 
    public  static <W> void method(W t){}
}

2.小结：

（1）泛型定义在类中和定义在方法上，可以一起使用；

（2）静态方法不可以访问类上定义的泛型（静态优于对象存在）。静态方法上使用泛型，要把泛型定义在方法上；

（3）用于放置泛型的类型参数的<>应出现在方法的其他所有修饰符之后和在方法的返回类型之前。

五.泛型接口

泛型定义在接口上并不多见。例子：

//接口定义泛型
interface Inter<T>
{
  void show(T t);
}
//实现类不知道什么类型，也使用泛型，实现Inter接口
class InterImpl<T> implements Inter<T>
{
  public void show(T t){}
}

六.泛型限定

（1）通配符 ？，也可以理解为占位符。使用?通配符可以引用其他各种参数化的类型，?通配符定义的变量主要用作引用，可以调用与参数化无关的方法，不能调用与参数化有关的方法。
（2）泛型的限定：
？ extends E: 可以接收E类型或者E的子类型。上限。
？ super E: 可以接收E类型或者E的父类型。下限

例子：

import java.util.*;
class Person
{
	private String name;
	Person(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
}
class Student extends Person
{
	Student(String name)
	{
		super(name);
	}
}

class  Demo
{
	public static void main(String[] args) 
	{
		ArrayList<Person> al = new ArrayList<Person>();
		al.add(new Person("abc1"));
		al.add(new Person("abc2"));
		al.add(new Person("abc3"));
		printColl(al);

		ArrayList<Student> al1 = new ArrayList<Student>();
		al1.add(new Student("abc--1"));
		al1.add(new Student("abc--2"));
		al1.add(new Student("abc--3"));
		printColl(al1); 
	}

//定义一个上限的泛型方法
public static void printColl(ArrayList<? extends Person> al)
	{
		Iterator<? extends Person> it = al.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next().getName());
		}
	}
}

Map
 

 一.Map集合的概述

1.Map<K,V>集合中存储的元素是成对出现的元素。这种成对出现的元素，我们称之为键值对元素。

该集合存储键值对，一对一对往里存，而且要保证键的唯一性。

2.Map的常见方法：

（1）、添加

        Vput(K key,V value);添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原有键对应值，并put方法会返回被覆盖的值。

        voidputAll(Map <? extends K,? extends V> m);添加一个集合

（2）、删除

        clear();清空

        Vremove(Object key);删除指定键值对

（3）、判断

        containsKey(Objectkey);判断键是否存在

        containsValue(Objectvalue)判断值是否存在

        isEmpty();判断是否为空

（4）、获取

        Vget(Object key);通过键获取对应的值

        size();获取集合的长度

        value();获取Map集合中所有值，返回一个Collection集合

        Set<Map.Entry<K,V>>entrySet();

        Set<K>  keySet();

 

二.Map集合的子类对象

（1）Hashtable:底层是哈希表数据结构，不可以存入Null值和null键。线程同步,jdk1.0出现的。

（2）HashMap:底层是哈希表数据结构，可以存入null值和null键。线程不同步，jdk1.2出现的，效率比HashTable高。

（3）TreeMap:底层是二叉树数据结构。线程不同步。可以用于个Map集合中的键进行排序。

注意：其实Set集合的底层就是Map集合，Set集合是只有键的Map集合。

面试题:Hashtable与HashMap的区别。

Hashtable：不可以存入Null值和null键，线程同步。

HashMap：可以存入null值和null键，线程不同步。

 

三.keySet

对Map集合采用ketSet()方法，获取Map集合键所对应的Set视图，Set集合中有迭代器，可以遍历键，对键采用map集合中的get方法获得键对应的值。

例子：

class  Demo
{
	public static void main(String[] args) 
	{
		Map<String,String> map=new HashMap<String,String>();
		map.put("01", "zhangsan");
		map.put("03", "wangwu");
		map.put("02", "lisi");
		map.put("04", "zhaoliu");
		Set<String> key=map.keySet();//获取map集合中所有键的Set集合
		Iterator<String> it=key.iterator();//有了Set集合，可以用其迭代器
		while(it.hasNext())
		{
			String key1=it.next();//获取键值
			System.out.println(key1+"  "+map.get(key1));//map中的get方法通过键值获取对应的值
		}
	}
}

四.entrySet

（1）.通过Map.Entry方法获得Map中键值映射关系，将关系作为元素存储到Set集合中，Map.Entry<K,V>接口有获取映射关系键和值得方法。getKey()获取键值；getValue()获取键值对应的值。 
（2）.其实，Entry也是一个接口，它是Map接口中的一个内部接口。

（3）例子：

import java.util.*;

class  Demo
{
	public static void main(String[] args) 
	{
		Map<String,String> map=new HashMap<String,String>();
		map.put("01", "zhangsan");
		map.put("03", "wangwu");
		map.put("02", "lisi");
		map.put("04", "zhaoliu");
		Set<Map.Entry<String, String>> key=map.entrySet();//获取map集合中所有键的Set集合
		Iterator<Map.Entry<String, String>> it=key.iterator();//有了Set集合，可以用其迭代器
		while(it.hasNext())
		{
			Map.Entry<String, String> ma=it.next();
			System.out.println(ma.getKey()+"   "+ma.getValue());//Map.Entry<k, v>接口中有getKey()、getValue()方法
		}
	}
}