Map集合

一，Map集合

1，概述

-将键映射到值的对象。 Map不能包含重复的键; 每个键可以映射到最多一个值。

2，特点

-存储元素的时候是按照 键值对 的方式来存储的

-也称之为双列集合。

-Map集合的键，可以为空， 唯一 ， 一个键对应一个值，值可重复，包括null

3，Map和Collecion的区别

-Map集合存储元素都是成对出现的 夫妻对

Map的键唯一 ，值是可以重复的

是双列集合的顶层接口

所有的数据结构只直接针对键 ，和值无关

-Collecion集合存储元素都是单独出现的 光棍

是单列集合的顶层接口

List 可重复

Set 唯一

所有的数据结构直接针对元素

4，成员方法

-添加

V put(K key, V value)

将指定的值与该映射中的指定键相关联（可选操作）。

注意：键是第一次出现，添加，返回null

键如果是第二次出现，替换，返回被替换掉的元素

void putAll(Map m)

将指定地图的所有映射复制到此映射（可选操作）。

package com.momo.demo;

import java.util.HashMap;

import java.util.Map;

/*

* Map添加功能

* */

public class Demo1 {

public static void main(String[] args) {

m = new HashMap<>();

System.out.println(m.put(1, "aaa"));

System.out.println(m);

System.out.println(m.put(1, "bbb"));

System.out.println(m.put(3, "ccc"));

System.out.println(m.put(4, "ddd"));

System.out.println(m);*/

m = new HashMap<>();

m.put("贾乃亮","李小璐");

m.put("文章","马伊利");

System.out.println(m.put("马蓉", "宝强"));

System.out.println(m.put("马蓉", "宋吉吉"));

System.out.println(m);

Map mm = new HashMap();

mm.putAll(m);

System.out.println(mm);

}

}

-删除

void clear()

从该地图中删除所有的映射（可选操作）。

V remove(Object key)

如果存在（从可选的操作），从该地图中删除一个键的映射。

boolean remove(Object key, Object value)

仅当指定的密钥当前映射到指定的值时删除该条目。

package com.momo.demo;

import java.util.HashMap;

import java.util.Map;

/*

* Map的删除功能

* */

public class Demo2 {

public static void main(String[] args) {

m = new HashMap<>();

m.put(1, "aaa");

m.put(2, "bbb");

m.put(3, "ccc");

m.put(4, "ddd");

System.out.println(m);

// System.out.println(m.remove(1));

// System.out.println(m.remove(8));

// m.clear();

System.out.println(m.remove(1, "aaa"));

System.out.println(m);

}

}

-判断

boolean containsKey(Object key)

如果此映射包含指定键的映射，则返回 true 。

boolean containsValue(Object value)

如果此地图将一个或多个键映射到指定的值，则返回 true 。

boolean equals(Object o)

将指定的对象与此映射进行比较以获得相等性。

boolean isEmpty()

如果此地图不包含键值映射，则返回 true 。

package com.momo.demo;

import java.util.HashMap;

import java.util.Map;

/*

* Map判断功能

* */

public class Demo3 {

public static void main(String[] args) {

m = new HashMap<>();

m.put(1, "aaa");

m.put(2, "bbb");

m.put(3, "ccc");

m.put(4, "ddd");

System.out.println(m);

/* System.out.println(m.containsKey(1));

System.out.println(m.containsKey(8));

System.out.println(m.containsValue("aaa"));

System.out.println(m.containsValue("a"));

System.out.println(m.isEmpty());*/

m2 = new HashMap<>();

m2.put(1, "aaa");

m2.put(2, "a");

m2.put(3, "ccc");

m2.put(4, "ddd");

System.out.println(m.equals(m2));

}

}

-替换

V replace(K key, V value)

只有当目标映射到某个值时，才能替换指定键的条目。

boolean replace(K key, V oldValue, V newValue)

仅当当前映射到指定的值时，才能替换指定键的条目。

package com.momo.demo;

import java.util.HashMap;

import java.util.Map;

/*

* Map替换功能

* */

public class Demo4 {

public static void main(String[] args) {

m = new HashMap<>();

m.put(1, "aaa");

m.put(2, "bbb");

m.put(3, "ccc");

m.put(4, "ddd");

System.out.println(m);

/* System.out.println(m.replace(1, "bbb"));

System.out.println(m.replace(11, "bbb"));*/

// System.out.println(m.replace(1, "aaa", "abc"));

System.out.println(m.replace(1, "ccc", "abc"));

System.out.println(m);

}

}

