Java学习：集合双列Map

最新推荐文章于 2023-12-13 09:26:46 发布
最新推荐文章于 2023-12-13 09:26:46 发布
阅读量133 收藏
点赞数
文章标签： java 数据结构与算法
原文链接：http://www.cnblogs.com/cainiao-chuanqi/p/11223283.html
版权

数据结构

数据结构：

数据结构_栈：先进后出

  • 入口和出口在同一侧

数据结构_队列：先进先出

  • 入口和出口在集合的两侧

数据结构_数组：

  • 查询快：数组的地址是连续的，我们通过数组的首地址可以找到数组，通过数组的索引可以快速的查找某一个元素。
  • 增删慢：数组的长度是固定的，我们想要增加/删除一个元素，必须创建一个新数组，把原数组的数据复制过来
例：
int[] arr = new int[]{1,2,3,4};

要把数组索引是3的元素删除

  • 必须创建一个新的数组，长度是原数组的长度-1
  • 把原数组的其它元素复制到新数组中
  • 在新数组的地址赋值给变量arr
  • 原数组会在内存中被销毁（垃回收收）

数据结构_链表：

  • 查询慢：链表中地址不是连续的，每次查询元素，都必须从头开始查询。
  • 增删快：链结构，增加/删除一个元素，对链的整体结构没有影响，所以增删快

链表中的每一个元素也称之为一个节点
一个节点包含了一个数据源(存储数组)，两指针域(存储地址)

  • 单向链：链中只有一条链，不能保证元素的顺序（存储元素和取出元素的顺序可能不一致）
  • 双向链：链中有两链，有一条链是专门记录元素的顺序，是一个有序的集合

二叉树：分支不能超过两

  • 排序树/查找树：在二叉树的基础上，元素是有大小顺序的（左子树小，右子树大）
  • 平衡树:左孩子和右孩子相等
  • 不平衡树:左孩子和右孩子不相等

红黑树：
特点：趋近于平衡树，查询的速度非常的快，查询叶子节点最大次数和最小次数不能超过2倍
约束：

  1. 节点可以是红色的或者是黑色的
  2. 根节点是黑色的
  3. 叶子节点（空节点）是黑色的
  4. 每个红色的节点的子节点都是黑色的
  5. 任何一个节点到其每一个叶子节点的所有路径上黑色节点数相等

List接口

java.util.list接口 extends Collection接口

List接口的特点：

  1. 有序的集合，存储元素和取出元素的顺序是一致的（存储123 取出123）
  2. 有索引，包含了一些带索引的方法
  3. 允许存储重复的元素

List接口中带索引的方法（特有）：

public void add(int index,E element):将指定的元素，添加到该集合中的指定位置上。
public E get(int index):返回集合中指定位置的元素。
public E remove(int index):移除列表中指定位置的元素，返回的是被移除的元素。
public E set(int index,E element):用指定元素替换集合中指定位置的元素，返回值的更新前的元素。

注意：
操作索引的时候，一定要防止索引越界异常

  • IndexOutOfBoundsException:索引越界异常，集合会报
  • ArrayIndexOutOfBoundsException:数组索引越界异常
  • StringIndexOutOfBoundsException:字符串索引越界异常
//创建一个List集合对象，多态
    List<String> list = new ArrayList<>();
    {
        //public void add(int index,E element):将指定的元素，添加到该集合中的指定位置上。
        //在索引2和索引3之间添加一个cainiao
        list.add(3,"cainiao");//{a,b,c,d}-->{a,b,c,cainiao,d}
        //移除元素
        String removeE = list.remove(2)
        //替换元素
        String setE = list.set(4,"A");
        }

List的子类

  • ArrayList集合

java.util.ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。

  • LinkedList集合

java.util.LinkedList集合数据存储的结构是链结构。方便元素添加，删除的集合。

java.util.LinkedList集合 implements List接口

