前言
上篇(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;
public class Demo1 {
public static void main(String[] args) {
Map 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;
public class Demo1 {
public static void main(String[] args) {
Map 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"));
查单个根据键拿到值
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));
}
先拿到map集合中所有的key(键)后再遍历
结果:
Cc、查询所有(两种方式)-第二种
拿到映射关系,键值都有了
//第二种:拿到映射关系
Set> entrySet = map.entrySet();
for (Entry entry : entrySet) {
System.out.println("键:"+entry.getKey()+"值:"+entry.getValue());
}
拿到映射关系,键值都有了
结果:
D、HashMap与Hashtable的区别
Hashtable hashtable = new Hashtable<>();
// public synchronized V put(K key, V value) synchronized同步
hashtable.put("a", 12);
Map 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
注意://之后是拿的底层
我们都能看到,Hashtable比HashMap多了一个 synchronized同步,同步既排队,这大大提升了线程安全性。而HashMap非同步 线程不安全
Hashtable在jdk1.8以下键是不能存放null的
String s="sadzfdsafkbsdjbfvsdjdsaksdfjdkfbuewfsdsabfdsafsdjsdafds";
思路:
实现思路:
1.做字符串切割,得到一个字符数组
2.接下来遍历,拿到单个字符
3.如果该字符没有出现过,即value值为null,那么该字符为key,值初始化为1
4.如果已经出现过,拿到原来的值+1
实现思路:
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;
public class Demo2 {
public static void main(String[] args) {
//需要创建一个字符串:
String s="sadzfdsafkbsdjbfvsdjdsaksdfjdkfbuewfsdsabfdsafsdjsdafds";
//切割成字符数组:
char[] array = s.toCharArray();
//定义一个Map集合并且循环遍历字符数组arr判断:
Map 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> set = map.entrySet();
//循环遍历
for (Entry 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;
public class Demo2 {
public static void main(String[] args) {
String s="sadzfdsafkbsdjbfvsdjdsaksdfjdkfbuewfsdsabfdsafsdjsdafds";
char[] array = s.toCharArray();
Map 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>aa=new ArrayList<>(map.entrySet());
//实现接口sort
aa.sort(new Comparator>() {
// 实现Comparator
@Override
public int compare(Entry o1, Entry o2) {
Integer sa= o1.getValue() - o2.getValue();
return sa==0?o1.getKey().compareTo(o2.getKey()):sa;//出现次数一样就按照字母的循序排序
}
});
//增强for循环遍历
for (Entry entry : aa) {
System.out.println(entry.getKey()+" 出现次数: "+entry.getValue()+"次");
}
}
}
结果:
二、泛型
泛型是一种不确定的数据类型:
比如:ArrayList E就是泛型。 这种不确定的数据类型需要在使用这个类的时候才能够确定出来。
泛型是可以省略的。如果省略,默认泛型是Object类型。
有泛型之前:不健壮的代码,会在运行时才会把错误暴露出来
有泛型之后:将潜在的问题暴露出来,早预防早治疗
将运行期出现的异常转换为编译期的错误
A、有泛型之前:
package com.oyang.map;
import java.util.HashSet;
import java.util.Set;
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);
}
}
}
}
泛型是一种不确定的数据类型:
比如:ArrayList
泛型是可以省略的。如果省略,默认泛型是Object类型。
有泛型之前:不健壮的代码,会在运行时才会把错误暴露出来
有泛型之后:将潜在的问题暴露出来,早预防早治疗
将运行期出现的异常转换为编译期的错误
package com.oyang.map;
import java.util.HashSet;
import java.util.Set;
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;
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;
public class Demo4 {
public static void main(String[] args) {
String [] arr = {"a","b","c","e"};
List list=Arrays.asList(arr);//数组的长度是不可变的,哪怕是转换成了集合,底层依然还是数组
// Object[] array = list.toArray();//集合转数组
list.add("f");
//java.lang.UnsupportedOperationException
System.out.println(list.size());
}
}
package com.oyang.map;
import java.util.Arrays;
import java.util.List;
public class Demo4 {
public static void main(String[] args) {
String [] arr = {"a","b","c","e"};
List 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;
public class Demo5 {
public static void main(String[] args) {
List 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);
}
}
集合之间的相互转换:
1.数组转成集合,本质上依然是一个数组,哪怕是转换成了集合,底层依然还是数组
2.集合与数组所具备的方法是不一样的,如对于数组而言,就没有判断内部包含哪个元素,而集合有
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;
public class Demo5 {
public static void main(String[] args) {
List 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;
public class Demo5 {
public static void main(String[] args) {
System.out.println("============对象=============");
List 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));
}
}
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,今日的学习就到此结束啦,如果对个位看官有帮助的话可以留下免费的赞哦(收藏或关注也行),如果文章中有什么问题或不足以及需要改正的地方可以私信博主,博主会做出改正的。个位看官,小陽在此跟大家说拜拜啦!



