Map集合接口

Map集合与Collection不是从属关系，是平级的

Map集合的映射特点
- 一个映射不能包含重复的键，由此键只能允许有一个空null
- 每个键最多只能和一个值对应
- 值可以重复，由此值允许多个是空null
- Map集合与Collection的子接口Set一样是无序的
Map<KEY,VALUE>：KEY和VALUE表示泛型，KEY和VALUE可以是任何数据类型【除基本数据类型之外】，实际项目中KEY一般是String类型

实现类

HashMap

特点

一个映射不能包含重复的键：

如果存在重复的KEY，则后面添加的会把前面的覆盖
其实键就是Set，元素唯一，只能有一个null，
元素是无序的（与添加顺序无关）
HashMap不是同步的，即线程不安全

如何将HashMap变成线程安全？

Collections.synchronizedMap(<HashMap集合>);

常用方法

public static void main(String[] args) {

        Map<String, String> maps = new HashMap<>();

        /*1.添加*/

        //加入单条键值对

        maps.put("智多星","吴用");

        maps.put("豹子头","林冲");

        maps.put("玉麒麟","卢俊义");

        Map<String, String> map1 = new HashMap<>();

        map1.put("小诸葛","富安");

        map1.put("及时雨","宋江");

        //加入一个集合：将一个集合复制到另一个集合中

        maps.putAll(map1);

        System.out.println("map集合："+maps);

        System.out.println("map1集合："+map1);

        /*2.清空*/

        map1.clear();

        System.out.println("map1是否为空："+map1.isEmpty());  //isEmpty()检查集合是否为空  返回布尔值

        /*3.获取*/

        //获取VALUE,通过KEY获取VALUE

        System.out.println("获取智多星的值："+maps.get("智多星"));

        //获取全部的KEY，返回一个Set集合

        Set<String> KEYSET = maps.keySet();

        System.out.println("获取KEY的Set集合："+KEYSET); //输出Map集合中的KEY

    /*4.遍历集合*/

        //遍历集合：通过遍历Set集合的KEYSET，来获取集合的值VALUE

        System.out.println("===============\n通过for()增强遍历HashMap集合");

        for (String str : KEYSET) {

            String value = maps.get(str);

            System.out.println(str+"——>"+value);

        //遍历集合：通过entrySet(),返回 Set<Map.Entry<K,V>>，一个Set集合

        System.out.println("===============\n通过entrySet()遍历HashMap集合");

        Set<Map.Entry<String, String>> entries = maps.entrySet();

        for (Map.Entry<String, String> entry : entries) {

            //获取KEY

            String key = entry.getKey();

            //获取VALUE

            String value = entry.getValue();

            System.out.println(key+"——>"+value);

    /*5.判断功能*/

        //是否包含指定的键KEY，返回布尔值

        System.out.println("maps集合中是否包含”玉麒麟“这个KEY："+(maps.containsKey("玉麒麟")?"是":"否"));

        //是否包含指定的值VALUE，返回布尔值

        System.out.println("maps集合中是否包含”宋江“这个VALUE："+(maps.containsValue("宋江")?"是":"否"));

        //检查集合是否为空null

        System.out.println("maps集合是否为空："+(maps.isEmpty()?"是":"否"));

        //HashMap不能同步，即线程不安全

        /*6.如何线程安全？*/

        Collections.synchronizedMap(maps);

        Collections.synchronizedMap(map1);

LinkedHashMap

特点
- 允许多个null 值和一个 null 键
- LinkedHashMap有顺序（添加顺序有关）与HashMap的区别
- LinkedHashMap线程不安全
代码

xxxxxxxxxx

 public static void main(String[] args) {

        /*LinkedHashMap*/

        Map<String, String> maps = new LinkedHashMap<>();

        maps.put("智多星","吴用");

        maps.put("豹子头","林冲");

        maps.put("玉麒麟","卢俊义");

        //LinkedHashMap根据元素添加顺序进行排序

        System.out.println(maps);

        /*HashMap*/

        Map<String, String> hashmap = new HashMap<String, String>();

        hashmap.put("智多星","吴用");

        hashmap.put("豹子头","林冲");

        hashmap.put("玉麒麟","卢俊义");

        //排序与添加顺序无关

        System.out.println(hashmap);

        //综上比较LinkedHashMap和HashMap之间的区别即元素是否有序

/*

LinkedHashMap-->{智多星=吴用, 豹子头=林冲, 玉麒麟=卢俊义}

HashMap-->{玉麒麟=卢俊义, 智多星=吴用, 豹子头=林冲}

*/

TreeMap

很少用到，需要自定义比较器
TreeMap可以参考TreeSet，TreeMap可以支持Map的排序
TreeMap根据键KEY的自然顺序进行排序，或者根据创建映射【键和值相对应】时提供的Comparator进行排序，具体取决于使用的构造方法。
特点
- 可以按照KEY来排序
- KEY不能为null，KEY不能重复，VALUE值可以有多个null
- 线程不安全

代码

封装类

xxxxxxxxxx

/*

Student实现Comparable接口，则TreeMap可以根据KEY来排序

*/

public class Student implements Comparable<Student> {

    private String name ;

    private int age;

    public Student() {

    public Student(String name, int age) {

        this.name = name;

        this.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;

/**

     * @param o

     * @return

     * 自定义比较器：根据年龄来比较

*/

    @Override

    public int compareTo(Student o) {

        return this.age - o.age;

    @Override

    public String toString() {

        return "Student{" +

                "name='" + name + '\'' +

                ", age=" + age +

                '}';

测试类

xxxxxxxxxx

public class HashMapDemo02  {

    public static void main(String[] args) {

        Map<Student, String> maps = new TreeMap<>();

        /*1.添加*/

        //加入单条键值对

        maps.put(new Student("智多星",30),"吴用");

        maps.put(new Student("豹子头",30),"林冲");

        maps.put(new Student("玉麒麟",30),"卢俊义");

        maps.put(new Student("小诸葛",25),"富安");

        System.out.println(maps);

/*答案

//因为以年龄age为排序依据，所以系统误认为第一条到第二条是同一条数据

//在Student中是设置根据年龄进行排序，TreeMap集合是根据KEY进行排序

{Student{name='小诸葛', age=25}=富安,

Student{name='智多星', age=30}=林冲,

Student{name='玉麒麟', age=33}=卢俊义}

*/

Hahstable

不常用
特点
1. HashTable是map的实现类
2. 不允许键和值为null，会报“空指针异常”
3. HashTable中的元素没有顺序（与添加的顺序无关）
4. HashTable是线程安全的：查看源码，用了

figure:last-child {
margin-bottom: 0.5rem;
}

#write ol,
#write ul {
position: relative;
}

img {
max-width: 100%;
vertical-align: middle;
}

button,
input,
select,
textarea {
color: inherit;
font: inherit;
}

input[type="checkbox"],
input[type="radio"] {
line-height: normal;
padding: 0px;
}

*,
::after,
::before {
box-sizing: border-box;
}

#write h1,
#write h2,
#write h3,
#write h4,
#write h5,
#write h6,
#write p,
#write pre {
width: inherit;
}

#write h1,
#write h2,
#write h3,
#write h4,
#write h5,
#write h6,
#write p {
position: relative;
}

p {
line-height: inherit;
}

h1,
h2,
h3,
h4,
h5,
h6 {
break-after: avoid-page;
break-inside: avoid;
orphans: 2;
}

p {
orphans: 4;
}

h1 {
font-size: 2rem;
}

h2 {
font-size: 1.8rem;
}

h3 {
font-size: 1.6rem;
}

h4 {
font-size: 1.4rem;
}

h5 {
font-size: 1.2rem;
}

h6 {
font-size: 1rem;
}

.md-math-block,
.md-rawblock,
h1,
h2,
h3,
h4,
h5,
h6,
p {
margin-top: 1rem;
margin-bottom: 1rem;
}

.hidden {
display: none;
}

.md-blockmeta {
color: rgb(204, 204, 204);
font-weight: 700;
font-style: italic;
}

a {
cursor: pointer;
}

sup.md-footnote {
padding: 2px 4px;
background-color: rgba(238, 238, 238, 0.7);
color: rgb(85, 85, 85);
border-radius: 4px;
cursor: pointer;
}

sup.md-footnote a,
sup.md-footnote a:hover {
color: inherit;
text-transform: inherit;
text-decoration: inherit;
}

#write input[type="checkbox"] {
cursor: pointer;
width: inherit;
height: inherit;
}

figure {
overflow-x: auto;
margin: 1.2em 0px;
max-width: calc(100% + 16px);
padding: 0px;
}

figure>table {
margin: 0px !important;
}

tr {
break-inside: avoid;
break-after: auto;
}

thead {
display: table-header-group;
}

table {
border-collapse: collapse;
border-spacing: 0px;
width: 100%;
overflow: auto;
break-inside: auto;
text-align: left;
}

table.md-table td {
min-width: 32px;
}

.CodeMirror-gutters {
border-right: 0px;
background-color: inherit;
}

.CodeMirror-linenumber {
user-select: none;
}

.CodeMirror {
text-align: left;
}

.CodeMirror-placeholder {
opacity: 0.3;
}

.CodeMirror pre {
padding: 0px 4px;
}

.CodeMirror-lines {
padding: 0px;
}

div.hr:focus {
cursor: none;
}

#write pre {
white-space: pre-wrap;
}

#write.fences-no-line-wrapping pre {
white-space: pre;
}

#write pre.ty-contain-cm {
white-space: normal;
}

.CodeMirror-gutters {
margin-right: 4px;
}

.md-fences {
font-size: 0.9rem;
display: block;
break-inside: avoid;
text-align: left;
overflow: visible;
white-space: pre;
background: inherit;
position: relative !important;
}

.md-diagram-panel {
width: 100%;
margin-top: 10px;
text-align: center;
padding-top: 0px;
padding-bottom: 8px;
overflow-x: auto;
}

#write .md-fences.mock-cm {
white-space: pre-wrap;
}

.md-fences.md-fences-with-lineno {
padding-left: 0px;
}

#write.fences-no-line-wrapping .md-fences.mock-cm {
white-space: pre;
overflow-x: auto;
}

.md-fences.mock-cm.md-fences-with-lineno {
padding-left: 8px;
}

.CodeMirror-line,
twitterwidget {
break-inside: avoid;
}

.footnotes {
opacity: 0.8;
font-size: 0.9rem;
margin-top: 1em;
margin-bottom: 1em;
}

.footnotes+.footnotes {
margin-top: 0px;
}

.md-reset {
margin: 0px;
padding: 0px;
border: 0px;
outline: 0px;
vertical-align: top;
background: 0px 0px;
text-decoration: none;
text-shadow: none;
float: none;
position: static;
width: auto;
height: auto;
white-space: nowrap;
cursor: inherit;
-webkit-tap-highlight-color: transparent;
line-height: normal;
font-weight: 400;
text-align: left;
box-sizing: content-box;
direction: ltr;
}

li div {
padding-top: 0px;
}

blockquote {
margin: 1rem 0px;
}

li .mathjax-block,
li p {
margin: 0.5rem 0px;
}

li {
margin: 0px;
position: relative;
}

blockquote> :last-child {
margin-bottom: 0px;
}

blockquote> :first-child,
li> :first-child {
margin-top: 0px;
}

.footnotes-area {
color: rgb(136, 136, 136);
margin-top: 0.714rem;
padding-bottom: 0.143rem;
white-space: normal;
}

#write .footnote-line {
white-space: pre-wrap;
}

@media print {

body,
html {
border: 1px solid transparent;
height: 99%;
break-after: avoid;
break-before: avoid;
}

#write {
margin-top: 0px;
padding-top: 0px;
border-color: transparent !important;
}

.typora-export * {
-webkit-print-color-adjust: exact;
}

html.blink-to-pdf {
font-size: 13px;
}

.typora-export #write {
padding-left: 32px;
padding-right: 32px;
padding-bottom: 0px;
break-after: avoid;
}