-获取

Set> entrySet()

返回此地图中包含的映射的Set视图。

V get(Object key)

返回到指定键所映射的值，或 null如果此映射包含该键的映射。

V getOrDefault(Object key, V defaultValue)

返回到指定键所映射的值，或 defaultValue如果此映射包含该键的映射。

Set keySet()

返回此地图中包含的键的Set视图。

int size()

返回此地图中键值映射的数量。

Collection values()

返回此地图中包含的值的Collection视图。

package com.momo.demo;

import java.util.Collection;

import java.util.HashMap;

import java.util.Map;

import java.util.Set;

/*

* Map获取功能

* */

public class Demo5 {

public static void main(String[] args) {

m = new HashMap<>();

m.put(1, "aaa");

m.put(2, "bbb");

m.put(3, "ccc");

m.put(4, "ddd");

System.out.println(m);

/* System.out.println(m.get(1));

System.out.println(m.get(22));*/

// System.out.println(m.size());

/* System.out.println(m.getOrDefault(1,"momo"));

System.out.println(m.getOrDefault(123,"momo"));

*/

keys = m.keySet();

for (Integer key : keys) {

String value = m.get(key);

System.out.println(key+"---"+value);

}*/

values = m.values();

for (String value : values) {

System.out.println(value);

}*/

/*

* Map.Entry 是Map集合中存储的 键值对 的对象

* K getKey()

返回与此条目相对应的键。

V getValue()

返回与此条目相对应的值。

* */

> entries = m.entrySet();

entry : entries) {

Integer key = entry.getKey();

String value = entry.getValue();

System.out.println(key+"--"+value);

}

}

}

5，Map集合的遍历方式

-keySet()+get()

先获取所有键集合，根据键获取值

-entrySet()

先获取所有键值对对象，在获取键和值

6,练习

-Map

-Map

-Map

package com.momo.demo;

import com.momo.po.Stu;

import com.momo.po.Tea;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.Map;

import java.util.Set;

/*

* Map集合键都是唯一的 ，但是我们这个案例，没有唯一

* 因为put方法底层依赖hashCode和equals方法

* 自定义对象没有重写这2个方法，默认比较的是地址值，所以成员变量一样的对象也存了多次(但是他们地址值不一样啊)

* 而我们一般认为成员变量都一样的时候，就是同一个对象，只存一个

* 注意：自定义对象作为键的时候，要重写这2个方法

* */

public class Demo15 {

public static void main(String[] args) {

lm = new LinkedHashMap<>();

lm.put(new Tea("西施",20),"kd20090501");

lm.put(new Tea("王昭君",21),"kd20090502");

lm.put(new Tea("貂蝉",26),"kd20090503");

lm.put(new Tea("杨玉环",22),"kd20090504");

lm.put(new Tea("王昭君",21),"kd20090502");

lm.put(new Tea("貂蝉",26),"kd20090503");

keys = lm.keySet();

for (Tea key : keys) {

String s = lm.get(key);

System.out.println(key.getName()+"--"+key.getAge()+"--"+s);

}*/

> entries = lm.entrySet();

entry : entries) {

Tea t = entry.getKey();

String value = entry.getValue();

System.out.println(t.getName()+"--"+t.getAge()+"--"+value);

}

}

}

package com.momo.demo;

import com.momo.po.Stu;

import com.momo.po.Tea;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.Map;

import java.util.Set;

public class Demo14 {

public static void main(String[] args) {

lm = new LinkedHashMap<>();

lm.put("kd20090501",new Tea("西施",20));

lm.put("kd20090502",new Tea("王昭君",21));

lm.put("kd20090503",new Tea("貂蝉",26));

lm.put("kd20090504",new Tea("杨玉环",22));

keys = lm.keySet();

for (String key : keys) {

Tea t = lm.get(key);

System.out.println(key+"--"+t.getName()+"--"+t.getAge());

}*/

> entries = lm.entrySet();

entry : entries) {

String key = entry.getKey();

Tea t = entry.getValue();

System.out.println(key+"--"+t.getName()+"--"+t.getAge());

}

}

}

package com.momo.demo;

import java.util.HashMap;

import java.util.Map;

import java.util.Set;

