Map集合下的常用类：
Map（键值对、键唯一、值不唯一）
Map集合中存储的是键值对，键不能重复，值可以重复。根据键得到值，对map集合遍历时先得到键的set集合，对set集合进行遍历，得到相应的值。
HashTable：底层的数据结构使用的是哈希表； 不可以存入null键null值； 该集合是线程同步的； 效率低；
HashMap：底层的数据结构使用的是哈希表； 可以存入null键null值； 该集合不是线程同步的； 效率高；
TreeMap：底层的数据接口使用的是二叉树； 线程不同步； 可以用于给Map集合中的键进行排序；
put:
1,往集合容器中添加键值对映射关系，
2，当集合中存在该键的映射关系，后来的关系会覆盖前面的映射关系
具体代码
package com.zhoutubing.map;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
* 初始map
* put
* 1.往集合容器中添加键值对映射关系
* 2.当集合中存在该键的映射关系，后来的映射关系会覆盖前面的映射关系
* 3.会返回上一个映射关系对应的值
* keySet
*
*
* entrySet
*
* 多表联查用map list<map>
* @author Administrator
*
*/
public class MapDemo {
public static void main(String[] args) {
Map<String, String> map=new HashMap<>();
map.put("zs", "65");
map.put("ls", "42");
map.put("ww", "23");
map.put("mz", "12");
map.put("zs", "24");
System.out.println(put);
}
}
结果图：
keyset拿值：
具体代码
package com.zhoutubing.map;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
* 初始map
* put
* 1.往集合容器中添加键值对映射关系
* 2.当集合中存在该键的映射关系，后来的映射关系会覆盖前面的映射关系
* 3.会返回上一个映射关系对应的值
* keySet
*
*
* entrySet
*
* 多表联查用map list<map>
* @author Administrator
*
*/
public class MapDemo {
public static void main(String[] args) {
Map<String, String> map=new HashMap<>();
map.put("zs", "65");
map.put("ls", "42");
map.put("ww", "23");
map.put("mz", "12");
map.put("zs", "24");
Set<String> keySet = map.keySet();
for (String key : keySet) {
System.out.println(key + ":" + map.get(key));
}
}
}
通过key值拿到value值
entrySet拿值：
具体代码
package com.zhoutubing.map;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
* 初始map
* put
* 1.往集合容器中添加键值对映射关系
* 2.当集合中存在该键的映射关系，后来的映射关系会覆盖前面的映射关系
* 3.会返回上一个映射关系对应的值
* keySet
*
*
* entrySet
*
* 多表联查用map list<map>
* @author Administrator
*
*/
public class MapDemo {
public static void main(String[] args) {
Map<String, String> map=new HashMap<>();
map.put("zs", "65");
map.put("ls", "42");
map.put("ww", "23");
map.put("mz", "12");
map.put("zs", "24");
Set<Entry<String, String>> entrySet = map.entrySet();
for (Entry<String, String> entry : entrySet) {
System.out.println(entry.getKey() +":"+ entry.getValue());
}
}
}
map应用：
当后面key，value值与之前的一样时 要重写equals和hashcody方法才会覆盖
package com.zhoutubing.map;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
/**
* 应用一：
1、将学生作为键，地址作为值进行存储，名字年龄相同则被认定为一个人，最后输出
2、最后按年龄进行排序
3、需求改变、按姓名进行排序
分析:
1.1 封装出一个学生的实体类
1.2 将不同的学生作为key，不同的地址作为value，存放到Map集合中
1.3 需要将重复的key给剔除掉
* @author Administrator
*
*/
public class TreeMapDemo {
public static void main(String[] args) {
HashMap<Student, String> hm=new HashMap<>();
hm.put(new Student("zs", 13), "beijing");
hm.put(new Student("ls", 16), "shanghai");
hm.put(new Student("ww", 29), "guanzhou");
hm.put(new Student("mz", 18), "shenzheng");
hm.put(new Student("zss", 13), "hangzhou");
System.out.println(hm.size());
Set<Entry<Student, String>> entrySet = hm.entrySet();
}
}
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;
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Student() {
super();
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
}
应用一：
1、将学生作为键，地址作为值进行存储，名字年龄相同则被认定为一个人，最后输出
2、最后按年龄进行排序
3、需求改变、按姓名进行排序
实现代码
package com.zhoutubing.map;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
/**
* 应用一：
1、将学生作为键，地址作为值进行存储，名字年龄相同则被认定为一个人，最后输出
2、最后按年龄进行排序
3、需求改变、按姓名进行排序
分析:
1.1 封装出一个学生的实体类
1.2 将不同的学生作为key，不同的地址作为value，存放到Map集合中
1.3 需要将重复的key给剔除掉
* @author Administrator
*
*/
public class TreeMapDemo {
public static void main(String[] args) {
// HashMap<Student, String> hm=new HashMap<>();
// TreeMap<Student, String> hm=new TreeMap<>();
TreeMap<Student, String> hm=new TreeMap<>(new stuComp());
hm.put(new Student("zs", 13), "beijing");
hm.put(new Student("ls", 16), "shanghai");
hm.put(new Student("ww", 29), "guanzhou");
hm.put(new Student("mz", 18), "shenzheng");
hm.put(new Student("zss", 13), "hangzhou");
// System.out.println(hm.size());
Set<Entry<Student, String>> entrySet = hm.entrySet();
for (Entry<Student, String> entry : entrySet) {
System.out.println(entry.getKey() + "---->" + entry.getValue());
}
}
}
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;
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Student() {
super();
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
@Override
public int hashCode() {
return this.getName().hashCode() + this.age;
}
@Override
public boolean equals(Object obj) {
if(obj instanceof Student) {
Student stu=(Student)obj;
return this.getName().equals(stu.getName()) && this.getAge()== stu.getAge();
}
return false;
}
@Override
public int compareTo(Student o) {
int num=this.getAge() - o.getAge();
if(num == 0) {
return this.getName().compareTo(o.getName());
}
return num;
}
}
class stuComp implements Comparator<Student>{
@Override
public int compare(Student o1, Student o2) {
// TODO Auto-generated method stub
int num=o1.getName().compareTo(o2.getName());
if(num == 0) {
return o1.getAge() - o2.getAge();
}
return num;
}
}
输出结果为：
这是按照a-z排序的
应用二：
统计字符串中字符出现次数
按次数排序
实现代码
package com.zhoutubing.map;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
/**
* 应用二：
统计字符串中字符出现次数
按次数排序
1. 统计字符出现的次数？
2. 从a到z进行统计
分析：
1. 字符是唯一的，可以将其作为map集合的key，次数就是map集合的值value；
2. 将指定的字符串装到一个集合中进行筛选，将字符串转成一个字符；
3. 当字符第一次出现的时候，意味着在map集合中找不到对应的value值
当字符第二次出现的时候，意味着map集合中存在对应的值，给他对应的值加一
* @author Administrator
*
*/
public class HashMapDemo {
public static void main(String[] args) {
String s="sdfagaewfaqwqwyjjnffdfbsdfanmadsww";
getRepeatTimes(s);
}
/**
* 统计次数的方法
*/
private static void getRepeatTimes(String s) {
// TODO Auto-generated method stub
char[] charArray = s.toCharArray();
Map<Character, Integer> map=new TreeMap<>();
for (char c : charArray) {
if(map.get(c)==null) {
map.put(c, 1);
}else {
map.put(c, map.get(c)+1);
// i++ 先赋值后运算, ++i 先运算后赋值;
}
}
StringBuffer sb= new StringBuffer();
Set<Entry<Character, Integer>> entrySet = map.entrySet();
for (Entry<Character, Integer> entry : entrySet) {
sb.append(entry.getKey()+"("+entry.getValue()+")");
}
System.out.println(sb.toString());
}
}
效果图：
拓展：
Map是一个键值对的集合。也就是说，一个映射不能包含重复的键，每个键最多映射到一个值。该接口取代了Dictionary抽象类。实现map接口的类有：HashMap、TreeMap、HashTable、Properties、EnumMap。
散列映射表对键进行散列，树映射表用键的整体顺序对元素进行排序，并将其组织成搜索村。散列或比较函数只能作用于键，与键关联的值不能进行散列或比较。
如何选择散列映射表与树映射表。散列稍微快一些，如果不需要按照排列顺序访问键，就最好选择散列。映射表中键必须是唯一的，不能对同一个键存放两个值。如果对同一个键两次调用put方法，第二个值就会取代第一个值。实际上，put方法会返回用这个键参数存储的上一个值。
集合框架并没有将映射表本身视为一个集合（其他的数据结构框架则将映射表视为对pairs的集合，或者视为用键作为索引的值的集合）。然而，可以获得映射表的视图，这是一组实现了Collection接口或者它的子接口的视图。有3个视图，它们分别是：键集、值集和键/值对集，键与键/值对形成了一个集，这是因为在映射表中一个键只能有一个副本。下列方法将返回这3个视图（条目集的元素是静态内部类Map.Entry的对象）。
Set<K> keyset();
Collection<K> values();
Set<Map.Entry<K,V>> entrySet();
注意，keySet既不是HashSet，也不是TreeSet，而是实现了Set接口的某个其他类的对象。初看起来，keyset方法创建了一个新集，并将映射表中的所有键都填进去，然后返回这个集。但是，情况并非如此。取而代之的是：keySet方法返回一个实现了Set接口的某个类的对象，这个类的方法对原映射表进行操作。Set接口扩展了Collection接口，因此可以与使用任何集合一样使用keySet。例如，可以杖举映射表中的所有键：
Set<String> keys = map.keySet();
for(String key: keys){
System.out.println(key);
}
如果想要同时查看键与值，可以通过杖举各个条目（entries）查看，以避免对值进行查找。
for(Map.Entry<String, Employee> entry : staff.entrySet()){
String key = entry.getKey();
Employee value = entry.getValue();
System.out.println("key = " + key + ", value = " + value);
}
199
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