.typora-export #write::after {
height: 0px;
}
}

.footnote-line {
margin-top: 0.714em;
font-size: 0.7em;
}

a img,
img a {
cursor: pointer;
}

pre.md-meta-block {
font-size: 0.8rem;
min-height: 0.8rem;
white-space: pre-wrap;
background: rgb(204, 204, 204);
display: block;
overflow-x: hidden;
}

p>.md-image:only-child:not(.md-img-error) img,
p>img:only-child {
display: block;
margin: auto;
}

p>.md-image:only-child {
display: inline-block;
width: 100%;
}

#write .MathJax_Display {
margin: 0.8em 0px 0px;
}

.md-math-block {
width: 100%;
}

.md-math-block:not(:empty)::after {
display: none;
}

[contenteditable="true"]:active,
[contenteditable="true"]:focus {
outline: 0px;
box-shadow: none;
}

.md-task-list-item {
position: relative;
list-style-type: none;
}

.task-list-item.md-task-list-item {
padding-left: 0px;
}

.md-task-list-item>input {
position: absolute;
top: 0px;
left: 0px;
margin-left: -1.2em;
margin-top: calc(1em - 10px);
border: none;
}

.math {
font-size: 1rem;
}

.md-toc {
min-height: 3.58rem;
position: relative;
font-size: 0.9rem;
border-radius: 10px;
}

