Map集合
前言：
set集合中的自然排序和比较器排序
目录
一、map集合的特点及遍历方式
二、字符串出现的次数
三.泛型
一、map集合的特点及遍历方式
代码展示：
package com.chendongli.map;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
* map集合的特点
* 键值对
* 遍历：拿到key再拿值
* 拿到映射关系 键值都有了
* @author zjjt
*
*/
public class Demo1 {
public static void main(String[] args) {
Map map = new HashMap<>();
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);
map.put("d", 4);
System.out.println("添加"+map);
Object remove = map.remove("b");
System.out.println("删除后"+map);
System.out.println("删除的元素"+remove);
map.put("c", 32);
System.out.println("修改后"+map);
// 查询单个
System.out.println("查询单个"+map.get("c"));
// 查询所有
//第一种方法：先拿到map集合中的所有key
Set keys = map.keySet();
for (Object key : keys) {
System.out.println("① 键："+key+"值："+map.get(key));
}
//第二种方法：拿到映射关系
Set> entryset = map.entrySet();
for (Entry entry : entryset) {
System.out.println("② 键："+entry.getKey()+"值："+entry.getValue());
}
}
} 效果图：
面试题：
Hashtable与hashmap都是以键值对的方式存在
Hashtable与hashmap的区别：1、Hashtable 是线程安全的 2、jdk1.8以下Hashtable的key是不能存放null
论证1的代码：
Hashtable table = new Hashtable<>();
table.put("s", 1);//public synchronized V put(K key, V value)
Map map = new HashMap<>();//V put(K key, V value);
map.put("a", 1); 二、字符串出现的次数
代码展示：
package com.chendongli.map;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
public class Demo2 {
public static void main(String[] args) {
String s = "asjhdfhjhsafjsjljkejrjtjttrjytj";
/**
* 实现思路：
* 1.做字符串的切割：得到一个字符数组
* 2.接下来遍历，拿到单个字符
* 3.如果该字符没有出现过，即value值为null，那么该字符为key，值初始化为1
* 4.如果已经出现过，拿到原来的值加1
*
* debugger的使用：调试代码
* 1.打断点
* 2.采用debug的方式运行程序
* 3.进入调试窗口，左上方有一个step over调试箭头，快捷键F6
* 4.接下来可以通过F6一步步调试当前程序对应的每一个变量值
*/
char [] arr = s.toCharArray();
Map map = new HashMap<>();
for (char c : arr) {
Integer value = map.get(c);
if(value == null) {
map.put(c, 1);
}
else {
map.put(c, value+1);
}
}
Set> entryset = map.entrySet();
for (Entry entry : entryset) {
System.out.println(entry.getKey()+":"+entry.getValue());
}
}
}
效果图：
拓展：字符串出现的次数+按字符排序
代码展示：
package com.chendongli.map;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.Map.Entry;
public class Demo2 {
public static void main(String[] args) {
String s = "asjhdfhjhsafjsjljkejrjtjttrjytj";
/**
* 实现思路：
* 1.做字符串的切割：得到一个字符数组
* 2.接下来遍历，拿到单个字符
* 3.如果该字符没有出现过，即value值为null，那么该字符为key，值初始化为1
* 4.如果已经出现过，拿到原来的值加1
*
* debugger的使用：调试代码
* 1.打断点
* 2.采用debug的方式运行程序
* 3.进入调试窗口，左上方有一个step over调试箭头，快捷键F6
* 4.接下来可以通过F6一步步调试当前程序对应的每一个变量值
*作业：按照字符的出现次数进行排序输出
*/
char [] arr = s.toCharArray();
Map map = new TreeMap<>();
for (char c : arr) {
Integer value = map.get(c);
if(value == null) {
map.put(c, 1);
}
else {
map.put(c, value+1);
}
}
Set> entryset = map.entrySet();
for (Entry entry : entryset) {
System.out.println(entry.getKey()+":"+entry.getValue());
}
}
}
效果图：
字符出现次数的排序
代码展示：
package com.chendongli.map;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.Map.Entry;
public class Demo2 {
public static void main(String[] args) {
String s = "asjhdfhjhsafjsjljkejrjtjttrjytj";
/**
* 实现思路：
* 1.做字符串的切割：得到一个字符数组
* 2.接下来遍历，拿到单个字符
* 3.如果该字符没有出现过，即value值为null，那么该字符为key，值初始化为1
* 4.如果已经出现过，拿到原来的值加1
*
* debugger的使用：调试代码
* 1.打断点
* 2.采用debug的方式运行程序
* 3.进入调试窗口，左上方有一个step over调试箭头，快捷键F6
* 4.接下来可以通过F6一步步调试当前程序对应的每一个变量值
*作业：按照字符的出现次数进行排序输出
*/
char [] arr = s.toCharArray();
Map map = new TreeMap<>();
for (char c : arr) {
Integer value = map.get(c);
if(value == null) {
map.put(c, 1);
}
else {
map.put(c, value+1);
}
}
List> listMap = new ArrayList<> (map.entrySet());
//System.out.println(listMap);
Set> entryset = map.entrySet();
//方法一
for (Map.Entry entry : entryset) {
// System.out.println(entry.getKey() + ":" + entry.getValue());
//listMap.add(entry);
}
// listMap.stream().sorted((o1,o2)->{
// return o1.getValue() - o2.getValue();
// }).forEach((item)->{
// System.out.println("降序"+item.getKey()+":"+item.getValue());
// });
//方法二
Collections.sort(listMap, new Comparator>(){
@Override
public int compare(Entry o1, Entry o2) {
return o1.getValue() - o2.getValue();
}
});
System.out.println("升序"+listMap);
}
}
效果图：
三.泛型
打印偶数
代码展示：
package com.chendongli.map;
import java.util.HashSet;
import java.util.Set;
/**
* 泛型
* @author zjjt
*
*/
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);
for (Object obj : set) {
if(Integer.valueOf(obj.toString()) % 2 == 0) {
System.out.println("打印偶数"+obj);
}
}
}
}效果图：
可能出现的情况：
泛型出现之前，不健壮的代码，会在运行时才会把错误暴露出来
泛型出现之后，将潜在的问题暴露出来，早预防早治疗
将运行器出现的异常转换为编译器期间的错误
代码展示：
package com.chendongli.map;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 集合之间的相互转换
* @author zjjt
*
*/
public class Demo4 {
public static void main(String[] args) {
String [] arr = {"a","b","c","d"};
List list = Arrays.asList(arr);
list.add("e");
System.out.println(list.size());
}
} 运行结果：
注意：数组转换之后还是一个数组，所以这种编码是不可以的
代码展示：
package com.chendongli.map;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
/**
* 对于工具类其他方法的运用
* sort
* tostring
* @author zjjt
*
*/
public class Demo5 {
public static void main(String[] args) {
List list = new ArrayList<>();
list.add("b");
list.add("c");
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);
}
} 效果图：
代码展示：
package com.chendongli.map;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
/**
* 对于工具类其他方法的运用
* sort
* tostring
* @author zjjt
*
*/
public class Demo5 {
public static void main(String[] args) {
// List list = new ArrayList<>();
// list.add("b");
// list.add("c");
// 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);
List list = new ArrayList<>();
list.add(new Person("a", 18));
list.add(new Person("c", 17));
list.add(new Person("b", 20));
System.out.println(list);
// Collections.sort(list);
Collections.sort(list, (y,x)-> x.getName().compareTo(y.getName()));
System.out.println("倒序"+list);
Integer [] arr = {3,6,9,2,5,8};
Arrays.sort(arr,(x,y)-> y - x);
System.out.println("简单ff==="+Arrays.toString(arr));
}
}
class Person /*implements Comparable*/{
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) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
/*@Override
public int compareTo(Person o) {
return o.getName().compareTo(this.name);
}*/
}
效果图：
