【JavaSE笔记】集合(五)

本期知识点： Map及其相关 Collections集合工具类

1.Map

a.概述

将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

b.Map和Collection的区别?

i.Map集合，是一种键值对的一种映射关系。存储的是键值对的形式的元素。键是唯一的，值可以重复。 HashMap TreeMap 子实现类 ii.Collection集合是集合框架的顶层接口。存储的是单独出现的元素。子接口List元素可以重复，子接口Set元素唯一。 ArrayList Vector LinkedList 子实现类

c.Map接口功能

A:添加功能：

V put(K key,V value)   添加元素(键和值的具体元素) 其他用法:如果键是第一次存储的时候,返回值null(小细节) 如果键已经存在,再次存储的时候将第一次的值返回,并且后面的值覆盖掉前面的值

B:删除功能：

void clear()   从此映射中移除所有映射关系(移出所有的键和值) V remove(Object key)   删除键,返回值

C:判断功能：

boolean containsKey(Object key) 判断当前Map集合中是否存在key:键 boolean containsValue(Object value)判断当前Map姐中是否存在value:值

D:获取功能：

V get(Object key)  返回指定键所映射的值 Set<K> keySet()  获取所有的键的集合 Collection<V> values()  获取所有的值的集合 Set<Map.Entry<K,V>>

E:长度功能：

int size()

import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Set; public class 获取功能 { public static void main(String[] args) { //创建Map集合对象 Map<String, String> m = new HashMap<String,String>(); //添加元素 m.put("Ash", "Thermite"); m.put("Twitch", "Montagne "); m.put("Glaz", "Fuze"); m.put("Blitz", "IQ"); //V get(Object key)返回指定键所映射的值 String a = m.get("Ash"); System.out.println("Values:"+a); //Set<K> keySet():获取所有的键的集合 Set<String> k = m.keySet(); System.out.println("AllKey:"+k); //Collection<V> values():获取所有的值的集合 Collection<String> v =m.values(); System.out.println("AllValues:"+v); } } //out: //Values:Thermite //AllKey:[Blitz, Twitch, Ash, Glaz] //AllValues:[IQ, Montagne , Thermite, Fuze] import java.util.HashMap; import java.util.Map; public class 添加删除长度功能 { public static void main(String[] args) { Map<String,String> m = new HashMap<String,String>(); //给集合添加元素 m.put("Ash", "Thermite"); m.put("Twitch", "Montagne "); m.put("Glaz", "Fuze"); m.put("Blitz", "IQ"); //void clear() 移除所有映射关系 // m.clear(); // System.out.println(m);//{} //V remove(Object key):删除键,返回值 System.out.println(m.remove("Ash"));//Thermite System.out.println(m.remove("Glaz"));//Fuze System.out.println(m);//{Blitz=IQ, Twitch=Montagne } //int size(); System.out.println(m.size());//2 } }

d.Map集合的遍历

i:键找值

1):获取所有键的集合 2):遍历键的集合,得到每一个键 3):根据键到集合中去找值

ii:键值对对象找键和值

1):获取所有的键值对对象的集合 2):遍历键值对对象的集合，获取每一个键值对对象 3):根据键值对对象去获取键和值 4):接口 Map.Entry<K,V>:(正在封闭接口：Map<K,V>) public static interface Map.Entry<K,V> 映射项（键-值对）。Map.entrySet 方法返回映射的 collection 视图，其中的元素属于此类。获得映射项引用的唯一 方法是通过此 collection 视图的迭代器来实现。 方法： boolean equals(Object o)   比较指定对象与此项的相等性。如果给定对象也是一个映射项，并且两个项表示相同的映射关系，则返回 true。 K getKey()   与此项对应的键 V getValue()   返回与此项对应的值。如果已经从底层映射中移除了映射关系（通过迭代器的 remove 操作），则此调用的结果是不确定的。

i.