ArrayList集合的特点：

  1. 底层是一个链的结构：查询慢，增删快
  2. 里边包含了大量操作首尾元素的方法

注意：
使用ArrayList集合特有的方法，不能使用多态

  • public void addFirst(E e):将指定元素插入此列表的开头
  • public void addLast(E e):将指定元素添加到此列表的结尾
  • public void addpush(E e):将元素推如此列表所表示的推栈
  • public E getFirst():返回此列表的第一个元素。
  • public E getLast():返回此列表的最后一个元素。
  • public E removeFirst():移除并返回此列表的第一个元素。
  • public E removeLast():移除并返回此列表的最后一个元素。
  • public E pop():从此列表所表示的推栈处弹出一个元素。相当于removeFirst
  • public boolean isEmpty():如果列表不包含元素，则返回true

Vector集合

Vector 类可以实现可增长的对象数组。
与新collection不同，Vector是同步的。

Set接口

java.util.Set接口 extends Collection接口

Set接口的特点：

  1. 不允许存储重复的元素
  2. 没有索引，没有带索引的方法，也不能使用普通的for循环遍历
java.util.HashSet集合 implements Set接口

HashSet特点：

  1. 不允许存储重复的元素
  2. 没有索引，没有带索引的方法，也不能使用普通的for循环遍历
  3. 是一个无序的集合，存储元素和取出元素的顺序有可能不一致
  4. 底层是一个哈希表结构(查询的速度非常快)
Set<Integer> set = new HashSet<>();
//使用add方法往集合中添加元素
set.add(1);
set.add(3);
set.add(2);
set.add(1);
//使用迭代器遍历Set集合
Iterator<Integer> it = set.iterator();
while(it.hasNext(){
    Iterator n = it.next();
    System.out.println(n);//1,2,3 无序且不重复
}

HashSet集合存储数据的结构（哈希表）

哈希值：是一个十进制的整数，由系统随机给出（就是对象的地址值，是一个逻辑地址，是模拟出来得到的地址，不是数据实际存储的物理地址）
在Object类有一个方法，可以获取对象的哈希值

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

HashCode方法的源码：

public native int hashCode();
native:代表该方法调用的是本地操作系的的方法

哈希表

哈希表：hashSet集合存储数据的结构
jdk1.8版本之前：哈希表 = 数组+链表
jdk1.8版本之后：

  • 哈希表 = 数组+链表；
  • 哈希表 = 数组+红黑树（提高查询的速度）

哈希表的特点：速度快

存储数据到集合中，先计算元素的哈希值

  • abc:96354 在数组的存储位置
  • 重地——通话：1179395 两元素不同，但是哈希值相同 哈希冲突


数组结构：把元素进行了分组（相同哈希值的元素是一组）

链表/红黑树结构：把相同哈希值的元素连到一起（如何链表的长度超过了8位，那么就会把链转换位红黑树（提高查询的速度））

Set集合存储元素不重复的原理

Set集合存储元素不重复的元素的前提：

前提:存储的元素必须重写hashCode方法和equals方法

//创建HashSet集合对象
HashSet<String> set = new HashSet<>();//哈希表：数组+链表/红黑树 
String s1 = new String("abc");
String s2 = new String("abc");

set.add(s1);
set.add(s2);
set.add("重地");
set.add("通话");
set.add("abc");
System.out.println(set);/[重地，通话，abc]

原因：
Set集合在调用add方法的时候，add方法会调用元素hashCode方法和equals方法，判断元素是否重复

HashSet存储自定义类型元素

Set集合报错元素原因：
存储的元素（String，Integer,...Student,Person...),必须重写hashCode方法和equals方法

LinkedHashSet集合

java.util.LinkedHashSet集合 extends HashSet集合

LinkedHashSet集合特点:
底层是一个哈希表（数组+链表/红黑树+链表：多了一条链（记录元素的存储顺序），保存元素有序