.md-toc-content {
position: relative;
margin-left: 0px;
}

.md-toc-content::after,
.md-toc::after {
display: none;
}

.md-toc-item {
display: block;
color: rgb(65, 131, 196);
}

.md-toc-item a {
text-decoration: none;
}

.md-toc-inner:hover {
text-decoration: underline;
}

.md-toc-inner {
display: inline-block;
cursor: pointer;
}

.md-toc-h1 .md-toc-inner {
margin-left: 0px;
font-weight: 700;
}

.md-toc-h2 .md-toc-inner {
margin-left: 2em;
}

.md-toc-h3 .md-toc-inner {
margin-left: 4em;
}

.md-toc-h4 .md-toc-inner {
margin-left: 6em;
}

.md-toc-h5 .md-toc-inner {
margin-left: 8em;
}

.md-toc-h6 .md-toc-inner {
margin-left: 10em;
}

@media screen and (max-width: 48em) {
.md-toc-h3 .md-toc-inner {
margin-left: 3.5em;
}

.md-toc-h4 .md-toc-inner {
margin-left: 5em;
}

.md-toc-h5 .md-toc-inner {
margin-left: 6.5em;
}

.md-toc-h6 .md-toc-inner {
margin-left: 8em;
}
}

a.md-toc-inner {
font-size: inherit;
font-style: inherit;
font-weight: inherit;
line-height: inherit;
}