import java.util.HashMap; import java.util.Map; import java.util.Set; public class Map集合的遍历_键找值 { public static void main(String[] args) { //创建Map集合对象 Map<String, String> m = new HashMap<String,String>(); //给集合添加元素 m.put("Ash", "Thermite"); m.put("Twitch", "Montagne "); m.put("Glaz", "Fuze"); m.put("Blitz", "IQ"); //获取所有键的值 Set<String> s = m.keySet(); //遍历所有键的集合 for (String k : s) { String v = m.get(k); System.out.println(k+"---"+v); } } } //out: // Blitz---IQ // Twitch---Montagne // Ash---Thermite // Glaz---Fuze

ii. import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; import java.util.Set; public class Map集合的遍历_键值对对象找键和值 { public static void main(String[] args) { //创建Map集合对象 Map<String, String> m = new HashMap<String,String>(); //给集合添加元素 m.put("Ash", "Thermite"); m.put("Twitch", "Montagne "); m.put("Glaz", "Fuze"); m.put("Blitz", "IQ"); //获取 键值对 对象的集合 Set<Entry<String, String>> s = m.entrySet(); //遍历 键值对 对象的集合 for (Entry<String, String> me : s) { //键值对 对象中有两个方法 关于 Key 和 Values //K getKey():获取键 //V getValue():获取值 String key = me.getKey(); String values = me.getValue(); System.out.println(key+"---"+values); } } } //out: // Blitz---IQ // Twitch---Montagne // Ash---Thermite // Glaz---Fuze

2.Map集合体系图：

3.HashMap的嵌套

a.ArrayList-HashMap

import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import java.util.Set; public class ArrayList_HashMap { public static void main(String[] args) { ArrayList<HashMap<String, Integer>> a = new ArrayList<HashMap<String, Integer>>(); HashMap<String, Integer> m = new HashMap<String,Integer>(); m.put("Ash", 22); m.put("Fuze", 23); m.put("Glaz", 22); a.add(m); //ArrayList迭代器 Iterator<HashMap<String, Integer>> it = a.iterator(); while(it.hasNext()){ HashMap<String, Integer> n = it.next(); Set<String> keySet = n.keySet(); for (String key : keySet) { Integer values = n.get(key); System.out.println(key+"---"+values); } } System.out.println("-----------"); //增强for for (HashMap<String, Integer> hm : a) { Set<String> keySet = hm.keySet(); for (String k : keySet) { Integer values = hm.get(k); System.out.println(k+"---"+values); } } } } //out: // Ash---22 // Fuze---23 // Glaz---22 // ----------- // Ash---22 // Fuze---23 // Glaz---22

b.HashMap-HashMap

import java.util.HashMap; import java.util.Set; public class HashMap_HashMap { public static void main(String[] args) { HashMap<String, HashMap<String, Integer>> hm = new HashMap<String, HashMap<String, Integer>>(); HashMap<String, Integer> m1 = new HashMap<String, Integer>(); m1.put("Tom", 20); m1.put("Peter", 21); hm.put("自动化", m1); HashMap<String, Integer> m2 = new HashMap<String, Integer>(); m2.put("Ash", 22); m2.put("Rook", 21); hm.put("计算机", m2); //遍历 Set<String> hms = hm.keySet(); for (String hmk : hms) { System.out.println(hmk); HashMap<String, Integer> hmv = hm.get(hmk); Set<String> hmss = hmv.keySet(); for (String hmkk : hmss) { Integer hmvv = hmv.get(hmkk); System.out.println(hmkk+"---"+hmvv); } } } } //out: // 自动化 // Tom---20 // Peter---21 // 计算机 // Ash---22 // Rook---21

c.HashMap-ArrayList

import java.util.ArrayList; import java.util.HashMap; import java.util.Set; public class HashMap_ArrayList { public static void main(String[] args) { HashMap<String, ArrayList<String>> m = new HashMap<String, ArrayList<String>>(); ArrayList<String> a = new ArrayList<String>(); a.add("Ash"); a.add("Glaz"); a.add("Fuze"); m.put("进攻方", a); Set<String> keySet = m.keySet(); for (String key : keySet) { System.out.println(key); ArrayList<String> values = m.get(key); for (String vkey : values) { System.out.println(vkey); } } } } //out: // 进攻方 // Ash // Glaz // Fuze

d.Hashtable和HashMap的区别:

HashMap集合:允许有null键和null值,从线程的角度考虑:他是一个线程不安全,不同步,执行效率高 Hashtable集合:不允许有null键,从线程的角度考虑:他是一个线程安全的,同步,效率低

4.TreeMap

TreeMap:基于红黑树结果

两种排序:自然排序,比较器排序

import java.util.Set; import java.util.TreeMap; public class TreeMapDemo { public static void main(String[] args) { //创建TreeMap集合对象 TreeMap<String, Integer> t = new TreeMap<String, Integer>(); //添加元素 t.put("Ash", 21); t.put("Fuze", 21); t.put("Glaz", 21); t.put("Tom", 21); //遍历 Set<String> keySet = t.keySet(); for (String k : keySet) { Integer v = t.get(k); System.out.println(k+"---"+v); } } } //out: // Ash---21 // Fuze---21 // Glaz---21 // Tom---21

public class Student { private String name; private int age; public Student() { super(); // TODO Auto-generated constructor stub } public Student(String name, int age) { super(); 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; } } import java.util.Comparator; import java.util.Set; import java.util.TreeMap; public class TreeMapStudentDemo { public static void main(String[] args) { TreeMap<Student, String> t = new TreeMap<Student, String>(new Comparator<Student>() { @Override public int compare(Student o1, Student o2) { //按照年龄大小排序 int a = o1.getAge()-o2.getAge(); //按照名字内容 int b = a == 0? o2.getName().compareTo(o1.getName()):a; return b; } }); //创建学生对象 Student s1 = new Student("Tom",21); Student s2 = new Student("Ash",22); Student s3 = new Student("Peter",20); Student s4 = new Student("Rush",21); //添加 t.put(s1, "自动化"); t.put(s2, "自动化"); t.put(s3, "计算机"); t.put(s4, "计算机"); //获取所有的键的集合 Set<Student> keySet = t.keySet(); for (Student k : keySet) { String v = t.get(k); System.out.println(k.getName()+"---"+k.getAge()+"---"+v); } } } //out: // Peter---20---计算机 // Tom---21---自动化 // Rush---21---计算机 // Ash---22---自动化

5.Collections

a.概述:

对集合操作的工具类

b.Collections和Collection的区别?

Collection:集合:顶层次的一个根接口,有两个子接口:List,Set Collections:对集合操作的工具类,具体的类:它针对集合进程操作!

c.方法：

public static <T> void sort(List<T> list)   默认自然排序:将集合中的元素升序排序 public static <T> int binarySearch(List> list,T key)  二分查找搜索法:key:查找的元素 public static void reverse(List list)  反转功能

public static void shuffle(List<?> list)   随机置换,打乱顺序

import java.util.ArrayList; import java.util.Collections; public class Demo01 { public static void main(String[] args) { ArrayList<Integer> a = new ArrayList<Integer>(); //添加元素: a.add(20) ; a.add(17); a.add(19) ; a.add(18) ; a.add(24) ; a.add(23) ; a.add(22) ; System.out.println(a); // public static <T> void sort(List<T> list) // 默认自然排序:将集合中的元素升序排序 Collections.sort(a); System.out.println(a); // public static <T> int binarySearch(List> list,T key):二分查找搜索法:key:查找的元素 int index = Collections.binarySearch(a, 20); System.out.println(index); // public static void reverse(List list):反转功能 Collections.reverse(a); System.out.println(a); // public static void shuffle(List<?> list):随机置换,打乱顺序 Collections.shuffle(a); System.out.println(a); } }