HashSet<String> set = new HashSet<>();//[]无序，不允许重复
LinkedHashSet<String> set = new LinkedHashSet<>();[]//有序，不允许重复

可变参数

可变参数：是JDK1.5 之后出现的新特性

使用前提：

  • 当方法的参数列表数据类型已经确定，但是参数的个数不确定，就可以使用可变参数。

使用格式：定义方法时使用

  • 修饰符 返回值类型 方法名（数据类型...变量名){}

可变参数的原理：

  • 可变参数底层就是一个数组，根据传递参数个数不同，会创建不同长度的数组，来存储这些参数
  • 传递的参数个数，可以是0个 （不传递），1，2...多个

可变参数的注意事项：

  1. 一个方法的参数列表，只能有一个可变参数
  2. 如果方法的参数有多个，那么可变参数必须写在参数列表的末尾
public static void method(String b, double c ,int d ,int...a){}

//可变参数的特殊（终极）写法
public static void method(Object...obj){}

Collections集合工具类的方法
java.util.Collections是集合工具类，用来对集合进行操作。部分方法如下：
    public static <T> void sort(List<T> List ,Comparator<? super T>):将集合中元素按照指定规则排序。
    
    Comparator和Comparable的区别
        Comparable：自己（this）和别人（参数）比较，自己需要实现Comparable接口，重写比较的规则compareTo方法
        Comparator:相当于找一个第三方的裁判，比较两
        
    Comparator的排序规则：
        o1-o2:升序

Map集合

Collection接口: 定义了单列集合规范 Collection<E>

  • 每次存储一个元素 单个元素

Map接口：定义了双列集合的规范 Map<K,V>

  • 每次存储一对元素

java.util.Map<K,V>集合

Map集合的特点：

  1. Map集合是一个双列集合，一个元素包含两值（一个key，一个value）
  2. Map集合中的元素，key和value的数据类型可以相同，也可以不同
  3. Map集合中的元素，key是不允许重复的，value是可以重复的
  4. Map集合中的元素，key和value是一一对应的
java.util.HashMap<K,V>集合 implements Map<K,V>接口

HashMap集合的特点：
1.HashMap集合底层是哈希值：查询的速度特别的快

  • JDK.8之前：数组+单向链表
  • JDK.8之后：数组+单向链表/红黑树（链表的长度超过8）：提高查询的速度

2.HashMap集合是一个无序的集合，存储元素和取出元素的顺序有可能不一致

java.util.LinkedHashMap<k,v>集合 extends HashMap<K,V>集合

LinkedHashMap的特点：

  1. LinkedHashMap集合底层是哈希表+链表（保证迭代的顺序）
  2. LinkedHashMap集合是一个有序的集合，存储元素和取出元素的顺序是一致的

Map接口中的常用方法

public V put (K key,V value):把指定的键与指定的值添加到Map集合中。

返回值：v

  • 存储键值对的时候，key不重复，返回值V是null
  • 存储键值对的时候，key重复，会使用新的value替换map中重复的value，返回被替换的value值

public V remove（Object key）：把指定的值 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
返回值：V

  • key存在，v返回被删除的值
  • key不存在，v返回null

public V get(Object key)根据指定的键，在Map集合中获取对应的值。
返回值：

  • key存在，返回对应的value值
  • key不存在，返回null

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

  • 包含返回true，不包含返回false

Map集合的第一种遍历方式：通过键找值的方式

Map集合中的方法：

  • Set<K> keySet() 返回此映射中包含的键的 Set 视图。

实现步骤：

  1. 使用Map集合中的方法keySet(),把Map集合所有的key取出来，存储到一个Set集合中。
  2. 遍历Set集合，获取Map集合中的每一个Key
  3. 通过Map集合中的方法get（key），通过key找到value

Entry键值对对象

Map.Entry<K,V>:在Map接口中有一个内部接口Entry
作用：当Map集合一创建，那么就会在Map集合中创建一个Entry对象，用来记录键与值（键值对对象,键与值的映射关系)

