JAVA集合进阶（Set、Map集合）

一、Set系列集合

1.1 认识Set集合的特点

Set集合是属于Collection体系下的另一个分支，它的特点如下图所示

下面我们用代码简单演示一下，每一种Set集合的特点。

//Set<Integer> set = new HashSet<>();   //无序、无索引、不重复
//Set<Integer> set = new LinkedHashSet<>(); //有序、无索引、不重复
Set<Integer> set = new TreeSet<>(); //可排序(升序)、无索引、不重复
set.add(666);
set.add(555);
set.add(555);
set.add(888);
set.add(888);
set.add(777);
set.add(777);
System.out.println(set); //[555, 666, 777, 888]

1.2 HashSet集合底层原理

HashSet集合底层是基于哈希表实现的，哈希表根据JDK版本的不同，也是有点区别的

  • JDK8以前：哈希表 = 数组+链表

  • JDK8以后：哈希表 = 数组+链表+红黑树

我们发现往HashSet集合中存储元素时，底层调用了元素的两个方法：一个是hashCode方法获取元素的hashCode值（哈希值）；另一个是调用了元素的equals方法，用来比较新添加的元素和集合中已有的元素是否相同。

  • 只有新添加元素的hashCode值和集合中以后元素的hashCode值相同、新添加的元素调用equals方法和集合中已有元素比较结果为true, 才认为元素重复。

  • 如果hashCode值相同，equals比较不同，则以链表的形式连接在数组的同一个索引为位置（如上图所示）

在JDK8开始后，为了提高性能，当链表的长度超过8时，就会把链表转换为红黑树，如下图所示：

1.3 HashSet去重原理

HashSet存储元素的原理，依赖于两个方法：一个是hashCode方法用来确定在底层数组中存储的位置，另一个是用equals方法判断新添加的元素是否和集合中已有的元素相同。

要想保证在HashSet集合中没有重复元素，我们需要重写元素类的hashCode和equals方法。比如以下面的Student类为例，假设把Student类的对象作为HashSet集合的元素，想要让学生的姓名和年龄相同，就认为元素重复。

public class Student{private String name; //姓名private int age; //年龄private double height; //身高//无参数构造方法public Student(){}//全参数构造方法public Student(String name, int age, double height){this.name=name;this.age=age;this.height=height;}//...get、set、toString()方法自己补上..//按快捷键生成hashCode和equals方法//alt+insert 选择 hashCode and equals@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;
​Student student = (Student) o;
​if (age != student.age) return false;if (Double.compare(student.height, height) != 0) return false;return name != null ? name.equals(student.name) : student.name == null;}
​@Overridepublic int hashCode() {int result;long temp;result = name != null ? name.hashCode() : 0;result = 31 * result + age;temp = Double.doubleToLongBits(height);result = 31 * result + (int) (temp ^ (temp >>> 32));return result;}
}

接着，写一个测试类，往HashSet集合中存储Student对象。

public class Test{public static void main(String[] args){Set<Student> students = new HashSet<>();Student s1 = new Student("至尊宝",20, 169.6);Student s2 = new Student("蜘蛛精",23, 169.6);Student s3 = new Student("蜘蛛精",23, 169.6);Student s4 = new Student("牛魔王",48, 169.6);students.add(s1);students.add(s2);students.add(s3);students.add(s4);for(Student s : students){System.out.println(s);}}
}

打印结果如下，我们发现存了两个蜘蛛精，当时实际打印出来只有一个，而且是无序的。

Student{name='牛魔王', age=48, height=169.6}
Student{name='至尊宝', age=20, height=169.6}
Student{name='蜘蛛精', age=23, height=169.6}

1.4 LinkedHashSet底层原理

LinkedHashSet它底层采用的是也是哈希表结构，只不过额外新增了一个双向链表来维护元素的存取顺序。如下下图所示：

每次添加元素，就和上一个元素用双向链表连接一下。第一个添加的元素是双向链表的头节点，最后一个添加的元素是双向链表的尾节点。

把上个案例中的集合改成LinkedList集合，我们观察效果怎样

public class Test{public static void main(String[] args){Set<Student> students = new LinkedHashSet<>();Student s1 = new Student("至尊宝",20, 169.6);Student s2 = new Student("蜘蛛精",23, 169.6);Student s3 = new Student("蜘蛛精",23, 169.6);Student s4 = new Student("牛魔王",48, 169.6);students.add(s1);students.add(s2);students.add(s3);students.add(s4);for(Student s : students){System.out.println(s);}}
}
打印结果如下Student{name='至尊宝', age=20, height=169.6}
Student{name='蜘蛛精', age=23, height=169.6}
Student{name='牛魔王', age=48, height=169.6}

