【黑马程序员】集合框架(下)——Java复习笔记

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

Map

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

(2)Map和Collection的区别?

A:Map 存储的是键值对形式的元素，键唯一，值可以重复。

B:Collection 存储的是单独出现的元素，子接口Set元素唯一，子接口List元素可重复。

注意：Map集合的数据结构只针对键有效，跟值无关

(3)Map接口功能概述

A:添加功能

put(key,val)添加并返回旧值。如果键不存在，则直接添加，返回null。如果键已存在，则把此值替代旧值，返回旧值

B:删除功能

clear()

remove(Obj key)根据键删除键值对 并返回值

C:判断功能

containsKey(Obj key)判断集合是否包含指定的键

containsValue(Obj val) 。。。。值

isEmpty()

D:获取功能

entrySet() 返回键值对对象的Set集合

get(Obj key)根据键获取值

keySet() 获取集合中所有键的Set集合

Collection values() 获取集合中所有值的Collection集合

E:长度功能

size() 键值对数量

(4)Map集合的遍历

方法1:键找值
a:获取所有键的集合 keySet()
b:遍历键的集合,得到每一个键 foreach keyset
c:根据键到集合中去找值 map.get(key)

方法2:键值对对象找键和值
a:获取所有的键值对对象的集合 Set<Map.Entry<K,V>> set = map.entrySet();
b:遍历键值对对象的集合，获取每一个键值对对象for(Map.Entry<K,V> me:set){String key = me.getKey;String val = me.getValue;}
c:根据键值对对象去获取键和值 for循环里sout(key,val)

(5)HashMap

是基于哈希表的Map接口实现，哈希表的作用是保证键的唯一性，依赖于equals和hashCode方法，如果键是自定义类的话需要重写这俩方法，否则不能保证唯一性

与Hashtable区别：

HashMap：用于替代Hashtable。不同步，效率高不安全，允许null键和值，

Hashtable（注意t是小写）：同步，效率低，不允许null键和值

(6)LinkedHashMap

是Map接口的哈希表和链接列表实现，具有可预知的迭代顺序（不是排序，是存储与取出顺序一致）

(7)TreeMap

是基于红黑树的Map接口的实现

集合总结

(1)Collection (单列集合)
| - - List (有序,可重复)
|| - -ArrayList
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
|| - -Vector
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
|| - -LinkedList
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。

| - -Set (无序,唯一)
|| - -HashSet
底层结构式哈希表,依赖两个方法hashCode()和equals() 自动生成即可
执行顺序:先判断hashCode()值是否相同
相同:继续执行equals(),看返回值,true则不添加.false则添加
不同:添加
||| - -LinkedHashSet
底层数据结构由链表和哈希表组成,由链表保证元素有序,由哈希表保证唯一性

|| - -TreeSet(真正的排序)
底层数据结构是红黑树
根据比较的返回值是否是0来决定唯一性
排序:自然排序和比较器排序
自然排序(元素具备比较性):
让元素所属的类实现Comparator接口
比较器排序(集合具备比较性)
让集合接收一个Comparator的实现类对象

(2)Map (双列集合)
Map集合的数据结构仅仅针对键有效,与值无关

| - -HashMap
底层结构式哈希表,线程不安全,效率高,依赖两个方法hashCode()和equals() 自动生成即可
执行顺序:先判断hashCode()值是否相同
相同:继续执行equals(),看返回值,true则不添加.false则添加
不同:添加

|| - -LinkedHashMap
底层数据结构由链表和哈希表组成,由链表保证元素有序,由哈希表保证唯一性

| - -Hashtable(线程安全,效率低)  其他同HashMap

| - -TreeMap
底层数据结构是红黑树
根据比较的返回值是否是0来决定唯一性
排序:自然排序和比较器排序
自然排序(元素具备比较性):
让元素所属的类实现Comparator接口
比较器排序(集合具备比较性)
让集合接收一个Comparator的实现类对象

集合常用方法及遍历方式

Collection:
add()
remove()
contains()
iterator()
size()

遍历:foreach或迭代器

|—List
get()
遍历:普通for
|—Set

Map:
put()
remove()
containsKey()  containsValue()
keySet()
get()
value()
entrySet()
size()
遍历:根据键找值;
根据键值对分别找键和值