Map集合遍历的第二种方式：使用Entry对象遍历

Set<Map.Entry<K,V> entrySet() 返回此映射中包含的键的 Set 视图。
实现步骤：

  1. Set<Map.Entry<K,V>> entrySet(): 把Map集合内部的多个Entry对象取出来存储到一个Set集合中
  2. 遍历Set集合：获取Set集合中的每一个Enter对象
  3. 获取Entry对象中的方法：getKey()获取key，getValue() 获取value

HashMap存储自定义类型键值

key：Person类型

  • Person类型必须重写hashCode方法和equals方法，以保证key唯一

value：String类型

  • 可以重复
java.util.linkedHashMap<K,V> extends HashMap<K,V>

Map 接口的哈希表和链表列表实现，具有可预知的迭代顺序。

底层原理：

  • 哈希表+链表（记录元素的顺序）

Hashtable集合

java.util.Hashtable<K,V>集合 implements Map<k,V>接口
  • Hashtable：底层也是一个哈希表，是一个线程安全的集合，是单线程集合，速度慢
  • HashMap：底层是一个哈希表，是一个线程不安全的集合，是多线程的集合，速度快
  • HashMap集合（之前学的所有集合）：可以存储null值，null键
  • Hashtable集合：不能存储null值，null键
  • Hashtable集合和Vector集合一样，在jdk1.2版本之后被更先进的集合（HashMap，ArrayList)取代了
  • Hashtable的子类properties依然活跃在历舞台
  • Properties集合是一个唯一和I/O流相结合的集合

练习：

  • 计算一个字符串中每一个字符出现的次数

分析：
1.使用Scanner获取用户输入的字符串
2.创建Map集合，key是字符串中的字符，value是字符的个数
3.遍历字符串，获取每一个字符
4.使用获取到的字符，去Map集合判断key是否存在

  • key存在：
通过字符（key），获取value（字符个数）
value++
put(key,value)把新的value存储到Map集合中
  • Key不存在：
put（key，1）