public class Demo13 {

public static void main(String[] args) {

hm = new HashMap<>();

hm.put("宝强","马蓉");

hm.put("文章","马伊利");

hm.put("贾乃亮","李小璐");

/*

keys = hm.keySet();

for (String key : keys) {

String valeu = hm.get(key);

System.out.println(key+"---"+valeu);

}*/

> entries = hm.entrySet();

entry : entries) {

String key = entry.getKey();

String value = entry.getValue();

System.out.println(key+",,"+value);

}

}

}

二，HashMap

1，概述

-基于哈希表的实现的Map接口。

-并允许null的值和null键。

- HashMap类大致相当于Hashtable ，除了它是不同步的，并允许null

-这个类不能保证Map的顺序

2,特点

-键唯一，无序，允许为空，线程不安全

3，构造方法

HashMap()

构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）。

HashMap(int initialCapacity)

构造一个空的 HashMap具有指定的初始容量和默认负载因子（0.75）。

HashMap(Map m)

构造一个新的 HashMap与指定的相同的映射 Map 。

4，成员方法

-都是讲过的

5，练习

-HashMap

-HashMap

-HashMap

三，LinkedHashMap

1，概述

-哈希表和链表实现的Map接口，具有可预测的迭代次序。

这种实现不同于HashMap，它维持于所有条目的运行双向链表。

此链接列表定义迭代排序，通常是将键插入到地图（插入顺序 ）中的顺序 。

2，特点

-键唯一，有序，允许为空，线程不安全

3，构造方法

LinkedHashMap()

构造具有默认初始容量（16）和负载因子（0.75）的空插入订购 LinkedHashMap实例。

LinkedHashMap(int initialCapacity)

构造具有指定初始容量和默认负载因子（0.75）的空插入订购 LinkedHashMap实例。

LinkedHashMap(Map m)

构造具有与指定地图相同映射的插入序列 LinkedHashMap实例。

4,成员方法

-都是讲过的

5，练习

-LinkedHashMap

-LinkedHashMap

-LinkedHashMap

package com.momo.demo;

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.Map;

public class Demo6 {

public static void main(String[] args) {

m = new LinkedHashMap<>();

m.put(3, "ccc");

m.put(4, "ddd");

m.put(1, "aaa");

m.put(2, "bbb");

m.put(3, "ccc");

m.put(4, "ddd");

System.out.println(m);

}

}

四， TreeMap

1，概述

-一个红黑树基于NavigableMap实现。

该地图是根据排序natural ordering其密钥，

或通过Comparator在地图创建时提供，这取决于所使用的构造方法。

2，特点

-可排序：自然排序，比较器排序(取决于构造方法)

-键唯一，不能为空

package com.momo.demo;

import java.util.LinkedHashMap;

import java.util.TreeMap;

public class Demo7 {

public static void main(String[] args) {

//无参构造， 自然排序

m = new TreeMap<>();

m.put(3, null);

m.put(4, null);

m.put(1, "aaa");

m.put(2, "bbb");

m.put(null, "ccc");

m.put(4, null);

System.out.println(m);

}

}

3，构造方法

TreeMap()

使用其键的自然排序构造一个新的空树状图。

TreeMap(Comparator comparator)

构造一个新的，空的树图，按照给定的比较器排序。

TreeMap(Map m)

构造一个新的树状图，其中包含与给定地图相同的映射，根据其键的 自然顺序进行排序 。

4，成员方法(虽然有特有方法，但是不难，用的也不多)

Map.Entry ceilingEntry(K key)

返回与大于或等于给定键的最小键相关联的键值映射，如果没有此键，则 null 。

K ceilingKey(K key)

返回大于或等于给定键的 null键，如果没有此键，则返回 null 。

Map.Entry firstEntry()

返回与该地图中的最小键相关联的键值映射，如果地图为空，则返回 null 。

K firstKey()

返回此地图中当前的第一个（最低）键。

Map.Entry floorEntry(K key)

返回与小于或等于给定键的最大键相关联的键值映射，如果没有此键，则 null 。

K floorKey(K key)

返回小于或等于给定键的最大键，如果没有这样的键，则返回 null 。

Map.Entry higherEntry(K key)

返回与最小密钥相关联的密钥值映射严格大于给定密钥，如果没有这样的密钥则 null 。

K higherKey(K key)

返回严格大于给定键的最小键，如果没有这样的键，则返回 null 。

