Java语言的Map集合、Debug追踪、模拟斗地主的洗牌与发牌

最新推荐文章于 2022-07-15 16:45:54 发布
最新推荐文章于 2022-07-15 16:45:54 发布
阅读量168 收藏
点赞数
分类专栏： Java语言进阶 文章标签： java 链表 hashmap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Williams10/article/details/108408654
版权

第一章 Map集合

1.1 概述

在这里插入图片描述java.util.Map<k,v>集合
Map集合的特点:
1.Map集合是一个双列集合,一个元素包含两个值(一个key,一个value)
2.Map集合中的元素,key和value的数据类型可以相同,也可以不同
3.Map集合中的元素,key是不允许重复的,value是可以重复的
4.Map集合中的元素,key和value是一一对应

1.2 Map常用子类

java.util.HashMap<k,v>集合
java.util.HashMap<k,v>集合 implements Map<k,v>接口
HashMap集合的特点:
1.HashMap集合底层是哈希表:查询的速度特别的快
JDK1.8之前:数组+单向链表
JDK1.8之后:数组+单向链表|红黑树(链表的长度超过8):提高查询的速度
2.hashMap集合是一个无序的集合,存储元素和取出元素的顺序有可能不一致

java.util.LinkedHashMap<k,v>集合
java.util.LinkedHashMap<k,v>集合 extends HashMap<k,v>集合
LinkedHashMap的特点:
1.LinkedHashMap集合底层是哈希表+链表(保证迭代的顺序)
2.LinkedHashMap集合是一个有序的集合,存储元素和取出元素的顺序是一致的

tips：Map接口中的集合都有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同。

1.3 Map接口中的常用方法

Map接口中定义了很多方法，常用的如下：

  • public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
  • public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
  • public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
  • boolean containsKey(Object key) 判断集合中是否包含指定的键。
  • public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
  • public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。
import java.util.HashMap;
import java.util.Map;

public class Demo01Map {
    public static void main(String[] args) {
        show01();
    }

    /*
      public V put(K key, V value):  把指定的键与指定的值添加到Map集合中。
          返回值:v
              存储键值对的时候,key不重复,返回值V是null
              存储键值对的时候,key重复,会使用新的value替换map中重复的value,返回被替换的value值
   */
    private static void show01() {
        //创建 Map集合对象，多态
        Map<String,String> map = new HashMap<>();

        String v1 = map.put("海绵宝宝","派大星1");
        System.out.println("v1:" + v1);//v1:null

        String v2 = map.put("海绵宝宝","派大星2");
        System.out.println("v2:" + v2);//v2:派大星1

        System.out.println(map);//{海绵宝宝=派大星2}

        map.put("猴子","猩猩");
        map.put("狮子","老虎");
        map.put("长臂猿","猩猩");
        System.out.println(map);//{猴子=猩猩, 海绵宝宝=派大星2, 狮子=老虎, 长臂猿=猩猩}
    }
}

tips:

使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中；

若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。

1.4 Map集合遍历键找值方式在这里插入图片描述

键找值方式：即通过元素中的键，获取键所对应的值
Map集合的第一种遍历方式:通过键找值的方式。
Map集合中的方法:
Set keySet() 返回此映射中包含的键的 Set 视图。
实现步骤:
1.使用Map集合中的方法keySet(),把Map集合所有的key取出来,存储到一个Set集合中
2.遍历set集合,获取Map集合中的每一个key
3.通过Map集合中的方法get(key),通过key找到value

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Demo02KeySet {
    public static void main(String[] args) {
        //创建Map集合对象
        Map<String,Integer> map = new HashMap<>();
        map.put("泰勒",180);
        map.put("沈梦辰",170);
        map.put("惠若琪",195);

        //1.使用Map集合中的方法keySet(),把Map集合所有的key取出来,存储到一个Set集合中
        Set<String> set = map.keySet();

        // 2.遍历set集合,获取Map集合中的每一个key
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            String key = it.next();
            //3.通过Map集合中的方法get(key),通过key找到value
            Integer value = map.get(key);
            System.out.println(key+ "=" + value);
        }
        System.out.println("===============");
        //使用增强for遍历Set集合
        for (String key : set) {
            //3.通过Map集合中的方法get(key),通过key找到value
            Integer value = map.get(key);
            System.out.println(key + "=" + value);
        }
        System.out.println("================");
        //使用增强for遍历Set集合
        for (String key : set) {
            //3.通过Map集合中的方法get((key),通过key找到value
            Integer value = map.get(key);
            System.out.println(key + "=" +value);
        }
    }
}

