DAY16
MAP集合
比如 key-------------value
Abcd-------------1234
像这种键值对应关系的数据,Java给我们提供了一种容器,就是Map集合
Map一个根接口学习几个实现类: HashMap Hashtable TreeMap,用多态的方式来创建对象
Map<String, String> hm = new HashMap<String, String>();
Map是双列集合,主要用来存储 有键值对应关系的数据 Map是一个接口
HashMap Hashtable区别 HashMap非同步的,效率高,数据不安全 Hashtable同步的,效率第,数据安全
HashMap 底层数据结构是哈希表 特点:元素无序 且唯一 元素唯一 是靠元素重写 equlse方法和hashCode方法
// LinkedHashMap 底层数据结构是链表和哈希表 链表保证元素有序,哈希表保证元素唯一
// TreeMap 底层数据结构是二叉树 它能够对元素进行排序 排序对元素有要求 要求元素实现 Comparable<T>接口
// 重写 compareTo 方法 元素放置的顺序 就是根据这个方法的返回值正 负 0来确定
// 常见方法
HashMap<Object, Object> hm = new HashMap<>();
// hm.put(key, value); 添加数据 第一次添加 返回值是null 再添加就会上一次的值 键相同 值覆盖
// hm.size() 获取集合长度
// hm.isEmpty()//判断集合是否为空
// hm.containsKey(key) 判断集合有没有这个键
// hm.containsValue(value) 判断集合有没有这个值
// hm.get(key) 根据键获取对应值
// hm.keySet() 获取所有的键的set集合
// hm.entrySet();// 获取所有的键值对 对象集合 Entry<Object, Object> 有两个方法 getKey 和
// getValue
// hm.values(); 获取所有值的集合
// hm.clear(); 清除所有的元素
// hm.remove(key) 根据键移除一对
1 存储数据用put 方法,放置数据
第一次采用put 放置数据的时候 返回的是null
第二次放置键相同的数据 会返回上一次的值
import java.util.HashMap;
import java.util.Map;
public class MapDemo {
public static void main(String[] args) {
String str = hm.put("EDG", "666");
String str2 = hm.put("RNG1", "233");
hm.put("LGD", "886");
hm.put("JDG", "663");
System.out.println(str);
System.out.println(str2);
System.out.println(hm);//打印地址值,或者其它
2 删除功能
void clear():移除所有的键值对元素
V remove(Object key)：根据键删除键值对元素，并把值返回
hm.clear();
String value = hm.remove("LGD");//根据键名 从集合中移除这个组键值,返回这个键所对应的值
System.out.println(value);
System.out.println(hm);
3 判断功能
boolean containsKey(Object key)：判断集合是否包含指定的键
boolean containsValue(Object value):判断集合是否包含指定的值
boolean isEmpty()：判断集合是否为空
boolean b = hm.containsKey(5);
b = hm.containsValue("电子竞技");
hm.clear();
b = hm.isEmpty();
4 获取功能
Set<Map.Entry<K,V>> entrySet(): 返回一个键值对的Set集合
V get(Object key):根据键获取值
Set<K> keySet():获取集合中所有键的集合
Collection<V> values():获取集合中所有值的集合
遍历Map集合
Set<K> keySet():获取集合中所有键的集合
Set<Integer> keySet = hm.keySet();//获取键的集合
for (Integer key : keySet) {
hm.get(key) 通过键 找值
System.out.println(key + "=====" + hm.get(key));
}
Map 集合的数据结构只跟键有关 跟值没关系
第二种遍历Map 集合的方式
Set<Map.Entry<K,V>> entrySet(): 返回一个键值对的Set集合
Entry<K,V> 键值对对象 ,把键和值封装起来看做一个对象
Entry<K,V>
getKey()
返回与此项对应的键。
V getValue()
返回与此项对应的值。
entrySet(); 获取所有的键值对 对象Entry<Integer, String>
Set<Entry<Integer, String>> entrySet = hm.entrySet();
for (Entry<Integer, String> en : entrySet) {
Entry 键值对对象里面提过了两个方法 getKey获取键 getValue 获取值
System.out.println(en.getKey() + "----" + en.getValue());
}
获取map 集合中所有的值
Collection<String> values = hm.values();
for (String v : values) {
System.out.println(v);
}
}
}
举例
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
public class MapDemo {
public static void main(String[] args) {
// A:案例演示: HashMap集合键是String值是Student的案例
HashMap<String, Student> hm = new HashMap<String, Student>();
hm.put("01", new Student("熊大", 81));
hm.put("02", new Student("熊二", 82));
hm.put("03", new Student("熊三", 83));
hm.put("04", new Student("熊四", 84));
hm.put("05", new Student("熊无", 85));
System.out.println(hm);
// 方式1
Set<String> keySet = hm.keySet();
for (String key : keySet) {
System.out.println(key + "====" + hm.get(key).getName() + "--" + hm.get(key).getAge());
}
// 方式2 遍历
System.out.println("-------------------------------------------------------------------");
Set<Entry<String, Student>> entrySet = hm.entrySet();
for (Entry<String, Student> en : entrySet) {
String key = en.getKey();
Student stu = en.getValue();
System.out.println(key + "==" + stu.getName() + "--" + stu.getAge());
}
}
}
LinkedHashMap的概述: Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序
LinkedHashMap的特点： 底层的数据结构是链表和哈希表 元素有序 并且唯一
元素的有序性由链表数据结构保证 唯一性由 哈希表数据结构保证
Map集合的数据结构只和键有关
LinkedHashMap<Integer, String> map = new LinkedHashMap<Integer, String>();
有序:指的是存的顺序跟取的顺序一致
public static voiimport java.util.LinkedHashMap;
import java.util.Map.Entry;
import java.util.Set;
public class Test3 {
public static void main(String[] args) {
map.put(1, "狗大);
map.put(0, "狗二");
map.put(3, "狗三");
map.put(4, "狗大");
map.put(2, "狗小");
map.put(1, "狗五");
// 遍历
Set<Entry<Integer, String>> entrySet = hm.entrySet();
for (Entry<Integer, String> en : entrySet) {
Integer key = en.getKey();
String value = en.getValue();
System.out.println(key + "===" + value);
}
}
}
import java.util.Collection;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
public class MapTest {
public static void main(String[] args) {
HashMap<Integer, String> hm = new HashMap<Integer, String>();
hm.put(1, "斗鱼");
hm.put(2, "虎牙");
hm.put(3, "熊猫");
hm.put(4, "天才);
hm.put(5, "战旗");
判断功能
boolean containsKey(Object key)：判断集合是否包含指定的键
boolean containsValue(Object value):判断集合是否包含指定的值
boolean isEmpty()：判断集合是否为空
boolean b = hm.containsKey(5);
b = hm.containsValue("斗鱼");
hm.clear();
b = hm.isEmpty();
System.out.println(b);
获取功能
Set<Map.Entry<K,V>> entrySet(): 返回一个键值对的Set集合
V get(Object key):根据键获取值
Set<K> keySet():获取集合中所有键的集合
Collection<V> values():获取集合中所有值的集合
Set<K> keySet():获取集合中所有键的集合
V get(Object key):根据键获取值
System.out.println("------------------------------------------------");
Set<Integer> keySet = hm.keySet();//获取键的集合
for (Integer key : keySet) {
hm.get(key) 通过键 找值
System.out.println(key + "=====" + hm.get(key));
}
TreeMap
TreeMap:数据结构是红黑树 特点:元素唯一,而且还能对元素进行排序 :自然排序和比较器排序 TreeMap 不允许插入null键
TreeMap<Student, String> map = new TreeMap<Student, String>();
// new TreeMap(new Comparator<Student>() {
//
// @Override
// public int compare(T o1, T o2) {
// // TODO Auto-generated method stub
// return 0;
// }
// });
public static void main(String[] args) {
TreeMap<String, String> treeMap = new TreeMap<String, String>();
// treeMap.put(null, "abc");
// treeMap.put(null, null);
treeMap.put("ddd", null);
System.out.println(treeMap);
// 获取map集合的长度 size()
System.out.println(treeMap.size());
}
}
用TreeMap 存储键是Integer 值是 String 类型的数据
TreeMap 底层数据结构是红黑树 它能够保证元素唯一,能够对元素进行排序,排序要有条件 排序的元素必须实现Comparable接口 重写 CmcompareTo(T)
元素实现了Comparable<Integer> 接口 重写了里面的CmcompareTo(T o) 比较此对象与指定对象的顺序。
import java.util.Set;
import java.util.TreeMap;
public class TreeDemo2 {
public static void main(String[] args) {
TreeMap<Integer,String> map= new TreeMap<Integer,String>();
map.put(0, "RNG");
map.put(1, "EDG");
map.put(3, "LGD");
map.put(2, "QG");
Set<Integer>keySet= map.keySet();
for(Integer mp :keySet){
System.out.println(mp+map.get(mp));
}
}
}
二 Collection
import java.io.LineNumberInputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.ListIterator;
public class ListUtils {
public static void main(String[] args) {
// 集合工具类 Collections 针对的是 Collection集合
// Collections类概述: 针对集合操作 的工具类
// Collections成员方法
// public static <T> void sort(List<T> list): 排序,默认按照自然顺序
// public static <T> int binarySearch(List<?> list,T key): 二分查找
// public static <T> T max(Collection<?> coll): 获取最大值
// public static void reverse(List<?> list): 反转
// public static void shuffle(List<?> list): 随机置换
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(20);
list.add(30);
list.add(1);
list.add(0);
list.add(10);
// 采用集合工具类进行排序
Collections.sort(list);
// Object[] a = list.toArray();//先把集合转成数组
// Arrays.sort(a);//排列数组里面的元素
// 获取迭代器
// ListIterator<T> i = list.listIterator();
// 遍历集合中的元素
// for (int j=0; j<a.length; j++) {
// i.next();//获取每一个元素
// i.set((T)a[j]);//替换了集合中的元素
// }
// public static <T> int binarySearch(List<?> list,T key);
// 二分查找,前提是元素必须有序
int index = Collections.binarySearch(list, 20);
System.out.println(index);
Integer max = Collections.max(list);
Integer min = Collections.min(list);
System.out.println(max + "==" + min);
// 随机打乱集合中元素的顺序
// Collections.shuffle(list);
Collections.reverse(list);
System.out.println(list);
}
}
课堂练习:1案例演示: 需求：用户随便输入一段字符串 统计字符串中每个字符出现的次数
import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;
public class Test1 {
public static void main(String[] args) {
HashMap<Character, Integer> map = new HashMap<Character, Integer>();
Scanner sc = new Scanner(System.in);
System.out.println("请输入一段字符");
String str = sc.nextLine();
char [] chs = str.toCharArray();
for (char key: chs){
Integer value = map.get(key);
if(value == null){
map.put(key,1);
}else{
value++;
map.put(key,value);
}
}
Set<Character> keySet= map.keySet();
StringBuilder sb = new StringBuilder();
for (Character ch : keySet) {
sb.append(ch).append("(").append(map.get(ch)).append(")");
}
System.out.println(sb.toString());
}
}
2 嵌套排序
import java.util.HashMap;
import java.util.Set;
public class Test2 {
public static void main(String[] args) {
HashMap <String,Integer> map1 = new HashMap<String,Integer>();
map1.put("RNG",666);
map1.put("edg",622);
HashMap<String, Integer> map2 = new HashMap<String,Integer>();
map2.put("LGD", 233);
map2.put("QG", 2233);
HashMap<String, HashMap<String, Integer>> map = new HashMap<String,HashMap<String,Integer>>();
map.put("LPL", map1);
map.put("lspl",map2);
Set<String>keySet=map.keySet();
for(String key:keySet){
System.out.println(key);
HashMap<String, Integer> map3 = map.get(key);
Set<String> keySet2 = map3.keySet();
for(String key2:keySet2){
System.out.println(key2+map3.get(key2));
}
System.out.println();
}
}
}
3 HashMap和Hashtable的区别:
HashMap: 线程不安全,效率高.允许null值和null键
Hashtable: 线程安全 , 效率低.不允许null值和null键
4 斗地主小游戏
import java.util.ArrayList;
import java.util.Collections;
public class Game2 {
public static void main(String[] args) throws Exception{
ArrayList<String> Paibox = new ArrayList<String>();
String[] colors ={ "♥", "♠", "♦", "♣" };
String[] nums = { "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K" };
for (String color : colors){
for (String num: nums){
Paibox.add(color+num);
}
}
Paibox.add("☼");
Paibox.add("☽");
Collections.shuffle(Paibox);
Collections.shuffle(Paibox);
ArrayList<String> RNG = new ArrayList<String>();
ArrayList<String> EDG = new ArrayList<String>();
ArrayList<String> LGD = new ArrayList<String>();
ArrayList<String> 底牌 = new ArrayList<String>();
for (int i =0;i<Paibox.size();i++){
if(i>=Paibox.size()-3){
底牌.add(Paibox.get(i));
}else if (i%3==0){
RNG.add(Paibox.get(i));
}else if (i%3==1){
EDG.add(Paibox.get(i));
}else if (i%3==0){
LGD.add(Paibox.get(i));
}
}
lookPai("RNG", RNG);
lookPai("EDG", EDG);
lookPai("LGD", LGD);
lookPai("底牌", 底牌);
}
private static void lookPai(String string, ArrayList<String> list) {
System.out.println(string);
for (String pai:list){
System.out.println(pai+" ");
}
System.out.println();
}
}
4871
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