Map.Entry lastEntry()

返回与该地图中最大关键字关联的键值映射，如果地图为空，则返回 null 。

K lastKey()

返回当前在此地图中的最后（最高）键。

Map.Entry lowerEntry(K key)

返回与最大密钥相关联的密钥值映射严格小于给定密钥，如果没有这样的密钥，则 null 。

K lowerKey(K key)

返回严格小于给定键的最大键，如果没有这样的键，则返回 null 。

Map.Entry pollFirstEntry()

删除并返回与该地图中的最小键相关联的键值映射，如果地图为空，则返回 null 。

Map.Entry pollLastEntry()

删除并返回与该地图中最大密钥相关联的键值映射，如果地图为空，则返回 null 。

SortedMap subMap(K fromKey, K toKey)

返回此地图部分的视图，其关键字范围从 fromKey （含）到 toKey ，独占。

package com.momo.demo;

import java.util.LinkedHashMap;

import java.util.Map;

import java.util.SortedMap;

import java.util.TreeMap;

public class Demo7 {

public static void main(String[] args) {

//无参构造， 自然排序

m = new TreeMap<>();

m.put(3, null);

m.put(4, null);

m.put(1, "aaa");

m.put(2, "bbb");

// m.put(null, "ccc");

m.put(6, "hah");

System.out.println(m);

entry = m.ceilingEntry(5);

entry = m.floorEntry(5);

System.out.println(entry);*/

sm = m.subMap(1, 3);

System.out.println(m);

System.out.println(sm);

}

}

5，练习

-TreeMap

-TreeMap

package com.momo.demo;

import java.util.Map;

import java.util.Set;

import java.util.TreeMap;

import java.util.TreeSet;

public class Demo16 {

public static void main(String[] args) {

ts = new TreeMap<>();

ts.put("baoqiang","marong");

ts.put("nailiang","xiaolu");

ts.put("wenzhang","yili");

ts.put("momo","xiaolongnv");

keys = ts.keySet();

for (String key : keys) {

String value = ts.get(key);

System.out.println(key+"--"+value);

}

System.out.println("-------------------");

> entries = ts.entrySet();

entry : entries) {

System.out.println(entry.getKey()+"--"+entry.getValue());

}

}

}

package com.momo.demo;

import com.momo.po.Stu;

import java.util.Map;

import java.util.Set;

import java.util.TreeMap;

import java.util.TreeSet;

public class Demo17 {

public static void main(String[] args) {

ts = new TreeMap<>();

ts.put("baoqiang",new Stu(1,"baoqiang",35));

ts.put("nailiang",new Stu(2,"nailiang",36));

ts.put("wenzhang",new Stu(3,"wenzhang",38));

ts.put("momo",new Stu(4,"momo",18));

keys = ts.keySet();

for (String key : keys) {

Stu stu = ts.get(key);

System.out.println(key+"--"+stu);

}

System.out.println("-------------------");

> entries = ts.entrySet();

entry : entries) {

System.out.println(entry.getKey()+"--"+entry.getValue());

}

}

}

-自定义对象 作为键，进行自然排序，比较器排序

package com.momo.demo;

import com.momo.po.Stu;

import java.util.*;

public class Demo18 {

public static void main(String[] args) {

//自然排序

ts = new TreeMap<>();

//比较器排序

() {

@Override

public int compare(Stu o1, Stu o2) {

int i = o1.getId()-o2.getId();

return i;

}

});

ts.put(new Stu(1,"baoqiang",35),"beilvle");

ts.put(new Stu(2,"nailiang",36),"pituile");

ts.put(new Stu(3,"wenzhang",38),"yaodi");

ts.put(new Stu(4,"momo",18),"shuaige");

keys = ts.keySet();

for (Stu key : keys) {

String s = ts.get(key);

System.out.println(key+"--"+s);

}

System.out.println("-------------------");

> entries = ts.entrySet();

entry : entries) {

System.out.println(entry.getKey()+"--"+entry.getValue());

}

}

}

package com.momo.po;

public class Stu implements Comparable{

private int id;

private String name;

private int age;

public Stu() {

}

public Stu(int id, String name, int age) {

this.id = id;

this.name = name;

this.age = age;

}

public int getId() {

return id;

}

public void setId(int id) {

this.id = id;

}

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() {

return "Stu{" +

"id=" + id +

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

", age=" + age +

'}';

}

@Override

public int compareTo(Stu o) {

int i = o.id-this.id;

int i2 = i==0?this.name.compareTo(o.name):i;

int i3 = i2==0?this.age-o.age:i2;

return i3;

}

}

