J2EE基础-集合框架Map_set>

前言

上篇(http://t.csdn.cn/i9015)中我们已经认识了集合框架set，这篇我们将学习集合框架Map

目录

前言

一、Map集合

A、特点

B、map集合增删改

 C、遍历方式

Ca、查询单个

 Cb、查询所有(两种方式)-第一种

Cc、查询所有(两种方式)-第二种

D、HashMap与Hashtable的区别

案例一、统计map集合中字符串出现的次数

 思路：

 OK、我们延伸一下，按字符出现的次数进行排序

 二、泛型

A、有泛型之前：

B、有泛型之后：

三、集合框架工具类

A、集合之间的相互转换

​编辑Aa、结论：

B、基本数据类型排序

 C、对象等其他数据类型排序

---

一、Map集合

A、特点

Map是一个无序，键值对的集合，键不可以重复，值可以重复，键重复则后者覆盖前者，Map集合没有继承Collection接口

package com.oyang.map;
 
import java.util.HashMap;
import java.util.Map;
 
/**
 * map集合的特点
 * 键值对 & 无序
 * @author yang 
 *
 * @date 2022年6月9日下午1:53:49
 */
public class Demo1 {
	public static void main(String[] args) {
		Map<String,Integer> map = new HashMap<>();
		//增
		map.put("s", 1);
		//  V put(K key, V value);
		map.put("a", 2);
		map.put("c", 3);
		map.put("d", 4);
		map.put("g", 5);
		System.out.println(map);		
	}
}

打印一下

 我们可以看到，它是无序输出的，所以是没有继承Collection接口的

B、map集合增删改

package com.oyang.map;
 
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
 
/**
 * map集合的特点
 * 键值对 & 无序
 * @author yang 
 *
 * @date 2022年6月9日下午1:53:49
 */
public class Demo1 {
	public static void main(String[] args) {
		Map<String,Integer> map = new HashMap<>();
		//增
		map.put("s", 1);
		//  V put(K key, V value);
		map.put("a", 2);
		map.put("c", 3);
		map.put("d", 4);
		map.put("g", 5);
		System.out.println(map);
		//删	返回的是删除的值
		
		Object remove = map.remove("s");
		System.out.println("删除的值:"+remove);
		System.out.println("==============删除后===============");
		System.out.println(map);
		
		//改 也是调用put方法
		map.put("a", 22);
		System.out.println(map);
	}
}

打印结果：

 C、遍历方式

Ca、查询单个

查单个根据键拿到值        

		System.out.println(map.get("a"));

结果：

 Cb、查询所有(两种方式)-第一种

先拿到map集合中所有的key(键)后再遍历

		Set set = map.keySet();//先拿到map集合中所有的key(键)
		//再遍历
		for (Object key : set) {
			System.out.println("键："+key+"值："+map.get(key));
		}

结果：

Cc、查询所有(两种方式)-第二种

拿到映射关系，键值都有了

	//第二种：拿到映射关系
		Set<Entry<String, Integer>> entrySet = map.entrySet();
		for (Entry<String, Integer> entry : entrySet) {
			System.out.println("键："+entry.getKey()+"值："+entry.getValue());
		}

结果：

D、HashMap与Hashtable的区别

	
		Hashtable<String,Integer> hashtable = new Hashtable<>();
		// public synchronized V put(K key, V value) synchronized同步
		hashtable.put("a", 12);
		
		Map<String,Integer> map = new HashMap<>();
		//增
		map.put("s", 1);
		//  V put(K key, V value);

 注意：//之后是拿的底层

我们都能看到，Hashtable比HashMap多了一个 synchronized同步，同步既排队，这大大提升了线程安全性。而HashMap非同步 线程不安全

Hashtable在jdk1.8以下键是不能存放null的

案例一、统计map集合中字符串出现的次数

String s="sadzfdsafkbsdjbfvsdjdsaksdfjdkfbuewfsdsabfdsafsdjsdafds";

 思路：

实现思路：
   1.做字符串切割，得到一个字符数组
   2.接下来遍历，拿到单个字符
   3.如果该字符没有出现过，即value值为null，那么该字符为key，值初始化为1
   4.如果已经出现过，拿到原来的值+1

 代码：

package com.oyang.map;
 
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
 
/**
 * 字符串出现的次数
 * @author yang 
 *
 * @date 2022年6月9日下午2:32:49
 */
public class Demo2 {
	public static void main(String[] args) {
        //需要创建一个字符串：
		String s="sadzfdsafkbsdjbfvsdjdsaksdfjdkfbuewfsdsabfdsafsdjsdafds";
        //切割成字符数组：
		char[] array = s.toCharArray();
        //定义一个Map集合并且循环遍历字符数组arr判断： 
		Map<Character, Integer> map=new TreeMap<>();用TreeMap可以按字母排序
		for (char c : array) {
			Integer value = map.get(c);
			if(value==null) {
				map.put(c, 1);
			}else {
				map.put(c, value+1);
			}
		}
        //拿到映射关系
		Set<Entry<Character,Integer>> set = map.entrySet();
        //循环遍历
		for (Entry<Character, Integer> entry : set) {
			System.out.println(entry.getKey()+"  出现次数:  "+entry.getValue()+"次");
		}
	}
}

结果：

 OK、我们延伸一下，按字符出现的次数进行排序

代码：

package com.oyang.map;
 
 
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;	
import java.util.Set;
import java.util.TreeMap;
 
/**
 * 字符串出现的次数
 * @author yang 
 *
 * @date 2022年6月9日下午2:32:49
 */
public class Demo2 {
	public static void main(String[] args) {
		String s="sadzfdsafkbsdjbfvsdjdsaksdfjdkfbuewfsdsabfdsafsdjsdafds";
 
		char[] array = s.toCharArray();
		Map<Character, Integer> map=new TreeMap<>();
		for (char c : array) {
			Integer value = map.get(c);
			if(value==null) {
				map.put(c, 1);
			}else {
				map.put(c, value+1);
			}
		}
		List<Map.Entry<Character, Integer>>aa=new ArrayList<>(map.entrySet());
 
		//实现接口sort
		aa.sort(new Comparator<Map.Entry<Character, Integer>>() {
//			实现Comparator
			@Override
			public int compare(Entry<Character, Integer> o1, Entry<Character, Integer> o2) {
	
				Integer sa= o1.getValue() - o2.getValue();
				
				return sa==0?o1.getKey().compareTo(o2.getKey()):sa;//出现次数一样就按照字母的循序排序
			}
		});
		
		//增强for循环遍历
		for (Entry<Character, Integer> entry : aa) {
			System.out.println(entry.getKey()+"  出现次数:  "+entry.getValue()+"次");
		}
	}
}

结果：

 二、泛型

 泛型是一种不确定的数据类型：

    比如：ArrayList<E> E就是泛型。 这种不确定的数据类型需要在使用这个类的时候才能够确定出来。

 泛型是可以省略的。如果省略，默认泛型是Object类型。

  有泛型之前：不健壮的代码，会在运行时才会把错误暴露出来

  有泛型之后：将潜在的问题暴露出来，早预防早治疗
                         将运行期出现的异常转换为编译期的错误

A、有泛型之前：

package com.oyang.map;
 
import java.util.HashSet;
import java.util.Set;
 
/**
 * @author yang 
 *
 * @date 2022年6月9日下午4:08:57
 */
public class Demo3 {
	public static void main(String[] args) {
		Set set=new HashSet<>();
		set.add(1);
		set.add(2);
		set.add(3);
		set.add(4);
		set.add(5);
		set.add(6 );
		for (Object obj : set) {
			if(Integer.valueOf(obj.toString()) %2==0) {
				System.out.println(obj);
			}
		}
		
		
	}
}

此时，编译期没有错，运行也是没有错的：

 但是，当其他调用者并不知道要输入什么类型，如果他输入字符串时，会产生什么后果呢？

package com.oyang.map;
 
import java.util.HashSet;
import java.util.Set;
 
/**
 * @author yang 
 *
 * @date 2022年6月9日下午4:08:57
 */
public class Demo3 {
	public static void main(String[] args) {
		Set set=new HashSet<>();
		set.add(1);
		set.add(2);
		set.add(3);
		set.add(4);
		set.add(5);
		set.add("a");
		for (Object obj : set) {
			if(Integer.valueOf(obj.toString()) %2==0) {
				System.out.println(obj);
			}
		}
	}
}

此时，编译期没有错，但是运行期呢？

 我们可以看到，不加泛型：不会出现编译报错！但是运行有问题

B、有泛型之后：

 数据类型不匹配时编译期就直接报错！

在一些重复性的方法进行多个类的使用时，添加泛型进行编码效率的提高！

三、集合框架工具类

A、集合之间的相互转换

package com.oyang.map;
 
import java.util.Arrays;
import java.util.List;
 
/**
 * @author yang 
 *
 * @date 2022年6月9日下午4:54:29
 */
public class Demo4 {
	public static void main(String[] args) {
		String [] arr = {"a","b","c","e"};
		List<String> list=Arrays.asList(arr);//数组的长度是不可变的，哪怕是转换成了集合，底层依然还是数组
//		Object[] array = list.toArray();//集合转数组
		list.add("f");
		//java.lang.UnsupportedOperationException 
		System.out.println(list.size());	
	}
}

运行后： 

Aa、结论：

 集合之间的相互转换:

1.数组转成集合，本质上依然是一个数组，哪怕是转换成了集合，底层依然还是数组
2.集合与数组所具备的方法是不一样的，如对于数组而言，就没有判断内部包含哪个元素，而集合有

B、基本数据类型排序

sort(List):根据元素的自然顺序对指定List集合元素按升序排序

sort(List,Comparator):根据指定的Comparator产生的顺序对List集合元素进行排序

package com.oyang.map;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
 
/**
 * 对于工具类其他方法的应用
 * sort
 * tostring
 * @author yang 
 *
 * @date 2022年6月9日下午5:05:35
 */
public class Demo5 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		list.add("c");
		list.add("h");
		list.add("b");
		list.add("f");
		list.add("r");
		list.add("a");
		System.out.println("正常打印："+list);
 		Collections.sort(list);
		System.out.println("排序后："+list);
		//这里面的x、y指的是集合中的元素
		Collections.sort(list, (x,y)->y.compareTo(x));
		System.out.println("降序后："+list);
	}
}

