集合体系结构

集合类的特点

提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变

集合类的体系图

Collection(单列)

概述
- 是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
- JDK 不提供此接口的任何直接实现，它提供更具体的子接口（如Set和List）实现

Collection集合的常用方法

方法名	说明
boolean add(E e)	添加元素
boolean remove(Object o)	从集合中移除指定的元素
void clear()	清空集合中的元素
boolean contains(Object o)	判断集合中是否存在指定的元素
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中元素的个数

import java.util.ArrayList;
import java.util.Collection;/*创建Collection集合的对象多态的方式ArrayList()| boolean remove(Object o)   | 从集合中移除指定的元素             || -------------------------- | ---------------------------------- || void   clear()             | 清空集合中的元素                   || boolean contains(Object o) | 判断集合中是否存在指定的元素       || boolean isEmpty()          | 判断集合是否为空                   || int   size()               | 集合的长度，也就是集合中元素的个数 |*/
public class CollectionDemo {public static void main(String[] args) {//创建Collection集合的对象Collection<String> c=new ArrayList<String>();//        //添加元素：boolean add(E e)
//        c.add("hello");
//        c.add("world");
//        c.add("java");//boolean add(E e):添加元素System.out.println( c.add("hello"));System.out.println(c.add("world"));System.out.println(c.add("java"));//boolean remove(Object o)   | 从集合中移除指定的元素
//        System.out.println(c.remove("hello"));//void   clear()             | 清空集合中的元素                   |
//        c.clear();// boolean contains(Object o) | 判断集合中是否存在指定的元素
//        System.out.println(c.contains("hello"));
//        System.out.println(c.contains("javaSE"));// | boolean isEmpty()          | 判断集合是否为空
//        System.out.println(c.isEmpty());// int   size()               | 集合的长度，也就是集合中元素的个数 |System.out.println(c.size());//输出集合对象System.out.println(c);}
}

迭代器的介绍
   - 迭代器，集合的专用遍历方式
   - Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
   - 迭代器是通过集合的iterator()方法得到的，所以我们说它是依赖于集合而存在的
遍历方法

