java之集合（详细-Map,Set,List）

1集合体系概述

1.1集合的概念

集合是一种容器，用来装数据的，类似于数组，但集合的大小可变，开发中也非常常用。

1.2集合分类

集合分为单列集合和多列集合

Collection代表单列集合，每个元素（数据）只包含一个值。

Map代表双列集合，每个元素包含两个值（键值对）。 

1.3Colleection集合体系

Collection集合特点

List系列集合：添加的元素是有序、可重复、有索引。

  1. ArrayList、LinekdList ：有序、可重复、有索引。

Set系列集合：添加的元素是无序、不重复、无索引。

  1. HashSet: 无序、不重复、无索引；
  2. LinkedHashSet: 有序(先添加的再前面，后添加的再后面）、不重复、无索引。
  3. TreeSet：按照大小默认升序排序、不重复、无索引。 

1.4Map集合体系

 Map集合体系的特点

注意：Map系列集合的特点都是由键决定的，值只是一个附属品，值是不做要求的

  • HashMap（由键决定特点）: 无序、不重复、无索引；  （用的最多）
  • LinkedHashMap （由键决定特点）:由键决定的特点：有序（先添加的再前面，后添加的再后面）、不重复、无索引。
  • TreeMap （由键决定特点）:按照大小默认升序排序、不重复、无索引。

2.Collection集合

2.1 Collection的常用方法

为啥要先学Collection的常用方法？

Collection是单列集合的祖宗，它规定的方法（功能）是全部单列集合都会继承的。

 举例说明：

package com.test.可删;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
public class Test {public static void main(String[] args) {Collection<String> c = new ArrayList<>(); // 多态写法// 1.public boolean add(E e)：添加元素, 添加成功返回true。c.add("java1");c.add("java1");c.add("java2");c.add("java2");c.add("java3");System.out.println(c);//[java1, java1, java2, java2, java3]// 2.public boolean isEmpty()：判断集合是否为空 是空返回true,反之。System.out.println(c.isEmpty()); // false// 3.public int size()：获取集合的大小。System.out.println(c.size());//5// 4.public boolean contains(Object obj)：判断集合中是否包含某个元素。System.out.println(c.contains("java1")); // trueSystem.out.println(c.contains("Java1")); // false// 5.public boolean remove(E e)：删除某个元素:如果有多个重复元素默认删除前面的第一个！System.out.println(c.remove("java1"));//trueSystem.out.println(c);//[java1, java2, java2, java3]// 6.public Object[] toArray()：把集合转换成数组Object[] arr = c.toArray();System.out.println(Arrays.toString(arr));//[java1, java2, java2, java3]// 7.public void clear()：清空集合的元素。c.clear();System.out.println(c);//[]}
}

扩展：把一个集合的全部数据倒入到另一个集合中去
package com.test.可删;
import java.util.ArrayList;
import java.util.Collection;
public class Test {public static void main(String[] args) {// 把一个集合的全部数据倒入到另一个集合中去。Collection<String> c1 = new ArrayList<>();c1.add("java1");c1.add("java2");Collection<String> c2 = new ArrayList<>();c2.add("java3");c2.add("java4");c1.addAll(c2); // 就是把c2集合的全部数据倒入到c1集合中去。System.out.println(c1);//[java1, java2, java3, java4]System.out.println(c2);//[java3, java4]}
}

2.2Collection的遍历方式

2.2.1迭代器

迭代器概述

迭代器是用来遍历集合的专用方式(数组没有迭代器)，在Java中迭代器的代表是Iterator。

Collection集合获取迭代器的方法

Iterator迭代器中的常用方法

举例

package com.test.可删;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Test {public static void main(String[] args) {Collection<String> c = new ArrayList<>();c.add("赵敏");c.add("小昭");c.add("素素");c.add("灭绝");System.out.println(c);// c = [赵敏, 小昭, 素素,灭绝]// 使用迭代器遍历集合// 1、从集合对象中获取迭代器对象-手动一个一个取。Iterator<String> it = c.iterator();
//        System.out.println(it.next());//赵敏
//        System.out.println(it.next());//小昭
//        System.out.println(it.next());//素素
//        System.out.println(it.next());//灭绝// System.out.println(it.next()); // 出现异常的// 2、我们应该使用循环结合迭代器遍历集合。while (it.hasNext()){String ele = it.next();System.out.println(ele);}}
}

2.2.2增强for

  • 增强for可以用来遍历集合或者数组。
  • 增强for遍历集合，本质就是迭代器遍历集合的简化写法。 
package com.test.可删;
import java.util.ArrayList;
import java.util.Collection;
public class Test {public static void main(String[] args) {Collection<String> c = new ArrayList<>();c.add("赵敏");c.add("小昭");c.add("素素");c.add("灭绝");System.out.println(c);// c = [赵敏, 小昭, 素素, 灭绝]// 使用增强for遍历集合或者数组。for (String ele : c) {System.out.println(ele);}String[] names = {"迪丽热巴", "古力娜扎", "稀奇哈哈"};//数组的增强for循环for (String name : names) {System.out.println(name);}}
}

2.2.3Lambda表达式

Lambda表达式遍历集合

  • 得益于JDK 8开始的新技术Lambda表达式，提供了一种更简单、更直接的方式来遍历集合。

需要使用Collection的如下方法来完成

package com.test.可删;
import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Consumer;
public class Test {public static void main(String[] args) {Collection<String> c = new ArrayList<>();c.add("赵敏");c.add("小昭");c.add("殷素素");c.add("周芷若");System.out.println(c);// [赵敏, 小昭, 殷素素, 周芷若]// default void forEach(Consumer<? super T> action):  结合Lambda表达式遍历集合：c.forEach(new Consumer<String>() {@Overridepublic void accept(String s) {System.out.println(s);}});//简化c.forEach((String s) -> {System.out.println(s);});//简化c.forEach(s  -> {System.out.println(s);});//简化c.forEach(s  -> System.out.println(s) );//最终简化表达式c.forEach(System.out::println );}
}

2.3List集合

List系列集合特点:   有序，可重复，有索引  

  • ArrayList：有序，可重复，有索引。  
  • LinkedList：有序，可重复，有索引。

2.3.1List集合的特有方法

List集合因为支持索引，所以多了很多与索引相关的方法，当然，Collection的功能List也都继承了。

package com.test.可删;
import java.util.ArrayList;
import java.util.List;
public class Test {public static void main(String[] args) {// 1.创建一个ArrayList集合对象（有序、可重复、有索引）List<String> list = new ArrayList<>();  // 一行经典代码list.add("蜘蛛精");list.add("至尊宝");list.add("至尊宝");list.add("牛夫人");System.out.println(list); // [蜘蛛精, 至尊宝, 至尊宝, 牛夫人]// 2.public void add(int index, E element): 在某个索引位置插入元素。list.add(2, "紫霞仙子");System.out.println(list);//[蜘蛛精, 至尊宝, 紫霞仙子, 至尊宝, 牛夫人]// 3.public E remove(int index): 根据索引删除元素,返回被删除元素System.out.println(list.remove(2));//紫霞仙子System.out.println(list);//[蜘蛛精, 至尊宝, 至尊宝, 牛夫人]// 4.public E get(int index): 返回集合中指定位置的元素。System.out.println(list.get(3));//牛夫人// 5.public E set(int index, E element): 修改索引位置处的元素,修改成功后，会返回原来的数据System.out.println(list.set(3, "牛魔王"));//牛夫人System.out.println(list);//[蜘蛛精, 至尊宝, 至尊宝, 牛魔王]}
}

2.3.2List集合支持的遍历方式

  1. for循环（因为List集合有索引）
  2. 迭代器
  3. 增强for循环
  4. Lambda表达式

 第2,3,4的遍历方式，如有不清楚，见2.2小节

package com.test.可删;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("糖宝宝");list.add("蜘蛛精");list.add("至尊宝");//（1）for循环for (int i = 0; i < list.size(); i++) {// i = 0 1 2String s = list.get(i);System.out.println(s);}//（2）迭代器。Iterator<String> it = list.iterator();while (it.hasNext()) {System.out.println(it.next());}//（3）增强for循环（foreach遍历）for (String s : list) {System.out.println(s);}//（4）JDK 1.8开始之后的Lambda表达式list.forEach(s -> {System.out.println(s);});}
}

2.3.3ArrayList集合

2.3.3.1ArrayList集合的底层原理

2.3.3.2ArrayList集合适合和不适合的应用场景
  1. ArrayList适合:根据索引查询数据，比如根据随机索引取数据(高效)!或者数据量不是很大时!
  2. ArrayList不适合:数据量大的同时又要频繁的进行增删操作!

2.3.4LinkedList集合

2.3.4.1 LinkedList集合的底层原理
  • 基于双链表实现的。
  • 特点：查询慢，增删相对较快，但对首尾元素进行增删改查的速度是极快的。

LinkedList新增了：很多首尾操作的特有方法。

2.3.4.2LinkedList的应用场景

LinkedList的应用场景之一：可以用来设计队列（先进先出，后进后出）（只是在首尾增删元素,用LinkedList来实现很合适!）

LinkedList的应用场景之一：可以用来设计栈（先进后出，后进先出）（只是在首部增删元素，用LinkedList来实现很合适!）

package com.test.可删;
import java.util.LinkedList;
public class Test {public static void main(String[] args) {// 1、创建一个队列。LinkedList<String> queue = new LinkedList<>();// 入队queue.addLast("第1号人");queue.addLast("第2号人");queue.addLast("第3号人");queue.addLast("第4号人");System.out.println(queue);//[第1号人, 第2号人, 第3号人, 第4号人]// 出队System.out.println(queue.removeFirst());//第1号人System.out.println(queue.removeFirst());//第2号人System.out.println(queue.removeFirst());//第3号人System.out.println(queue);//[第4号人]System.out.println("--------------------------------------------------");// 2、创建一个栈对象。LinkedList<String> stack = new LinkedList<>();// 压栈(push)stack.push("第1颗子弹");stack.push("第2颗子弹");stack.push("第3颗子弹");stack.push("第4颗子弹");System.out.println(stack);//[第4颗子弹, 第3颗子弹, 第2颗子弹, 第1颗子弹]// 出栈(pop)System.out.println(stack.pop());//第4颗子弹System.out.println(stack.pop());//第3颗子弹System.out.println(stack);//[第2颗子弹, 第1颗子弹]}
}

2.4Set集合

Set系列集合特点：无序：添加数据的顺序和获取出的数据顺序不一致；  不重复； 无索引; 

  • HashSet : 无序、不重复、无索引。
  • LinkedHashSet：有序、不重复、无索引。
  • TreeSet：排序、不重复、无索引。

注意： Set要用到的常用方法，基本上就是Collection提供的！！ 自己几乎没有额外新增一些常用功能！ 

2.4.1HashSet集合

2.4.1.1哈希值

注意：在正式了解HashSet集合的底层原理前，我们需要先搞清楚一个前置知识：哈希值！

哈希值

  • 就是一个int类型的数值，Java中每个对象都有一个哈希值。
  • Java中的所有对象，都可以调用Obejct类提供的hashCode方法，返回该对象自己的哈希值。

public int hashCode()：返回对象的哈希码值。 

对象哈希值的特点 

  • 同一个对象多次调用hashCode()方法返回的哈希值是相同的。
  • 不同的对象，它们的哈希值一般不相同，但也有可能会相同(哈希碰撞)。

2.4.1.2HashSet集合的底层原理
  • 基于哈希表实现。
  • 哈希表是一种增删改查数据，性能都较好的数据结构。

哈希表

JDK8之前，哈希表 = 数组+链表

JDK8开始，哈希表 = 数组+链表+红黑树

2.4.1.3两个内容一样的对象，如何让HashSet集合去重

自定义的类型的对象，比如两个内容一样的学生对象，如果让HashSet集合能够去重复！ 

结论：如果希望Set集合认为2个内容一样的对象是重复的， 必须重写对象的hashCode()和equals()方法

具体的实现：

java集合篇之练习题（List,Map等的应用练习）-CSDN博客

2.4.1.4LinkedHashSet集合的底层原理

LinkedHashSet：有序（添加和获取元素的顺序是一致的）、不重复、无索引。

LinkedHashSet集合的底层原理：依然是基于哈希表(数组、链表、红黑树)实现的。

但是，它的每个元素都额外的多了一个双链表的机制记录它前后元素的位置。

2.4.2TreeSet集合

2.4.2.1TreeSet集合的特点和注意事项

特点：不重复、无索引、可排序（默认升序排序 ，按照元素的大小，由小到大排序）

底层是基于红黑树实现的排序。

注意：

对于数值类型：Integer , Double，默认按照数值本身的大小进行升序排序。

对于字符串类型：默认按照首字符的编号升序排序。

对于自定义类型如Student对象，TreeSet默认是无法直接排序的。

2.4.2.2TreeSet自定义排序规则

TreeSet集合存储自定义类型的对象时，必须指定排序规则，支持如下两种方式来指定比较规则。

方式一

让自定义的类（如学生类）实现Comparable接口，重写里面的compareTo方法来指定比较规则。

方式二

通过调用TreeSet集合有参数构造器，可以设置Comparator对象（比较器对象，用于指定比较规则。

public TreeSet(Comparator<? super E> comparator)

 根据方式一解决对象排序

 根据方式二解决对象排序 

注意：如果既用了方式一又用了方式二进行自定义排序，那么TreeSet就近选择自己自带的比较器对象进行排序； 

自定义排序总结：

两种方式中，关于返回值的规则：

  • 如果认为第一个元素 >  第二个元素 返回正整数即可。
  • 如果认为第一个元素 < 第二个元素返回负整数即可。
  • 如果认为第一个元素 = 第二个元素返回0即可，此时Treeset集合只会保留一个元素，认为两者重复。

2.5总结

1）、如果希望记住元素的添加顺序，需要存储重复的元素，又要频繁的根据索引查询数据？

用ArrayList集合（有序、可重复、有索引），底层基于数组的。（常用） 

2）、如果希望记住元素的添加顺序，且增删首尾数据的情况较多？

用LinkedList集合（有序、可重复、有索引），底层基于双链表实现的。

3）.  如果不在意元素顺序，也没有重复元素需要存储，只希望增删改查都快？

用HashSet集合（无序，不重复，无索引），底层基于哈希表实现的。 （常用）

4）.如果希望记住元素的添加顺序，也没有重复元素需要存储，且希望增删改查都快？

用LinkedHashSet集合（有序，不重复，无索引）， 底层基于哈希表和双链表。

5）.  如果要对元素进行排序，也没有重复元素需要存储？且希望增删改查都快？

用TreeSet集合，基于红黑树实现。

3.Collection其他相关知识

3.1可变参数

就是一种特殊形参，定义在方法、构造器的形参列表里，格式是：数据类型...参数名称；

可变参数的特点和好处

特点：可以不传数据给它；可以传一个或者同时传多个数据给它；也可以传一个数组给它。

好处：常常用来灵活的接收数据。

可变参数的注意事项：

  • 可变参数在方法内部就是一个数组。
  • 一个形参列表中可变参数只能有一个
  • 可变参数必须放在形参列表的最后面
package com.test.可删;
import java.util.Arrays;
public class Test {public static void main(String[] args) {// 特点：test(); // 不传数据test(10); // 传输一个数据给它test(10, 20, 30); // 传输多个数据给它test(new int[]{10, 20, 30, 40}); // 传输一个数组给可变参数}// 注意事项1：一个形参列表中，只能有一个可变参数。// 注意事项2：可变参数必须放在形参列表的最后面public static void test(int...nums){// 可变参数在方法内部，本质就是一个数组。System.out.println(nums.length);System.out.println(Arrays.toString(nums));System.out.println("-----------------------------------------");}
}

4.Collections工具类

Collections是一个用来操作集合的工具类

Collections提供的常用静态方法

package com.test.可删;
import com.test.集合框架.p140.Student;
import java.util.*;
public class Test {public static void main(String[] args) {// 1、public static <T> boolean addAll(Collection<? super T> c, T...elements)：为集合批量添加数据List<String> names = new ArrayList<>();Collections.addAll(names, "张三", "王五", "李四", "张麻子");System.out.println(names);//[张三, 王五, 李四, 张麻子]// 2、public static void shuffle(List<?> list)：打乱List集合中的元素顺序。Collections.shuffle(names);System.out.println(names);// 3、 public static <T> void sort(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);//[2, 3, 5]// 4、public static <T> void sort(List<T> list， Comparator<? super T> c): 对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, 165.5));Collections.sort(students, new Comparator<Student>() {@Overridepublic int compare(Student o1, Student o2) {return Double.compare(o1.getHeight(), o2.getHeight());}});System.out.println(students);}
}

 注意：Collections只能支持对List集合进行排序

5.Map集合

认识Map集合

  • Map集合称为双列集合，格式：{key1=value1 , key2=value2 , key3=value3 , ...}， 一次需要存一对数据做为一个元素.
  • Map集合的每个元素“key=value”称为一个键值对/键值对对象/一个Entry对象，Map集合也被叫做“键值对集合”
  • Map集合的所有键是不允许重复的，但值可以重复，键和值是一一对应的，每一个键只能找到自己对应的值

Map集合在什么业务场景下使用

需要存储一一对应的数据时，就可以考虑使用Map集合来做

package com.test.可删;
import java.util.*;
public class Test {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);//{手表=220, 手机=2, Java=2, null=null}Map<Integer, String> map1 = new TreeMap<>(); // 可排序，不重复，无索引map1.put(23, "Java");map1.put(23, "MySQL");map1.put(19, "李四");map1.put(20, "王五");System.out.println(map1);//{19=李四, 20=王五, 23=MySQL}}
}

5.1Map集合的常用方法

Map是双列集合的祖宗，它的功能是全部双列集合都可以继承过来使用的。

Map的常用方法如下：

package com.test.可删;
import java.util.*;
public class Test {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());//4// 3、public void clear():清空集合//map.clear();//System.out.println(map);//{}// 4.public boolean isEmpty(): 判断集合是否为空，为空返回true ,反之！System.out.println(map.isEmpty());//false// 5.public V get(Object key)：根据键获取对应值int v1 = map.get("手表");System.out.println(v1);//220System.out.println(map.get("手机")); // 2System.out.println(map.get("张三")); // null// 6. public V remove(Object key)：根据键删除整个元素(删除键会返回键的值)System.out.println(map.remove("手表"));//220System.out.println(map);//{null=null, Java=2, 手机=2}// 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);//[null, Java, 手机]// 10.public Collection<V> values(); 获取Map集合的全部值。Collection<Integer> values = map.values();System.out.println(values);//[null, 2, 2]// 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);//{java3=10, java2=222, java1=10}System.out.println(map2);//{java3=10, java2=222}}
}

 5.2Map集合的遍历方式

（1）Map集合的遍历方式一：键找值

先获取Map集合全部的键，再通过遍历键来找值

需要用到Map的如下方法：

package com.test.可删;
import java.util.*;
public class Test {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);}}
}

（2）Map集合的遍历方式二：键值对

把“键值对“看成一个整体进行遍历（难度较大）

package com.test.可删;
import java.util.*;
public class Test {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// 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）Map集合的遍历方式三：Lambda  

需要用到Map的如下方法

package com.test.可删;
import java.util.*;
public class Test {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.forEach(new BiConsumer<String, Double>() {
//            @Override
//            public void accept(String k, Double v) {
//                System.out.println(k + "---->" + v);
//            }
//        });map.forEach(( k,  v) -> {System.out.println(k + "---->" + v);});}
}

 5.3HashMap集合的底层原理

HashMap（由键决定特点）: 无序、不重复、无索引；  （用的最多）

HashMap跟HashSet的底层原理是一模一样的，都是基于哈希表实现的。

实际上：原来学的Set系列集合的底层就是基于Map实现的，只是Set集合中的元素只要键数据，不要值数据而已。

HashMap底层原理基于哈希表实现

  • HashMap集合是一种增删改查数据，性能都较好的集合
  • 但是它是无序，不能重复，没有索引支持的（由键决定特点）
  • HashMap的键依赖hashCode方法和equals方法保证键的唯一
  • 如果键存储的是自定义类型的对象，可以通过重写hashCode和equals方法，这样可以保证多个对象内容一样时，HashMap集合就能认为是重复的。

5.4LinkedHashMap集合的底层原理 

LinkedHashMap （由键决定特点）: 有序、不重复、无索引。

 底层数据结构依然是基于哈希表实现的，只是每个键值对元素又额外的多了一个双链表的机制记录元素顺序(保证有序)

实际上：原来学习的LinkedHashSet集合的底层原理就是LinkedHashMap。

5.5TreeMap集合的底层原理 

TreeMap （由键决定特点）:按照键的大小默认升序排序、不重复、无索引。

原理：TreeMap跟TreeSet集合的底层原理是一样的，都是基于红黑树实现的排序。

TreeMap集合同样也支持两种方式来指定排序规则

  • 让类实现Comparable接口，重写比较规则。
  • TreeMap集合有一个有参数构造器，支持创建Comparator比较器对象，以便用来指定比较规则。 

6.集合的嵌套

集合的嵌套：集合中的元素又是一个集合 

案例可参考链接：

java集合篇之练习题（List,Map等的应用练习）-CSDN博客

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

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

相关文章

uni-app多环境配置动态修改

uni-app多环境配置动态修改

前言 这篇文章主要介绍uniapp在Hbuilderx 中&#xff0c;通过工程化&#xff0c;区分不同环境、动态修改小程序appid以及自定义条件编译&#xff0c;解决代码发布和运行时手动切换问题。 背景 当我们使用uniapp开发同一个项目发布不同的环境二级路径不同时&#xff0c;这时候…
阅读更多...
继电器控制与C++编程：实现安全开关控制的技术分享

继电器控制与C++编程：实现安全开关控制的技术分享

在现代生活中，继电器作为一种重要的电气控制元件，在电气设备的安全控制中起到了至关重要的作用。通过低电流控制高电流，继电器能够有效地隔离控制电路与被控设备，从而保障使用者的安全。本项目将介绍如何通过树莓派Pico与继电器模块结合，使用C++编程实现继电器的控制。 一…
阅读更多...
软考中级-软件设计师通过心路经验分享

软考中级-软件设计师通过心路经验分享

执念&#xff0c;第四次终于通过了 没买书&#xff0c;下班后每天2小时&#xff0c;四个2个月终于过了 学习经验&#xff1a; 1.下班后学习真的靠毅力&#xff0c;和上学的时候考证不是一个状态&#xff0c;大家要及时调整&#xff0c;否则过程很痛苦 2.失败三次的经验&#xf…
阅读更多...
分布式 Raft算法 总结

分布式 Raft算法 总结

前言 相关系列 《分布式 & 目录》《分布式 & Raft算法 & 总结》《分布式 & Raft算法 & 问题》 参考文献 《Raft一致性算法论文译文》《深入剖析共识性算法 Raft》 简介 Raft 木筏是一种基于日志复制实现的分布式容错&一致性算法。在Raft算法…
阅读更多...
仿iOS日历、飞书日历、Google日历的日模式

仿iOS日历、飞书日历、Google日历的日模式

仿iOS日历、飞书日历、Google日历的日模式&#xff0c;24H内事件可自由上下拖动、自由拉伸。 以下是效果图&#xff1a; 具体实现比较简单&#xff0c;代码如下&#xff1a; import android.content.Context; import android.graphics.Canvas; import android.graphics.Color;…
阅读更多...
朗致面试---IOS/安卓/Java/架构师

朗致面试---IOS/安卓/Java/架构师

朗致面试---IOS/安卓/Java/架构师 一、面试概况二、总结三、算法题目参考答案 一、面试概况 一共三轮面试&#xff1a; 第一轮是逻辑行测&#xff0c;25道题目&#xff0c;类似于公务员考试题目&#xff0c;要求90分钟内完成。第二轮是技术面试&#xff0c;主要是做一些数据结…
阅读更多...
浅谈I-STARIS国际演艺集团为融合中国市场，开办的各类中式训练营

浅谈I-STARIS国际演艺集团为融合中国市场，开办的各类中式训练营

I-STARIS国际演艺集团给旗下各国演员们开办针对性的训练营&#xff0c;有针对中文基础的&#xff0c;有针对中国戏曲的&#xff0c;有针对中国武术的&#xff0c;不由让我们想到了老版《红楼梦》拍摄之前&#xff0c;演员们足足训练了三个月&#xff0c;才开始进入拍摄。1984年…
阅读更多...
电脑怎么设置通电自动开机（工控机）

电脑怎么设置通电自动开机（工控机）

操作系统&#xff1a;win10 第一步&#xff0c;电脑开机时按del键进入bios页面。 第二步&#xff0c;选择advanced下的IT8712 Super IO Configuration 第三步&#xff0c;找到Auto Power On&#xff0c;将其从Power off设置为Power On 第四步&#xff0c;F10保存&#xff0c;大…
阅读更多...
springboot+javafx使用aop切面导致的fx:id不能被注入问题

springboot+javafx使用aop切面导致的fx:id不能被注入问题

记录一个我遇到得问题 问题描述 我本来使用AOP切面来进行全局异常管理&#xff0c;但是使用AOP之后fxml中通过fx:id绑定得参数无法被注入 Slf4j Component Aspect public class GlobalExceptionAspect {AfterThrowing(pointcut "execution(* com.shkj.videoclassifica…
阅读更多...
MATLAB图卷积神经网络GCN处理分子数据集节点分类研究

MATLAB图卷积神经网络GCN处理分子数据集节点分类研究

全文链接&#xff1a;https://tecdat.cn/?p38570 本文主要探讨了如何利用图卷积网络&#xff08;GCN&#xff09;对图中的节点进行分类。介绍了相关的数据处理、模型构建、训练及测试等环节&#xff0c;通过对分子数据集的操作实践&#xff0c;展示了完整的节点分类流程&#…
阅读更多...
Ubuntu安装Gitlab详细图文教程

Ubuntu安装Gitlab详细图文教程

1、环境准备 1.1、Ubuntu环境 Ubuntu24.04Sever版安装教程 1.2、更新系统 sudo apt update -y sudo apt-get update sudo apt-get upgrade 2、安装Nginx 2.1 安装nginx # 安装 apt install nginx -y 2.2 修改nginx配置⽂件 # 修改nginx配置 vim /etc/nginx/si…
阅读更多...
1. 机器学习基本知识(2)——机器学习分类

1. 机器学习基本知识(2)——机器学习分类

1.4 机器学习分类 1.4.1 训练监督 1. 监督学习&#xff1a;已对训练数据完成标记 分类&#xff1a;根据数据及其分类信息来进行训练&#xff0c;使模型能够对新的数据进行分类 回归&#xff1a;给出一组特征值来预测目标数值 2. 无监督学习&#xff1a;没有对训练数据进行任…
阅读更多...
Jupyter Notebook 切换虚拟环境

Jupyter Notebook 切换虚拟环境

方法 切换到需要添加到Jupyter Notebook中的虚拟环境&#xff0c;执行&#xff1a; python -m ipykernel install --name Jupyter Notebook中显示的虚拟环境名称如果遇到 [Errno 13] Permission denied: /usr/local/share/jupyter类似的权限问题&#xff0c;可能是没有对应的…
阅读更多...
【游戏设计原理】7 - 加德纳的多元智能理论

【游戏设计原理】7 - 加德纳的多元智能理论

虽然多元智能理论是对认知方式的分类&#xff0c;但它也可以为游戏设计提供丰富的思路和策略&#xff0c;帮助设计师创建更具吸引力、包容性和多样性的游戏。通过理解不同玩家的认知方式和优势&#xff0c;我们可以更精准地设计游戏的元素和玩法&#xff0c;使其能够吸引广泛的…
阅读更多...
SAP MMPV报错MMPV_DATE_CHECK

SAP MMPV报错MMPV_DATE_CHECK

异常提示&#xff1a;MMPV_DATE_CHECK检查失败&#xff0c;请参照NOTE 1082841。 解决方法&#xff1a; TCODE&#xff1a;SU3 在用户参数上增加&#xff1a;参数 MMPV_READ_NOTE 参数值&#xff1a;当天日期。
阅读更多...
Flink CDC技术介绍

Flink CDC技术介绍

Flink CDC&#xff08;Change Data Capture&#xff09;是基于数据库的日志CDC技术&#xff0c;实现了全增量一体化读取的数据集成框架&#xff0c;可以高效地实现海量数据的实时集成。 Flink CDC是一种功能强大、灵活易用的数据集成框架&#xff0c;适用于多种实时数据处理场…
阅读更多...
uni-app之web-view组件 postMessage 通信【跨端开发系列】

uni-app之web-view组件 postMessage 通信【跨端开发系列】

&#x1f517; uniapp 跨端开发系列文章&#xff1a;&#x1f380;&#x1f380;&#x1f380; uni-app 组成和跨端原理 【跨端开发系列】 uni-app 各端差异注意事项 【跨端开发系列】uni-app 离线本地存储方案 【跨端开发系列】uni-app UI库、框架、组件选型指南 【跨端开…
阅读更多...
机器学习辅助天线性能极限突破

机器学习辅助天线性能极限突破

电磁超构表面与天线技术的结合离不开三个尺度下对三个方面的考虑&#xff0c;即微观的单元、介观的排布、宏观的性能这三个尺度的分析、综合与调控。在单元设计层面&#xff0c;目前主要依靠经验和大规模数值迭代&#xff0c;耗时长、成功率不稳定、通用性较差&#xff1b;在阵…
阅读更多...
Deveco报错Only files in a module can be previewed

Deveco报错Only files in a module can be previewed

创建工程后需要看看预览的效果&#xff0c;却出现了这个错误 到Index.ets文件下重新构建工程 详细可以查询 鸿蒙报错&#xff08;Only files in a module can be previewed&#xff09;
阅读更多...
uniappp配置导航栏自定义按钮(解决首次加载图标失败问题)

uniappp配置导航栏自定义按钮(解决首次加载图标失败问题)

1.引入iconfont的图标&#xff0c;只保留这两个文件 2.App.vue引入到全局中 import "./static/fonts/iconfont.css"3.pages.json中配置text为图标对应的unicode {"path": "pages/invite/invite","style": {"h5": {"…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023