1.5 Entry键值对对象

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

Map集合中的方法:
Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射关系的 Set 视图。

实现步骤:
1.使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来,存储到一个Set集合中
2.遍历Set集合,获取每一个Entry对象
3.使用Entry对象中的方法getKey()和getValue()获取键与值

public class Demo03EntrySet {
    public static void main(String[] args) {
        //创建Map集合
        Map<String,Integer> map = new HashMap<>();
        map.put("泰勒",180);
        map.put("沈梦辰",170);
        map.put("惠若琪",195);

        //1.使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来,存储到一个Set集合中
        Set<Map.Entry<String,Integer>> set = map.entrySet();

        //2.遍历Set集合,获取每一个Entry对象
        //使用迭代器遍历Set集合
        Iterator<Map.Entry<String, Integer>> it = set.iterator();
        while (it.hasNext()) {
            Map.Entry<String, Integer> entry = it.next();
            //3.使用Entry对象中的方法getKey()和getValue()获取键与值
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + "=" + value);
        }
        System.out.println("=================");
        //使用增强for遍历Set集合
        for (Map.Entry<String, Integer> entry : set) {
            //3.使用Entry对象中的方法getKey()和getValue()获取键与值
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + "=" + value);
        }
    }
}

1.6 Map集合遍历键值对方式在这里插入图片描述

1.7 HashMap存储自定义类型键值 HashMap存储自定义类型键值

Map集合保证key是唯一的:
作为key的元素,必须重写hashCode方法和equals方法,以保证key唯一。

import java.util.Objects;

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    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;
    }
}

import java.util.HashMap;
import java.util.Set;

public class Demo01HashMapSavePerson {
    public static void main(String[] args) {
        show01();
    }

    /*
        HashMap存储自定义类型键值
        key:String类型
            String类重写hashCode方法和equals方法,可以保证key唯一
        value:Person类型
            value可以重复(同名同年龄的人视为同一个)
     */
    private static void show01() {
        //创建HashMap集合
        HashMap<String,Person> map = new HashMap<>();
        //往集合中添加元素
        map.put("深圳",new Person("小宝",16));
        map.put("哈尔滨",new Person("小祥",18));
        map.put("上海",new Person("英子",21));
        map.put("深圳",new Person("二蛋",16));
        //使用keySet加增强for遍历Map集合
        Set<String> set = map.keySet();
        for (String key : set) {
            Person value = map.get(key);
            System.out.println(key + "-->" + value);
        }
    }
}
  • 当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法(如果忘记，请回顾HashSet存放自定义对象)。
  • 如果要保证map中存放的key和取出的顺序一致，可以使用java.util.LinkedHashMap集合来存放。

1.8 LinkedHashMap

在HashMap下面有一个子类LinkedHashMap，它是链表和哈希表组合的一个数据存储结构。

java.util.LinkedHashMap<K,V> entends HashMap<K,V>
Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。
底层原理:
哈希表+链表(记录元素的顺序)

import java.util.HashMap;
import java.util.LinkedHashMap;

public class Demo01LinkedHashMap {
    public static void main(String[] args) {
        HashMap<String,String> map = new HashMap<>();
        map.put("a","a");
        map.put("e","e");
        map.put("d","d");
        map.put("a","f");
        System.out.println(map);//key不允许重复，无序{a=f, d=d, e=e}

        LinkedHashMap<String,String> linked = new LinkedHashMap<>();
        linked.put("a","a");
        linked.put("e","e");
        linked.put("d","d");
        linked.put("a","f");
        System.out.println(linked);//key不允许重复，有序{a=f, e=e, d=d}
    }
}

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集合是一个唯一和IO流相结合的集合

import java.util.HashMap;
import java.util.Hashtable;

public class Demo02Hashtable {
    public static void main(String[] args) {
        HashMap<String,String> map = new HashMap<>();
        map.put(null,"a");
        map.put("b",null);
        map.put(null,null);
        System.out.println(map);//{null=null, b=null}

        Hashtable<String,String> table = new Hashtable<>();
       //table.put(null,"a");//NullPointerException
       //table.put("b",null);//NullPointerException
       table.put(null,null);//NullPointerException
    }
}

1.9 Map集合练习

练习:
计算一个字符串中每个字符出现次数

分析:
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集合,输出结果
在这里插入图片描述

import java.util.Calendar;
import java.util.HashMap;
import java.util.Scanner;