Collections工具类

(1)是针对集合进行操作的工具类，都是静态方法

(2)面试题：Collection和Collections的区别
A:Collection 是单列集合的顶层接口，有两个子接口List和Set
B:Collections 是针对集合进行操作的工具类，可以对集合进行排序和查找等

(3)常见的几个小方法：
A:public static <T> void sort(List<T> list) 排序，默认自然排序，储存自定义对象的时候记得在元素类中实现Comparator接口或者在sort方法的构造方法参数中用匿名内部类实现比较器（两者都实现，则按照比较器排序）   比较器实现：Collections.sort(list,new Comparator<>(){…})

B:public static <T> int binarySearch(List<?> list,T key) 二分查找

C:public static <T> T max(Collection<?> coll) 最大值
D:public static void reverse(List<?> list) 反转
E:public static void shuffle(List<?> list) 随机置换

练习

1.模拟斗地主洗牌和发牌并对牌进行排序

牌堆用HashMap按牌从小到大存储,再把key值用ArrayList存储,洗牌洗的是key,发牌发的是key,每个人用TreeSet存牌即可排序,看牌只需按key去找对应的牌.代码如下

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;

/**
* Created by mo on 15/11/12.
* 模拟斗地主洗牌发牌看牌 + 排序
*/
public class DouDiZhu2 {
public static void main(String[] args) {

//用HashMap,按从小到大的顺序存储牌,洗牌 分牌 排序的时候只需对键操作,看牌的时候根据键显示值
HashMap<Integer,String> pokes = new HashMap<>();

//定义花色 数字 都按从小到大添加
String[] numbers={"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
String[] colors = {"♦","♣","❤","♠"};

//拼接花色 数字 并添加到集合
//双重for 从numbers里按顺序取出 分别用四个花色和它拼 拼完添加到牌堆
//再用一个ArrayList接收键
ArrayList<Integer>  key = new ArrayList<>();
int index = 0;
for (String num : numbers){
for (String color:colors){
String b = color.concat(num);
pokes.put(index,b);
key.add(index);
index++;
}
}

//按顺序加入大小王
pokes.put(52,"小王");
pokes.put(53,"大王");
key.add(52);
key.add(53);

//洗牌
// shuffle接收List集合,所以用ArrayList存储key,然后对ArrayList随机置换
Collections.shuffle(key);

//发牌
//用TreeSet存储每个人的牌,可以自动实现按key的自然顺序排序
TreeSet<Integer> A = new TreeSet<>();
TreeSet<Integer> B = new TreeSet<>();
TreeSet<Integer> C = new TreeSet<>();
TreeSet<Integer> diPai = new TreeSet<>();

for (int x=0;x<54;x++){
if (x >= 51){
diPai.add(key.get(x));
}else if (x % 3 == 0){
A.add(key.get(x));
}else if (x % 3 == 1){
B.add(key.get(x));
}else if (x % 3 == 2){
C.add(key.get(x));
}
}

//看牌
//按key获取val值显示出来
lookPoke("A",A,pokes);
lookPoke("B",B,pokes);
lookPoke("C",C,pokes);
lookPoke("底牌",diPai,pokes);
}

//看牌
public static void lookPoke(String name,TreeSet<Integer> ts,HashMap<Integer,String> hm){
System.out.println(name+"的牌为:");
for (Integer x : ts){
System.out.print(hm.get(x)+"\t");
}
System.out.println();
}
}

2.获取10个1-20之间的随机数,不能重复

3.键盘录入数据,用0结束,返回录入数据的最大值

import java.util.*;

/**
* Created by mo on 15/11/10.
* 1.获取10个1-20之间的随机数,不能重复
* 2.键盘录入数据,用0结束,返回录入数据的最大值
*/
public class getRandomNoDupNum {
public static void main(String[] args) {
getNum();
getMax();
}

/*
需求1:获取10个1-20之间的随机数,不能重复
*/
public static void getNum(){

ArrayList newList = new ArrayList();

while (newList.size() <10){

int s = (int) (Math.random()*20+1);
String ss = String.valueOf(s);

if (!newList.contains(ss)){
newList.add(ss);
}

}

for (Object x:newList){
System.out.println(x);
}
}

//需求1的方法2 HashSet
public static void getNum2(){
HashSet<Integer> hs = new HashSet<>();
Random r = new Random();
while(hs.size()<10){
hs.add(r.nextInt(20)+1);
}
}

/*
需求2:键盘录入数据,用0结束,返回录入数据的最大值
*/
public static void getMax(){
System.out.println("请输入数据.输入0退出");

Scanner sc = new Scanner(System.in);

ArrayList<Integer> list = new ArrayList<>();

while(true){
int num = sc.nextInt();
if (num!=0){
list.add(num);
}else {
break;
}
}

//toArray(T[] a)方法把集合转为Integer类型数组, Integer[] arr1 = list.toArray(arr);  arr与arr1地址值一样 所以简化为如下
Integer[] arr  = new Integer[list.size()];
list.toArray(arr);

Arrays.sort(arr);
System.out.println(arr[arr.length-1]);
}

}

4.”abcdcbdbzabcbadbddeaabcbdbcabaabc”要求获取字符串中每个字母出现的次数

import java.util.Set;
import java.util.TreeMap;

/**
* Created by mo on 15/11/11.
* "abcdcbdbzabcbadbddeaabcbdbcabaabc"要求获取字符串中每个字母出现的次数
* 要求结果为a(5)b(4)...
*
*/
public class MapDemo {
public static void main(String[] args) {
String key = "aaaaabbbbzzzzzzssss";
char[] arr = key.toCharArray();

TreeMap<Character,Integer> tm = new TreeMap<Character, Integer>();

//        for (char x:arr){
//            if (!tm.containsKey(x)){
//                tm.put(x,1);
//            }else {
//                tm.put(x,(tm.get(x))+1);
//            }
//        }

for(char x:arr){
Integer i = tm.get(x);
if (i == null){
tm.put(x,1);
}else {
i++;
tm.put(x,i);
}
}

Set<Character> st = tm.keySet();

//        for (Character x:st){
//            System.out.print(x+"("+tm.get(x)+")");
//        }

//用StringBuilder,效率更高
StringBuilder sb = new StringBuilder();
for (Character x:st){
sb.append(x).append('(').append(tm.get(x)).append(')');
}
System.out.println(sb);
}
}

5.用键盘录入5个学生姓名,语数外成绩,按总分从高到低输出

import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

/**
* Created by mo on 15/11/11.
*
* 用键盘录入5个学生姓名,语数外成绩,按总分从高到低输出
*
* 分析 写StudentScore类
*      Scanner录入
*      TreeSet储存数据 匿名内部类实现Comparator
*      从高到低遍历  原理:compare方法从s1-s2改为s2-s1
*
*/
public class StudentInformation {
public static void main(String[] args) {

TreeSet<StudentScore> ts = new TreeSet<>(new Comparator<StudentScore>() {
@Override
public int compare(StudentScore s1, StudentScore s2) {
//从高到低则s2-s1
//主要条件
int num = s2.getSumScore() - s1.getSumScore() ;

//次要条件
int num2 = num == 0 ? s1.getName().compareTo(s2.getName()):num;
int num3 = num2 ==0?s1.getChineseScore()-s2.getChineseScore():num2;
int num4 = num3 ==0?s1.getEnglishScore()-s2.getEnglishScore():num3;
int num5 = num4 ==0?s1.getMathScore()-s2.getMathScore():num4;
return num5;
}
});

for (int x= 1;x<=5;x++){
Scanner sc = new Scanner(System.in);
System.out.println("请输入第"+x+"位学生姓名");
String name = sc.nextLine();

System.out.println("请输入第"+x+"位学生数学成绩");
int ms = sc.nextInt();

System.out.println("请输入第"+x+"位学生语文成绩");
int cs = sc.nextInt();

System.out.println("请输入第"+x+"位学生英语成绩");
int es = sc.nextInt();

StudentScore stu = new StudentScore(es,name,cs,ms);
ts.add(stu);
}
System.out.println("录入完毕");
System.out.println("学生成绩如下:");
System.out.printf("%-10s %-10s %-10s %-10s %-10s%n","姓名","语文成绩","数学成绩","英语成绩","总分");

for (StudentScore x:ts){
System.out.printf("%-10s %-10s %-10s %-10s %-10s%n",x.getName(),x.getChineseScore(),x.getMathScore(),x.getEnglishScore(),x.getSumScore());
}
}
}

class StudentScore{
private String name;
private int ChineseScore;
private int MathScore;
private int EnglishScore;

public String getName() {
return name;
}

public int getChineseScore() {
return ChineseScore;
}

public int getMathScore() {
return MathScore;
}

public int getEnglishScore() {
return EnglishScore;
}

public int getSumScore() {
return this.ChineseScore+this.MathScore+this.EnglishScore;
}

public StudentScore(int englishScore, String name, int chineseScore, int mathScore) {
EnglishScore = englishScore;
this.name = name;
ChineseScore = chineseScore;
MathScore = mathScore;

}

public StudentScore(){}
}

6.三层嵌套

import java.util.*;

/**
* Created by mo on 15/11/11.
* 三层嵌套 HashMap HashMap ArrayList
*
* 需求:
*    黑马
*        bj  北京
*            javase    基础班
*                              name    age
*                              name    age
*            javaee    就业班
*        xa  西安
*        sz  深圳
*        sh  上海
*/
public class TwoHashMapOneArrayList {
public static void main(String[] args) {
//第一层集合HashMap 黑马
//键 "XX校区"   值 HashMap 校区代号bj xa等
HashMap<String,HashMap<String,ArrayList<Student>>> itheima = new HashMap<>();

//第二层集合HashMap 各校区
//键 XX班    值ArrayList<Student> XX班的学生
HashMap<String,ArrayList<Student>> bj = new HashMap<>();
HashMap<String,ArrayList<Student>> xa = new HashMap<>();
HashMap<String,ArrayList<Student>> sz = new HashMap<>();
HashMap<String,ArrayList<Student>> sh = new HashMap<>();

//第三层集合ArrayList  XX班的学生
//储存的是学生对象
ArrayList<Student> BJSEstudents = new ArrayList<>();
ArrayList<Student> BJEEstudents = new ArrayList<>();
ArrayList<Student> XASEstudents = new ArrayList<>();
ArrayList<Student> XAEEstudents = new ArrayList<>();
ArrayList<Student> SZSEstudents = new ArrayList<>();
ArrayList<Student> SZEEstudents = new ArrayList<>();
ArrayList<Student> SHSEstudents = new ArrayList<>();
ArrayList<Student> SHEEstudents = new ArrayList<>();

Student stu1 = new Student("sb1",10,10001);
Student stu2 = new Student("sb2",19,10002);
Student stu3 = new Student("sb3",22,10003);
Student stu4 = new Student("sb4",34,10004);
Student stu5 = new Student("sb5",12,10005);
Student stu6 = new Student("sb6",24,10006);
Student stu7 = new Student("sb7",17,10007);
Student stu8 = new Student("sb8",18,10008);

BJSEstudents.add(stu1);
BJEEstudents.add(stu2);
XASEstudents.add(stu3);
XAEEstudents.add(stu4);
SZSEstudents.add(stu5);
SZEEstudents.add(stu6);
SHSEstudents.add(stu7);
SHEEstudents.add(stu8);

bj.put("基础班",BJSEstudents);
bj.put("就业班",BJEEstudents);
xa.put("基础班",XASEstudents);
xa.put("就业班",XAEEstudents);
sz.put("基础班",SZSEstudents);
sz.put("就业班",SZEEstudents);
sh.put("基础班",SHSEstudents);
sh.put("就业班",SHEEstudents);

itheima.put("北京校区",bj);
itheima.put("西安校区",xa);
itheima.put("深圳校区",sz);
itheima.put("上海校区",sh);

//遍历储存好的数据 显示在控制台
Set<String> xqkey = itheima.keySet() ;
System.out.println("黑马");

for (String xq:xqkey){
System.out.println("\t"+xq);

HashMap<String,ArrayList<Student>> banji = itheima.get(xq);
Set<String> banji1 = banji.keySet();

for (String bjkey:banji1){
System.out.println("\t\t"+bjkey);

ArrayList<Student> stu = banji.get(bjkey);

for (Student st:stu){
System.out.println("\t\t\t"+st);
}
}
}

}
}