.footnote-line a:not(.reversefootnote) {
color: inherit;
}

.md-attr {
display: none;
}

.md-fn-count::after {
content: ".";
}

code,
pre,
samp,
tt {
font-family: var(--monospace);
}

kbd {
margin: 0px 0.1em;
padding: 0.1em 0.6em;
font-size: 0.8em;
color: rgb(36, 39, 41);
background: rgb(255, 255, 255);
border: 1px solid rgb(173, 179, 185);
border-radius: 3px;
box-shadow: rgba(12, 13, 14, 0.2) 0px 1px 0px, rgb(255, 255, 255) 0px 0px 0px 2px inset;
white-space: nowrap;
vertical-align: middle;
}

.md-comment {
color: rgb(162, 127, 3);
opacity: 0.8;
font-family: var(--monospace);
}

code {
text-align: left;
vertical-align: initial;
}

a.md-print-anchor {
white-space: pre !important;
border-width: initial !important;
border-style: none !important;
border-color: initial !important;
display: inline-block !important;
position: absolute !important;
width: 1px !important;
right: 0px !important;
outline: 0px !important;
background: 0px 0px !important;
text-decoration: initial !important;
text-shadow: initial !important;
}

.md-inline-math .MathJax_SVG .noError {
display: none !important;
}

.html-for-mac .inline-math-svg .MathJax_SVG {
vertical-align: 0.2px;
}

.md-math-block .MathJax_SVG_Display {
text-align: center;
margin: 0px;
position: relative;
text-indent: 0px;
max-width: none;
max-height: none;
min-height: 0px;
min-width: 100%;
width: auto;
overflow-y: hidden;
display: block !important;
}

.MathJax_SVG_Display,
.md-inline-math .MathJax_SVG_Display {
width: auto;
margin: inherit;
display: inline-block !important;
}

.MathJax_SVG .MJX-monospace {
font-family: var(--monospace);
}

.MathJax_SVG .MJX-sans-serif {
font-family: sans-serif;
}

.MathJax_SVG {
display: inline;
font-style: normal;
font-weight: 400;
line-height: normal;
zoom: 90%;
text-indent: 0px;
text-align: left;
text-transform: none;
letter-spacing: normal;
word-spacing: normal;
overflow-wrap: normal;
white-space: nowrap;
float: none;
direction: ltr;
max-width: none;
max-height: none;
min-width: 0px;
min-height: 0px;
border: 0px;
padding: 0px;
margin: 0px;
}

.MathJax_SVG * {
transition: none 0s ease 0s;
}

.MathJax_SVG_Display svg {
vertical-align: middle !important;
margin-bottom: 0px !important;
margin-top: 0px !important;
}

.os-windows.monocolor-emoji .md-emoji {
font-family: "Segoe UI Symbol", sans-serif;
}

.md-diagram-panel>svg {
max-width: 100%;
}

[lang="mermaid"] svg,
[lang="flow"] svg {
max-width: 100%;
height: auto;
}

[lang="mermaid"] .node text {
font-size: 1rem;
}

table tr th {
border-bottom: 0px;
}

video {
max-width: 100%;
display: block;
margin: 0px auto;
}

iframe {
max-width: 100%;
width: 100%;
border: none;
}

.highlight td,
.highlight tr {
border: 0px;
}