public class Demo03MapTest {
    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);
        }
    }
}

第二章 补充知识点

2.1 JDK9对集合添加的优化

JDK9的新特性:
List接口,Set接口,Map接口:里边增加了一个静态的方法of,可以给集合一次性添加多个元素
static List of​(E… elements)
使用前提:
当集合中存储的元素的个数已经确定了,不在改变时使用
注意:
1.of方法只适用于List接口,Set接口,Map接口,不适用于接接口的实现类
2.of方法的返回值是一个不能改变的集合,集合不能再使用add,put方法添加元素,会抛出异常
3.Set接口和Map接口在调用of方法的时候,不能有重复的元素,否则会抛出异常

import java.util.List;
import java.util.Map;
import java.util.Set;

public class Demo01JDK9 {
    public static void main(String[] args) {
        List<String> list = List.of("e","f","e","g","h");
        System.out.println(list);//[e, f, e, g, h]
        //list.add("l");//UnsupportedOperationException:不支持操作异常

        //Set<String> set = Set.of("e","f","e","g","h");//IllegalArgumentException:非法参数异常,有重复的元素
        Set<String> set  = Set.of("e","f","g","h");//[g, f, e, h]
        System.out.println(set);
        //set.add("l");//UnsupportedOperationException:不支持操作异常

       // Map<String,Integer> map = Map.of("张三", 17, "李四", 20, "王五", 21,"张三",18);//IllegalArgumentException:非法参数异常,有重复的元素
        Map<String,Integer> map = Map.of("张三", 17, "李四", 20, "王五", 21);
        System.out.println(map);//{李四=20, 王五=21, 张三=17}
        //map.put("赵四",45);;//UnsupportedOperationException:不支持操作异常
    }
}

2.2 Debug追踪

使用IDEA的断点调试功能，查看程序的运行过程
Debug调试程序:
可以让代码逐行执行,查看代码执行的过程,调试程序中出现的bug
使用方式:
在行号的右边,鼠标左键单击,添加断点(每个方法的第一行,哪里有bug添加到哪里)
右键,选择Debug执行程序
程序就会停留在添加的第一个断点处
执行程序:
F8:逐行执行程序
F7:进入到方法中
Shift+F8:跳出方法
F9:跳到下一个断点,如果没有下一个断点,那么就结束程序
ctrl+F2:退出debug模式,停止程序
Console:切换到控制台

        public class Demo01Debug {
        public static void main(String[] args) {
        /*int a = 10;
        int b = 20;
        int sum = a + b;
        System.out.println(sum);*/

        /*for (int i = 0; i <3 ; i++) {
            System.out.println(i);
        }*/

            print();

        }

        private static void print() {
            System.out.println("HelloWorld");
            System.out.println("HelloWorld");
            System.out.println("HelloWorld");
            System.out.println("HelloWorld");
            System.out.println("HelloWorld");
        }
    }

第三章 模拟斗地主洗牌发牌

3.1 案例介绍

在这里插入图片描述

3.3 实现代码步骤

斗地主综合案例:有序版本
1.准备牌
2.洗牌
3.发牌
4.排序
5.看牌

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.Callable;

