黑马程序员——java基础——集合中注意的问题

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

第一个问题泛型问题：

泛型是jdk1.5后的新特性，泛型在集合中经常使用，为什么要有泛型呢？

泛型解决的问题：

1：程序的类型没确定时，取出集合中元素的时候，在编译时不会报错，可是一运行就报异常，存在安全隐患，定义了泛型，程序一编译发现集合中装的数据类型不一样，此时就会报异常，这是程序员就可以解决类型不同导致的异常，这就解决了此安全隐患问题。

2：因为集合中的类型不一样，所以要强制类型转换，有了泛型就解决了类型转换的麻烦。

泛型的格式：

1：<>括号就是泛型定义符号，只要看到此符号就是定义泛型，括号是用来接收数据类型的。

2:自定义类泛型的定义格式：class Utils <T>{}。注意静态方法不可以访问类上定义的泛型，如果静态方法操作的类型不确定，那么我们可以把泛型定义在方法上。

3:自定义函数泛型的定义格式：public <T> void show(){}。注意泛型定义在方法上是<>放在返回类型的前面

4:泛型定义在接口上：Interface inter<T>。

5：泛型中通配符<?>，如果需求是要用到一个类以及他的全部子类，那么它的书写格式为<?extends class>也就是上限，<? super class>下限，这也叫泛型的限定。

下面是泛型使用代码演示：

<span style="font-size:18px;"><span style="font-size:18px;">package blogday1;
class Wang{//定义一个类
	private String name;
	private int age;	
	
}
class Xiao{//定义一个类
	private String name;
	private int age;
	
	
}
class Utils<T>{//定义一个代泛型的工具类
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public void show(){
		System.out.println(getAge()+""+getName());
		}
	public void show1(T t){
		System.out.println(t);
	}
	}
public class GenericDemo {
	public static void main(String[] args) {
		Utils<Wang> w=new Utils<>();//得到工具类对象，并且往里面传递要接受的类型
		w.setAge(50);//调用工具类里面的
		w.setName("wang");
		w.show();
		Utils<Xiao> x=new Utils<>();
		w.setAge(40);
		w.setName("xiao");
		w.show();
		Utils<String> s=new Utils<String>();
		s.show1("xiaozhijiang");
		Utils<Integer> s1=new Utils<Integer>();
		s1.show1(new Integer(56));
		
		
		
	}

}</span></span>

以上代码，演示了泛型的用法，以及泛型的好处。

第二个map集合的问题

map集合的特点：

1：该集合存储键值对，一对一对往里面村，并且保证键的唯一性。

Map对应的3个能实现类，以及各自的特点：

Hashtable:底层是哈希表的数据结构，不可以出现空键空值，该集合是线程同步的，出现在jdk1.0,效率最低。

Hashmap:底层是哈希表的数据结构，可以出现空键空值，该集合是线程是不同步的，出现在jdk1.2，效率高。

TreeMap:底层是二叉树的数据结构，线程不同步，可以用于给map集合中的键进行排序。

Map集合里面的一些常用方法

1：添加

put(Kay k，Value v)；

putAll(Map<? extends key，? extends value> m)

2:删除

clear()；

remove(Object v)

3:判断

containsValue(Object v)；containsKey(Object k)；isEmpty()；

4：获取

get(Object k);

size();

valus();

keyset（）；

entry();

基本方法实现代码如下：

<span style="font-size:18px;"><span style="font-size:18px;">package blogday1;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapDemo {
	public static void main(String[] args) {
		Map<String, String> map=new HashMap<String, String>();//定义了一个map集合对象
		map.put("01", "xiao01");//往集合里面装东西，学号和姓名。注意如果存放数据的时候键相等，那么键对应的值将会覆盖原来的值，那么
			//map.put（）函数将返回原来键对应的值
		map.put("02", "xiao02");
		map.put("03", "xiao03");
		map.put("04", "xiao04");
		map.put("05", "xiao05");
		map.put(null, "jhkljkl");
		map.remove("05");
		Set<String> key=map.keySet();//定义一个set集合来装Map集合里面的键
		for(Iterator<String> it=key.iterator();it.hasNext();){//通过迭代器取出set集合里面的键
			String key1=it.next();
			String v=map.get(key1);//通过键值获得键所对应的值
			System.out.println(v);
		}
		Collection<String> coll=map.values();//定义一个Collection集合来存放map.values返回的map中的所有元素
		System.out.println(coll);	
	}

}
</span></span>

map集合中没有迭代器，要取出map集合中的元素只能靠get（key）函数获取map集合中键对应的值，思路有俩个，方法有俩个

keyset（）；

entry()；

第一个将map集合中的键放到set集合中，然后再通过迭代器获得set集合中的键，最后通过键获得map集合中对应的值。

第二个将map集合中的键值对应的关系放到一个集合里面，然后在通过这个对应关系对象中的，getvalue（）与getkey（）方法得到，map集合中的键和值。

下面代码是一个练习，方便我们理解map集合中的问题，代码如下：

要求，往集合里面放学生和学生地址，学生为键，地址为值，然后获取集合里面的数据，按照学生年龄从小到大排序输出：

<span style="font-size:18px;"><span style="font-size:18px;">package blogday1;

import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

class Student2 implements Comparable<Student2>{
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	@Override
	public int hashCode() {//重写hashcode函数。
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {//重写equals函数
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student2 other = (Student2) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	@Override
	public String toString() {//重写toString函数
		return "Student [name=" + name + ", age=" + age + "]";
	}
	@Override
	public int compareTo(Student2 s) {
		// TODO Auto-generated method stub
		int num=new Integer(this.age).compareTo(new Integer(s.age));
		return num;
	}
	
}

public class MaoDemo2 {
public static void main(String[] args) {
	Student2 s=new Student2();
	s.setAge(21);
	s.setName("lisi1");
	Student2 s1=new Student2();
	s1.setAge(22);
	s1.setName("lisi2");
	Student2 s2=new Student2();
	s2.setAge(23);
	s2.setName("lisi3");
	Student2 s3=new Student2();
	s3.setAge(12);
	s3.setName("lisi4");
	Student2 s4=new Student2();
	s4.setAge(19);
	s4.setName("lisi5");
	TreeMap<Student2, String> hm=new TreeMap<Student2,String>();
	hm.put(s, "beijing");
	hm.put(s1, "nanjing");
	hm.put(s2, "shanghai");
	hm.put(s3, "chongqi");
	hm.put(s4, "hubei");
	Set<Map.Entry<Student2, String>> entryset=hm.entrySet();
	for(Iterator<Map.Entry<Student2, String>>it=entryset.iterator();it.hasNext();){
		Map.Entry<Student2, String> me=it.next();
		Student2 st=me.getKey();
		String str=me.getValue();
		System.out.println(st.getAge()+""+st.getName()+""+str);
	}
}
}
</span></span>

以上代码注意事项：

1：建立一个学生类，要覆盖那些方法，为什么要覆盖这些方法

首先get（）set（）方法为了设置类的私有变量和获取类的私有变量，然后是hashCode() ，equals（）这些方法是为了让对象可以存储在hash表数据结构的集合中toString（）方法是为了方便将成员变量以字符串的形式输出。

2：取元素引入了一个Map.Entry类型，用于表示键值对之间的对应关系，把此对应关系存到set集合中去，然后通过迭代其取出set集合中的Map.Entry类型的对应关系，然后调用Mao.Entry类中的函数getkey（）和getvalue（）得到Map集合中的键值。

在这里集合问题就说完了！