package com.momo.demo;

import com.momo.po.Stu;

import java.util.*;

public class Demo19 {

public static void main(String[] args) {

//自然排序

ts = new TreeMap<>();

//比较器排序

() {

@Override

public int compare(Stu o1, Stu o2) {

int i = o1.getId()-o2.getId();

return i;

}

});

ts.put(new Stu(1,"baoqiang",35),new Stu(11,"aaa",12));

ts.put(new Stu(2,"nailiang",36),new Stu(22,"aaa",12));

ts.put(new Stu(3,"wenzhang",38),new Stu(33,"aaa",12));

ts.put(new Stu(4,"momo",18),new Stu(666,"田美",19));

keys = ts.keySet();

for (Stu key : keys) {

Stu s = ts.get(key);

System.out.println(key+"--"+s);

}

System.out.println("-------------------");

> entries = ts.entrySet();

entry : entries) {

System.out.println(entry.getKey()+"--"+entry.getValue());

}

}

}

6，Map集合练习

-"sdlfkjsfljsdlfjksdfljksed" 获取字符串中每一个字符出现的次数

结果格式： a(5)b(6)0(8)...

-集合嵌套遍历

单列集合和双列集合相互嵌套的遍历

package com.momo.demo;

import com.momo.po.Stu;

import java.util.Set;

import java.util.TreeMap;

/*

* qiming

* xianzigongsi

* java

* 学生。。。

* anquan

* 学生。。。

* beijinggongsi

* java

* 学生。。。

* anquan

* 学生。。。

* xianyangzigongsi

* java

* 学生。。。

* anquan

* 学生。。。

* */

public class Demo23 {

public static void main(String[] args) {

> xian = new TreeMap<>();

{

java = new TreeMap<>();

java.put("kd101", new Stu(1, "aaa", 11));

java.put("kd102", new Stu(2, "bbb", 12));

java.put("kd103", new Stu(3, "ccc", 13));

java.put("kd104", new Stu(4, "ddd", 11));

python = new TreeMap<>();

python.put("yd101", new Stu(1, "momo", 11));

python.put("yd102", new Stu(2, "xiaobao", 12));

python.put("yd103", new Stu(3, "xiaolong", 13));

security = new TreeMap<>();

security.put("an101", new Stu(1, "danqing", 11));

security.put("an102", new Stu(2, "ruichang", 12));

security.put("an103", new Stu(3, "zhangxin", 13));

xian.put("java", java);

xian.put("python", python);

xian.put("security", security);

}

> beijing = new TreeMap<>();

{

java = new TreeMap<>();

java.put("kd101", new Stu(1, "aaa", 11));

java.put("kd102", new Stu(2, "bbb", 12));

java.put("kd103", new Stu(3, "ccc", 13));

java.put("kd104", new Stu(4, "ddd", 11));

python = new TreeMap<>();

python.put("yd101", new Stu(1, "momo", 11));

python.put("yd102", new Stu(2, "xiaobao", 12));

python.put("yd103", new Stu(3, "xiaolong", 13));

security = new TreeMap<>();

security.put("an101", new Stu(1, "danqing", 11));

security.put("an102", new Stu(2, "ruichang", 12));

security.put("an103", new Stu(3, "zhangxin", 13));

beijing.put("java", java);

beijing.put("python", python);

beijing.put("security", security);

}

>> qiming = new TreeMap<>();

qiming.put("xian",xian);

qiming.put("beijing",beijing);

qmkeys = qiming.keySet();

System.out.println("qiming");

for (String qmkey : qmkeys) {

System.out.println(qmkey);

> xiaoqus = qiming.get(qmkey);

xiaoqukeys = xiaoqus.keySet();

for (String xiaoqukey : xiaoqukeys) {

System.out.println("\t"+xiaoqukey);

banjikeys = xiaoqus.get(xiaoqukey);

banji = banjikeys.keySet();

for (String s : banji) {

Stu stu = banjikeys.get(s);

System.out.println("\t"+"\t"+s+"---"+stu.getName()+"--"+stu.getAge());

}

}

System.out.println("---------------");

}

}

}

