java Map的子类-java学习笔记，
java Map的子类-java学习笔记，
* 作为学生来说，是根据学号来区分不同的学生的，那么假设我现在已经知道了学生的学号，我要根据学号去获取学生姓名，请问怎么做呢?
* 如果采用前面讲解过的集合，我们只能把学号和学生姓名作为一个对象的成员，然后存储整个对象，将来遍历的时候，判断，获取对应的名称。
* 但是呢，如果我都能把学生姓名拿出来了，我还需要根据编号去找吗?
* 针对我们目前的这种需求：仅仅知道学号，就想知道学生姓名的情况，Java就提供了一种新的集合 Map。
* 通过查看API，我们知道Map集合的一个最大的特点，就是它可以存储键值对的元素。这个时候存储我们上面的需求，就可以这样做
* 学号1 姓名1
* 学号2 姓名2
* 学号3 姓名3
* 学号2(不行)姓名4
* 学号4 姓名4
- Map集合的特点：
* 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
*
- Map集合和Collection集合的区别?
* Map集合存储元素是成对出现的，Map集合的键是唯一的，值是可重复的。可以把这个理解为：夫妻对
* Collection集合存储元素是单独出现的，Collection的儿子Set是唯一的，List是可重复的。可以把这个理解为：光棍(11.11)
*
* 注意：
* Map集合的数据结构值针对键有效，跟值无关
* HashMap，TreeMap等会讲。
* Collection集合的数据结构是针对元素有效
* Map集合的功能概述：
* 1:添加功能
* V put(K key,V value):添加元素。这个其实还有另一个功能?先不告诉你，等会讲
* 如果键是第一次存储，就直接存储元素，返回null
* 如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
* 2:删除功能
* void clear():移除所有的键值对元素
* V remove(Object key)：根据键删除键值对元素，并把值返回
* 3:判断功能
* boolean containsKey(Object key)：判断集合是否包含指定的键
* boolean containsValue(Object value):判断集合是否包含指定的值
* boolean isEmpty()：判断集合是否为空
* 4:获取功能
* Set<Map.Entry<K,V>> entrySet():???
* V get(Object key):根据键获取值
* Set<K> keySet():获取集合中所有键的集合
* Collection<V> values():获取集合中所有值的集合
* 5：长度功能
* int size()：返回集合中的键值对的对数
public class MapDemo {
public static void main(String[] args) {
// 创建集合对象
Map<String, String> map = new HashMap<String, String>();
// 添加元素
// V put(K key,V value):添加元素。这个其实还有另一个功能?先不告诉你，等会讲
// System.out.println("put:" + map.put("文章", "马伊俐"));null
// System.out.println("put:" + map.put("文章", "姚笛"));马伊俐
map.put("邓超", "孙俪");
map.put("黄晓明", "杨颖");
map.put("周杰伦", "蔡依林");
map.put("刘恺威", "杨幂");
// void clear():移除所有的键值对元素
// map.clear();
// V remove(Object key)：根据键删除键值对元素，并把值返回
// System.out.println("remove:" + map.remove("黄晓明"));孙俪
// System.out.println("remove:" + map.remove("黄晓波"));null
// boolean containsKey(Object key)：判断集合是否包含指定的键
// System.out.println("containsKey:" + map.containsKey("黄晓明")); true
// System.out.println("containsKey:" + map.containsKey("黄晓波"));false
// boolean isEmpty()：判断集合是否为空
// System.out.println("isEmpty:"+map.isEmpty());false
//int size()：返回集合中的键值对的对数
System.out.println("size:"+map.size());4
// 输出集合名称
System.out.println("map:" + map);
}
}
(4)Map集合的遍历
A:键找值
a:获取所有键的集合
b:遍历键的集合,得到每一个键
c:根据键到集合中去找值
B:键值对对象找键和值
a:获取所有的键值对对象的集合
b:遍历键值对对象的集合，获取每一个键值对对象//me是对象
String key = me.getKey();
String value = me.getValue();
c:根据键值对对象去获取键和值
代码体现：
Map<String,String> hm = new HashMap<String,String>();
hm.put("it002","hello");
hm.put("it003","world");
hm.put("it001","java");
//方式1 键找值
Set<String> set = hm.keySet();
for(String key : set) {
String value = hm.get(key);
System.out.println(key+"---"+value);
}
//方式2 键值对对象找键和值
Set<Map.Entry<String,String>> set2 = hm.entrySet();
for(Map.Entry<String,String> me : set2) {
String key = me.getKey();
String value = me.getValue();
System.out.println(key+"---"+value);
}
(5)HashMap集合的练习
A:HashMap<String,String>
B:HashMap<Integer,String>
C:HashMap<String,Student>
D:HashMap<Student,String>//需要重写Hashcode和equals因为键用的是哈希表
- LinkedHashMap:是Map接口的哈希表和链接列表实现，具有可预知的迭代顺序。
- 由哈希表保证键的唯一性
- 由链表保证值的有序(存储和取出的顺序一致)
(6)TreeMap集合的练习
A:TreeMap<String,String>
B:TreeMap<Student,String>//需要实现Comparactor接口
public class TreeMapDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
TreeMap<Student, Integer> th = new TreeMap<Student, Integer>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
// TODO Auto-generated method stub
//主要条件按照年龄排序
int num = s1.getAge() - s2.getAge();
//次要条件
Int num2=num==0?s1.getName().compareTo(s2.getName()):num;
return num2;
}
});
Student s = new Student("张三", 25);
Student s2 = new Student("李四", 25);
Student s3 = new Student("王二", 25);
Student s4 = new Student("麻子", 25);
Student s5 = new Student("小明", 25);
Student s6 = new Student("二愣", 25);
th.put(s, 222);
th.put(s2, 333);
th.put(s3, 655);
th.put(s4, 789);
th.put(s5, 325);
th.put(s6, 125);
Set<Student> set = th.keySet();
for (Student key : set) {
Integer i = th.get(key);
System.out.println(key + "---" + i);
}
}
}
(7)案例
A:统计一个字符串中每个字符出现的次数
public class Demo_1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int count = 0;
// 定义一个字符串
String s = "我啊是uahhaiueghv阿强";
// 定义一个hashmap
//因为TreeMap实现了Comparable接口所以可以实现排序所以使用TreeMap
TreeMap<Character, Integer> ha = new TreeMap<Character, Integer>();
//把字符串转成字符数组
char[] c = s.toCharArray();
Set<Character> set = ha.keySet();
for (char i : c) {
//得到值
Integer in = ha.get(i);// 得到值也就是个数然后覆盖****
if (!ha.containsKey(i)) {
ha.put(i, 1);
} else {
//重新覆盖值
put(i, ++in);
}
}
//字符串缓冲区
StringBuilder sb = new StringBuilder();
for (Character ch : set) {
//这个必须这样写因为这个没遍历都会出现一次添加****
append(ch).append('(').append(ha.get(ch)).append(')');
}
System.out.println(sb.toString());
}
}
B:集合的嵌套遍历
a:HashMap嵌套HashMap
public class HashMapDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
HashMap<String, HashMap<String, Student>> ha = new HashMap<String, HashMap<String, Student>>();
HashMap<String, Student> ha1 = new HashMap<String, Student>();
Student s = new Student("张三", 25);
Student s2 = new Student("李四", 25);
Student s3 = new Student("王二", 25);
Student s4 = new Student("麻子", 25);
Student s5 = new Student("小明", 25);
Student s6 = new Student("二愣", 25);
ha1.put("100", s);
ha1.put("101", s2);
ha1.put("102", s3);
ha1.put("103", s4);
ha1.put("104", s5);
ha1.put("105", s6);
HashMap<String, Student> ha2 = new HashMap<String, Student>();
Student s11 = new Student("狗蛋", 25);
Student s22 = new Student("黑子", 20);
Student s33 = new Student("狗子", 26);
Student s44 = new Student("耗子", 15);
Student s55 = new Student("铁蛋", 16);
Student s66 = new Student("小黑", 24);
ha2.put("201", s11);
ha2.put("202", s22);
ha2.put("203", s33);
ha2.put("204", s44);
ha2.put("205", s55);
ha2.put("206", s66);
ha.put("jc", ha1);
ha.put("jy", ha2);
Set<String> set = ha.keySet();
for (String ss : set) {
HashMap<String, Student> h = ha.get(ss);
Set<String> ser_2 = h.keySet();
for (String hh : ser_2) {
System.out.println(h.get(hh).getName()+"---"+h.get(hh).getAge()+"---"+hh);
}
}
}
}
b:HashMap嵌套ArrayList
public class HashMaptoArrayList {
public static void main(String[] args) {
// TODO Auto-generated method stub
HashMap<String, ArrayList<String>> hatolist = new HashMap<String, ArrayList<String>>();
ArrayList<String> list = new ArrayList<String>();
list.add("张飞");
list.add("吕布");
list.add("貂蝉");
list.add("曹操");
list.add("关羽");
ArrayList<String> list_2 = new ArrayList<String>();
list_2.add("孙悟空");
list_2.add("唐玄藏");
list_2.add("猪八戒");
list_2.add("沙悟净");
list_2.add("白龙马");
hatolist.put("三国演义", list);
hatolist.put("西游记", list_2);
//得到健
Set<String> s = hatolist.keySet();
for (String ss : s) {
System.out.println(ss);
ArrayList<String> arr = hatolist.get(ss);
for(String sss:arr){
System.out.println("\t"+sss);
}
}
}
}
c:ArrayList嵌套HashMap
public class ArrayListtoHashMap {
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList<HashMap<Integer, String>> arr = new ArrayList<HashMap<Integer, String>>();
HashMap<Integer, String> ha = new HashMap<Integer, String>();
ha.put(100, "张三");
ha.put(101, "李四");
ha.put(102, "王二");
ha.put(103, "麻子");
ha.put(104, "小明");
ha.put(105, "二愣");
HashMap<Integer, String> ha1 = new HashMap<Integer, String>();
ha1.put(201, "狗蛋");
ha1.put(202, "铁蛋");
ha1.put(203, "耗子");
ha1.put(204, "华子");
ha1.put(205, "柳家");
arr.add(ha);
arr.add(ha1);
for (HashMap<Integer, String> h : arr) {
Set<Integer> set = h.keySet();
for(Integer i:set){
System.out.println(i+"---"+h.get(i));
}
System.out.println();
}
}
}
d:多层嵌套
public class HashMapDemo {
public static void main(String[] args) {
// 创建大集合
HashMap<String, HashMap<String, ArrayList<Student>>> czbkMap = new HashMap<String, HashMap<String, ArrayList<Student>>>();
// 北京校区数据
HashMap<String, ArrayList<Student>> bjCzbkMap = new HashMap<String, ArrayList<Student>>();
ArrayList<Student> array1 = new ArrayList<Student>();
Student s1 = new Student("林青霞", 27);
Student s2 = new Student("风清扬", 30);
array1.add(s1);
array1.add(s2);
ArrayList<Student> array2 = new ArrayList<Student>();
Student s3 = new Student("赵雅芝", 28);
Student s4 = new Student("武鑫", 29);
array2.add(s3);
array2.add(s4);
bjCzbkMap.put("基础班", array1);
bjCzbkMap.put("就业班", array2);
czbkMap.put("北京校区", bjCzbkMap);
// 晚上可以自己练习一下
// 上海校区数据自己做
// 广州校区数据自己做
// 西安校区数据
HashMap<String, ArrayList<Student>> xaCzbkMap = new HashMap<String, ArrayList<Student>>();
ArrayList<Student> array3 = new ArrayList<Student>();
Student s5 = new Student("范冰冰", 27);
Student s6 = new Student("刘意", 30);
array3.add(s5);
array3.add(s6);
ArrayList<Student> array4 = new ArrayList<Student>();
Student s7 = new Student("李冰冰", 28);
Student s8 = new Student("张志豪", 29);
array4.add(s7);
array4.add(s8);
xaCzbkMap.put("基础班", array3);
xaCzbkMap.put("就业班", array4);
czbkMap.put("西安校区", xaCzbkMap);
// 遍历集合
Set<String> czbkMapSet = czbkMap.keySet();
for (String czbkMapKey : czbkMapSet) {
System.out.println(czbkMapKey);
HashMap<String,ArrayList<Student>> czbkMapValue=czbkMap.get(czbkMapKey);
Set<String> czbkMapValueSet = czbkMapValue.keySet();
for (String czbkMapValueKey : czbkMapValueSet) {
System.out.println("\t"+czbkMapValueKey);
ArrayList<Student> czbkMapValueValue = czbkMapValue.get(czbkMapValueKey);
for (Student s : czbkMapValueValue) {
System.out.println("\t\t" + s.getName() + "---"
+ s.getAge());
}
}
}
}
}
* 1:Hashtable和HashMap的区别?
* Hashtable:线程安全，效率低。不允许null键和null值
* HashMap:线程不安全，效率高。允许null键和null值
* 2:List,Set,Map等接口是否都继承子Map接口?
* List，Set不是继承自Map接口，它们继承自Collection接口
* Map接口本身就是一个顶层接口
public class HashtableDemo {
public static void main(String[] args) {
// HashMap<String, String> hm = new HashMap<String, String>();
Hashtable<String, String> hm = new Hashtable<String, String>();
hm.put("it001", "hello");
// hm.put(null, "world"); //NullPointerException
// hm.put("java", null); // NullPointerException
System.out.println(hm);
}
}
2:Collections(理解)
(1)是针对集合进行操作的工具类
(2)面试题：Collection和Collections的区别
A:Collection 是单列集合的顶层接口，有两个子接口List和Set
B:Collections 是针对集合进行操作的工具类，可以对集合进行排序和查找等
(3)常见的几个小方法：
* 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):随机置换
- (4)案例
A:ArrayList集合存储自定义对象的排序
public class ListDemo {
public static void main(String[] args) {
ArrayList<Student> arr = new ArrayList<Student>();
Student s = new Student("张三", 15);
Student s2 = new Student("李四", 24);
Student s3 = new Student("王二", 23);
Student s4 = new Student("麻子", 25);
Student s5 = new Student("小明", 55);
Student s6 = new Student("二愣", 65);
arr.add(s);
arr.add(s6);
arr.add(s2);
arr.add(s3);
arr.add(s4);
arr.add(s5);
sort(arr,new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
// TODO Auto-generated method stub
int num=s1.getAge()-s2.getAge();
int num2=num==0?s1.getName().compareTo(s2.getName()):num;
return num2;
}
});
for(Student ss:arr){
System.out.println(ss);
}
}
}
B:模拟斗地主洗牌和发牌
C:模拟斗地主洗牌和发牌并对牌进行排序
/*
* 思路：
* A:创建一个HashMap集合
* B:创建一个ArrayList集合
* C:创建花色数组和点数数组
* D:从0开始往HashMap里面存储编号，并存储对应的牌
* 同时往ArrayList里面存储编号即可。
* E:洗牌(洗的是编号)
* F:发牌(发的也是编号，为了保证编号是排序的，就创建TreeSet集合接收)
* G:看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)
*/
public class PokerDemo {
public static void main(String[] args) {
// 创建一个HashMap集合
HashMap<Integer, String> hm = new HashMap<Integer, String>();
// 创建一个ArrayList集合
ArrayList<Integer> array = new ArrayList<Integer>();
// 创建花色数组和点数数组
// 定义一个花色数组
String[] colors = { "♠", "♥", "♣", "♦" };
// 定义一个点数数组
String[] numbers = { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q",
"K", "A", "2", };
// 从0开始往HashMap里面存储编号，并存储对应的牌,同时往ArrayList里面存储编号即可。
int index = 0;
for (String number : numbers) {
for (String color : colors) {
String poker = color.concat(number);
hm.put(index, poker);
array.add(index);
index++;
}
}
hm.put(index, "小王");
array.add(index);
index++;
hm.put(index, "大王");
array.add(index);
// 洗牌(洗的是编号)
Collections.shuffle(array);
// 发牌(发的也是编号，为了保证编号是排序的，就创建TreeSet集合接收)
TreeSet<Integer> fengQingYang = new TreeSet<Integer>();
TreeSet<Integer> linQingXia = new TreeSet<Integer>();
TreeSet<Integer> liuYi = new TreeSet<Integer>();
TreeSet<Integer> diPai = new TreeSet<Integer>();
for (int x = 0; x < array.size(); x++) {
if (x >= array.size() - 3) {
diPai.add(array.get(x));
} else if (x % 3 == 0) {
fengQingYang.add(array.get(x));
} else if (x % 3 == 1) {
linQingXia.add(array.get(x));
} else if (x % 3 == 2) {
liuYi.add(array.get(x));
}
}
// 看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)
lookPoker("风清扬", fengQingYang, hm);
lookPoker("林青霞", linQingXia, hm);
lookPoker("刘意", liuYi, hm);
lookPoker("底牌", diPai, hm);
}
// 写看牌的功能
public static void lookPoker(String name, TreeSet<Integer> ts,
HashMap<Integer, String> hm) {
System.out.print(name + "的牌是：");
for (Integer key : ts) {
String value = hm.get(key);
System.out.print(value + " ");
}
System.out.println();
}
}
转载 http://www.51csdn.cn/article/223.html
相关文章
- 暂无相关文章
用户点评