.CodeMirror {
height: auto;
}

.CodeMirror.cm-s-inner {
background: inherit;
}

.CodeMirror-scroll {
overflow: auto hidden;
z-index: 3;
}

.CodeMirror-gutter-filler,
.CodeMirror-scrollbar-filler {
background-color: rgb(255, 255, 255);
}

.CodeMirror-gutters {
border-right: 1px solid rgb(221, 221, 221);
background: inherit;
white-space: nowrap;
}

.CodeMirror-linenumber {
padding: 0px 3px 0px 5px;
text-align: right;
color: rgb(153, 153, 153);
}

.cm-s-inner .cm-keyword {
color: rgb(119, 0, 136);
}

.cm-s-inner .cm-atom,
.cm-s-inner.cm-atom {
color: rgb(34, 17, 153);
}

.cm-s-inner .cm-number {
color: rgb(17, 102, 68);
}

.cm-s-inner .cm-def {
color: rgb(0, 0, 255);
}

.cm-s-inner .cm-variable {
color: rgb(0, 0, 0);
}

.cm-s-inner .cm-variable-2 {
color: rgb(0, 85, 170);
}

.cm-s-inner .cm-variable-3 {
color: rgb(0, 136, 85);
}

.cm-s-inner .cm-string {
color: rgb(170, 17, 17);
}

.cm-s-inner .cm-property {
color: rgb(0, 0, 0);
}

.cm-s-inner .cm-operator {
color: rgb(152, 26, 26);
}

.cm-s-inner .cm-comment,
.cm-s-inner.cm-comment {
color: rgb(170, 85, 0);
}

.cm-s-inner .cm-string-2 {
color: rgb(255, 85, 0);
}

.cm-s-inner .cm-meta {
color: rgb(85, 85, 85);
}

.cm-s-inner .cm-qualifier {
color: rgb(85, 85, 85);
}

.cm-s-inner .cm-builtin {
color: rgb(51, 0, 170);
}

.cm-s-inner .cm-bracket {
color: rgb(153, 153, 119);
}

.cm-s-inner .cm-tag {
color: rgb(17, 119, 0);
}

.cm-s-inner .cm-attribute {
color: rgb(0, 0, 204);
}

.cm-s-inner .cm-header,
.cm-s-inner.cm-header {
color: rgb(0, 0, 255);
}

.cm-s-inner .cm-quote,
.cm-s-inner.cm-quote {
color: rgb(0, 153, 0);
}

.cm-s-inner .cm-hr,
.cm-s-inner.cm-hr {
color: rgb(153, 153, 153);
}

.cm-s-inner .cm-link,
.cm-s-inner.cm-link {
color: rgb(0, 0, 204);
}

.cm-negative {
color: rgb(221, 68, 68);
}

.cm-positive {
color: rgb(34, 153, 34);
}

.cm-header,
.cm-strong {
font-weight: 700;
}

.cm-del {
text-decoration: line-through;
}

.cm-em {
font-style: italic;
}

.cm-link {
text-decoration: underline;
}

.cm-error {
color: red;
}

.cm-invalidchar {
color: red;
}

.cm-constant {
color: rgb(38, 139, 210);
}

.cm-defined {
color: rgb(181, 137, 0);
}

div.CodeMirror span.CodeMirror-matchingbracket {
color: rgb(0, 255, 0);
}

div.CodeMirror span.CodeMirror-nonmatchingbracket {
color: rgb(255, 34, 34);
}

.cm-s-inner .CodeMirror-activeline-background {
background: inherit;
}

.CodeMirror {
position: relative;
overflow: hidden;
}

.CodeMirror-scroll {
height: 100%;
outline: 0px;
position: relative;
box-sizing: content-box;
background: inherit;
}

.CodeMirror-sizer {
position: relative;
}

.CodeMirror-gutter-filler,
.CodeMirror-hscrollbar,
.CodeMirror-scrollbar-filler,
.CodeMirror-vscrollbar {
position: absolute;
z-index: 6;
display: none;
}

.CodeMirror-vscrollbar {
right: 0px;
top: 0px;
overflow: hidden;
}

.CodeMirror-hscrollbar {
bottom: 0px;
left: 0px;
overflow: hidden;
}

.CodeMirror-scrollbar-filler {
right: 0px;
bottom: 0px;
}

.CodeMirror-gutter-filler {
left: 0px;
bottom: 0px;
}

.CodeMirror-gutters {
position: absolute;
left: 0px;
top: 0px;
padding-bottom: 30px;
z-index: 3;
}

