map集合和泛型

1.map集合的特点

无序、以键值对的形式添加元素，键不能重复，值可以重复.它没有继承Collection接口

map集合的覆盖相当于修改,也就是说再次添加一个相同键的不同值,结果会被新加进来的覆盖

下图可验证

 注意:hashset的键可以为null,值也可以为null

遍历所有的键值对有两种方式

方法一:

Set<Object> key = map.keySet();
	for (Object o : key) {
		System.out.println(o+"---"+map.get(o));
	}

 方法二:

Set<Entry<Object, Object>> set = map.entrySet();
	for (Entry<Object, Object> entry : set) {
		System.out.println(entry);
	}

2.统计字符串中字符出现的次数

package com.map;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
 * 统计字符串中字符出现的次数
 * @author zjjt
 *
 */
public class demo2 {
	public static void main(String[] args) {

		String str="wqdqcsacsafsfasfaygyuyucv";
		char[] chars = str.toCharArray();
		Map<Character, Integer> map=new HashMap<Character, Integer>();
		for (char c : chars) {
			Integer in = map.get(c);
			System.out.println(in);
			if(in==null||in==0) {
				map.put(c, 1);
			}else {
				map.put(c, in+1);
			}
		}
//遍历
		Set<Entry<Character, Integer>> set = map.entrySet();
		for (Entry<Character, Integer> e : set) {
			System.out.println(e);
		}
		
	}

}

3.泛型

泛型最大的好处是:将运行时产生的异常转换为编译期的错误

举个例子:

要获取到值为偶数的键

可看到结果是对的,如果这时候在map里添加一个value不为int类型的值编译会通过,但是运行会报错

 所以,我们写代码时一定要写好相对的泛型

4.泛型类的思考

class common{
	public List<Object> list(Object o){
		System.out.println("aaaaa");
		return null;
	}
}
class book{
	
}
class order{
	
}
class bookdao extends common{
	
}
class orderdao extends common{
	
}

 当bookdao和orderdao同时继承common类时,为了区分是book还是order,可使用泛型类

class common<T>{
	public List<T> list(T t){
		System.out.println("aaaaa");
		return null;
	}
}
class book{
	
}
class order{
	
}
class bookdao extends common<book>{
	
	@Override
	public List<book> list(book t) {
		// TODO Auto-generated method stub
		return super.list(t);
	}
}
class orderdao extends common<order>{
	@Override
	public List<order> list(order t) {
		// TODO Auto-generated method stub
		return super.list(t);
	}
}

此时重写list方法时,会将各自的泛型字符带上,方便区分

对于common类来说,被继承类写出的方法里 括号里面是什么就代表什么

类与抽象类的区别:

1.类里面不允许有抽象方法

2.抽象类里可以有抽象方法

注意:如果不是泛型类型,那么方法内部不能使用泛型(不完全对)

比如:

class common{
	public <T> List<T> list(T t){
		System.out.println("aaaaa");
		return null;
	}

	public List<order> list(order t) {
		// TODO Auto-generated method stub
		return null;
	}

	public List<book> list(book t) {
		// TODO Auto-generated method stub
		return null;
	}
}

这种是比较高级的写法

5.collections

1.collections排序

2.集合转换成数组

toArray

6.Arrays 

数组直接打印是不会出现的

要用Arrays.toString()

String[] s=new String[] {"a","b","c","d"};
		System.out.println(s);
		System.out.println(Arrays.toString(s));

 数组转换成集合

List<String> asList = Arrays.asList(s);

s为一个数组

注意:数组变成集合不能违背数组本身的特点,即不能对数组的元素增加和删除否则会报以下错误

 array也可以用sort排序,具体操作看下图