结果：

 C、对象等其他数据类型排序

代码：

package com.oyang.map;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
 
/**
 * 对于工具类其他方法的应用
 * sort
 * tostring
 * @author yang 
 *
 * @date 2022年6月9日下午5:05:35
 */
public class Demo5 {
	public static void main(String[] args) {
		System.out.println("============对象=============");
		List<Person> list = new ArrayList<>();
		list.add(new Person("c",20));
		list.add(new Person("a",13));
		list.add(new Person("f",54));
		list.add(new Person("h",45));
		list.add(new Person("d",38));
		list.add(new Person("m",22));
		System.out.println("升序"+list);
		Collections.sort(list, (x,y)->x.getName().compareTo(y.getName()));
		System.out.println("降序："+list);
		
		System.out.println("============数组=============");
		//升序
		Integer [] arr= {2,5,1,7,4,8,6};
		 Arrays.sort(arr);
		 System.out.println("升序："+Arrays.toString(arr));
		 
		//降序
		 Integer [] arra= {2,5,1,7,4,8,6};
		 Arrays.sort(arra, (x,y)-> y-x);
		 System.out.println("降序："+Arrays.toString(arra));
	}
}
/**
 * Person 实体类
 * @author yang 
 *
 * @date 2022年6月9日下午6:13:35
 */
class Person{
	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 Person() {
		// TODO Auto-generated constructor stub
	}
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
}

 结果：

---

 OK，今日的学习就到此结束啦，如果对个位看官有帮助的话可以留下免费的赞哦(收藏或关注也行),如果文章中有什么问题或不足以及需要改正的地方可以私信博主，博主会做出改正的。个位看官，小陽在此跟大家说拜拜啦！