JAVASE学习笔记第16天
集合（Map概述）
/**
1、概念：Map集合：该集合存储键值对。一对一对往里存，而且要保证键的唯一性。
2、常见的方法：
添加
put(K key , Vvalue);
putAll(May<?extends K, ? extends V>m)
删除
clear();
remove(Objectkey)
判断
containsValue(Objectvalue)
containsKey(Objectkey)
isEmpty()
获取
get(Object key)
size()
values()
Map:
|---hashMap
|---hashtable
|---TreeMap
*/
集合（Map子类对象的特点（面试））
1、Hashtable: 底层是哈希表数据结构，不可以存入null键null值，线程是同步的。JDK1.0,效率低
2、HashMap: 底层是哈希表数据结构，可以存入null键null值，线程不同步，JDK1.2,效率高。
3、TreeMap: 底层是二叉树的数据结构，线程非同步，可以用于给Map结合中的键进行排序。
4、注意：其实Set集合的底层就是使用了Map集合。
集合（Map的共性方法）
import java.util.*;
class Demo1
{
publicstatic void main(String[] args)
{
HashMap<String,String>map = new HashMap<String,String>();
//添加元素
System.out.println(map.put("01","liming"));//返回的是null
System.out.println(map.put("01","lihua")); //返回的是lihua
/*注意:在添加元素的时候，返回的是null
但是当同一个键，添加多个值的时候，这个键对应的是最后一个值，
而且返回的是最后这个值。
*/
map.put("03","lilei");
map.put("04","xiaoming");
//删除
System.out.println("remove:"+map.remove("01"));
//判断
sop("containsKey:"+map.containsKey("01"));
sop("containsValue:"+map.containsValue("lilei"));
//获取
sop("size:"+map.size());
sop("get:"+map.get("01")); //当不存在的时候，返回null
sop("map:"+map);
sop("values:"+map.values());
}
publicstatic void sop(Object obj)
{
System.out.println(obj);
}
}
集合（Map—keySet）
/**
Map集合第一种取出方式，使用Set<K> keySet()
原理：将Map集合转换成Set集合，再通过迭代器取出。
步骤：
1，将Map结合中的所有的键存入到Set集合中,用keySet()方法
2，使用迭代器的方式取出所有的键，再根据get方法获取每一个键所对应的值。
*/
import java.util.*;
class Demo2
{
public static voidmain(String[] args)
{
HashMap<String,String>map = new HashMap<String,String>();
map.put("01","lihua");
map.put("02","liming");
map.put("03","lili");
map.put("04","wangming");
//使用keySet方法，获取Map集合中的所有的键
Set<String>keySet = map.keySet();
// System.out.println("keySet:"+keySet);
//通过迭代器，取出所有的键
for(Iterator<String>it = keySet.iterator();it.hasNext();)
{
//System.out.println(it.next());
//通过map集合的get方法取出所有的值
String s =it.next();
System.out.println("get:"+map.get(s));
}
}
}
集合（Map—entrySet）
/**
Map.Entry 其实Entry也是一个接口，它是Map接口中的一个内部接口
interface Map
{
public static interfaceEntry
{
public abstractObject getKey();
pulbic abstractObject getValue();
}
}
map集合的第二种取出方式:
set<Map.Entry<k,v>> entrySet
原理：将Map集合中的映射关系存入到Set集合中，
而这个关系的数据类型就是Map.Entry，
然后根据Map.Entry对象的getKey(),以及getValue()方法获取键值对。
*/
import java.util.*;
class Demo3
{
public static voidmain(String[] args)
{
Map<String,String>map = new HashMap<String,String>();
map.put("01","liming01");
map.put("02","liming02");
map.put("03","liming03");
map.put("04","liming04");
//调用Map集合的entrySet()方法，将映射关系取出
Set<Map.Entry<String,String>>set = map.entrySet();
//创建迭代器
for(Iterator<Map.Entry<String,String>>it = set.iterator();it.hasNext();)
{
Map.Entry me = it.next();
//通过Map.Entry的getKey() 方法和getValue()方法，获取键值对
System.out.println("key="+me.getKey()+",value="+me.getValue());
}
}
}
集合（Map练习）
/**
需求：
每一个学生都有对应的归属地
学生属性：姓名，年龄，注意：姓名和年龄相同的视为同一个学生
保证学生的唯一性。
思路：
1，描述学生
2，定义Map容器，将学生作为键，将地址作为值，存入
3，取出
总结：
1 在描述类的时候，如果这个类可能创建好多的对象，
那么，那么尽量的实现comparable接口（复写compareTo()方法）
并且，复写hashCode方法，以及equals方法。
2 值一定是唯一的。
*/
//导包
import java.util.*;
//描述学生
class Student implementsComparable<Student> //Comparable<? extends E>
{
privateString name;
privateint age;
Student(Stringname,int age)
{
this.name=name;
this.age=age;
}
//复写compareTo方法
publicint compareTo(Student stu)
{
intnum = new Integer(this.age).compareTo(new Integer(stu.age));
if(num==0)
returnthis.name.compareTo(stu.name);
returnnum;
}
//复写hashCode
publicint hashCode()
{
returnname.hashCode()+this.age*23;
}
//复写equals方法
publicboolean equals(Object obj)
{
if(!(objinstanceof Student))
thrownew ClassCastException("类型不匹配");
Studentstu= (Student)obj;
returnthis.name.equals(stu.name) && this.age==stu.age;
}
publicString getName()
{
returnname;
}
publicint getAge()
{
returnage;
}
}
class Test
{
publicstatic void main(String[] args)
{
//闯将map集合
Map<Student,String>map =new HashMap<Student,String>();
//将数据存入
map.put(newStudent("lili",20),"beijing");
map.put(newStudent("lili",20),"beijing");
map.put(newStudent("lili01",22),"hunan");
map.put(newStudent("wangsan",19),"wuhan");
map.put(newStudent("lili03",20),"beijing");
//使用entrySet取出映射关系
Set<Map.Entry<Student,String>>entrySet = map.entrySet();
for(Iterator<Map.Entry<Student,String>>it = entrySet.iterator(); it.hasNext();)
{
Map.Entry<Student,String>me = it.next(); //这里也要指定键值对
Studentstu = me.getKey();
Stringadr= me.getValue();
System.out.println("Student="+stu.getName()+".."+stu.getAge()+", "+"adr="+adr);
}
//使用keySet取出键
Set<Student>keySet = map.keySet();
for(Iterator<Student>it = keySet.iterator();it.hasNext();)
{
Studentstu= it.next();
System.out.println("Student="+stu.getName()+".........."+stu.getAge()+","+map.get(stu));
}
}
}
集合（TreeMap练习）
/**
需求：对学生对象的年龄进行升序排序
思路：因为数据是以键值对的形式存在的，
所以要使用可以排序的Map集合，即TreeMap
注意在实现Comparable，和Comparator的时候别忘了写泛型。
*/
import java.util.*;
//自定义一个比较器
class StuNameCompatator implementsComparator<Student>
{
publicint compare(Student stu1,Student stu2)
{
intnum = stu1.getName().compareTo(stu2.getName());
if(num==0)
returnnew Integer(stu1.getAge()).compareTo(new Integer(stu2.getAge()));
returnnum;
}
}
class Test2
{
publicstatic void main(String[] args)
{
TreeMap<Student,String>tm = new TreeMap<Student,String>(new StuNameCompatator());
tm.put(newStudent("alili01",02),"beijing");
tm.put(newStudent("lili02",12),"tianjin");
tm.put(newStudent("blili03",22),"shanghai");
tm.put(newStudent("dlili04",3),"beijing");
Set<Map.Entry<Student,String>>entrySet = tm.entrySet();
for(Iterator<Map.Entry<Student,String>>it = entrySet.iterator();it.hasNext();)
{
Map.Entry<Student,String>me = it.next();
Studentstu=me.getKey();
Stringadr = me.getValue();
System.out.println("Student="+stu.getName()+".."+stu.getAge()+", "+"adr="+adr);
}
}
}
集合（TreeMap练习—字母出现的次数）（不熟悉）
/**
需求：
“sdgegegekmmm”获取字符串中字母出现的次数
希望打印的结果为：a(1)c(2).....
分析：
根据打印的结果，发现每个字母和次数之间存在着映射关系
思路：
1，将字符串转换为字符数组（因为要对每个字符进行操作）
2，定义一个map集合，（因为打印的结果按照字母顺序排序，所以使用TreeMap）
3，遍历字符数组
将每一个字符作为键去查看map集合
如果返回结果为null，则将该键和1存入到map集合
如果返回返回的结果为具体的具体的数字，则将值加1，再将该键和新的值作为键值对存入
4，按照给定的格式输出
总结：
1、在写程序的时候，每写完一个功能，就验证一下，（可以答应一下结果）
基本的功能都写完了之后，再进一步的思考优化。
2、当数据之间存在映射关系的时候，可以选择map集合。
3、StringBuffer这个容器，可以存放任意类型的对象，
返回来的可以变成字符串
*/
import java.util.*;
class Test3
{
public static voidmain(String[] args)
{
String str ="s+++dg==egegekmmm";
System.out.println(change(str));
}
//定义功能
public static Stringchange(String str)
{
//转换为字符数组
char[] chs =str.toCharArray();
//创建一个TreeMap集合
TreeMap<Character,Integer>tm = new TreeMap<Character,Integer>();
//遍历
for(int x=0;x<chs.length;x++)
{
//代码优化
if(!(chs[x]>'a' && chs[x]<'z' || chs[x]>'A' && chs[x]<'Z'))
continue; //妙用
//将每一个字符作为键去查map表
Integervalue = tm.get(chs[x]);
if(value==null)
tm.put(chs[x],1);
else
{
value=value+1;
tm.put(chs[x],value);
}
}
StringBuffer sb =new StringBuffer();
//使用KeySet获取键
Set<Character>keySet=tm.keySet();
for(Iterator<Character>it = keySet.iterator();it.hasNext();)
{
Characterch=it.next();
Integer in= tm.get(ch);
sb.append(ch+"("+in+")");
}
returnsb.toString();
}
}
集合（map扩展）
/*
有一个学校，学校中有两个班级，每个班级中有学生和对应的学号
“传智播客”
|---“预热”
|---“01” ----“王五”
|---“02” -----“赵六”
|--“就业”
|--“01”----“张三”
|--“02”---“李四“
思路1：
将学校看成一个map集合，键为班级，值为map1集合，
map1集合中存放着键为编号，值为姓名
思路2：
将编号和姓名作为一个对象封装
然后将学校看成一个集合，将键看为班级，将值看为由学生组成的单例集合
*/
import java.util.*;
class Demo4
{
publicstatic void main(String[] args)
{
//定义大map集合
HashMap<String,HashMap<String,String>>czbo = new HashMap<String,HashMap<String,String>>();
//定义小map集合1
HashMap<String,String>yure = new HashMap<String,String>();
//定义小map集合2
HashMap<String,String>jiuye = new HashMap<String,String>();
//关联
czbo.put("yure",yure);
czbo.put("jiuye",jiuye);
yure.put("01","wangwu");
yure.put("02","zhaoliu");
jiuye.put("01","zhangsan");
jiuye.put("02","lisi");
//遍历大集合
Set<Map.Entry<String,HashMap<String,String>>>entrySet= czbo.entrySet();
for(Iterator<Map.Entry<String,HashMap<String,String>>>it =entrySet.iterator();it.hasNext();)
{
Map.Entry<String,HashMap<String,String>>me = it.next();
Stringbanji=me.getKey();
HashMap<String,String>hm=me.getValue();
System.out.println("banji"+banji);
method(hm);
}
}
//遍历小集合
publicstatic void method( HashMap<String,String>hm)
{
Set<String>keySet=hm.keySet();
for(Iterator<String>it=keySet.iterator();it.hasNext();)
{
Stringid=it.next();
Stringname=hm.get(id);
System.out.println("id:"+id+" name:"+name);
}
}
}
JAVASE学习笔记第16天相关推荐
- JavaSE学习笔记（持续更新）
这里写目录标题 JavaSE学习笔记(持续更新) Java跨平台原理与核心机制 1.跨平台原理: 2.两种核心机制: JDK11的安装流程 Java程序开发的三个步骤(无编辑器版) Eclipse安装 ...
- 重拾JavaSE学习笔记
重拾JavaSE学习笔记 1.常用DOS命令 2.了解Java 2.1 .java特性 2.2.JDK .JRE.JVM 2.3.java的加载和执行 3.开发环境搭建 3.1.安装jdk 3.2.配 ...
- C# 学习笔记（16）ComboBox下拉列表框宽度自适应
C# 学习笔记(16)ComboBox下拉列表框宽度自适应 当下拉列表框中内容宽度大于下拉列表框宽度时 下拉列表框不能将内容全部显示出来 可以在下拉时,对下拉列表框内容进行重绘 /// <sum ...
- SpringBoot学习笔记（16）：单元测试
SpringBoot学习笔记(16):单元测试 单元测试 单元测试(英语:Unit Testing)又称为模块测试,是针对程序模块(软件设计的最小单位)来进行正确性检验的测试工作.程序单元是应用的最小 ...
- 深度学习笔记（16） 误差分析（一）
深度学习笔记(16) 误差分析(一) 1. 进行误差分析 2. 清除标注错误的数据 1. 进行误差分析 假设正在调试猫分类器 然后在开发集取得了90%准确率,相当于10%错误 这离希望的目标还有很远 ...
- 深度学习笔记 | 第16讲：语音识别——一份简短的技术综述
原标题:深度学习笔记 | 第16讲:语音识别--一份简短的技术综述 大家好!又到了每周一狗熊会的深度学习时间了.在上一讲中,小编给大家介绍了经典的 seq2seq,以及著名的注意力模型,并且小编在这些 ...
- Zemax学习笔记（16）- ZEMAX_分析＞报告使用说明
Zemax学习笔记(16)- ZEMAX_分析>报告使用说明 总述 1.报告图 2.数据报告 3.摘要数据 总述 在ZEMAX中,想要获取系统最直接的参数,最方便的工具不失为系统分析>报告 ...
- 几何光学学习笔记（16）- 4.5 光楔
几何光学学习笔记(16)- 4.5 光楔 4.5 光楔 1.共轴双光楔 2.偏轴双光楔 4.5 光楔 折射角 a 很小的棱镜称为光楔,它在光学仪器中有很多用途.折射棱镜的公式用于光楔时可以简化.光线的 ...
- 【JavaSE学习笔记】
JavaSE学习笔记 一.java的基本语法 变量运算规则 编码情况1中l后面没有加L,默认是int变量 编码情况2中b1=b+1中的1默认是int型变量,会出错 string类型 string里面可 ...
最新文章
- Exchange2003表单和OWA选项中更改密码设置
- double 导出txt保留两位_使用Jade“精修”XRD图谱并导出数据
- 程序员成功之路 ——The road ahead for programmer（转引）
- Centos6.5子域名绑定子目录
- Jsp中的动态INCLUDE和静态INCLUDE的区别?
- layoutSubviews什么时候触发调用
- P3389-[模板]高斯消元法
- 创维25TI9000工厂模式
- python提取包含特定字符串的行_python提取具有某种特定字符串的行数据方法
- NLP之路-python爬虫
- SQL Server2005创建新数据库时不允许创建新数据库的问题
- 科技公司如何占据了你的每一分钟？
- css3动画保持状态不变
- java异步判断数据库是否有重复字段值
- Python—字典（当索引不好用时）
- 使用 paddle来进行文本生成
- 织梦模板修改｛dede:list｝标签后，可支持权重排序、flag标签功能
- vue实现点击播放英语单词
- 十二种兵器与他们的主人
- C盘清理——借助软件TreeSizeFree【网盘分享】（亲测有效）