.CodeMirror-gutter {
white-space: normal;
height: 100%;
box-sizing: content-box;
padding-bottom: 30px;
margin-bottom: -32px;
display: inline-block;
}

.CodeMirror-gutter-wrapper {
position: absolute;
z-index: 4;
background: 0px 0px !important;
border: none !important;
}

.CodeMirror-gutter-background {
position: absolute;
top: 0px;
bottom: 0px;
z-index: 4;
}

.CodeMirror-gutter-elt {
position: absolute;
cursor: default;
z-index: 4;
}

.CodeMirror-lines {
cursor: text;
}

.CodeMirror pre {
border-radius: 0px;
border-width: 0px;
background: 0px 0px;
font-family: inherit;
font-size: inherit;
margin: 0px;
white-space: pre;
overflow-wrap: normal;
color: inherit;
z-index: 2;
position: relative;
overflow: visible;
}

.CodeMirror-wrap pre {
overflow-wrap: break-word;
white-space: pre-wrap;
word-break: normal;
}

.CodeMirror-code pre {
border-right: 30px solid transparent;
width: fit-content;
}

.CodeMirror-wrap .CodeMirror-code pre {
border-right: none;
width: auto;
}

.CodeMirror-linebackground {
position: absolute;
left: 0px;
right: 0px;
top: 0px;
bottom: 0px;
z-index: 0;
}

.CodeMirror-linewidget {
position: relative;
z-index: 2;
overflow: auto;
}

.CodeMirror-wrap .CodeMirror-scroll {
overflow-x: hidden;
}

.CodeMirror-measure {
position: absolute;
width: 100%;
height: 0px;
overflow: hidden;
visibility: hidden;
}

.CodeMirror-measure pre {
position: static;
}

.CodeMirror div.CodeMirror-cursor {
position: absolute;
visibility: hidden;
border-right: none;
width: 0px;
}

.CodeMirror div.CodeMirror-cursor {
visibility: hidden;
}

.CodeMirror-focused div.CodeMirror-cursor {
visibility: inherit;
}

.cm-searching {
background: rgba(255, 255, 0, 0.4);
}

@media print {
.CodeMirror div.CodeMirror-cursor {
visibility: hidden;
}
}

:root {
--side-bar-bg-color: #fafafa;
--control-text-color: #777;
}

html {
font-size: 16px;
}

body {
font-family: "Open Sans", "Clear Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
color: rgb(51, 51, 51);
line-height: 1.6;
}

#write {
max-width: 860px;
margin: 0px auto;
padding: 30px 30px 100px;
}

#write>ul:first-child,
#write>ol:first-child {
margin-top: 30px;
}

a {
color: rgb(65, 131, 196);
}

h1,
h2,
h3,
h4,
h5,
h6 {
position: relative;
margin-top: 1rem;
margin-bottom: 1rem;
font-weight: bold;
line-height: 1.4;
cursor: text;
}

h1:hover a.anchor,
h2:hover a.anchor,
h3:hover a.anchor,
h4:hover a.anchor,
h5:hover a.anchor,
h6:hover a.anchor {
text-decoration: none;
}

h1 tt,
h1 code {
font-size: inherit;
}

h2 tt,
h2 code {
font-size: inherit;
}

h3 tt,
h3 code {
font-size: inherit;
}

h4 tt,
h4 code {
font-size: inherit;
}

h5 tt,
h5 code {
font-size: inherit;
}

h6 tt,
h6 code {
font-size: inherit;
}

h1 {
padding-bottom: 0.3em;
font-size: 2.25em;
line-height: 1.2;
border-bottom: 1px solid rgb(238, 238, 238);
}

h2 {
padding-bottom: 0.3em;
font-size: 1.75em;
line-height: 1.225;
border-bottom: 1px solid rgb(238, 238, 238);
}

h3 {
font-size: 1.5em;
line-height: 1.43;
}

h4 {
font-size: 1.25em;
}

h5 {
font-size: 1em;
}

h6 {
font-size: 1em;
color: rgb(119, 119, 119);
}

p,
blockquote,
ul,
ol,
dl,
table {
margin: 0.8em 0px;
}

li>ol,
li>ul {
margin: 0px;
}

hr {
height: 2px;
padding: 0px;
margin: 16px 0px;
background-color: rgb(231, 231, 231);
border: 0px none;
overflow: hidden;
box-sizing: content-box;
}

li p.first {
display: inline-block;
}

ul,
ol {
padding-left: 30px;
}

ul:first-child,
ol:first-child {
margin-top: 0px;
}