1.5 TreeSet集合

TreeSet集合的特点是可以对元素进行排序，但是必须指定元素的排序规则。

如果往集合中存储String类型的元素，或者Integer类型的元素，它们本身就具备排序规则，所以直接就可以排序。

Set<Integer> set1= new TreeSet<>();
set1.add(8);
set1.add(6);
set1.add(4);
set1.add(3);
set1.add(7);
set1.add(1);
set1.add(5);
set1.add(2);
System.out.println(set1); //[1,2,3,4,5,6,7,8]
​
Set<Integer> set2= new TreeSet<>();
set2.add("a");
set2.add("c");
set2.add("e");
set2.add("b");
set2.add("d");
set2.add("f");
set2.add("g");
System.out.println(set1); //[a,b,c,d,e,f,g]

如果往TreeSet集合中存储自定义类型的元素，比如说Student类型，则需要我们自己指定排序规则，否则会出现异常。

//创建TreeSet集合，元素为Student类型
Set<Student> students = new TreeSet<>();
​
//创建4个Student对象
Student s1 = new Student("至尊宝",20, 169.6);
Student s2 = new Student("紫霞",23, 169.8);
Student s3 = new Student("蜘蛛精",23, 169.6);
Student s4 = new Student("牛魔王",48, 169.6);
​
//添加Studnet对象到集合
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
System.out.println(students);

此时运行代码，会直接报错。原因是TreeSet不知道按照什么条件对Student对象来排序。

我们想要告诉TreeSet集合按照指定的规则排序，有两种办法：

第一种：让元素的类实现Comparable接口，重写compareTo方法

第二种：在创建TreeSet集合时，通过构造方法传递Compartor比较器对象

  • 排序方式1：我们先来演示第一种排序方式

//第一步：先让Student类，实现Comparable接口
//注意：Student类的对象是作为TreeSet集合的元素的
public class Student implements Comparable<Student>{private String name;private int age;private double height;//无参数构造方法public Student(){}//全参数构造方法public Student(String name, int age, double height){this.name=name;this.age=age;this.height=height;}//...get、set、toString()方法自己补上..//第二步：重写compareTo方法//按照年龄进行比较，只需要在方法中让this.age和o.age相减就可以。/*原理：在往TreeSet集合中添加元素时，add方法底层会调用compareTo方法，根据该方法的结果是正数、负数、还是零，决定元素放在后面、前面还是不存。*/@Overridepublic int compareTo(Student o) {//this：表示将要添加进去的Student对象//o: 表示集合中已有的Student对象return this.age-o.age;}
}

此时，再运行测试类，结果如下

Student{name='至尊宝', age=20, height=169.6}
Student{name='紫霞', age=20, height=169.8}
Student{name='蜘蛛精', age=23, height=169.6}
Student{name='牛魔王', age=48, height=169.6}

  • 排序方式2：接下来演示第二种排序方式