public class DouDiZhu {
    public static void main(String[] args) {
        //1.准备牌
        //创建一个Map集合,存储牌的索引和组装好的牌
        HashMap<Integer,String> poker = new HashMap<>();
        //创建一个List集合，存储牌的索引
        ArrayList<Integer> pokerIndex = new ArrayList<>();
        //定义两个集合，存储花色和牌的序号
        List<String> colors = List.of("♠", "♥", "♣", "♦");
        List<String> numbers = List.of("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 number : numbers) {
            for (String color : colors) {
                poker.put(index,color+number);
                pokerIndex.add(index);
                index++;
            }
        }
        //System.out.println(poker);
        //System.out.println(pokerIndex);

        /*
            2.洗牌
            使用Collections中的方法shuffle(List)
         */
        Collections.shuffle(pokerIndex);
        //System.out.println(pokerIndex);

        /*
            3.发牌
         */
        //定义4个集合,存储玩家牌的索引,和底牌的索引
        ArrayList<Integer> player01 = new ArrayList<>();
        ArrayList<Integer> player02 = new ArrayList<>();
        ArrayList<Integer> player03 = new ArrayList<>();
        ArrayList<Integer> diPai =new ArrayList<>();
        //遍历存储牌索引的List集合,获取每一个牌的索引
        for (int i = 0; i < pokerIndex.size(); i++) {
            Integer in = pokerIndex.get(i);
            //先判断底牌
            if (i>=51) {
                //给底牌发牌
                diPai.add(in);
            }else if (i%3==0) {
                //给玩家1发牌
                player01.add(in);
            }else if(i%3==1){
                //给玩家2发牌
                player02.add(in);
            }else if(i%3==2){
                //给玩家3发牌
                player03.add(in);
            }
        }

         /*
            4.排序
            使用Collections中的方法sort(List)
            默认是升序排序
         */
     Collections.sort(player01);
     Collections.sort(player02);
     Collections.sort(player03);
     Collections.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集合中,找到对应的牌
     */

    private static void lookPoker(String name,HashMap<Integer,String> poker,ArrayList<Integer> list) {
        //输出游戏玩家名称，不换行
        System.out.print(name+":");
        //遍历玩家或者底牌集合，获取牌的索引
        for (Integer key : list) {
            //使用牌的索引，去Map集合中，找到对应的牌


            String value = poker.get(key);
            System.out.print(value+"");
        }
        System.out.println();//打印完每一个玩家的牌,换行
    }
}
Williams10
关注
专栏目录
数据结构—Map集合
且将&的博客
12-05 545
数据结构，hashMap
Java——Map集合、Map集合遍历键找值方式、Entry键值对对象、HashMap存储自定义类型键值、LinkedHashMap
m0_52196529的博客
10-26 1404
Java——Map集合、Map集合遍历键找值方式、Entry键值对对象、HashMap存储自定义类型键值、LinkedHashMap、Java代码计算一个字符串中每个字符出现次数
数据结构之Map集合
鲜衣怒马楼兰月
05-20 757
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...
map集合
hou_yi_tao的博客
06-08 479
1、集合框架Map介绍 遍历方式一 通过键找值： 获取所有键的集合，然后遍历键的集合，获取到每一个键，接着根据键找值 Map<String, String> map=new HashMap<>(); map.put("bb", "13"); map.put("aa", "12"); map.put("cc", "14"); map.put("dd", "15...
JAVA 数据结构 集合map
qq_43141232的博客
07-08 274
map: public static void main(String[] args) { Map<String, String> m = new HashMap<>(); m.put("001","aa"); m.put("002","bb"); m.put("003","ccc"); //key相同时会将值覆盖 m.put("003","ccdc"); System.
Map集合架构总结
weixin_30883777的博客
04-07 118
说明;这里先学习Map集合，然后再学习Set集合，是因为Set集合中的HashSet依赖于hashMap,就是通过hashMap集合来实现的，TreeSet集合依赖于TreeMap集合，TreeSet集合就是通过TreeMap实现的。基于此，先学习Map集合框架和比较重要的Map实现类。 1、Map集合框架的总体介绍 如图所示是Map集合的整体架构图： ...
Java基础学习系列--（六）【Map集合,HashMapTreeMap,斗地主、图书管理系统，排序算法】
*** 喵桑_Rachel ***
03-27 831
day06【Map】 第一章 Map集合 1.1 概述 现实生活中，我们常会看到这样的一种集合：IP地址与主机名，身份证号与个人，系统用户名与系统用户对象等，这种一一对应的关系，就叫做映射。Java提供了专门的集合类用来存放这种对象关系的对象，即java.util.Map接口。 我们通过查看Map接口描述，发现Map接口下的集合与Collection接口下的集合，它们存储数据的形式不同，如下图。 Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。 M
15 Map接口（HashMap、LinkedHashMap）、keySet()方式遍历、Entry方式遍历、HashTable、of方法、Debug追踪、模拟斗地主、统计字符串中字符出现次数
Birdlun的博客
08-26 412
目录 Map集合 MaMap常用子类 Map接口中的常用方法 HashMap 列：HashMap集合实现put（）、remave（）、get（）方法 列：HashMap（）遍历：keySet()-->将键存储到set集合中 列：使用Entry对象遍历 列：HashMap存储对象 列: 计算一个字符串中每个字符出现次数 LinkedHashMap Hashtable JDK9对集合添加的优化 列：接口.of()方法使用、Collections集合工具类中addAll...
java高级 Map集合
bbbeddd的博客
08-18 157
1 Map<K ，V>集合：与Collection接口不同的是，每次存储的都是一对元素，也就是 K（key键）和V（value值）这一对，他们之间的关系称之为映射。 映射的规则：键是唯一的，值可以重复，但是一个键只能对应一个值。 2Map接口的常用实现类： 1HashMap<K,V>集合:底层是哈希表，查询快，无序的，多线程，不安全，可存储null ...
第十一章、集合_Collection/泛型/斗地主案例（单列）/数据结构/List/Set/Collections/Map/斗地主案例（双列）_黑马Java第57期个人学习笔记_个人笔记
91健的博客
09-05 659
第十一章：集合【Collection、泛型、斗地主案例（单列）、数据结构、List集合、Set集合、Collections工具类、Map集合、Debug调试、斗地主案例（双列）】 第一节、Collection集合 一、集合 （一）概述 1、集合：集合是java中提供的一种容器，可以用来存储多个数据。 2、集合和数组的区别 （1）数组的长度是固定的。...
集合详解—Map集合
qq_44346427的博客
03-04 2735
Map集合
数据结构与算法-Map集合
逍遥云恋
10-18 327
代码示例 package *; /** * @program: data-structure * @description: * @author: ChenWenLong * @create: 2019-09-10 11:13 **/ public class MyMap<T,K> { //键值对数组 Entry[] array; int size...
常用数据集合—Map
pydlxh的博客
06-10 379
1、实现Map的类 2、数据结构 数组 + 链表(红黑树） 3、HashMap源码 构造函数 tableSizeFor决定了集合大小均是2的指数幂 所有集合存储方式都是在添加元素时决定了数据结构，所以接下来看下put 如果要将hash冲突用红黑树存储，数组长度小于64则要扩容，因为hash冲突严重 2、节点数据结构 3、get和remove就比较简单这里就省略了吧 4、线程安全的Map ，HashTable、ConcurrentHashMap Ha.
java map集合加数据结构_Java集合（List，Set，Map）
weixin_42421284的博客
02-25 281
一List1.常见的数据结构1. 数组(ArrayList)2. 链表(LinkedList)3. 堆栈 特点FILO(先进后出)4. 队列(先进先出)1.集合框架的体系1.继承体系：Collection(所有集合类接口的超级接口)|--List:特点 有序(添加的顺序)可以重复的数据|--ArrayList ：查询和修改效率高，但是删除和插入效率低。(线程不安全)|--LinkedList ：...
map数据结构
JSON_J的博客
07-15 1814
关于map的用法及与Object区别
Map集合
小菜鸟的博客
01-30 311
1.Map集合概述  Map用于保存具有映射关系的数据，因此Map集合里保存着两组值，一组值用于保存Map里的key，另外一组用于保存Map里的value，key和value都可以是任何引用类型的数据。Map的key不允许重复，即同一个Map对象的任何两个key通过equals()方法比较总是返回false。 1.1Map接口中的常用方法     a.put方法：将指定的键与值对
Java数据结构和Map集合（笔记）
m0_52893000的博客
06-08 159
数据结构 数据结构的常用数据结构有：栈，数组，队列，链表，红黑树 栈(stack又称堆栈) 它是运算受限的运算表，其限制是仅允许在标的一端进行插入和删除操作，不允许在其他任何位置进行添加、查找、删除等操作 特点 1.先进后出（弹夹） 2.栈的出入口都是栈的顶端位置 队列(queue，简称队) 他跟堆栈一样，也是运算受限的运算表，其限制是仅允许在表的一端进行插入，而在表的另一端删除 特点 1.先进先出（火车过山洞） 2.队列的入口、出口各占一侧 数组(Array) 是有序的元素序
java容器---Map集合的体系结构
u011521890的专栏
10-25 1504
Map集合的共性方法：     K - 此映射所维护的键的类型     V - 映射值的类型     增     put(K key, V value)     putAll(Map m)     删     remove(Object key)     判断     containsKey(Object key) 是否包含指定键     containsValue(Ob
Map集合结构的理解 [java]
m0_57001006的博客
12-08 148
Map结构的理解: Map中存储的是键值对(也就是key — value),但是具体的key和value是如何存储的? Map中对于键值对不是一个一个key和value单独进行存储的,而是通过先将key和value这两个值封装成为一Entry对象 key和value作为我们的Entry中的两个属性 底层是一个一个Entry对象进行存储的 所以我们也说我们的Map集合的底层是通过Entry[]进行存储的. 也就是我们使用put(K key, V value)方法在HashMap对象中添加元素时,
java利用集合完成斗地主的洗牌 发牌 排序 看牌功能
最新发布
05-25
下面是利用Java集合实现斗地主的洗牌、发牌、排序和看牌功能的示例代码： ```java import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.List; import java....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值