ul:last-child,
ol:last-child {
margin-bottom: 0px;
}

blockquote {
border-left: 4px solid rgb(223, 226, 229);
padding: 0px 15px;
color: rgb(119, 119, 119);
}

blockquote blockquote {
padding-right: 0px;
}

table {
padding: 0px;
word-break: initial;
}

table tr {
border-top: 1px solid rgb(223, 226, 229);
margin: 0px;
padding: 0px;
}

table tr:nth-child(2n),
thead {
background-color: rgb(248, 248, 248);
}

table tr th {
font-weight: bold;
border-width: 1px 1px 0px;
border-top-style: solid;
border-right-style: solid;
border-left-style: solid;
border-top-color: rgb(223, 226, 229);
border-right-color: rgb(223, 226, 229);
border-left-color: rgb(223, 226, 229);
border-image: initial;
border-bottom-style: initial;
border-bottom-color: initial;
margin: 0px;
padding: 6px 13px;
}

table tr td {
border: 1px solid rgb(223, 226, 229);
margin: 0px;
padding: 6px 13px;
}

table tr th:first-child,
table tr td:first-child {
margin-top: 0px;
}

table tr th:last-child,
table tr td:last-child {
margin-bottom: 0px;
}

.CodeMirror-lines {
padding-left: 4px;
}

.code-tooltip {
box-shadow: rgba(0, 28, 36, 0.3) 0px 1px 1px 0px;
border-top: 1px solid rgb(238, 242, 242);
}

.md-fences,
code,
tt {
border: 1px solid rgb(231, 234, 237);
background-color: rgb(248, 248, 248);
border-radius: 3px;
padding: 2px 4px 0px;
font-size: 0.9em;
}

code {
background-color: rgb(243, 244, 244);
padding: 0px 2px;
}

.md-fences {
margin-bottom: 15px;
margin-top: 15px;
padding-top: 8px;
padding-bottom: 6px;
}

.md-task-list-item>input {
margin-left: -1.3em;
}

@media print {
html {
font-size: 13px;
}

table,
pre {
break-inside: avoid;
}

pre {
overflow-wrap: break-word;
}
}

.md-fences {
background-color: rgb(248, 248, 248);
}

#write pre.md-meta-block {
padding: 1rem;
font-size: 85%;
line-height: 1.45;
background-color: rgb(247, 247, 247);
border: 0px;
border-radius: 3px;
color: rgb(119, 119, 119);
margin-top: 0px !important;
}

.mathjax-block>.code-tooltip {
bottom: 0.375rem;
}

.md-mathjax-midline {
background: rgb(250, 250, 250);
}

#write>h3.md-focus::before {
left: -1.5625rem;
top: 0.375rem;
}

#write>h4.md-focus::before {
left: -1.5625rem;
top: 0.285714rem;
}

#write>h5.md-focus::before {
left: -1.5625rem;
top: 0.285714rem;
}

#write>h6.md-focus::before {
left: -1.5625rem;
top: 0.285714rem;
}

.md-image>.md-meta {
border-radius: 3px;
padding: 2px 0px 0px 4px;
font-size: 0.9em;
color: inherit;
}

.md-tag {
color: rgb(167, 167, 167);
opacity: 1;
}

.md-toc {
margin-top: 20px;
padding-bottom: 20px;
}

.sidebar-tabs {
border-bottom: none;
}

#typora-quick-open {
border: 1px solid rgb(221, 221, 221);
background-color: rgb(248, 248, 248);
}

#typora-quick-open-item {
background-color: rgb(250, 250, 250);
border-color: rgb(254, 254, 254) rgb(229, 229, 229) rgb(229, 229, 229) rgb(238, 238, 238);
border-style: solid;
border-width: 1px;
}

.on-focus-mode blockquote {
border-left-color: rgba(85, 85, 85, 0.12);
}

header,
.context-menu,
.megamenu-content,
footer {
font-family: "Segoe UI", Arial, sans-serif;
}

.file-node-content:hover .file-node-icon,
.file-node-content:hover .file-node-open-state {
visibility: visible;
}

.mac-seamless-mode #typora-sidebar {
background-color: var(--side-bar-bg-color);
}

.md-lang {
color: rgb(180, 101, 77);
}

.html-for-mac .context-menu {
--item-hover-bg-color: #E6F0FE;
}

#md-notification .btn {
border: 0px;
}

.dropdown-menu .divider {
border-color: rgb(229, 229, 229);
}

.ty-preferences .window-content {
background-color: rgb(250, 250, 250);
}