5.遍历Map集合，输出结果

    public class CaiNiao{
        public static void main(String[] args){
            //1.使用Scanner获取用户输入的字符串
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入一个字符串：");
            String str = sc.next();
            //2.创建Map集合，key是字符串中的字符，value是字符的个数
            HashMap<Character.Integer> map = new HashMap<>();
            //3.遍历字符串，获取每一个字符
            for(char c : str.toCharArray()){
                //4.使用获取到的字符，去Map集合判断key是否存在
                if(map.containsKey(c)){
                    //key存在 
                    Integer value = map.get(c);
                    value++;
                    map.put(c,value);
                }else{
                    //key不存在 
                    map.put(c,1);
                }
            }
            //5.遍历Map集合，输出结果
            for(Character key : map.keySet(){
                Integer value = map.get(key);
                System.out.println(key+"="+value);
            }    
        }
    }

JDK9对集合添加的优化

JDK9的新特性：

  • list接口，Set接口，Map接口：里边增加了一个静态的方法of，可以给集合一次性添加多个元素
  • static <E> List<E> of (E... elements)

使用前提：

  • 当集合中存储的元素的个数已经确定了，不在改变时使用

注意：

  1. of方法只适用于list接口，set接口，Map接口，不适用于接口的实现类
  2. 2of方法的返回值是一个不能改变的集合，集合不能再使用add，put方法添加元素，会抛出异常
  3. 3Set接口和Map接口在调用of方法的时候，不能有重复的元素，否则会抛出异常

Debug追踪

Debug调试程序：

  • 可以让代码逐行执行，查看代码执行的过程，调试程序中出现的bug

使用方式：

  • 在行号的右边，鼠标左键单击，添加断点（每个方法的第一行，哪里有bug添加到哪里）
  • 右键，选择Debug执行程序
  • 程序就会停留在添加的第一个断点处

执行程序：

  • f8:逐行执行程序
  • f7:进入到方法中
  • shift + f8:跳出方法
  • f9：跳到下一个断点，如果没有下一个断点，那么就结束程序
  • ctrl + f2：退出debug模式，停止程序

斗地主综合案例：有序版本（双列）

  • 1.准备牌
  • 2.洗牌
  • 3.发牌
  • 4.排序
  • 5.看牌

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class CaiNiao{
    public static void main(String[] args){
    //1.准备牌
    //创建一个Map集合，存储牌的索引和组装好的牌
    HashMap<Integer,String> poker = new HashMap<>();    
    //创建一个List集合，存储花色和牌索引
    ArrayList<Integer> pokerIndex = new ArrayList<>();
    //定义两个数组，一个数组存储牌的花色，一个数组存储牌的序号
    String[] colors = {"?","?","?","??"};
    String[] numbers = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
    //先把大王和小王存储到集合中
    //定义一个牌的索引
    int index = 0;
    poker.put(index,"大王");
    pokerIndex.add(index);
    index++;
    poker.put(index,"小王");
    pokerIndex.add(index);
    index++;

    //循环嵌套遍历两个数组，组装52张牌
    for(String numbers:numbers){
        for (String color : colors){
            poker.put(index.color+number);
            pokerIndex.add(index);
            index++;
        }
    }
    //    System.out.println(poker);
    //    System.out.println(pokerIndex);
    
    /*
    2.洗牌
    使用集合的工具类Collections中的方法
    static void shuffle(List<?> list) 使用默认的随机源对指定列表进行置换。
    
    */
    Collections.shuffle(poker);
    //System.out.println(poker)；
    
    /*
    3.发牌
    */
    //定义4 个集合，存储玩家的牌和底牌
    ArrayList<String> player01 = new ArrayList<>();
    ArrayList<String> player02 = new ArrayList<>();
    ArrayList<String> player03 = new ArrayList<>();
    ArrayList<String> dipai = new ArrayList<>();
    /*
    遍历poker集合，获取每一张牌
    使用poker集合的索引%3给3个玩家轮流发牌
    剩余3张牌给底牌
    注意：
        先判断底牌(i>51),否则牌就发没了
    
    */
    for(int i = 0;i<poker.size();i++){
        //获取每一张牌
        String p = poker.get(i);
        //轮流发牌
        if(i>=51){
            //给底牌发牌
            diPai.add(p);
        }else if (i%3==0){
            //给玩家1发牌
            player01.add(p);
        }else if (i%3==1){
            //给玩家2发牌
            player02.add(p);
        }else if(i%3==2){
            //给玩家3发牌
            player03.add(p);
        }
    }
    
    /*
        4.排序
        使用Collectio中的方法sort(List)
        默认是升序排序
    */
    Collection.sort(player01);
    Collection.sort(player02);
    Collection.sort(player03);
    Collection.sort(dipai);
    
    
    
        //5.看牌
    lookpoker("刘德华：",poker,player01);
    lookpoker("周润发：",poker,player02);
    lookpoker("周星驰：",poker,player03);
    lookpoker("底牌 ：",poker,dipai);

    }
    /*
        定义一个看牌方法，提高代码的复用性
        参数：
            String name:玩家名称
            HashMap<Integer，String> poker:存储牌的poker集合
            ArrayList<Integer> List:存储玩家和底牌的list集合
        查表法：
            遍历玩家或者底牌集合，获取牌的索引
            使用牌的索引，去Map集合中，找到对应的牌

    */
    
    public static void lookpoker(String name ,HashMap<Integer,String> poker,ArrayList<Integer> list){
        //输出玩家名称，不换行
        System.out.println(name + "；");
        //遍历玩家或者底牌集合，获取牌的索引
        for(Integer key : list){
            //使用牌的索引，去Map集合中，找到对应的牌
            String value = poker.get(key);
            System.out.println(value+"");
        }
        System.out.println();//打印完每一个玩家的牌，换行
    }
    

}

 

转载于:https://www.cnblogs.com/cainiao-chuanqi/p/11223283.html

weixin_30394333
关注
【Java学习】第23节：集合类 - Map(HashMap、TreeMap)&源码解析
m0_46013789的博客
05-23 1388
Java是一种广泛使用的编程语言，由Sun Microsystems（现在是Oracle Corporation）首次推出。它是一种跨平台的编程语言，意味着您可以编写一次代码，然后在多个不同的计算机系统上运行，而无需对其进行修改。Java被广泛用于开发各种类型的应用程序，包括企业级应用、移动应用、Web应用、游戏等。
9 Java数据结构（下）：集合进阶之Map(双列集合)系列、不可变集合、操作集合的Stream流：Map接口、HashMap实现类、LinkedHashMap实现类、TreeMap实现类9
最新发布
smalltorch的博客
08-28 745
双列集合的特点（1）双列集合一次需要存一对数据，分别为键和值（2）键不能重复，值可以重复（3）键和值是一一对应的，每一个键只能找到自己对应的值（4）键＋值这个整体我们称之为“键值对”或者“键值对对象”，在Java中叫做“Entry对象”在双列集合的体现中，一个接口、三个实现类HashMap底层是哈希表结构的。
Java集合---Map（双列）集合
zyl1112的博客
10-28 285
集合类的特点 提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变 我们要学习集合那首先得知道集合的体系结构： 集合的体系图： 通过图可以看出集合分为单列集合和双列集合，我们这里主要将双列集合。 ...
Java——双向map BiMap
热门推荐
小欣儿的专栏
08-08 1万+
BiMap是guava中一个有用的集合类型，很简单，它就是一个双向的映射。 反向转换一个Map 一个普通的map是一个key/value的集合，你可以使用key来查询value，例如，我来创建一个字段： · Map<String,String> britishToAmerican = Maps.newHashMap(); britishToAmerican.put("auberg...
Map(双列集合)
weixin_34090562的博客
11-10 60
出现的原因：现实生活中有些数据成对存在。 特点：键不可重复，值可以重复。 ----------|Map 数据都是以键值对的形式存在，键唯一，值可重复。 -------------|HashMap 基于哈希表实现的。 存储原理： 往hashMap添加元素的时候，首先会调用键的hashCode()方法，得到该元素的哈希值，根据哈希值算出在哈...
java双向集合Map
qq_44761778的博客
11-10 1005
java Map集合
双key值map java_java Map 一个key其实可以保存多个value
weixin_35205982的博客
02-16 2034
该楼层疑似违规已被系统折叠隐藏此楼查看此楼java Map 一个key其实可以保存多个value http://www.bieryun.com/553.html我们平时使用的Map，都是只能在Map中保存一个相同的Key，我们后面保存的相同的key都会将原来的key的值覆盖掉，如下面的例子。package test62;import java.util.HashMap;import java.u...
java集合详解(双列集合Map)——全网最通俗易懂的讲解
扬帆天涯
12-13 452
Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。Collection中的集合称为单列集合，Map中的集合称为双列集合。需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。Map中常用的集合为HashMap集合、LinkedHashMap集合。Map接口中常用集合概述。
Java源码分析：集合-容器.pdf
04-02
双列集合则是指Map接口的集合，它存储的是键值对映射关系。 首先，Set集合是一个不允许重复元素的集合，它有多种实现方式，其中包括HashSet、TreeSet和LinkedHashSet。HashSet是基于HashMap实现的，其元素存储在...
双列集合(Map集合)
naoguoteng的博客
05-25 485
针对于键值对应关系的数据，Java为了我们方便操作，给我们提供了另外一种集合叫做Map 专门存储键值对应关系的数据。Map集合是一个不同于Conllection集合的集合，它们之间也没有什么联系。 键对应关系的数据：一个键只能对应一个值，键相同，值覆盖。 ...
转： java 双向map
weixin_34362991的博客
03-30 230
package tools; import java.util.HashMap; public class DuplexMap<K,V> { class Entry{ K k; V v; public Entry(K k,V v){ this.k=k; t...
【集合】Map(双列集合)
bug制造者
09-13 130
Map集合的数据结构仅仅针对键有效，与值无关。 存储的是键值对形式的元素，键唯一，值可重复。 HashMap 底层数据结构是哈希表。线程不安全，效率高 哈希表依赖两个方法：hashCode()和equals() 执行顺序 首先判断hashCode()值是否相同 是：继续执行equals(),看其返回值 true:说明元素重复，不添加 false:就直接添加到集合 否：就直接添加到集合 ...
java 之双列集合Map
qq_38808348的博客
01-24 448
Map是双列集合的根接口 1.是以键值对的形式存在 key --value 2. 键值对保持唯一 //map中的添加方法 HashMap map = new Hashmap<>(); map.put("as",20); Integer a = map.put("as",18); map.put("ad",19); //如果添加相同的key后面的那个value会替 换前面那个key的value
集合 -双列集合(Map)
reallllbj的博客
03-31 302
文章目录二. 集合2.双列集合(Map)2.1 集合概述:2.2 Map常用子类（HashMap）2.2.1 HashMap2.2.2 LinkedHashMap2.3 Map接口中的常用方法2.4 Map集合遍历键找值方式2.4.1 Entry键值对对象2.4.2 Map集合遍历键值对方式 二. 集合 2.双列集合(Map) 2.1 集合概述: IP地址与主机名，身份证号与个人，系统用户名与系统...
javaAPI(Map双列集合）
SG的专栏
07-19 611
Map集合成员方法增加功能V put(K key, V value)返回的是被覆盖的值当key在集合中不存在时，添加元素；当key在集合存在时候，替换元素 删除功能 void clear 清除所有键值对数据 V remove(Object key) 根据指定的键删除键值对 判断功能 boolean
【我的Java笔记】Map集合（双列集合）
午后红茶
11-18 353
Map集合（接口） 1.Map集合的概述： 将键映射到值的对象，一个映射不能包含重复的键，每个键最多只能映射到一个值 2.格式：Map K——键的类型 V——映射的值的类型 3.Map集合的功能概述： （1）添加功能 ： V put(K key,V value):添加元素。这个其实还有另一个功能?替换 如果键是第一次存储，就直接存储元素，返回null 如果键不是
java两个key的map_JAVA对两个map进行处理
weixin_42364551的博客
02-27 2378
我有两个map的大致结构如下：【idmap】111 aaa113 bbb114 ccc115 aaa116 ddd【shamap】:1 aaa2 bbb3 ccc4 ddd需要得到的结果是：1 aaa 1112 bbb 1133 ccc 1141 aaa 1154 ddd 116 这种的。就是说，shamap里面存的是没有重复的,然后每个value都对应一个序列1，2,3.....我需要做的其实就...
集合框架(Map双列集合)
a18622032257的博客
10-22 420
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------   Map集合与Collection集合却是Map是双列集合,Collection是单列集合 Map的键唯一,Collection的子体系Set是唯一的 Map集合的数据结构值针对键有效，跟值无关;Collection集合的数据结构是针对元素有效 首先还是来看下集合的体系图方便学习:
java双列集合
weixin_54718480的博客
04-16 225
键值对对象（Entry）
Java集合框架入门：单列与双列集合详解
集合主要分为单列集合（Collection）和双列集合（Map）。" 在Java编程中，集合框架扮演着核心角色，它允许开发者动态地存储和管理多个对象。标题和描述提及的"java基础知识 java集合"是指Java集合框架，这是Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值