集合框架map_DAY18
1:map集合(掌握)
(1)Map集合存储的是键值对元素。键是唯一的,值可以重复。
(2)Map和Collection的区别?
A:Map是双列集合，存储的元素键值对，键唯一，值可以重复。
B:Collection是单列集合，存储的元素是单一的，List集合可以重复，Set集合元素唯一。
(3)Map集合的功能
A:添加功能
V put(K key,V value)
B:删除功能
remove(K key)
C:判断功能
containsKey(K key)
containsValue(V value)
D:获取功能
V get(K key)
Set<K> keySet()
Collection<V> values()
Set<Map.Entry<K,V>> entrySet() 返回所有键值对对应关系
Map.Entry是Map内的一个内部接，包含的主要方法
K getKey()
V getValue()
V setValue(V value) 设置值
E:长度功能
int size()
(4)Map集合的数据结构问题：
Map集合的数据结构对键有效，跟值无关。
它的底层数据结构和Set中讲解的一致。
如果是哈希表结构，就需要重写hashCode()和equals()，保证存储元素的唯一性。
如果是二叉树结构，就有两种方式：Comparable,Comparator，保证存储的元素的有序性。 例子程序如下：
mport java.util.Comparator;
import java.util.TreeMap; /*
* 使用TreeMap存储<Person,String>
*/
public class Demo7 { public static void main(String[] args) {
//第一种方式：使键的类型实现Comparable接口，完成比较大小的逻辑
TreeMap<Person, String> map = new TreeMap<>();
Person p = new Person("唐嫣", 28);
String s = "貂蝉"; Person p2 = new Person("卢俊义",42);
String s2 = "玉麒麟"; Person p3 = new Person("2张顺",32);
String s3 = "浪里白条"; Person p4 = new Person("1花荣",32);
String s4 = "小李广"; map.put(p, s);
map.put(p2, s2);
map.put(p3, s3);
map.put(p4, s4); System.out.println(map); //第二种方式：创建集合对象时给予对应的比较器Comparator
TreeMap<Person, String> map2 = new TreeMap<>(new Comparator<Person>(){ @Override
public int compare(Person o1, Person o2) {
int result = o1.getName().compareTo(o2.getName());
if(result==0) {
result = o1.getAge()-o2.getAge();
}
return result;
}}); map2.put(p, s);
map2.put(p2, s2);
map2.put(p3, s3);
map2.put(p4, s4); System.out.println(map2);
} }
public class Person implements Comparable<Person>{
private String name;
private int age;
public Person() {
super();
// TODO Auto-generated constructor stub
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
//先比较年龄,后比较姓名
@Override
public int compareTo(Person o) {
//this：新传进来的对象 o：旧的对象
int result = this.age-o.age;
if(result==0) {
result = this.name.compareTo(o.name);
}
return result;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + 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;
}
}
(5)Map的遍历方式
假设有一个HashMap集合，存储的键和值都是String类型。名称叫hm。
A:根据键找值(掌握)
a:获取所有键的集合
b:遍历键的集合，获取到每一个键
c:根据键找值
代码体现：
Set<String> set = hm.keySet();
for(String key : set) {
String value = hm.get(key);
System.out.println(key+"---"+value);
}
B:根据键值对对象找键和值(理解)
a:获取所有键值对对象的集合
b:遍历键值对对象的集合，获取到每一个键值对对象
c:根据键值对对象获取键和值
代码体现：
Set<Map.Entry<String,String>> set = hm.entrySet();
for(Map.Entry<String,String> me : set) {
String key = me.getKey();
String value = me.getValue();
System.out.println(key+"---"+value);
}
(6)案例：
A:统计一个字符串中每个字符出现的次数
import java.util.Set;
import java.util.TreeMap; /**
* “aabcbdeeeeedbddcc”,获取字符串中每一个字母出现的次数。要求结果:a(2)b(3)c(3)d(4)e(5)
* 思路：字符串中的字符和数字存到treemap集合里，然后遍历输出
*/
public class MapTest1 {
public static void main(String[] args) {
// 定义一个字符串(可以改进为键盘录入)
String content ="aababcabcdabcde";
// 定义一个TreeMap集合
TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>(); //把字符串转换为字符数组
char[] chs = content.toCharArray(); //遍历字符数组，得到每一个字符
for(char ch : chs){
//拿刚才得到的字符作为键到集合中去找值，看返回值
Integer i = tm.get(ch); //是null:说明该键不存在，就把该字符作为键，1作为值存储
if(i == null){
tm.put(ch, 1);
}else {
//不是null:说明该键存在，就把值加1，然后重写存储该键和值
i++;
tm.put(ch,i);
}
} //定义字符串缓冲区变量
StringBuilder sb= new StringBuilder(); //遍历集合，得到键和值，进行按照要求拼接
Set<Character> set = tm.keySet();
for(Character key : set){
Integer value = tm.get(key);
sb.append(key).append("(").append(value).append(")");
} //把字符串缓冲区转换为字符串输出
String result = sb.toString();
System.out.println("result:"+result);
}
}
B:Map集合的嵌套存储和遍历
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set; /*
* List集合内元素为Map集合
*/
public class Test { public static void main(String[] args) {
//List嵌套List
//创建集合对象
ArrayList<ArrayList<String>> arrayList = new ArrayList<ArrayList<String>>();
//创建元素对象
ArrayList<String> list = new ArrayList<String>();
list.add("吕布");
list.add("赵云");
list.add("典韦");
list.add("关羽");
list.add("马超"); ArrayList<String> list2 = new ArrayList<String>();
list2.add("高俅");
list2.add("高衙内");
list2.add("蔡京");
list2.add("西门大官人"); //将集合元素放入集合对象
arrayList.add(list);
arrayList.add(list2); System.out.println(arrayList); //List嵌套Map
//创建集合对象
ArrayList<HashMap<String, Person>> arrayList2 = new ArrayList<HashMap<String, Person>>();
//创建元素对象
HashMap<String, Person> hashMap = new HashMap<String, Person>();
hashMap.put("五虎上将之一", new Person("关羽",38));
hashMap.put("五虎上将之二", new Person("张飞",34));
hashMap.put("五虎上将之三", new Person("赵云",32));
hashMap.put("五虎上将之四", new Person("马超",30));
hashMap.put("五虎上将之五", new Person("黄忠",60)); HashMap<String, Person> hashMap2 = new HashMap<String, Person>();
hashMap2.put("行者", new Person("武松",28));
hashMap2.put("神行太保", new Person("戴宗",34));
hashMap2.put("入云龙", new Person("公孙胜",32));
hashMap2.put("九纹龙", new Person("史进",30));
hashMap2.put("拼命三郎", new Person("石秀",29));
//将集合元素添加到集合中
arrayList2.add(hashMap);
arrayList2.add(hashMap2); //迭代外层的ArrayList，里边的每个元素均为Map对象
for (HashMap<String, Person> myMap : arrayList2) {
//HashMap<String, Person> myMap
//返回该map的所有key的Set集合
Set<String> keySet = myMap.keySet(); for (String key : keySet) {//迭代key的集合，获取每一个key
Person value = myMap.get(key); //通过键获取值
//拼写字符串，完成对每个map中元素的打印
System.out.println(key+":"+value.getName()+" "+value.getAge());
}
}
} }
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set; /*
* 使用Map嵌套List
*/
public class Test2 { public static void main(String[] args) {
//创建map集合
Map<String, ArrayList<Person>> map = new HashMap<String, ArrayList<Person>>(); //创建集合元素
String class1 = "0315基础班";
ArrayList<Person> arrayList = new ArrayList<Person>();
arrayList.add(new Person("唐嫣",28));
arrayList.add(new Person("龙哥",23));
arrayList.add(new Person("小龙女",16));
arrayList.add(new Person("涛哥",31)); String class2 = "0426就业班";
ArrayList<Person> arrayList2 = new ArrayList<Person>();
arrayList2.add(new Person("唐嫣",28));
arrayList2.add(new Person("高圆圆",32));
arrayList2.add(new Person("baby",26));
arrayList2.add(new Person("熊黛林",32)); //将集合元素添加到集合中
map.put(class1, arrayList);
map.put(class2, arrayList2); //遍历map集合
Set<Entry<String,ArrayList<Person>>> entrySet = map.entrySet(); Iterator<Entry<String, ArrayList<Person>>> iterator = entrySet.iterator(); while (iterator.hasNext()) {
Map.Entry<java.lang.String, java.util.ArrayList<cn.itcast2.Person>> entry = (Map.Entry<java.lang.String, java.util.ArrayList<cn.itcast2.Person>>) iterator
.next();
String key = entry.getKey();
ArrayList<Person> listValue = entry.getValue();
System.out.println(key);
Iterator<Person> iterator2 = listValue.iterator();
while (iterator2.hasNext()) {
Person person = (Person) iterator2.next();
System.out.println(person);
}
}
} }
import java.util.HashMap;
import java.util.Map;
import java.util.Set; /*
* Map嵌套Map
*/
public class Test3 { public static void main(String[] args) { Map<String, Map<String, Person>> map = new HashMap<String, Map<String,Person>>(); Map<String, Person> innerMap = new HashMap<String, Person>();
innerMap.put("师傅", new Person("唐三藏",34));
innerMap.put("大师兄", new Person("孙悟空",500));
innerMap.put("二师兄", new Person("朱悟能",800));
innerMap.put("三师弟", new Person("沙悟净",600)); Map<String, Person> innerMap2 = new HashMap<String, Person>();
innerMap2.put("顽石", new Person("贾宝玉",14));
innerMap2.put("十二金钗之一", new Person("薛宝钗",19));
innerMap2.put("十二金钗之二", new Person("王熙凤",28)); map.put("西游记", innerMap);
map.put("红楼梦", innerMap2); Set<String> keySet = map.keySet(); for (String key : keySet) {
Map<String, Person> value = map.get(key);
System.out.println(key);
Set<String> keySet2 = value.keySet();
for (String innerKey : keySet2) {
Person innerValuePerson = value.get(innerKey);
System.out.println(innerKey+":"+innerValuePerson);
}
}
} }
(7)Map集合的体系
Map
|--HashMap
|--LinkedHashMap
|--Hashtable
|--TreeMap
A:HashMap和Hashtable的区别?
HashMap键无序，不可重复，不安全，速度快，键和值都可以存放空值。
Hashtable键无序，不可重复，安全，速度慢，键和值都不可以存放空值。
B:LinkedHashMap的键的特点?
键有序，不可重复。
2:集合总结(什么时候使用谁?)
是否键值对：
是：Map
是否排序：
是：TreeMap
否：HashMap
不知道，HashMap
否：Collection
是否唯一：
是：Set
是否排序：
是：TreeSet
否：HashSet
不知道，HashSet
否：List
增删多：LinkedList
查询多：ArrayList
不知道，ArrayList
不知道，用ArrayList
3:集合体系总结
集合：
|--Collection
|--List
|--ArrayList
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
|--Vector
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
|--LinkedList
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。
|--Set
|--HashSet
底层数据结构是哈希表。
如何保证唯一性?
依赖hashCode()和equals()
顺序：
先判断hashCode()值是否相同：
是：继续走equals()，看返回值
true:元素重复。不添加
false:元素不重复。添加
否：直接添加
|--LinkedHashSet
底层数据结构是链表和哈希表。
由链表保证有序(存储和取出一致)。
由哈希表保证元素唯一。
|--TreeSet
底层数据结构是二叉树。
如果保证唯一性?
根据返回值是否是0。
如何排序：
自然排序：Comparable
比较器排序：Comparator
|--Map
|--HashMap
|--LinkedHashMap
|--Hashtable
|--TreeMap
附:例子
1、Map嵌套Map的例子
import java.util.HashMap;
import java.util.Set; /**
* 使用集合进行以下分类：
北京总部
-JAVAEE班：5个
-JAVASE班：8个
上海分校
-JAVAEE：4个
-JAVASE：7个 */
public class Map3 {
public static void main(String[] args) { //创建HashMap集合
HashMap<String,HashMap<String,String>> hashMap=new HashMap<String,HashMap<String,String>>(); //创建元素
HashMap<String,String> innerHashMap1=new HashMap<String,String>();
innerHashMap1.put("JavaEE班","5个");
innerHashMap1.put("JavaSE班","8个"); HashMap<String,String> innerHashMap2=new HashMap<String,String>();
innerHashMap2.put("JavaEE班","4个");
innerHashMap2.put("JavaSE班","7个"); //添加元素
hashMap.put("北京总部",innerHashMap1);
hashMap.put("上海分校",innerHashMap2); //遍历输出
Set<String> keySet=hashMap.keySet(); //外层key集合
for(String key:keySet){
System.out.println(key); //输出外层key
HashMap<String,String> innerHashMap= hashMap.get(key);//获取外层key对应的Value值
Set<String> inKeySet=innerHashMap.keySet();//内层key集合
for(String innerkey:inKeySet){
String innerValue=innerHashMap.get(innerkey);
System.out.println(" "+innerkey+":"+innerValue);//输出内层key与内层Vakue
} }
} }
2、模拟地主洗牌发牌
方法一：
import java.util.ArrayList;
import java.util.Collections; /*
* 模拟斗地主洗牌发牌版本1
*/
public class Test5 { public static void main(String[] args) { /*准备：
* 花色：♠♥♦♣ ArrayList
* 数字：3,4,5,6,7,8,9,10,J,Q,K,A,2 ArrayList
* 大小王：☺☻
* 得有一副54张的牌 ArrayList
* 洗牌：
* 打乱这副牌的顺序
* 发牌：
* 将54张牌分发到4个list手中，前三个17张，最后一个3张
* player ArrayList
* player2 ArrayList
* player3 ArrayList
* dipai ArrayList
*/ //准备花色
ArrayList<String> color = new ArrayList<String>();
color.add("♠");
color.add("♥");
color.add("♦");
color.add("♣"); //准备数字
ArrayList<String> number = new ArrayList<String>();
Collections.addAll(number, "3","4","5","6","7","8","9","10","J","Q","K","A","2"); //准备一副新牌
ArrayList<String> cards = new ArrayList<String>(); for (String thisColor : color) {
for (String thisNumber : number) {
cards.add(thisColor+thisNumber);
}
}
//加入大小王
cards.add("大☻");
cards.add("小☺"); System.out.println(cards);
//洗牌
Collections.shuffle(cards);
System.out.println(cards); //发牌 //准备四个list作为3个玩家和底牌
ArrayList<String> player = new ArrayList<String>();
ArrayList<String> player2 = new ArrayList<String>();
ArrayList<String> player3 = new ArrayList<String>();
ArrayList<String> dipai = new ArrayList<String>(); //遍历这副洗好的牌，遍历过程中，将牌发到三个玩家和dipai手中
for (int i = 0; i < cards.size(); i++) { if(i>=51) {//分配底牌
dipai.add(cards.get(i));
} else {
if(i%3==0) {
player.add(cards.get(i));
}else if(i%3==1) {
player2.add(cards.get(i));
}else {
player3.add(cards.get(i));
}
}
} //看牌
System.out.println(player);
System.out.println(player2);
System.out.println(player3);
System.out.println(dipai);
} }
方法二：
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet; /*
* 斗地主洗牌发牌版本2：每个人手中的元素是有顺序的。
*/
public class Test5 { /*准备：
* 花色：♠♥♦♣ ArrayList
* 数字：3,4,5,6,7,8,9,10,J,Q,K,A,2 ArrayList
* 大小王：☺☻
* ！！！！！！！！定义一个map集合：用来将数字与每一张牌进行对应
* 得有一副54张的牌 ArrayList里边为1-54的数
* 洗牌：
* 打乱这副牌的顺序
* 发牌：
* 将54张牌分发到4个TreeSet手中，前三个17张，最后一个3张
* player TreeSet
* player2 TreeSet
* player3 TreeSet
* dipai TreeSet
*/ public static void main(String[] args) { //准备花色
ArrayList<String> color = new ArrayList<String>();
color.add("♠");
color.add("♥");
color.add("♦");
color.add("♣"); //准备数字
ArrayList<String> number = new ArrayList<String>();
Collections.addAll(number, "3","4","5","6","7","8","9","10","J","Q","K","A","2"); //定义一个map集合：用来将数字与每一张牌进行对应
HashMap<Integer, String> hashMap = new HashMap<Integer, String>(); int index = 1;
for (String thisNumber : number) {
for (String thisColor : color) {
hashMap.put(index++, thisNumber+thisColor);
}
} //加入大小王
hashMap.put(index++, "小☺");
hashMap.put(index++, "大☻"); System.out.println(hashMap); //得有一副54张的牌 ArrayList里边为1-54的数的新牌
ArrayList<Integer> cards = new ArrayList<Integer>(); for (int i = 1; i <= 54; i++) {
cards.add(i);
} //洗牌
Collections.shuffle(cards);
System.out.println(cards); //创建三个玩家和底牌
TreeSet<Integer> player = new TreeSet<Integer>();
TreeSet<Integer> player2 = new TreeSet<Integer>();
TreeSet<Integer> player3 = new TreeSet<Integer>();
TreeSet<Integer> dipai = new TreeSet<Integer>(); //遍历这副洗好的牌，遍历过程中，将牌发到三个玩家和dipai手中
for (int i = 0; i < cards.size(); i++) {
if(i>=51) {
dipai.add(cards.get(i));
} else {
if(i%3==0) {
player.add(cards.get(i));
}else if(i%3==1) {
player2.add(cards.get(i));
}else {
player3.add(cards.get(i));
}
}
} //看牌
for (Integer key : dipai) {
System.out.print(hashMap.get(key)+", ");
}
System.out.println();
for (Integer key : player) {
System.out.print(hashMap.get(key)+", ");
}
System.out.println();
for (Integer key : player2) {
System.out.print(hashMap.get(key)+", ");
}
System.out.println();
for (Integer key : player3) {
System.out.print(hashMap.get(key)+", ");
}
} }
集合框架map_DAY18的更多相关文章
- 一起学 Java（三） 集合框架、数据结构、泛型
一.Java 集合框架 集合框架是一个用来代表和操纵集合的统一架构.所有的集合框架都包含如下内容: 接口:是代表集合的抽象数据类型.接口允许集合独立操纵其代表的细节.在面向对象的语言,接口通常形成一个 ...
- 【目录】JUC集合框架目录
JUC集合框架的目录整理如下: 1. [JUC]JUC集合框架综述 2. [JUC]JDK1.8源码分析之ConcurrentHashMap(一) 3. [JUC]JDK1.8源码分析之Concurr ...
- java面试题——集合框架
先来看一下集合框架关系图 Collection FrameWork 如下: Collection ├List │├LinkedList │├ArrayList │└Vector │ └Stack └S ...
- Java使用实现面向对象编程：第七章集合框架的解读=>重中之重
对于集合框架,是非常重要的知识,是程序员必须要知道的知识点. 但是我们为什么要引入集合框架呢? 我们之前用过数组存储数据,但是采用数组存储存在了很多的缺陷.而现在我们引用了集合框架,可以完全弥补了数组 ...
- Java集合框架List，Map，Set等全面介绍
Java集合框架的基本接口/类层次结构: java.util.Collection [I]+--java.util.List [I] +--java.util.ArrayList [C] +- ...
- Java集合框架练习-计算表达式的值
最近在看<算法>这本书,正好看到一个计算表达式的问题,于是就打算写一下,也正好熟悉一下Java集合框架的使用,大致测试了一下,没啥问题. import java.util.*; /* * ...
- Java 之 集合框架（JCF）
1.集合框架 a.框架:为了实现某一目的或功能,而预先提供的一系列封装好的.具有继承或实现关系的类与集合 b.集合:①定义:Java中对一些数据结构和算法进行封装,即封装(集合也是一种对象) ②特点: ...
- 【集合框架】Java集合框架综述
一.前言 现笔者打算做关于Java集合框架的教程,具体是打算分析Java源码,因为平时在写程序的过程中用Java集合特别频繁,但是对于里面一些具体的原理还没有进行很好的梳理,所以拟从源码的角度去熟悉梳 ...
- 【集合框架】JDK1.8源码分析之Comparable && Comparator（九）
一.前言 在Java集合框架里面,各种集合的操作很大程度上都离不开Comparable和Comparator,虽然它们与集合没有显示的关系,但是它们只有在集合里面的时候才能发挥最大的威力.下面是开始我 ...
随机推荐
- IntelliJ IDEA 2017版 spring-boot 2.03后 Pageable用法;Pageable用法，PageRequest过时，新用法；Pageable过时问题；
1.旧版本Pageable用法: 但是会显示,这个版本已经过时,这时可以查看源码. 一般,一个方法过时,就会在其附近形成一个新的同名的但是其他用法的方法.按照这个理念,来找这个源码.很幸运,蒙对了,我 ...
- 第29章：MongoDB-索引--全文索引
①全文索引 全文索引是用于对长文本检索来使用的,是用正则表达式只能对字符串类型的值进行检索.注意:创建索引是一件比较耗时耗费资源的事情,而全文索引更是耗时更厉害,如果对索引键的内容比较长,需要对内容进 ...
- 利用tcpcopy引流过程
tcpcopy是一个tcp流量复制工具,当前还支持udp和mysql流量的复制. 目的: 将机器10.24.110.21的5000端口流量引流到机器10.23.25.11的5000端口. 示例:将10 ...
- C#重点内容之：接口（interface）（一）网络初级示例
这一篇来源于网络,简单介绍了接口的概念 接口是体现面向对象编程思想优越性的一件利器,为什么这么说呢? 首先我们来看,接口是为继承而存在的,如果没有继承,那就自然不需要接口了,既然有继承,那就需要把可能 ...
- Grand Central Dispatch
什么是GCD? Grand Central Dispatch或者GCD,是一套低层API,提供了一种新的方法来进行并发程序编写.从基本功能上讲,GCD有点像NSOperationQueue,他们都允许 ...
- 【repost】 原生JS执行环境与作用域深入理解
首先,我们要知道执行环境和作用域是两个完全不同的概念. 函数的每次调用都有与之紧密相关的作用域和执行环境.从根本上来说,作用域是基于函数的,而执行环境是基于对象的(例如:全局执行环境即window对象 ...
- hihocoder#1631 : Cats and Fish
Description There are many homeless cats in PKU campus. They are all happy because the students in t ...
- java基础-day19
第08天 异常 今日内容介绍 u 异常体系&异常处理 u Throwable常用方法&自定义异常 u 递归 第1章 异常产生&异常处理 1.1 异常概述 什 ...
- PAT甲级 1122. Hamiltonian Cycle (25)
1122. Hamiltonian Cycle (25) 时间限制 300 ms 内存限制 65536 kB 代码长度限制 16000 B 判题程序 Standard 作者 CHEN, Yue The ...
- 《javascript高级程序设计》 touch事件的一个小错误
最近一段时候都在拜读尼古拉斯大神的<javascript高级程序设计>,真的是一本好书,通俗易懂,条理比<javascript权威指南>好理解一些,当然<javascri ...