.ty-preferences .nav-group-item.active {
color: white;
background: rgb(153, 153, 153);
}

.typora-export li,
.typora-export p,
.typora-export,
.footnote-line {
white-space: normal;
}

-->

Java笔记——Map集合的更多相关文章

java基础-Map集合
java基础-Map集合作者:尹正杰版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.Map集合概述我们通过查看Map接口描述,发现Map接口下的集合与Collection接口下的集合,它 ...
Java基础知识：Java实现Map集合二级联动1
Java实现Map集合二级联动 Map集合可以保存键值映射关系,这非常适合本实例所需要的数据结构,所有省份信息可以保存为Map集合的键,而每个键可以保存对应的城市信息,本实例就是利用Map集合实现了省 ...
java中map集合的迭代
import java.util.HashMap; import java.util.Iterator; import java.util.Map; public class TestMap { pu ...
Java实现Map集合二级联动
Map集合可以保存键值映射关系,这非常适合本实例所需要的数据结构,所有省份信息可以保存为Map集合的键,而每个键可以保存对应的城市信息,本实例就是利用Map集合实现了省市级联选择框,当选择省份信息时, ...
java中Map集合的理解
Map |--Hashtable:底层是哈希表数据结构,不可以存入null键null值.该集合是线程同步的.jdk1.0.效率低. |--HashMap:底层是哈希表数据结构,允许使用 null 值和 ...
Java基础知识：Java实现Map集合二级联动2
2. 定义获取省份的方法,创建一个Map集合,将上一步得到的映射集合赋值给它,使用Map集合的keySet()方法获取该集合中的所有键对象组成的Set 集合,即为省分集合,创建一个Object型一维数 ...
java基础——Map集合
Map以键值对的形式存储数据,其中Map.entry,是Map的内部类,它用来描述Map中的键值对.Map是一个接口,HashMap是他的一个实现类 Map中有几个重要的方法: get(Object ...
Java 利用Map集合计算一个字符串中每个字符出现的次数
步骤分析 1.给出一串字符串,字符串中可以包含字母.数字.符号等等. 2.创建一个Map集合,key是字符串中的字符,value是字符的个数. 3.遍历字符串,获取每一个字符. 5.使用获取到的字符, ...
java中Map集合的常用方法（转）
原文地址:https://www.cnblogs.com/xiaostudy/p/9510763.html Map集合和Collection集合的区别 Map集合是有Key和Value的,Collec ...

随机推荐

从0构建webpack开发环境(一) 一个简单webpack.config.js
本文基于webpack4.X,使用的包管理工具是yarn 概念相关就不搬运了,直接开始首先项目初始化 mkdir webpack-demo && cd webpack-demo ya ...
Vue Cli3 TypeScript 搭建工程
Vue Cli3出来也一段时间了,我想尝试下Vue结合TypeScript搭建个工程,感受下Vue下用TS...网上有一篇讲的非常详细的教程 vue-cli3.0 搭建项目模版教程(ts+vuex+ ...
python 数据分析 Numpy(Numerical Python Basic)
a = np.random.random((2,4)) a Out[5]: array([[0.20974732, 0.73822026, 0.82760722, 0.050551 ], [0.773 ...
05.Linux-CentOS系统本地Yum源搭建
CentOS系统 1.挂载镜像光盘[root@localhost ~]# mount /dev/sr0 /media/cdrom/ 2.创建本地yum源仓库[root@localhost ~]# cd ...
NtQuerySystemInformation
#include "stdafx.h" #include <Windows.h> #include <winternl.h> using namespace ...
idea 配置自动编译 livereload
1 pom中添加 spring-boot-devtools 依赖 <dependency> <groupId>org.springframework.boot</grou ...
python3-disc和set
dict Python内置了字典:dict的支持,dict全称dictionary,在其他语言中也称为map,使用键-值(key-value)存储,具有极快的查找速度. 举个例子,假设要根据同学的名字 ...
ForkJoinPool详解
本文的主要目的是介绍 ForkJoinPool 的适用场景,实现原理,以及示例代码. 说在前面可以说是说明,也可以说下面是结论: ForkJoinPool 不是为了替代 ExecutorService ...
Linux 性能测试工具 sysbench 的安装与简单使用
文章目录 Linux 性能测试工具 sysbench 的安装与简单使用一背景二实验环境 2.1 操作系统 2.2 其他配 ...
修改编码为utf8mb4 以支持emoji表情
环境: 项目db的所有字符集都已经初始化为utf-8,如 status命令显示如下: Server characterset: utf8Db characterset: utf8Client char ...

Java笔记——Map集合