//创建TreeSet集合时，传递比较器对象排序
/*
原理：当调用add方法时，底层会先用比较器，根据Comparator的compare方是正数、负数、还是零，决定谁在后，谁在前，谁不存。
*/
//下面代码中是按照学生的年龄升序排序
Set<Student> students = new TreeSet<>(new Comparator<Student>{@Overridepublic int compare(Student o1, Student o2){//需求：按照学生的身高排序return Double.compare(o1,o2); }
});
​
//创建4个Student对象
Student s1 = new Student("至尊宝",20, 169.6);
Student s2 = new Student("紫霞",23, 169.8);
Student s3 = new Student("蜘蛛精",23, 169.6);
Student s4 = new Student("牛魔王",48, 169.6);
​
//添加Studnet对象到集合
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
System.out.println(students);

1.6 总结Collection集合

1.7 并发修改异常

使用迭代器遍历集合时，可能存在并发修改异常。

我们先把这个异常用代码演示出来，再解释一下为什么会有这个异常产生

List<String> list = new ArrayList<>();
list.add("王麻子");
list.add("小李子");
list.add("李爱花");
list.add("张全蛋");
list.add("晓李");
list.add("李玉刚");
System.out.println(list); // [王麻子, 小李子, 李爱花, 张全蛋, 晓李, 李玉刚]
​
//需求：找出集合中带"李"字的姓名，并从集合中删除
Iterator<String> it = list.iterator();
while(it.hasNext()){String name = it.next();if(name.contains("李")){list.remove(name);}
}
System.out.println(list);

运行上面的代码，会出现下面的异常。这就是并发修改异常

为什么会出现这个异常呢？那是因为迭代器遍历机制，规定迭代器遍历集合的同时，不允许集合自己去增删元素，否则就会出现这个异常。

怎么解决这个问题呢？不使用集合的删除方法，而是使用迭代器的删除方法，代码如下：

List<String> list = new ArrayList<>();
list.add("王麻子");
list.add("小李子");
list.add("李爱花");
list.add("张全蛋");
list.add("晓李");
list.add("李玉刚");
System.out.println(list); // [王麻子, 小李子, 李爱花, 张全蛋, 晓李, 李玉刚]
​
//需求：找出集合中带"李"字的姓名，并从集合中删除
Iterator<String> it = list.iterator();
while(it.hasNext()){String name = it.next();if(name.contains("李")){//list.remove(name);it.remove(); //当前迭代器指向谁，就删除谁}
}
System.out.println(list);

二、Collection的其他操作

2.1 可变参数

关于可变参数我们首先要知道它是什么，然后要知道它的本质。搞清楚这两个问题，可变参数就算你学明白了。

  • 可变参数是一种特殊的形式参数，定义在方法、构造器的形参列表处，它可以让方法接收多个同类型的实际参数。

  • 可变参数在方法内部，本质上是一个数组

2.2 Collections工具类

有了可变参数的基础，我们再学习Collections这个工具类就好理解了，因为这个工具类的方法中会用到可变参数。

注意Collections并不是集合，它比Collection多了一个s，一般后缀为s的类很多都是工具类。这里的Collections是用来操作Collection的工具类。它提供了一些好用的静态方法，如下

我们把这些方法用代码来演示一下：

public class CollectionsTest{public static void main(String[] args){//1.public static <T> boolean addAll(Collection<? super T> c, T...e)List<String> names = new ArrayList<>();Collections.addAll(names, "张三","王五","李四", "张麻子");System.out.println(names);//2.public static void shuffle(List<?> list)：对集合打乱顺序Collections.shuffle(names);System.out.println(names);//3.public static <T> void short(List<T list): 对List集合排序List<Integer> list = new ArrayList<>();list.add(3);list.add(5);list.add(2);Collections.sort(list);System.out.println(list);}
}

上面我们往集合中存储的元素要么是Stirng类型，要么是Integer类型，他们本来就有一种自然顺序所以可以直接排序。但是如果我们往List集合中存储Student对象，这个时候想要对List集合进行排序自定义比较规则的。指定排序规则有两种方式，如下：

排序方式1：让元素实现Comparable接口，重写compareTo方法

比如现在想要往集合中存储Studdent对象，首先需要准备一个Student类，实现Comparable接口。

public class Student implements Comparable<Student>{private String name;private int age;private double height;//排序时：底层会自动调用此方法，this和o表示需要比较的两个对象@Overridepublic int compareTo(Student o){//需求：按照年龄升序排序//如果返回正数：说明左边对象的年龄>右边对象的年龄//如果返回负数：说明左边对象的年龄<右边对象的年龄，//如果返回0：说明左边对象的年龄和右边对象的年龄相同return this.age - o.age;}//...getter、setter、constructor..
}

然后再使用Collections.sort(list集合)对List集合排序，如下：

//3.public static <T> void short(List<T list): 对List集合排序
List<Student> students = new ArrayList<>();
students.add(new Student("蜘蛛精",23,169.7));
students.add(new Student("紫霞",22,169.8));
students.add(new Student("紫霞",22,169.8));
students.add(new Student("至尊宝",26,169.5));
​
/*
原理：sort方法底层会遍历students集合中的每一个元素，采用排序算法，将任意两个元素两两比较；每次比较时，会用一个Student对象调用compareTo方法和另一个Student对象进行比较；根据compareTo方法返回的结果是正数、负数，零来决定谁大，谁小，谁相等，重新排序元素的位置注意：这些都是sort方法底层自动完成的，想要完全理解，必须要懂排序算法才行；
*/
Collections.sort(students); 
System.out.println(students);

排序方式2：使用调用sort方法是，传递比较器

/*
原理：sort方法底层会遍历students集合中的每一个元素，采用排序算法，将任意两个元素两两比较；每次比较，会将比较的两个元素传递给Comparator比较器对象的compare方法的两个参数o1和o2,根据compare方法的返回结果是正数，负数，或者0来决定谁大，谁小，谁相等，重新排序元素的位置注意：这些都是sort方法底层自动完成的，不需要我们完全理解，想要理解它必须要懂排序算法才行.
*/
Collections.sort(students, new Comparator<Student>(){@Overridepublic int compare(Student o1, Student o2){return o1.getAge()-o2.getAge();}
}); 
System.out.println(students);

2.3 斗地主案例

我们先分析一下业务需求：

  • 总共有54张牌，每一张牌有花色和点数两个属性、为了排序还可以再加一个序号

  • 点数可以是：“3”,"4","5","6","7","8","9","10","J","Q","K","A","2"

  • 花色可以是：“♣”,"♠","♥","♦"

  • 斗地主时：三个玩家没人手里17张牌，剩余3张牌作为底牌

第一步：为了表示每一张牌有哪些属性，首先应该新建一个扑克牌的类
第二步：启动游戏时，就应该提前准备好54张牌
第三步：接着再完全洗牌、发牌、捋牌、看牌的业务逻辑

先来完成第一步，定义一个扑克类Card

public class Card {private String number;private String color;// 每张牌是存在大小的。private int size; // 0 1 2 ....
​public Card() {}
​public Card(String number, String color, int size) {this.number = number;this.color = color;this.size = size;}
​public String getNumber() {return number;}
​public void setNumber(String number) {this.number = number;}
​public String getColor() {return color;}
​public void setColor(String color) {this.color = color;}
​public int getSize() {return size;}
​public void setSize(int size) {this.size = size;}
​@Overridepublic String toString() {return color + number ;}
}

再完成第二步，定义一个房间类，初始化房间时准备好54张牌

public class Room {// 必须有一副牌。private List<Card> allCards = new ArrayList<>();
​public Room(){// 1、做出54张牌，存入到集合allCards// a、点数：个数确定了，类型确定。String[] numbers = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};// b、花色：个数确定了，类型确定。String[] colors = {"♠", "♥", "♣", "♦"};int size = 0; // 表示每张牌的大小// c、遍历点数，再遍历花色，组织牌for (String number : numbers) {// number = "3"size++; // 1 2 ....for (String color : colors) {// 得到一张牌Card c = new Card(number, color, size);allCards.add(c); // 存入了牌}}// 单独存入小大王的。Card c1 = new Card("",  "🃏" , ++size);Card c2 = new Card("", "👲" , ++size);Collections.addAll(allCards, c1, c2);System.out.println("新牌：" + allCards);}
}

最后完成第三步，定义一个启动游戏的方法，完成洗牌、发牌、捋牌、看牌的业务逻辑

/**
* 游戏启动
*/
public void start() {// 1、洗牌： allCardsCollections.shuffle(allCards);System.out.println("洗牌后：" + allCards);
​// 2、发牌，首先肯定要定义 三个玩家。 List(ArrayList)  Set(TreeSet)List<Card> linHuChong = new ArrayList<>();List<Card> jiuMoZhi = new ArrayList<>();List<Card> renYingYing = new ArrayList<>();// 正式发牌给这三个玩家，依次发出51张牌，剩余3张做为底牌。// allCards = [♥3, ♣10, ♣4, ♥K, ♦Q, ♣2, 🃏, ♣8, ....//             0     1   2   3   4   5   6 ...   % 3for (int i = 0; i < allCards.size() - 3; i++) {Card c = allCards.get(i);// 判断牌发给谁if(i % 3 == 0){// 请啊冲接牌linHuChong.add(c);}else if(i % 3 == 1){// 请啊鸠来接牌jiuMoZhi.add(c);}else if(i % 3 == 2){// 请盈盈接牌renYingYing.add(c);}}
​// 3、对3个玩家的牌进行排序sortCards(linHuChong);sortCards(jiuMoZhi);sortCards(renYingYing);// 4、看牌System.out.println("啊冲：" + linHuChong);System.out.println("啊鸠：" + jiuMoZhi);System.out.println("盈盈：" + renYingYing);List<Card> lastThreeCards = allCards.subList(allCards.size() - 3, allCards.size()); // 51 52 53System.out.println("底牌：" + lastThreeCards);jiuMoZhi.addAll(lastThreeCards);sortCards(jiuMoZhi);System.out.println("啊鸠抢到地主后：" + jiuMoZhi);
}
​
/*** 集中进行排序* @param cards*/
private void sortCards(List<Card> cards) {Collections.sort(cards, new Comparator<Card>() {@Overridepublic int compare(Card o1, Card o2) {// return o1.getSize() - o2.getSize(); // 升序排序return o2.getSize() - o1.getSize(); // 降序排序}});
}

不要忘记了写测试类了，

public class GameDemo {public static void main(String[] args) {//  1、牌类。//  2、房间Room m = new Room();//  3、启动游戏m.start();}
}

三、Map集合

3.1 Map概述体系

所谓双列集合，就是说集合中的元素是一对一对的。Map集合中的每一个元素是以key=value的形式存在的，一个key=value就称之为一个键值对，而且在Java中有一个类叫Entry类，Entry的对象用来表示键值对对象。

所有的Map集合有如下的特点：键不能重复，值可以重复，每一个键只能找到自己对应的值。

下面我们先写一个Map集合，保存几个键值对，体验一下Map集合的特点

public class MapTest1 {public static void main(String[] args) {// Map<String, Integer> map = new HashMap<>(); // 一行经典代码。 按照键 无序，不重复，无索引。Map<String, Integer> map = new LinkedHashMap<>(); // 有序，不重复，无索引。map.put("手表", 100);map.put("手表", 220); // 后面重复的数据会覆盖前面的数据（键）map.put("手机", 2);map.put("Java", 2);map.put(null, null);System.out.println(map);
​Map<Integer, String> map1 = new TreeMap<>(); // 可排序，不重复，无索引map1.put(23, "Java");map1.put(23, "MySQL");map1.put(19, "李四");map1.put(20, "王五");System.out.println(map1);}
}

Map集合也有很多种，在Java中使用不同的类来表示的，每一种Map集合其键的特点是有些差异的，值是键的一个附属值，所以我们只关注键的特点就可以了。

3.2 Map集合的常用方法

由于Map是所有双列集合的父接口，所以我们只需要学习Map接口中每一个方法是什么含义，那么所有的Map集合方法你就都会用了。

public class MapTest2 {public static void main(String[] args) {// 1.添加元素: 无序，不重复，无索引。Map<String, Integer> map = new HashMap<>();map.put("手表", 100);map.put("手表", 220);map.put("手机", 2);map.put("Java", 2);map.put(null, null);System.out.println(map);// map = {null=null, 手表=220, Java=2, 手机=2}
​// 2.public int size():获取集合的大小System.out.println(map.size());
​// 3、public void clear():清空集合//map.clear();//System.out.println(map);
​// 4.public boolean isEmpty(): 判断集合是否为空，为空返回true ,反之！System.out.println(map.isEmpty());
​// 5.public V get(Object key)：根据键获取对应值int v1 = map.get("手表");System.out.println(v1);System.out.println(map.get("手机")); // 2System.out.println(map.get("张三")); // null
​// 6. public V remove(Object key)：根据键删除整个元素(删除键会返回键的值)System.out.println(map.remove("手表"));System.out.println(map);
​// 7.public  boolean containsKey(Object key): 判断是否包含某个键 ，包含返回true ,反之System.out.println(map.containsKey("手表")); // falseSystem.out.println(map.containsKey("手机")); // trueSystem.out.println(map.containsKey("java")); // falseSystem.out.println(map.containsKey("Java")); // true
​// 8.public boolean containsValue(Object value): 判断是否包含某个值。System.out.println(map.containsValue(2)); // trueSystem.out.println(map.containsValue("2")); // false
​// 9.public Set<K> keySet(): 获取Map集合的全部键。Set<String> keys = map.keySet();System.out.println(keys);
​// 10.public Collection<V> values(); 获取Map集合的全部值。Collection<Integer> values = map.values();System.out.println(values);
​// 11.把其他Map集合的数据倒入到自己集合中来。(拓展)Map<String, Integer> map1 = new HashMap<>();map1.put("java1",  10);map1.put("java2",  20);Map<String, Integer> map2 = new HashMap<>();map2.put("java3",  10);map2.put("java2",  222);map1.putAll(map2); // putAll：把map2集合中的元素全部倒入一份到map1集合中去。System.out.println(map1);System.out.println(map2);}
}

3.3 Map集合遍历方式1

Map集合一共有三种遍历方式，我们先来学习第一种，他需要用到下面的两个方法

/***  目标：掌握Map集合的遍历方式1：键找值*/
public class MapTest1 {public static void main(String[] args) {// 准备一个Map集合。Map<String, Double> map = new HashMap<>();map.put("蜘蛛精", 162.5);map.put("蜘蛛精", 169.8);map.put("紫霞", 165.8);map.put("至尊宝", 169.5);map.put("牛魔王", 183.6);System.out.println(map);// map = {蜘蛛精=169.8, 牛魔王=183.6, 至尊宝=169.5, 紫霞=165.8}
​// 1、获取Map集合的全部键Set<String> keys = map.keySet();// System.out.println(keys);// [蜘蛛精, 牛魔王, 至尊宝, 紫霞]//         key// 2、遍历全部的键，根据键获取其对应的值for (String key : keys) {// 根据键获取对应的值double value = map.get(key);System.out.println(key + "=====>" + value);}}
}

3.4 Map集合遍历方式2

这里Map集合的第二种方式，是直接获取每一个Entry对象，把Entry存储扫Set集合中去，再通过Entry对象获取键和值。

/*** 目标：掌握Map集合的第二种遍历方式：键值对。*/
public class MapTest2 {public static void main(String[] args) {Map<String, Double> map = new HashMap<>();map.put("蜘蛛精", 169.8);map.put("紫霞", 165.8);map.put("至尊宝", 169.5);map.put("牛魔王", 183.6);System.out.println(map);// map = {蜘蛛精=169.8, 牛魔王=183.6, 至尊宝=169.5, 紫霞=165.8}// entries = [(蜘蛛精=169.8), (牛魔王=183.6), (至尊宝=169.5), (紫霞=165.8)]// entry = (蜘蛛精=169.8)// entry = (牛魔王=183.6)// ...// 1、调用Map集合提供entrySet方法，把Map集合转换成键值对类型的Set集合Set<Map.Entry<String, Double>> entries = map.entrySet();for (Map.Entry<String, Double> entry : entries) {String key = entry.getKey();double value = entry.getValue();System.out.println(key + "---->" + value);}}
}

3.5 Map集合遍历方式3

Map集合的第三种遍历方式，需要用到下面的一个方法forEach，而这个方法是JDK8版本以后才有的。调用起来非常简单，最好是结合的lambda表达式一起使用。

/*** 目标：掌握Map集合的第二种遍历方式：键值对。*/
public class MapTest3 {public static void main(String[] args) {Map<String, Double> map = new HashMap<>();map.put("蜘蛛精", 169.8);map.put("紫霞", 165.8);map.put("至尊宝", 169.5);map.put("牛魔王", 183.6);System.out.println(map);// map = {蜘蛛精=169.8, 牛魔王=183.6, 至尊宝=169.5, 紫霞=165.8}
​
​//遍历map集合，传递匿名内部类map.forEach(new BiConsumer<String, Double>() {@Overridepublic void accept(String k, Double v) {System.out.println(k + "---->" + v);}});//遍历map集合，传递Lambda表达式map.forEach(( k,  v) -> {System.out.println(k + "---->" + v);});}
}

3.6 Map集合案例

学习完Map集合的基本用法之后，接下来我们做一个综合案例，将Map集合运用一下。

先分析需求，再考虑怎么用代码实现

1.首先可以将80个学生选择的景点放到一个集合中去（也就是说，集合中的元素是80个任意的ABCD元素）
2.准备一个Map集合用来存储景点，以及景点被选择的次数
3.遍历80个学生选择景点的集合，得到每一个景点，判断Map集合中是否包含该景点如果不包含，则存储"景点=1"如果包含，则存获取该景点原先的值，再存储"景点=原来的值+1"; 此时新值会覆盖旧值
/*** 目标：完成Map集合的案例：统计投票人数。*/
public class MapDemo4 {public static void main(String[] args) {// 1、把80个学生选择的景点数据拿到程序中来。List<String> data = new ArrayList<>();String[] selects = {"A", "B", "C", "D"};Random r = new Random();for (int i = 1; i <= 80; i++) {// 每次模拟一个学生选择一个景点，存入到集合中去。int index = r.nextInt(4); // 0 1 2 3data.add(selects[index]);}System.out.println(data);
​// 2、开始统计每个景点的投票人数// 准备一个Map集合用于统计最终的结果Map<String, Integer> result = new HashMap<>();
​// 3、开始遍历80个景点数据for (String s : data) {// 问问Map集合中是否存在该景点if(result.containsKey(s)){// 说明这个景点之前统计过。其值+1. 存入到Map集合中去result.put(s, result.get(s) + 1);}else {// 说明这个景点是第一次统计，存入"景点=1"result.put(s, 1);}}System.out.println(result);}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/703406.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【架构】GPU架构总结

【架构】GPU架构总结

文章目录 GPU架构GPU渲染内存架构Streaming Multiprocessor(SM)CUDA CoreTensor CoreRT CoreCPU-GPU异构系统GPU资源管理模型 GPU架构演进G80 架构Fermi 架构Maxwell架构Tesla架构Pascal架构Volta 架构Turing架构Ampere 架构Hopper架构 参考文献 GPU架构 主要组成包括&#xf…
阅读更多...
外汇天眼：掌握这个方法，你也能成为交易高手！

外汇天眼：掌握这个方法，你也能成为交易高手！

在金融市场这个大潮中&#xff0c;外汇交易因其高杠杆、24小时交易等特点吸引着无数交易者。然而成功的交易并非易事&#xff0c;对于投资者来说&#xff0c;外汇交易市场是一个复杂且多变的市场&#xff0c;要在外汇市场中获得成功就需要扎实的外汇金融基础知识和独特的策略&a…
阅读更多...
压力测试工具Jmeter的下载与使用

压力测试工具Jmeter的下载与使用

1、进入官网下载Jmeter https://jmeter.apache.org/ 国内镜像&#xff08;下载的慢的话可以用国内镜像下载&#xff09; https://mirrors.cloud.tencent.com/apache/jmeter/binaries/ 2、跳转到下载页面 3、根据不同系统下载相应版本的Jmeter压缩包&#xff0c;Linux系统下载…
阅读更多...
Next Terminal 开源 轻量 简单的堡垒机

Next Terminal 开源 轻量 简单的堡垒机

Next Terminal是一个简单好用安全的开源交互审计系统&#xff0c;支持RDP、SSH、VNC、Telnet、Kubernetes协议。 目前支持的功能有&#xff1a; 授权凭证管理资产管理&#xff08;支持RDP、SSH、VNC、TELNET协议&#xff09;指令管理批量执行命令在线会话管理&#xff08;监控…
阅读更多...
医院LIS（全称Laboratory Information Management System）系统源码

医院LIS（全称Laboratory Information Management System）系统源码

目录 一、医院LIS系统概况 二、医院LIS系统建设必要性 三、为什么要使用LIS系统 四、技术框架 &#xff08;1&#xff09;总体框架 &#xff08;2&#xff09;技术细节 &#xff08;3&#xff09;LIS主要功能模块 五、LIS系统优势 &#xff08;1&#xff09;客户/用户…
阅读更多...
LeetCode_Java_环形链表(题目+思路+代码)

LeetCode_Java_环形链表(题目+思路+代码)

141.环形链表 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接到链表中的位…
阅读更多...
CSS cursor的一些相关属性

CSS cursor的一些相关属性

auto crosshair default e-resize help move n-resize ne-resize nw-resize pointer progress s-resize se-resize sw-resize text w-resize wait 上面是一些cursor的属性&#xff0c;非常多 cursor&#xff1a;pointer &#xff1b;这个呈现在页面上是一个小手状&#xff0c…
阅读更多...
49.仿简道云公式函数实战-文本函数-Ip

49.仿简道云公式函数实战-文本函数-Ip

1. Ip函数 获取当前用户的ip地址 注意是Ipv4的地址 2. 函数用法 IP() 3. 函数示例 获取当前用户的ip地址IP() 4. 代码实战 首先我们在function包下创建text包&#xff0c;在text包下创建IpFunction类&#xff0c;代码如下&#xff1a; package com.ql.util.express.sel…
阅读更多...
如何使用Lychee+cpolar搭建本地私人图床并实现远程访问存储图片

如何使用Lychee+cpolar搭建本地私人图床并实现远程访问存储图片

文章目录 1.前言2. Lychee网站搭建2.1. Lychee下载和安装2.2 Lychee网页测试2.3 cpolar的安装和注册 3.本地网页发布3.1 Cpolar云端设置3.2 Cpolar本地设置 4.公网访问测试5.结语 1.前言 图床作为图片集中存放的服务网站&#xff0c;可以看做是云存储的一部分&#xff0c;既可…
阅读更多...
EAP-TLS实验之Ubuntu20.04环境搭建配置（FreeRADIUS3.0）（二）

EAP-TLS实验之Ubuntu20.04环境搭建配置（FreeRADIUS3.0）（二）

上篇文章简要介绍了freeradius的搭建及配置&#xff0c;在最后数据库连接阶段还没进行测试验证&#xff0c;今天继续。 修改相关文件 1 radiusd.conf 打开762行注释&#xff08;&#xff04;INCLUDE mods-enabled/sql&#xff09;&#xff1b; 2 sites-available/default …
阅读更多...
Oracle数据泵跨大版本迁移数据库

Oracle数据泵跨大版本迁移数据库

Oracle数据泵跨大版本迁移数据库 source库导出元数据传输dump和数据文件到target库target库导入数据库迁移后的工作 &#x1f988;场景&#xff1a;将测试环境中一台Oracle 11g数据库迁移到另一台新搭建的19c数据库中。 &#x1f914;分析&#xff1a;由于是跨数据库大版本&…
阅读更多...
【大数据】Flink SQL 语法篇（四）：Group 聚合、Over 聚合

【大数据】Flink SQL 语法篇（四）：Group 聚合、Over 聚合

Flink SQL 语法篇&#xff08;四&#xff09;&#xff1a;Group 聚合、Over 聚合 1.Group 聚合1.1 基础概念1.2 窗口聚合和 Group 聚合1.3 SQL 语义1.4 Group 聚合支持 Grouping sets、Rollup、Cube 2.Over 聚合2.1 时间区间聚合2.2 行数聚合 1.Group 聚合 1.1 基础概念 Grou…
阅读更多...
Ubuntu22.04防火墙ufw用法

Ubuntu22.04防火墙ufw用法

一、安装ufw sudo apt update sudo apt install ufw 二、启用ufw sudo ufw enable 三、 查看状态 sudo ufw status 四、允许访问指定端口 注意&#xff1a;务必要允许外部能够访问22端口&#xff08;否则就无法ssh远程登录&#xff09; ufw allow 22 允许内部/外部访…
阅读更多...
将视频中的语音转换为文字：使用Python实现自动字幕

将视频中的语音转换为文字：使用Python实现自动字幕

在多媒体内容中&#xff0c;视频是一个信息量巨大的载体。然而&#xff0c;有时我们需要从视频中提取出语音信息并转换为文本&#xff0c;比如为视频制作字幕&#xff0c;或是从讲座录像中提取讲稿。这篇技术博客将向你展示如何使用Python将视频中的语音转换为文字。 准备工作…
阅读更多...
DevOps 周期的 6 个 C

DevOps 周期的 6 个 C

中型到大型软件开发项目涉及许多人员、多个团队、资源、工具和开发阶段。它们都需要以某种方式进行管理和简化&#xff0c;不仅可以获得所需的产品&#xff0c;而且还要确保将来在不断变化的环境下易于管理和维护。组织通常遵循许多项目管理模型和技术。DevOps 是其中之一&…
阅读更多...
【Rust】——所有权：Stack（栈内存）vs Heap（堆内存）（重点）

【Rust】——所有权：Stack（栈内存）vs Heap（堆内存）（重点）

&#x1f383;个人专栏&#xff1a; &#x1f42c; 算法设计与分析&#xff1a;算法设计与分析_IT闫的博客-CSDN博客 &#x1f433;Java基础&#xff1a;Java基础_IT闫的博客-CSDN博客 &#x1f40b;c语言&#xff1a;c语言_IT闫的博客-CSDN博客 &#x1f41f;MySQL&#xff1a…
阅读更多...
家用超声波清洗机哪个好？四款高评分超声波清洗机分享

家用超声波清洗机哪个好？四款高评分超声波清洗机分享

超声波清洗机可以说是眼镜党家中必备的一款超声波清洗机&#xff0c;毕竟它能高效的帮我们解决清洗眼镜的烦恼&#xff0c;也可以帮我们清洗家中其他的一些物品。很多朋友因为各种原因没有时间清洗眼镜以及家中的小物件物品&#xff0c;长时间下来一次物品或者是眼镜上就会堆积…
阅读更多...
SpringMVC的异常处理

SpringMVC的异常处理

异常分类 ： 预期异常（检查型异常）和运行时异常 1、使用@ExceptionHandle注解处理异常 @ExceptionHandle（value={***.class} 异常类型） public modelandview handelException（）{} 仅限当前类使用 2、全局处理方式 @ControllerAdvice + @ExceptionHandle 新建类 @Cont…
阅读更多...
设计模式--享元模式和组合模式

设计模式--享元模式和组合模式

享元模式 享元模式&#xff08;Flyweight Pattern&#xff09;又称为轻量模式&#xff0c;是对象池的一种实现。类似于线程池&#xff0c;线程池可以避免不停的创建和销毁多个对象&#xff0c;销毁性能。提供了减少对象数量从而改善应用所需的对象结构的方式。其宗旨是共享细粒…
阅读更多...
卷积神经网络 CNN

卷积神经网络 CNN

目录 卷积网络与传统网络的区别 参数共享 卷积神经网络整体架构 卷积操作的作用 卷积核的定义 卷积特征值计算方法 卷积层涉及的参数 边缘填充 ​编辑 卷积结果计算 池化层 整体网格架构 VGG网络架构 残差网络Resnet 卷积网络与传统网络的区别 卷积神经网络&#x…
阅读更多...
最新文章

Copyright @ 2022~2023