  //Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到Iterator<String> it = c.iterator();//用while循环改进元素的判断和获取while (it.hasNext()) {String s = it.next();System.out.println(s);}

List（可重复）

概述和特点
   概述
       - 有序集合(也称为序列)，用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素
       - 与Set集合不同，列表通常允许重复的元素
   特点
       - 有索引
       - 可以存储重复元素
       - 元素存取有序

特有方法

方法名	描述
void add(int index,E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索引处的元素

并发修改异常
   出现的原因
       迭代器遍历的过程中，通过集合对象修改了集合中的元素，造成了迭代器获取元素中判断预期修改值和实际修改值不一致，则会出现：ConcurrentModificationException
   解决的方案
       用for循环遍历，然后用集合对象做对应的操作即可

      //for循环方式for(int i=0; i<list.size(); i++) {Student s = list.get(i);System.out.println(s.getName() + "," + s.getAge());}

列表迭代器（ListIterator）
- 通过List集合的listIterator()方法得到，所以说它是List集合特有的迭代器
- 用于允许程序员沿任一方向遍历的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

增强for循环

  for(元素数据类型 变量名 : 数组/集合对象名) {循环体;
}

数据结构
   栈和列表
       - 栈结构
              先进后出
       - 队列结构
              先进先出
   数组和链表
       数组结构
           查询快、增删慢
       链表结构
           查询慢、增删快

List集合的实体类

子类的特点
   - ArrayList集合
          底层是数组结构实现，查询快、增删慢
   - LinkedList集合
          底层是链表结构实现，查询慢、增删快

LinkdeList集合的特有功能

特有方法

方法名	说明
public void addFirst(E e)	在该列表开头插入指定的元素
public void addLast(E e)	将指定的元素追加到此列表的末尾
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表中的最后一个元素
public E removeFirst()	从此列表中删除并返回第一个元素
public E removeLast()	从此列表中删除并返回最后一个元素

关于List集合的相关例子：

有如下Student 对象，

　 private String name;

private int age;

private int score;

private String classNum;

其中，classNum 表示学生的班号，例如“class05”。有如下List List list = new ArrayList();

list.add(new Student(“Tom”, 18, 100, “class05”));

list.add(new Student(“Jerry”, 22, 70, “class04”));

list.add(new Student(“Owen”, 25, 90, “class05”));

list.add(new Student(“Jim”, 30,80 , “class05”));

list.add(new Student(“Steve”, 28, 66, “class06”));

list.add(new Student(“Kevin”, 24, 100, “class04”));

在这个list 的基础上，完成下列要求：

//1）计算所有学生的平均年龄

//2）计算各个班级的平均分

学生类

public class Student {private String name;private int age;private int score;private String classNum;public Student() {}public Student(String name, int age, int score, String classNum) {this.name = name;this.age = age;this.score = score;this.classNum = classNum;}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;}public int getScore() {return score;}public void setScore(int score) {this.score = score;}public String getClassNum() {return classNum;}public void setClassNum(String classNum) {this.classNum = classNum;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +", score=" + score +", classNum='" + classNum + '\'' +'}';}
}

测试类：

import java.util.ArrayList;
import java.util.List;public class ListTest {public static void main(String[] args) {List<Student> list=new ArrayList<Student>();list.add(new Student("Tom",18,100,"class5"));list.add(new Student("Jerry",22,70,"class4"));list.add(new Student("Tom",25,90,"class5"));list.add(new Student("Tom",30,80,"class5"));list.add(new Student("Tom",28,66,"class6"));list.add(new Student("Tom",24,100,"class4"));//年龄int sumAge=0;//成绩//各个班级的总成绩double scoreSum5 = 0.0;double scoreSum4 = 0.0;double scoreSum6 = 0.0;//统计各个班级的人数int count5 = 0;int count4 = 0;int count6 = 0;//遍历list集合得到每一个学生for(Student student : list){//获取学生年龄Integer age = student.getAge();sumAge += age;//获取每个班级String classNum = student.getClassNum();if (classNum.equals("class5")){ //5班//获取成绩int score = student.getScore();scoreSum5 += score;count5++;}else if(classNum.equals("class4")){//4班int score = student.getScore();scoreSum4 += score;count4++;}else if(classNum.equals("class6")){//6班int score = student.getScore();scoreSum6 += score;count6++;}}//1） 计算所有学生的平均年龄System.out.println("所有学生的平均年龄：" + sumAge / list.size());// 2） 计算各个班级的平均分System.out.println("5班的平均分：" + scoreSum5 / count5);System.out.println("4班的平均分：" + scoreSum4 / count4);System.out.println("6班的平均分：" + scoreSum6 / count6);}
}

Set（不可重复）

特点
       - 元素存取无序
       - 没有索引、只能通过迭代器或增强for循环遍历
       - 不能存储重复元素
   哈希值
       哈希值简介
           是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
       如何获取哈希值
           Object类中的public int hashCode()：返回对象的哈希码值
       哈希值的特点
           - 同一个对象多次调用hashCode()方法返回的哈希值是相同的
           - 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同
   HashSet集合
       HashSet集合的特点
           - 底层数据结构是哈希表
           - 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
           - 没有带索引的方法，所以不能使用普通for循环遍历
           - 由于是Set集合，所以是不包含重复元素的集合
   HashSet集合保证元素唯一性源码分析
       HashSet集合保证元素唯一性的原理
          1.根据对象的哈希值计算存储位置
           如果当前位置没有元素则直接存入
           如果当前位置有元素存在，则进入第二步
       2.当前元素的元素和已经存在的元素比较哈希值
           如果哈希值不同，则将当前元素进行存储
           如果哈希值相同，则进入第三步
       3.通过equals()方法比较两个元素的内容
           如果内容不相同，则将当前元素进行存储
           如果内容相同，则不存储当前元素
   LinkedHashSet集合概述和特点
       LinkedHashSet集合特点
           - 哈希表和链表实现的Set接口，具有可预测的迭代次序
           - 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
           - 由哈希表保证元素唯一，也就是说没有重复的元素
   Set集合排序
       TreeSet集合概述和特点
           TreeSet集合概述
               - 元素有序，可以按照一定的规则进行排序，具体排序方式取决于构造方法
               - TreeSet()：根据其元素的自然排序进行排序
               - TreeSet(Comparator comparator) ：根据指定的比较器进行排序
               - 没有带索引的方法，所以不能使用普通for循环遍历
               - 由于是Set集合，所以不包含重复元素的集合
       自然排序Comparable的使用
           案例需求
               - 存储学生对象并遍历，创建TreeSet集合使用无参构造方法
               - 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
           实现步骤
               - 用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
               - 自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法
               - 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
       比较器排序Comparator的使用
           - 案例需求
               - 存储学生对象并遍历，创建TreeSet集合使用带参构造方法
               - 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
           - 实现步骤
               - 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
               - 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法
               - 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
   泛型
       泛型概述和好处
           - 泛型概述
                  是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型
               它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型。这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口
           - 泛型定义格式
               - <类型>：指定一种类型的格式。这里的类型可以看成是形参
               - <类型1,类型2…>：指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参
               - 将来具体调用时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型
           - 泛型的好处
               - 把运行时期的问题提前到了编译期间
               - 避免了强制类型转换
       泛型类
           - 定义格式
               修饰符 class 类名<类型> { }
       泛型方法
           定义格式
               修饰符 <类型> 返回值类型方法名(类型变量名) { }
       泛型接口
           定义格式
               修饰符 interface 接口名<类型> { }
       类型通配符
           - 类型通配符的作用
                  为了表示各种泛型List的父类，可以使用类型通配符
           - 类型通配符的分类
               - 类型通配符：<?>
                   - List<?>：表示元素类型未知的List，它的元素可以匹配任何的类型
                   - 这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中
               - 类型通配符上限：<? extends 类型>
                   - List<? extends Number>：它表示的类型是Number或者其子类型
               - 类型通配符下限：<? super 类型>
                   - List<? super Number>：它表示的类型是Number或者其父类型
   可变参数

           可变参数介绍
               可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了
           可变参数定义格式
               修饰符返回值类型方法名(数据类型… 变量名) { }
           可变参数注意事项
               - - 这里的变量其实是一个数组
               - 如果一个方法有多个参数，包含可变参数，可变参数要放在最后
       可变参数的使用
           Arrays工具类中有一个静态方法：
               - public static <T> List<T> asList(T... a)：返回由指定数组支持的固定大小的列表
               - 返回的集合不能做增删操作，可以做修改操作
           List接口中有一个静态方法：
               - public static <E> List<E> of(E... elements)：返回包含任意数量元素的不可变列表
               - 返回的集合不能做增删改操作
           Set接口中有一个静态方法：
               - - public static <E> Set<E> of(E... elements) ：返回一个包含任意数量元素的不可变集合
               - 在给元素的时候，不能给重复的元素
               - 返回的集合不能做增删操作，没有修改的方法

关于Set集合的相关例子：

在某次考试中，学生的成绩信息如下（公有属性）：姓名(String) 年龄（int）成绩(int): Tom 20 90； Jerry 22 95； John 20 100； Lily 22 100 ；Lucy 22 90； Kevin 22 90 请分别用Comparable和Comparator两个接口对以上同学的成绩做降序排序，如果成绩一样，那在成绩排序的基础上按照年龄由小到大排序，成绩和年龄都一样，则按照姓名的字典顺序排序。

(1).Comparable接口

public class Student implements Comparable<Student>{private String name;private  int age;private int score;public Student() {}public Student(String name, int age, int score) {this.name = name;this.age = age;this.score = score;}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;}public int getScore() {return score;}public void setScore(int score) {this.score = score;}@Overridepublic String toString() {return"姓名='" + name + '\'' +", 年龄=" + age +", 成绩=" + score ;}//如果成绩一样，那在成绩排序的基础上按照年龄由小到大排序，// 成绩和年龄都一样，则按照姓名的字典顺序排序。@Overridepublic int compareTo(Student o) {int num = this.score - o.score;int num1 = num == 0 ? this.age - o.age : num;int num2 = num1 == 0 ? this.name.compareTo(o.name) : num1;return num2;// return this.score - o.score == this.age - o.age ? this.name.compareTo(o.name) : (this.score - o.score == 0 ? this.age - o.age : this.score - o.score );}
}

import java.util.Set;
import java.util.TreeSet;public class SetTest8 {public static void main(String[] args) {//Comparable方式接口对以上同学的成绩做降序排序//创建TreeSet集合对象Set<Student> treeSet = new TreeSet<Student>();//创建学生对象treeSet.add(new Student("Tom", 20, 90));treeSet.add(new Student("Jerry", 22, 95));treeSet.add(new Student("John", 20, 100));treeSet.add(new Student("Lily", 22, 100));treeSet.add(new Student("Lucy", 22, 90));treeSet.add(new Student("Kevin", 22, 90));//遍历数组for (Student s : treeSet) {System.out.println(s);}}
}

（2）.Comparator

public class Student{private String name;//姓名private int age;//年龄private int score;//成绩public Student() {}public Student(String name, int age, int score) {this.name = name;this.age = age;this.score = score;}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;}public int getScore() {return score;}public void setScore(int score) {this.score = score;}@Overridepublic String toString() {return "姓名='" + name +" 年龄=" + age +" 成绩=" + score;}
}

public class SetTest8 {public static void main(String[] args) {//Comparator方式接口对以上同学的成绩做降序排序//创建TreeSet集合对象Set<Student> treeSet = new TreeSet<Student>(new Comparator<Student>() {@Overridepublic int compare(Student o1, Student o2) {int num = o1.getScore() - o2.getScore();int num1 = num == 0 ? o1.getAge() - o2.getAge() : num;int num2 = num1 == 0 ? o1.getName().compareTo(o2.getName()) : num1;return num2;}});//创建学生对象treeSet.add(new Student("Tom", 20, 90));treeSet.add(new Student("Jerry", 22, 95));treeSet.add(new Student("John", 20, 100));treeSet.add(new Student("Lily", 22, 100));treeSet.add(new Student("Lucy", 22, 90));treeSet.add(new Student("Kevin", 22, 90));//遍历数组for (Student student : treeSet) {System.out.println(student);}}
}

Map（双列）

Map集合
       概述和特点
           概述
               interface Map<K,V> K：键的类型；V：值的类型将键映射到值的对象；不能包含重复的键；每个键可以映射到最多一个值
           特点
               - 键值对映射关系
               - 一个键对应一个值
               - 键不能重复，值可以重复
               - 元素存取无序
       基本功能

方法名	说明
V put(K key,V value)	添加元素
V remove(Object key)	根据键删除键值对元素
void clear()	移除所有的键值对元素
boolean containsKey(Object key)	判断集合是否包含指定的键
boolean containsValue(Object value)	判断集合是否包含指定的值
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中键值对的个数

获取功能

方法名	说明
V get(Object key)	根据键获取值
Set<K> keySet()	获取所有键的集合
Collection<V> values()	获取所有值的集合
Set<Map.Entry<K,V>> entrySet()	获取所有键值对对象的集合

    遍历
           方式1
               遍历思路
                   我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
                   - 把所有的丈夫给集中起来
                   - 遍历丈夫的集合，获取到每一个丈夫
                   - 根据丈夫去找对应的妻子
               步骤分析
                   - 获取所有键的集合。用keySet()方法实现
                   - 遍历键的集合，获取到每一个键。用增强for实现
                   - 根据键去找值。用get(Object key)方法实现
           方式2
               遍历思路
                   我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
                   - 获取所有结婚证的集合
                   - 遍历结婚证的集合，得到每一个结婚证
                   - 根据结婚证获取丈夫和妻子
               步骤分析
                   - 获取所有键值对对象的集合
                       - Set<Map.Entry<K,V>> entrySet()：获取所有键值对对象的集合
                   - 遍历键值对对象的集合，得到每一个键值对对象
                       - 用增强for实现，得到每一个Map.Entry
                   - 根据键值对对象获取键和值
                       - 用getKey()得到键
                       - 用getValue()得到值
   Collections集合工具类
       作用
           是针对集合操作的工具类
       常用方法

方法名	说明
public static void sort(List<T> list)	将指定的列表按升序排序
public static void reverse(List<?> list)	反转指定列表中元素的顺序
public static void shuffle(List<?> list)	使用默认的随机源随机排列指定的列表

有关Map集合的例子：

【1】将以下车站对应关系的数据存储到map集合中，
key：表示站编号，value：表示站名，
并遍历打印(可以不按顺序打印)：
------------------------------------
站编号和站名对应关系如下：
1 朱辛庄
   2 育知路
   3 平西府
   4 回龙观东大街
   5 霍营
   6 育新
   7 西小口
   8 永泰庄
   9 林萃桥
   10 森林公园南门
   11 奥林匹克公园
   12 奥体中心
   13 北土城
   14 安华桥
   15 安德里北街
   16 鼓楼大街
   17 什刹海
   18 南锣鼓巷
19 中国美术馆
------------------------------------

【2】计算地铁票价规则：
总行程 3站内（包含3站）收费3元，
3站以上但不超过5站（包含5站）的收费4元，
5站以上的，在4元的基础上，每多1站增加2元，
10元封顶；

需要对键盘录入的上车站
和到达站进行判断，如果没有该站，
提示重新输入，直到站名存在为止
每站需要2分钟

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;public class Ride {public static void main(String[] args) {//创建HashMap,键是站编号，值是站名HashMap<Integer, String> hm = new HashMap<Integer, String>();//创建ArrayList,存放站编号ArrayList<Integer> array = new ArrayList<Integer>();//创建站名数组String[] stations = {"朱辛庄", "育知路", "平西府", "回龙东观大街", "霍营", "育新", "西小口", "永泰庄", "林萃桥","森林公园南门", "奥林匹克公园", "奥体中心", "北土城", "安华桥", "安德里北街", "鼓楼大街", "什刹海", "南锣鼓巷", "中国美术馆"};//从1开始往HashMap里面存储编号，并存储对应的站名。同时往ArrayList里面存储编号int index = 1;for (String station : stations) {hm.put(index, station);array.add(index);index++;}//遍历车站//获取所有键的集合。用keySet()方法实现Set<Integer> keySet = hm.keySet();//遍历键的集合，获取到每一个键。用增强for实现for (Integer key : keySet) {//根据键去找值。用get(Object key)方法实现String value = hm.get(key);System.out.println(key + "," + value);}//创建初始值(先建类型，在确定车站时在确定具体的值，为了便于后面获取车站的序号)Scanner sc = new Scanner(System.in);String start;String end;//上车站的确定while (true) {System.out.print("请输入上车站:");start = sc.nextLine();if (hm.containsValue(start)) {System.out.println("输入成功");break;} else {System.out.println("该站不存在，请重新输入");}}//下车站的确定while (true) {System.out.print("请输入下车站:");end = sc.next();if (hm.containsValue(end)) {System.out.println("输入成功");break;} else {System.out.println("该站不存在，请重新输入");}}//建立值int startNumber = 0;int endNumber = 0;int middle = 0;//上车站点的序号Set<Integer> keySet1 = hm.keySet();for (Integer key1 : keySet) {if (start.equals(hm.get(key1))) {startNumber = key1;}if (end.equals(hm.get(key1))) {endNumber = key1;}}//简化版（只可从序号小的站点出发）——后续可改良if (startNumber > endNumber) {middle = startNumber - endNumber;} else {middle = endNumber - startNumber;}//计算票价
//        计算地铁票价规则：
//        总行程 3站内（包含3站）收费3元，
//        3站以上但不超过5站（包含5站）的收费4元，
//        5站以上的，在4元的基础上，每多1站增加2元，
//        10元封顶；int money = 0;if (middle <= 3) {money = 3;}if (middle > 3 && middle <= 5) {money = 4;}if (middle >= 5) {money = 4 + (endNumber - 5) * 2;}money = money > 10 ? 10 : money;int time = middle * 2;System.out.println("从" + start + "到" + end +"共经过" + middle + "站" + "收费" + money +"元，大约需要" + time+ "分钟");}
}

容器集合——Collection(单列)、Map（双列）相关推荐

Map双列集合的用法，遍历方法
Map集合的常用方法. Map集合是一个双列集合,里面的每个元素都是一个键值对. Map<K,V> 有两个泛型, K 表示Map集合中键的类型. V 表示Map集合中值的数据类型. 常用方 ...
集合Collection和Map的基础掌握
1.Coolection 1 概述英文名称Collection,是用来存放对象的数据结构.其中长度可变,而且集合中可以存放不同类型的对象,并提供了一组操作成批对象的方法. 数组的缺点:长度固 ...
java-集合-Map(双列)——迪迦重制版
目录引言一:Map星云,集合(概要!!!,,,哦,不是,喊错了,盖亚!!!) 1.盖亚?(概要): 2.技能(特点): 3.举例: 4.创建Map集合的对象: 5.所有方法: 6.Map注意事项: ...
java 先进先出的map_「深入浅出」java集合Collection和Map
本系列文章主要对java集合的框架进行一个深入浅出的介绍,使大家对java集合有个深入的理解. 本篇文章主要具体介绍了Collection接口,Map接口以及Collection接口的三个子接口Set ...
单列变双列css_css 两列布局中单列定宽单列自适应布局的6种思路
前面的话说起自适应布局方式,单列定宽单列自适应布局是最基本的布局形式.本文将从float.inline-block.table.absolute.flex和grid这六种思路来详细说明如何巧妙地实现 ...
java-集合-Map(双列)——迪迦重制版，2021Java开发社招面试解答之性能优化
3.举例: 4.创建Map集合的对象: 5.所有方法: 6.Map注意事项: 二.HashMap(让我们来具体看看这Map星云把我迦迷得不要不要的小妖精) 1.盖亚!!!(无不无聊-)-概述: 2.可 ...
JAVA 基础之容器集合（Collection和Map）
目录前言一.Collection集合 1.1List集合 1.1.1ArrayList集合 1.1.2LinkedList集合 1.2Set集合 1.2.1HashSet集合 HashSet集合保 ...
java 双列集合Map 万字详解
目录一.前言二.概述三.特点四.常用方法 1. V put(K key, V value) : Δ代码演示 : 2. V get(Object key) : Δ代码演示 : 3. V remo ...
集合（Collection和Map）
Hash(散列函数) Hash,一般翻译做散列.杂凑,或音译为哈希,是把任意长度的输入通过散列算法变换成固定长度的输出,该输出就是散列值.这种转换是一种压缩映射,也就是,散列值的空间通常远小于输入的空 ...

容器集合——Collection(单列)、Map（双列）