Map集合（特点，遍历方式），HashMap，工具类，泛型

目录

1.Map集合的特点

2.Map集合的遍历方式

3.常用实现类HashMap

4.泛型

作用：将运行产生的异常转换为编译器的错误；提高代码健壮性

泛型类：通用增删改查的思考

5.集合框架工具类

Connections

集合转数组：toArray

Arrays

asList.add("3");违背数组本身特点，报错如下：

---

本篇文章思维导图如下：

1.Map集合的特点

增，删，改，查

键值对形式存在

key值可为空

    Map<String, Object> map = new HashMap<>();
        map.put("a", 1);//增加（key值，value）键值对的形式存在
        map.put("b", 2);
        map.put("c", 3);
        map.put("d", 4);
        map.put(null, 12);//value可为空，key值也可为空！！！
        System.out.println(map);//输出集合
        System.out.println(map.remove("b"));//删除，根据key值删除，输出的是下标
        System.out.println(map);//输出集合
        map.put("c",5);//修改，根据key值修改
        System.out.println(map);//输出集合
        System.out.println(map.get("a"));//查询，根据key值查询，输出value
 

 控制台输出结果为：

{null=12, a=1, b=2, c=3, d=4}            增
2                                                        删，输出value
{null=12, a=1, c=3, d=4}
{null=12, a=1, c=5, d=4}                    改
1                                                        查，输出value

2.Map集合的遍历方式

entrySet

//先获取map集合的映射关系
    Set<Entry<String, Object>> entrySet = map.entrySet();//set集合里面放的是关系
    for (Entry<String, Object> entry : entrySet) {
        System.out.println("key:" + entry.getKey() + ";value+" + entry.getValue());
    }

keySet

//先获取map集合中所有的key
    Set<String> keys = map.keySet();
    for (String key : keys) {
            System.out.println("key:" + key + ";value+" + map.get(map));
    }

 treemap----排序

3.常用实现类HashMap

统计字符串各字母出现的次数，举例如下：

    String a = "agahajakaiagdhjsgdimcjxkshxnmmchudnjgsaaahdisiudjdksh";
        char[] chars = a.toCharArray();
        Map<Character, Integer> map = new HashMap<Character, Integer>();
        for (char c : chars) {
            Integer num = map.get(c);
            if (num == null || num == 0) {// int类型默认值为0,即当该字符第一次出现
                map.put(c, 1);// 设置为1
            } else {// 反之不是第一次出现
                map.put(c, num + 1);
            }
        }
        Set<Entry<Character, Integer>> entrySet = map.entrySet();
        for (Entry<Character, Integer> entry : entrySet) {
            System.out.println(entry.getKey() + "出现了" + entry.getValue() + "次");
        }

控制台输出为：

a出现了9次
c出现了2次
d出现了6次
g出现了4次
h出现了6次
i出现了4次
j出现了5次
k出现了3次
m出现了3次
n出现了2次
s出现了5次
u出现了2次
x出现了2次

                                                4.泛型

作用：将运行产生的异常转换为编译器的错误；提高代码健壮性

        Map<String, Object> map = new HashMap<>();
        map.put("a", 1);// 增加（key值，value）键值对的形式存在
        map.put("b", 2);
        map.put("c", 3);
        map.put("d", 4);
        map.put("e", 5);
        // map.put("f", "小宝");
        // 编译不报错，运行会报错， java.lang.String cannot be cast to java.lang.Integer
        // String不能转化为Integer
        // 筛选出value为偶数对应的key值
        Set<Entry<String, Object>> entrySet = map.entrySet();
        for (Entry<String, Object> entry : entrySet) {
            Object value = entry.getValue();
            Integer val = (Integer) value;
            if (val % 2 == 0) {
                System.out.println("偶数对应的key值为：" + entry.getKey());
            }
        }

泛型类：通用增删改查的思考

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类来说,被继承类写出的方法里，括号里面是什么就代表什么

                                        5.集合框架工具类

Connections

排序：

public class Demo5 {
	public static void main(String[] args) {
		List<Students> list = new ArrayList<>();
		list.add(new Students("hpw", 26));
		list.add(new Students("wyf", 36));
		list.add(new Students("dmz", 16));
		Collections.sort(list, new Comparator<Students>() {

			@Override
			public int compare(Students o1, Students o2) {
				// TODO Auto-generated method stub
				return o1.getAge() - o2.getAge();// 年龄从低到高排列
			}
		});
		list.toArray();
		for (Object o : list) {
			System.out.println(o);
		}
	}
}

class Students {
	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 Students(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return 0;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Students other = (Students) 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;
	}

}

集合转数组：toArray

list.toArray();

Arrays

toString

asList

sort

String[] arr = new String[] { "a", "b", "c", "d", "e", "f" };
        System.out.println(arr);//输出地址 [Ljava.lang.String;@7852e922
        for (String string : arr) {
            System.out.println(string);
        } //输出 a b c d e f
        System.out.println(arr.toString());//输出地址 [Ljava.lang.String;@7852e922
        System.out.println(Arrays.toString(arr));// 输出[a, b, c, d, e, f]
        // 将数组变成集合来操作，不能违背数组本身的特点，能修改查询，不能增加删除
        List<String> asList = Arrays.asList(arr);
       // asList.add("3");//会报错，不能增加
        Integer[] ar = new Integer[] { 1, 3, 7, 2, 0, 3 };
        Arrays.sort(arr);//排序

asList.add("3");违背数组本身特点，报错如下：

Exception in thread "main" java.lang.UnsupportedOperationException
    at java.util.AbstractList.add(AbstractList.java:148)
    at java.util.AbstractList.add(AbstractList.java:108)
    at com.ltf.Demo5.main(Demo5.java:40)