集合框架Map介绍
Map中存放的都是一组组映射关系（Key==value）
Map中的key不要求有序，不允许重复。value同样不要求有序，但可以重复。
最常见的Map实现类是HashMap，
储存方式是哈希表，优点是查询指定元素效率高。
在集合中是允许嵌套的
在map集合中key值不能重复，但是value值可以
put:
- 往集合容器中添加键值对映射关系
- 当集合中存在该键的映射关系，后来的关系会覆盖前面的映射关系
代码演示：
package com.xhh.map;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
/**
* 三个map集合中特别的方法
* 1、put
* 新增的用途
* 修改的用途（当容器中已经存在了的key，再次存放，那么会覆盖原有的key所对应的值 value）
* 调用此方法，可以获取原来的key对应的值
* 开发中的案例：
* 主播刷排名
* @author Administrator
*/
public class MapDemo {
public static void main(String[] args) {
Map<Object, Object> map=new HashMap<>();
map.put("a", 12);
map.put("b", 24);
map.put("c", 34);
map.put("d", 46);
map.put("e", 56);
map.put("a", 15);
System.out.println(map);
}
}
运行结果：
运行结果：
调用次方法，可以获取原来key对应的值
Map特有的遍历方式
- 第一种：map.entrySet
代码演示：
package com.xhh.map;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
/**
* 三个map集合中特别的方法
* 1、put
* 新增的用途
* 修改的用途（当容器中已经存在了的key，再次存放，那么会覆盖原有的key所对应的值value）
* 调用此方法，可以获取原来的key对应的值
* 开发中的案例：
* 主播刷排名
*
* 2、entrySet
* 3、keySet
* 这两个方法是map集合中所特有的遍历方法
*
* HashMap是无序的，集合的底层是set集合做的
*
* HashMap 数据结构 哈希表
* TreeMap 数据结构 二叉树
* 能够进行自然排序以及比较器排序
*
* map集合是不继承collection接口的
* 这也就意味着它不具备迭代器的方法
*
* @author Administrator
* */
public class MapDemo {
public static void main(String[] args) {
Map<Object, Object> map=new HashMap<>();
map.put("zs", 12);
map.put("ww", 23);
map.put("ls", 33);
map.put("zl", 22);
map.put("tq", 42);
map.put("mazi", 62);
Object old=map.put("zl", 23);
System.out.println(map);
System.out.println(old);
Set<Entry<Object,Object>> entrySet=map.entrySet();
for (Entry<Object, Object> entry : entrySet) {
System.out.println("key:"+entry.getKey()+",value:"+entry.getValue());
}
}
}
运行结果：
- 第二种：map.keySet
代码演示：
package com.xhh.map;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
/**
- 三个map集合中特别的方法
- 1、put
- 新增的用途
- 修改的用途（当容器中已经存在了的key，再次存放，那么会覆盖原有的key所对应的值value）
- 调用此方法，可以获取原来的key对应的值
- 开发中的案例：
- 主播刷排名
-
- 2、entrySet
- 3、keySet
- 这两个方法是map集合中所特有的遍历方法
-
- HashMap是无序的，集合的底层是set集合做的
-
- HashMap 数据结构 哈希表
- TreeMap 数据结构 二叉树
- 能够进行自然排序以及比较器排序
-
- map集合是不继承collection接口的
- 这也就意味着它不具备迭代器的方法
-
- @author Administrator
- */
public class MapDemo {
public static void main(String[] args) {
Map<Object, Object> map=new HashMap<>();
map.put("zs", 12);
map.put("ww", 23);
map.put("ls", 33);
map.put("zl", 22);
map.put("tq", 42);
map.put("mazi", 62);
Object old=map.put("zl", 23);
System.out.println(map);
System.out.println(old);
Set<Entry<Object,Object>> entrySet=map.entrySet();
for (Entry<Object, Object> entry : entrySet) {
System.out.println("key:"+entry.getKey()+",value:"+entry.getValue());
}
System.out.println("---------------------");
Set<Object> keySet =map.keySet();
for (Object key : keySet) {
System.out.println("key:"+key+",value:"+map.get(key));
}
}
}
运行结果：
Map集合和Collection集合的区别
- Map集合是有Key和Value的，Collection集合是只有Value。
- Collection集合底层也是有Key和Value，只是隐藏起来
- Map不是Collection的接口
- Map接口有三个实现类：HashMap，HashTable，LinkeHashMap
- Map特点：元素按键值对存储，无放入顺序
- map集合中的泛型要使用包装类，或者是引用数据类型
小结：
Map
Hashtable：底层是哈希表数据结构，不可以存入null键null值，该集合石线程同步的，jdk1.0，效率低
HashMap：底层是哈希表数据结构，允许使用null值和null键，该集合是不同步的。将Hashtable替代；jdk1.2，效率高
TreeMap：底层是二叉树数据结构，线程不同步，可以用于给Map集合中的键进行排序
注意：
添加元素时，如果键已经在集合中存在，那么后添加的值会覆盖原来的值，并且put方法会将原有的值返回
Map集合的应用
应用1：
1.将学生作为键，地址作为值进行存储，名字年龄相同则被认定为一个人，最后输出
思路:
- 封装学生类
- 判重(hashCode/eqequals)
- 打印
代码演示：
package com.xhh.map;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Set;
import java.util.TreeMap;
public class HashMapDemo {
public static void main(String[] args) {
HashMap map=new HashMap<>();
// TreeMap map=new TreeMap<>(new StuNameComp());
map.put(new Student("zs", 25), "beijing");
map.put(new Student("ls", 35), "shanghai");
map.put(new Student("ww", 28), "guangzhou");
map.put(new Student("zl", 25), "shenzheng");
map.put(new Student("ls", 25), "changsha");
map.put(new Student("ls", 25), "hangzhou");
Set keySet=map.keySet();
for (Object key : keySet) {
System.out.println(key);
}
}
}
class Student {
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;
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("Student [name=");
builder.append(name);
builder.append(", age=");
builder.append(age);
builder.append("]");
return builder.toString();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Student() {
super();
}
@Override
public int hashCode() {
return this.name.hashCode()+this.age;
}
@Override
public boolean equals(Object obj) {
Student stu=(Student) obj;
return this.name.equals(stu.name) && this.age==stu.age;
}
}
运行结果：
从打印结果可以看出，名字年龄相同已经被认定为一个人
2.最后按年龄进行排序
代码：
package com.xhh.map;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Set;
import java.util.TreeMap;
public class HashMapDemo {
public static void main(String[] args) {
HashMap map=new HashMap<>();
// TreeMap map=new TreeMap<>(new StuNameComp());
map.put(new Student("zs", 25), "beijing");
map.put(new Student("ls", 35), "shanghai");
map.put(new Student("ww", 28), "guangzhou");
map.put(new Student("zl", 25), "shenzheng");
map.put(new Student("ls", 25), "changsha");
map.put(new Student("ls", 25), "hangzhou");
Set keySet=map.keySet();
for (Object key : keySet) {
System.out.println(key);
}
}
}
class Student implements Comparable<Student>{
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;
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("Student [name=");
builder.append(name);
builder.append(", age=");
builder.append(age);
builder.append("]");
return builder.toString();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Student() {
super();
}
@Override
public int hashCode() {
return this.name.hashCode()+this.age;
}
@Override
public boolean equals(Object obj) {
Student stu=(Student) obj;
return this.name.equals(stu.name) && this.age==stu.age;
}
/**
* 按年龄进行排序
* 比完主要条件，在比次要条件
*/
@Override
public int compareTo(Student o) {
int num=this.age-o.age;
if(num==0) {
this.name.compareTo(o.name);
}
return num;
}
}
运行结果：
3.需求改变、按姓名进行排序
package com.xhh.map;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Set;
import java.util.TreeMap;
public class HashMapDemo {
public static void main(String[] args) {
// HashMap map=new HashMap<>();
TreeMap map=new TreeMap<>(new StuNameComp());
map.put(new Student("zs", 25), "beijing");
map.put(new Student("ls", 35), "shanghai");
map.put(new Student("ww", 28), "guangzhou");
map.put(new Student("zl", 25), "shenzheng");
map.put(new Student("ls", 25), "changsha");
map.put(new Student("ls", 25), "hangzhou");
Set keySet=map.keySet();
for (Object key : keySet) {
System.out.println(key);
}
}
}
/**
* 按名字进行排序
* @author linyaodong
*
*/
class StuNameComp implements Comparator<Student>{
@Override
public int compare(Student o1, Student o2) {
int num=o1.getName().compareTo(o2.getName());
if(num==0) {
return o1.getAge()-o2.getAge();
}
return num;
}
}
class Student implements Comparable<Student>{
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;
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("Student [name=");
builder.append(name);
builder.append(", age=");
builder.append(age);
builder.append("]");
return builder.toString();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Student() {
super();
}
@Override
public int hashCode() {
return this.name.hashCode()+this.age;
}
@Override
public boolean equals(Object obj) {
Student stu=(Student) obj;
return this.name.equals(stu.name) && this.age==stu.age;
}
/**
* 比完主要条件，在比次要条件
*
*/
@Override
public int compareTo(Student o) {
int num=this.age-o.age;
if(num==0) {
this.name.compareTo(o.name);
}
return num;
}
}
运行结果：
应用2：
1.统计字符出现的次数
2.从a到z进行排序
分析:
- 字符是唯一的,可以将其作为map集合的key,次数就是map集合的值value
- 将指定的字符串装到一个集合中进行筛选,将字符串转成一个数
- 当字符第一次出现的时候,意味着在map集合中找不到对应的value值,给它赋值唯一当字符第二次出现的时候,意味着map集合中存在对应的值,给它对应的值加1
代码演示：
package com.xhh.map;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
/**
* 统计字符串中字符出现次数
* alklalkdnadadaawdaw
* a(7)d(4)....w(2)
1、分析结果得出结论：我们需要将字符a-z当作键key，将次数作为值value，
* 也就是说我们需要创建一个map集合来做这些事情
* 2、需要将待处理的字符串转成字符数组，以便于获取map集合的key
* 3、如果该字符（a）第一出现的时候，就给a对应key映射值value赋值为1
* 如果说该字符再次出现，那么就是value+1；
* 4、打印出a(4)b(9)...z(7)格式串
* 意味着需要对key进行排序
* @author linyaodong
* */
public class TreeMapDemo {
public static void main(String[] args) {
String str="alklalkdnadadaawdaw";
// Map<Character, Integer> map=new HashMap<>();
Map<Character, Integer> map=new TreeMap<>();
char [] chaeArry= str.toCharArray();
for (char c : chaeArry) {
Integer obj=map.get(c);
if(obj==null) {
//之前没有出现过，这是第一次出现
map.put(c, 1);
}else {
//之前这个字符已经出现过
map.put(c, ++obj);
}
}
StringBuilder sb=new StringBuilder();
Set<Entry<Character, Integer>> entrtySet=map.entrySet();
for (Entry<Character, Integer> entry : entrtySet) {
sb.append(entry.getKey()+"("+entry.getValue()+")");
}
System.out.println(sb);
}
}
运行结果：
集合框架工具类（Collections、Arrays）
Collections.reverseOrder() 反转
- 正常排序
代码演示：
package com.xhh.map;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
public class HashMapDemo {
public static void main(String[] args) {
// HashMap map=new HashMap<>();
TreeMap map=new TreeMap<>(new StuNameComp());
map.put(new Student("zs", 25), "beijing");
map.put(new Student("ls", 35), "shanghai");
map.put(new Student("ww", 28), "guangzhou");
map.put(new Student("zl", 25), "shenzheng");
map.put(new Student("ls", 25), "changsha");
map.put(new Student("ls", 25), "hangzhou");
Set<Entry<Student, String>>entrySet=map.entrySet();
for (Entry<Student, String> entry : entrySet) {
System.out.println(entry.getKey()+"----"+entry.getValue());
}
}
}
/**
* 按名字进行排序
* @author linyaodong
*
*/
class StuNameComp implements Comparator<Student>{
@Override
public int compare(Student o1, Student o2) {
int num=o1.getName().compareTo(o2.getName());
if(num==0) {
return o1.getAge()-o2.getAge();
}
return num;
}
}
class Student implements Comparable<Student>{
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;
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("Student [name=");
builder.append(name);
builder.append(", age=");
builder.append(age);
builder.append("]");
return builder.toString();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Student() {
super();
}
@Override
public int hashCode() {
return this.name.hashCode()+this.age;
}
@Override
public boolean equals(Object obj) {
Student stu=(Student) obj;
return this.name.equals(stu.name) && this.age==stu.age;
}
/**
* 比完主要条件，在比次要条件
*
*/
@Override
public int compareTo(Student o) {
int num=this.age-o.age;
if(num==0) {
this.name.compareTo(o.name);
}
return num;
}
}
运行结果：
- 反转倒序
代码演示
package com.xhh.map;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
public class HashMapDemo {
public static void main(String[] args) {
// HashMap map=new HashMap<>();
TreeMap map=new TreeMap<>(Collections.reverseOrder(new StuNameComp()));
map.put(new Student("zs", 25), "beijing");
map.put(new Student("ls", 35), "shanghai");
map.put(new Student("ww", 28), "guangzhou");
map.put(new Student("zl", 25), "shenzheng");
map.put(new Student("ls", 25), "changsha");
map.put(new Student("ls", 25), "hangzhou");
Set<Entry<Student, String>>entrySet=map.entrySet();
for (Entry<Student, String> entry : entrySet) {
System.out.println(entry.getKey()+"----"+entry.getValue());
}
}
}
/**
* 按名字进行排序
* @author linyaodong
*
*/
class StuNameComp implements Comparator<Student>{
@Override
public int compare(Student o1, Student o2) {
int num=o1.getName().compareTo(o2.getName());
if(num==0) {
return o1.getAge()-o2.getAge();
}
return num;
}
}
class Student implements Comparable<Student>{
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;
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("Student [name=");
builder.append(name);
builder.append(", age=");
builder.append(age);
builder.append("]");
return builder.toString();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Student() {
super();
}
@Override
public int hashCode() {
return this.name.hashCode()+this.age;
}
@Override
public boolean equals(Object obj) {
Student stu=(Student) obj;
return this.name.equals(stu.name) && this.age==stu.age;
}
/**
* 比完主要条件，在比次要条件
*
*/
@Override
public int compareTo(Student o) {
int num=this.age-o.age;
if(num==0) {
this.name.compareTo(o.name);
}
return num;
}
}
运行结果：
扫一扫
1071
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