package com.momo.demo;

import com.momo.po.Stu;

import java.util.Map;

import java.util.Set;

import java.util.TreeMap;

public class Demo22 {

public static void main(String[] args) {

> qiming = new TreeMap<>();

java = new TreeMap<>();

java.put("kd101",new Stu(1,"aaa",11));

java.put("kd102",new Stu(2,"bbb",12));

java.put("kd103",new Stu(3,"ccc",13));

java.put("kd104",new Stu(4,"ddd",11));

python = new TreeMap<>();

python.put("yd101",new Stu(1,"momo",11));

python.put("yd102",new Stu(2,"xiaobao",12));

python.put("yd103",new Stu(3,"xiaolong",13));

security = new TreeMap<>();

security.put("an101",new Stu(1,"danqing",11));

security.put("an102",new Stu(2,"ruichang",12));

security.put("an103",new Stu(3,"zhangxin",13));

qiming.put("java",java);

qiming.put("python",python);

qiming.put("security",security);

keys = qiming.keySet();

for (String key : keys) {

tm = qiming.get(key);

xuehaos = tm.keySet();

System.out.println(key);

for (String xuehao : xuehaos) {

Stu stu = tm.get(xuehao);

System.out.println("\t" + xuehao + "--" + stu.getName() + "--" + stu.getAge());

}

}*/

>> entries = qiming.entrySet();

> entry : entries) {

String key = entry.getKey();

System.out.println(key);

tm = entry.getValue();

> entries1 = tm.entrySet();

entry1 : entries1) {

String key1 = entry1.getKey();

Stu sru = entry1.getValue();

System.out.println("\t"+key1+"--"+sru.getName());

}

System.out.println("---------------------------------");

}

}

}

package com.momo.demo;

import com.momo.po.Stu;

import java.util.*;

public class Demo21 {

public static void main(String[] args) {

> list = new ArrayList<>();

() {

@Override

public int compare(Stu o1, Stu o2) {

return o1.getId()-o2.getId();

}

});

t1.put(new Stu(1,"abc",12),89757);

t1.put(new Stu(2,"df",12),1111);

t1.put(new Stu(3,"er",12),31);

() {

@Override

public int compare(Stu o1, Stu o2) {

return o1.getId()-o2.getId();

}

});

t2.put(new Stu(1,"df",12),8);

t2.put(new Stu(2,"dfdfdf",12),11);

t2.put(new Stu(3,"dfdf",12),3);

list.add(t1);

list.add(t2);

tm : list) {

> entries = tm.entrySet();

entry : entries) {

System.out.println(entry.getKey().getName()+"---"+entry.getValue());

}

}*/

tm : list) {

stus = tm.keySet();

for (Stu stu : stus) {

Integer i = tm.get(stu);

System.out.println(stu.getName()+"-----"+stu.getAge()+"---"+i);

}

System.out.println("---------------------");

}

}

}

package com.momo.demo;

import com.momo.po.Stu;

import com.momo.po.Tea;

import java.util.*;

public class Demo20 {

public static void main(String[] args) {

//比较器排序

> ts = new TreeMap<>(new Comparator() {

@Override

public int compare(Tea o1, Tea o2) {

return o1.getAge()-o2.getAge();

}

});

momo = new ArrayList<>();

momo.add(new Stu(1,"aa",11));

momo.add(new Stu(2,"bb",11));

momo.add(new Stu(3,"cc",11));

cang = new ArrayList<>();

cang.add(new Stu(1,"郑硕",12));

cang.add(new Stu(2,"李威",13));

cang.add(new Stu(3,"赵凯",14));

ts.put(new Tea("momo",18),momo);

ts.put(new Tea("cang",38),cang);

keys = ts.keySet();

for (Tea key : keys) {

list = ts.get(key);

System.out.println(key.getName());

for (Stu stu : list) {

System.out.println("\t"+stu.getName());

}

System.out.println("------------------");

}*/

>> entries = ts.entrySet();

> entry : entries) {

Tea t = entry.getKey();

list = entry.getValue();

System.out.println(t.getName());

for (Stu stu : list) {

System.out.println("\t"+stu.getName());

}

}

}

}

package com.momo.demo;

import java.util.ArrayList;

import java.util.LinkedList;

public class Demo8 {

public static void main(String[] args) {

list1 = new ArrayList<>();

list1.add("宝强");

list1.add("马蓉");

list1.add("宋吉吉");

list2 = new ArrayList<>();

list2.add("唐僧");

list2.add("猴子");

list2.add("八戒");

list2.add("沙和尚");

list3 = new ArrayList<>();

list3.add("金莲");

list3.add("大郎");

list3.add("门庆");

> big = new LinkedList<>();

big.add(list1);

big.add(list2);

big.add(list3);

list : big) {

for (String s : list) {

System.out.println(s);

}

System.out.println("--------------");

}

}

}

package com.momo.demo;

import com.momo.po.Stu;

import java.util.ArrayList;

import java.util.LinkedList;

/*

3个班

西游班

水浒班

红楼班

* */

public class Demo9 {

public static void main(String[] args) {

xiyou = new LinkedList<>();

xiyou.add(new Stu(1,"唐生",18));

xiyou.add(new Stu(2,"悟空",30));

shuihu = new LinkedList<>();

shuihu.add(new Stu(101,"金莲",18));

shuihu.add(new Stu(102,"武松",26));

honglou = new LinkedList<>();

honglou.add(new Stu(1,"宝玉",18));

honglou.add(new Stu(2,"黛玉",19));

honglou.add(new Stu(3,"宝钗",20));

> big = new ArrayList<>();

big.add(xiyou);

big.add(shuihu);

big.add(honglou);

list : big) {

//System.out.println(list);

for (Stu stu : list) {

System.out.println(stu.getName()+"--"+stu.getAge());

}

System.out.println("--------------");

}

}

}

package com.momo.demo;

import java.util.Random;

import java.util.TreeSet;

/*

* 获取10个1-50随机数，要求不能重复

* */

public class Demo11 {

public static void main(String[] args) {

ts = new TreeSet<>();

Random r = new Random();

while (ts.size()<10){

int i = r.nextInt(50)+1;

ts.add(i);

}

for (Integer t : ts) {

System.out.println(t);

}

}

}

package com.momo.demo;

import com.momo.po.Student;

import java.util.Comparator;

import java.util.Scanner;

import java.util.TreeSet;

/*

* 键盘输入几个学生信息(科目成绩)，按照总成绩从高到低排序

* */

public class Demo12 {

public static void main(String[] args) {

() {

@Override

public int compare(Student o1, Student o2) {

int i = o2.getSum()-o1.getSum();//总成绩

int i2 = i==0?o2.getMath()-o1.getMath():i;

int i3 = i2==0?o2.getEnlish()-o1.getEnlish():i2;

int i4 = i3==0?o2.getChinese()-o1.getChinese():i3;

int i5 = i4==0?o2.getId()-o1.getId():i4;

return i5;

}

});

Scanner sc = new Scanner(System.in);

System.out.println("要开始录入学生信息吗？1-开始 0-结束");

aa:while (true) {

int i = sc.nextInt();

switch (i) {

case 1:

System.out.println("开始录入：");

System.out.println("编号：");

int id = sc.nextInt();

System.out.println("数学成绩：");

int math = sc.nextInt();

System.out.println("英语成绩：");

int english = sc.nextInt();

System.out.println("中文成绩：");

int chinese = sc.nextInt();

ts.add(new Student(id,math,english,chinese));

System.out.println("还要继续录入吗？1-开始 0-结束");

break;

case 0:

System.out.println("结束录入。");

System.out.println("成绩从高到低的排序如下：");

for (Student s : ts) {

System.out.println(s.getSum()+","+s.getMath()+","+s.getEnlish()+","+s.getChinese()+","+s.getId());

}

break aa;

default:

System.out.println("输入有误。。。");

break;

}

}

}

}

package com.momo.po;

public class Student {

private int id;

private int math;

private int enlish;

private int chinese;

public Student() {

}

public Student(int id, int math, int enlish, int chinese) {

this.id = id;

this.math = math;

this.enlish = enlish;

this.chinese = chinese;

}

public int getId() {

return id;

}

public void setId(int id) {

this.id = id;

}

public int getMath() {

return math;

}

public void setMath(int math) {

this.math = math;

}

public int getEnlish() {

return enlish;

}

public void setEnlish(int enlish) {

this.enlish = enlish;

}

public int getChinese() {

return chinese;

}

public void setChinese(int chinese) {

this.chinese = chinese;

}

public int getSum(){

return math+enlish+chinese;

}

}

---