Map接口-HashMap、HashTable＜K,V＞、LinkedHashMap、TreeMap。Collections类-概述、成员方法、练习斗地主

最新推荐文章于 2024-01-09 11:30:31 发布

Tony-1fan

最新推荐文章于 2024-01-09 11:30:31 发布

阅读量151

点赞数

分类专栏： java 文章标签： java hashmap 字符串

本文链接：https://blog.csdn.net/qq_39497997/article/details/113360545

版权

java 专栏收录该内容

34 篇文章 1 订阅

订阅专栏

文章目录

1 Map集合
2 HashMap
3 Hashtable

1 Map集合

1.1 概述

将键映射到值的对象。 Map不能包含重复的键; 每个键可以映射到最多一个值。

1.2 Map集合和Collection集合区别？

Map集合存储元素的时候都是成对出现的。Map集合的键是唯一的。值可以重复。—双列集合
Collection集合存储元素的时候是单独出现的。Collection的子接口List是可重复的
Set是唯一的。—单列集合。
Map集合的数据结构都针对的是键，只对键有效，根值无关。
Collection集合的数据结构针对元素。

1.3 Map集合的方法

添加
V put(K key, V value) 添加元素。这个方法还有另外一个功能。
如果键是第一次出现，就是存储元素，返回null
如果键不是第一次出现，就用值把之前的值替换掉了，返回的是被替换的值。
void putAll(Map<? extends K,? extends V> m) 添加指定Map集合中的所有元素
删除
void clear() 从该Map中删除所有的键值对元素
V remove(Object key) 删除指定键值对元素，返回被删除的值
default boolean remove(Object key, Object value) 根据指定的键值对删除元素
判断
boolean containsKey(Object key) 如果此映射包含指定键的映射，则返回 true 。
boolean containsValue(Object value) 如果此地图将一个或多个键映射到指定的值，则返回 true 。
boolean isEmpty() 如果此地图不包含键值映射，则返回 true 。
获取
Set<Map.Entry<K,V>> entrySet() 返回此地图中包含的映射的Set视图。
V get(Object key) 返回到指定键所映射的值，
Set keySet() 返回此地图中包含的键的Set视图。
int size() 返回此地图中键值映射的数量。
Collection values() 返回此地图中包含的值的Collection视图。
替换
default V replace(K key, V value) 只有当目标映射到某个值时，才能替换指定键的条目。
default boolean replace(K key, V oldValue, V newValue)
仅当当前映射到指定的值时，才能替换指定键的条目。

package com.momo.demo;

import java.util.HashMap;
import java.util.Map;

/*
* Map集合方法
* */
public class Demo9 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<>();
       /* //添加方法
        System.out.println(map.put("马蓉","宝强"));
        System.out.println(map.put("冠希","阿娇"));
        System.out.println(map.put("马蓉","宋吉吉"));
        System.out.println(map);*/
        map.put("宝强","马蓉");
        map.put("冠希","阿娇");
        map.put("文章","马伊利");
        map.put("默默","倩倩");
        System.out.println(map);
       // System.out.println(map.size());

       /* Map<String,String> map2 = new HashMap<>();
        map2.putAll(map);
        System.out.println(map2);*/

       //删除功能
       // map.clear();
        //String value = map.remove("小宝");
        //String value = map.remove("文章");
        //System.out.println(value);

       // boolean boo = map.remove("小宝", "默默");
       // boolean boo = map.remove("宝强","玛丽");
        //boolean boo = map.remove("hahh","马蓉");
       /* boolean boo = map.remove("宝强","马蓉");
        System.out.println(boo);*/
        //System.out.println(map);

        //判断
        /*System.out.println(map.containsKey("小宝"));
        System.out.println(map.containsKey("默默"));*/

        /*System.out.println(map.containsValue("小宝"));
        System.out.println(map.containsValue("马伊利"));*/

       /* System.out.println(map.isEmpty());
        map.clear();
        System.out.println(map.isEmpty());*/
       // map = null;
       // System.out.println(map.isEmpty());
    }
}

package com.momo.demo;

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

/*
* Map集合方法
* */
public class Demo10 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<>();
        map.put("宝强","马蓉");
        map.put("冠希","阿娇");
        map.put("文章","马伊利");
        map.put("默默","倩倩");
        map.put("冠希","马蓉");
        System.out.println(map);

       /* System.out.println(map.get("小宝"));
        System.out.println(map.get("默默"));*/
        //System.out.println(map.size());

        /*Set<String> keys = map.keySet();
        for(String key:keys){
            System.out.println(key);
        }*/

        Collection<String> values = map.values();
        for(String value:values){
            System.out.println(value);
        }
    }
}

package com.momo.demo;

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

/*
* Map方法
*   获取了键值对对象集合
*   Set<Map.Entry<String, String>> entries = map.entrySet();
*
* Map.Entry:键值对对象
*   Map集合中的键值对
*       K getKey()
        返回与此条目相对应的键。
        V getValue()
        返回与此条目相对应的值。

 * */
public class Demo11 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<>();

        map.put("宝强","马蓉");
        map.put("冠希","阿娇");
        map.put("文章","马伊利");
        map.put("默默","倩倩");
        System.out.println(map);
        System.out.println("------------");
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for(Map.Entry<String, String> entry:entries){
           // System.out.println(entry);
            System.out.println(entry.getKey()+"---"+entry.getValue());
        }
    }
}

package com.momo.demo;

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

/*
* Map集合的遍历
* 方式一：根据键值对对象获取键和值
*   获取所有的键值对对象集合
*   遍历集合获取每一个键值对对象
*   根据键值对对象获取键和值
* 思路：
*   先获取所有的结婚证
*   遍历拿到每一个结婚证
*   根据结婚证获取男人和女人
*
*
* 方式二：根据键获取值
*   获取所有的键集合
*   遍历集合，获取每一个键
*   根据键获取值
* 思路：
*   把所有的男人集中到一起
*   每次叫一个男人出来
*   让男人自己去找他的女人
* */
public class Demo12 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<>();

        map.put("宝强","马蓉");
        map.put("冠希","阿娇");
        map.put("文章","马伊利");
        map.put("默默","倩倩");

        //方式一
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for(Map.Entry<String, String> entry:entries){
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+":"+value);
        }
        System.out.println("------------");
        //方式二
        Set<String> keys = map.keySet();
        for(String key:keys){
            String value = map.get(key);
            System.out.println(key+"::"+value);
        }
    }
}

package com.momo.demo;

import java.util.HashMap;
import java.util.Map;

public class Demo13 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<>();

        map.put("宝强","马蓉");
        map.put("冠希","阿娇");
        map.put("文章","马伊利");
        map.put("默默","倩倩");
        System.out.println(map);

        /*System.out.println(map.replace("宝强","哈哈"));
        System.out.println(map.replace("小宝","哈尼"));*/
        System.out.println(map.replace("宝强","mama","asa"));
        System.out.println(map.replace("宝强","马蓉","asa"));
        System.out.println(map);
    }
}

2 HashMap

2.1，概述

-基于哈希表的实现的Map接口，可以保证键的唯一
-无序唯一，允许null的值和null键
-不同步，线程不安全，效率高。

2.2 构造方法

HashMap()
HashMap(int initialCapacity)
HashMap(Map<? extends K,? extends V> m)

2.3 成员方法

刚才都讲过了

2.4 HashMap练习

分别存储不同类型的键和值，遍历
HashMap<String,String>
HashMap<Integer,String>
HashMap<String,Student>
HashMap<Student,String>

package com.momo.demo;

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

public class Demo14 {
    public static void main(String[] args) {
        HashMap<Integer,String> hh = new HashMap<>();
        hh.put(101,"小宝");
        hh.put(102,"小米");
        hh.put(103,"小默");
        hh.put(101,"宝宝");

        /*hh.put(001,"小宝");
        hh.put(002,"小米");
        hh.put(003,"小默");
        hh.put(001,"宝宝");*/

        Set<Integer> keys = hh.keySet();
        for(Integer it:keys){
            System.out.println(it+":"+hh.get(it));
        }
    }
}

package com.momo.demo;

import com.momo.domain.Tea;

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

public class Demo15 {
    public static void main(String[] args) {
        HashMap<String, Tea> hh = new HashMap<>();
        Tea t1 = new Tea("王昭君",18);
        Tea t2 = new Tea("西施",22);
        Tea t3 = new Tea("貂蝉",24);
        Tea t4 = new Tea("陈圆圆",25);

        hh.put("110",t1);
        hh.put("120",t2);
        hh.put("111",t3);
        hh.put("115",t4);

        Set<String> strings = hh.keySet();
        for(String s:strings){
            Tea t = hh.get(s);
            System.out.println(s+"::"+t.getName()+"::"+t.getAge());
        }
    }
}

package com.momo.demo;

import com.momo.domain.Tea;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
//自定义对象作为键的时候，要保证唯一，需要重写方法，自动生成即可。
public class Demo16 {
    public static void main(String[] args) {
        HashMap<Tea, String> hh = new HashMap<>();
        Tea t1 = new Tea("王昭君",18);
        Tea t2 = new Tea("西施",22);
        Tea t3 = new Tea("貂蝉",24);
        Tea t4 = new Tea("陈圆圆",25);
        Tea t5 = new Tea("西施",22);

        hh.put(t1,"110");
        hh.put(t2,"120");
        hh.put(t3,"130");
        hh.put(t4,"140");
        hh.put(t5,"110");

        Set<Map.Entry<Tea, String>> entries = hh.entrySet();
        for(Map.Entry<Tea, String> entry:entries){
            Tea t = entry.getKey();
            String value = entry.getValue();
            System.out.println(t.getName()+","+t.getAge()+"--"+value);
        }

    }
}

3 Hashtable<K,V>

3.1 和HashMap基本一样

但是HashTable安全的，不允许null值和null键

3.2 把HashMap的练习用Hashtable做一遍就行了

4 LinkedHashMap<K,V>

4.1 概述

哈希表和链表实现的Map接口，具有可预测的迭代次序。
有序（存取顺序），唯一，不同步

4.2 构造方法

LinkedHashMap()
LinkedHashMap(int initialCapacity)
LinkedHashMap(Map<? extends K,? extends V> m)

4.3 成员方法

常用的也都说过了

4.4 练习

存储不同类型的键和值，遍历

package com.momo.demo;

import java.util.LinkedHashMap;
import java.util.Set;

public class Demo17 {
    public static void main(String[] args) {
        LinkedHashMap<Integer,String> hh = new LinkedHashMap<>();
        hh.put(1,"aa");
        hh.put(2,"bb");
        hh.put(3,"cc");
        hh.put(1,"dd");

        Set<Integer> integers = hh.keySet();
        for (Integer key:integers){
            System.out.println(key+"---"+hh.get(key));
        }
    }
}

5 TreeMap

5.1 概述

一个红黑树基于NavigableMap实现，保证键的唯一和排序
排序依然有2中：取决于所使用的构造方法
自然排序
比较器排序

5.2 构造方法

TreeMap()
TreeMap(Comparator<? super K> comparator)
TreeMap(Map<? extends K,? extends V> m)

5.3 成员方法

常用的也都说过了，它里面还有一些没有讲过的方法，也都很简单，自己玩，不会的问我。

package com.momo.demo;

import java.util.Set;
import java.util.TreeMap;

public class Demo18 {
    public static void main(String[] args) {
        TreeMap<Integer,String> tt = new TreeMap<>();

        tt.put(5,"龙五");
        tt.put(1,"发哥");
        tt.put(2,"龙五");
        //tt.put(5,"adf");

        Set<Integer> integers = tt.keySet();
        for(Integer key:integers){
            String value = tt.get(key);
            System.out.println(key+"---"+value);
        }
    }
}

package com.momo.demo;

import com.momo.domain.Tea;

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

/*
* TreeMap<String,Tea>
* */
public class Demo19 {
    public static void main(String[] args) {
        TreeMap<String, Tea> tt = new TreeMap<>();
        Tea t1 = new Tea("王昭君",18);
        Tea t2 = new Tea("西施",22);
        Tea t3 = new Tea("貂蝉",24);
        Tea t4 = new Tea("陈圆圆",25);
        Tea t5 = new Tea("西施",22);

        tt.put("101",t1);
        tt.put("105",t2);
        tt.put("103",t3);
        tt.put("104",t4);
        tt.put("102",t5);

        Set<Map.Entry<String, Tea>> entries = tt.entrySet();
        for(Map.Entry<String, Tea> entry:entries){
            String key = entry.getKey();
            Tea t = entry.getValue();
            System.out.println(key+":"+t.getName()+":"+t.getAge());
        }
    }
}

package com.momo.demo;

import com.momo.domain.Tea;

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

/*
 * TreeMap<Tea,String>
 * */
public class Demo20 {
    public static void main(String[] args) {
        //使用无参构造，默认使用自然排序
        //自定义对象作为键，要能够进行自然排序，需要实现自然排序接口
        TreeMap<Tea, String> tt = new TreeMap<>();
        Tea t1 = new Tea("王昭君",18);
        Tea t2 = new Tea("西施",22);
        Tea t3 = new Tea("貂蝉",24);
        Tea t4 = new Tea("陈圆圆",25);
        Tea t5 = new Tea("西施",22);

        tt.put(t1,"111");
        tt.put(t2,"222");
        tt.put(t3,"333");
        tt.put(t4,"444");
        tt.put(t5,"555");

        Set<Tea> teas = tt.keySet();
        for(Tea t:teas){
            String value = tt.get(t);
            System.out.println(t.getName()+"::"+t.getAge()+"::"+value);
        }
    }
}

package com.momo.domain;
//自然排序自定义类需要实现该接口
public class Tea implements Comparable<Tea>{
    private String name;
    private int age;

    public Tea() {
    }

    public Tea(String name, int age) {
        this.name = name;
        this.age = 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;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Tea)) return false;

        Tea tea = (Tea) o;

        if (age != tea.age) return false;
        return name != null ? name.equals(tea.name) : tea.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

    @Override
    //最终根据这个方法的返回值决定顺序，和是否要存储
    public int compareTo(Tea o) {
        //按年龄
        int i = this.age-o.age;
        //年龄一样，比较姓名
        int ii = i ==0?this.name.compareTo(o.name):i;
        return ii;
    }
}

package com.momo.demo;

import com.momo.domain.Tea;

import java.util.Comparator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

/*
 * TreeMap<Tea,String>
 * */
public class Demo21 {
    public static void main(String[] args) {
        //使用带参构造，用比较器排序
      /*  TreeMap<Tea, String> tt = new TreeMap<>(new Comparator<Tea>() {
            @Override
            public int compare(Tea o1, Tea o2) {
                //年龄
                int i = o1.getAge()-o2.getAge();
                //姓名
                int ii = i == 0?o1.getName().compareTo(o2.getName()):i;
                return ii;
            }
        });*/

        TreeMap<Tea, String> tt = new TreeMap<>(
                (o1, o2) ->{
                //年龄
                int i = o1.getAge()-o2.getAge();
                //姓名
                int ii = i == 0?o1.getName().compareTo(o2.getName()):i;
                return ii; }
        );

        Tea t1 = new Tea("王昭君",18);
        Tea t2 = new Tea("西施",22);
        Tea t3 = new Tea("貂蝉",24);
        Tea t4 = new Tea("陈圆圆",25);
        Tea t5 = new Tea("西施",22);

        tt.put(t1,"111");
        tt.put(t2,"222");
        tt.put(t3,"333");
        tt.put(t4,"444");
        tt.put(t5,"555");

        Set<Tea> teas = tt.keySet();
        for(Tea t:teas){
            String value = tt.get(t);
            System.out.println(t.getName()+"::"+t.getAge()+"::"+value);
        }
    }
}

package com.momo.domain;

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

    public Tea() {
    }

    public Tea(String name, int age) {
        this.name = name;
        this.age = 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;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Tea)) return false;

        Tea tea = (Tea) o;

        if (age != tea.age) return false;
        return name != null ? name.equals(tea.name) : tea.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

}

6 Map集合的练习

6.1 键盘输入一个字符串（之考虑有英文字母组成的字符串），获取字符串中每个字符出现的次数

要求：输出的形式：  
"abcdabcab"  结果：a(3)b(3)c(2)d(1)...
有2种做法

package com.momo.demo;

import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;

/*
* 键盘输入一个字符串（之考虑有英文字母组成的字符串），获取字符串中每个字符出现的次数
	要求：输出的形式：
	"abcdabcab"  结果：a(3)b(3)c(2)d(1)...
	有2种做法
	*
分析：
*   定义一个TreeMap集合
*       键：Character
*       值：Integer
*   把字符串转换成字符数组
*   遍历字符数组获取每一个字符
*   拿每一个字符作为键到集合中找，看有没有这个键，看返回值
*       是null，说明该键不存在，就存入集合，值给1
*       不是null，说明键已经存在，把值+1
*   定义一个字符串缓冲区
*    遍历集合，获取键和值，按照格式拼接
*    把字符串缓冲区编程字符串即可
*
*
* 另外一种做法：
*   定义26个统计变量，遍历字符串。获取每一个字符进行判断。
*   对应的统计变量++。最后拼接输出即可。
* */
public class Demo2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串：");
        String s = sc.nextLine();

        TreeMap<Character,Integer> map = new TreeMap<>();

        char[] chs = s.toCharArray();

        for(char ch:chs){
            Integer value = map.get(ch);

            if(value==null){
                map.put(ch,1);
            }else{
                value++;
                map.put(ch,value);
            }
        }

        StringBuilder sb = new StringBuilder();

        Set<Character> keys = map.keySet();
        for(Character ch:keys){
            Integer value = map.get(ch);

            sb.append(ch).append("(").append(value).append(")");
        }

        String str = sb.toString();

        System.out.println(str);
    }
}

6.2 集合的嵌套遍历

HashMap嵌套HashMap
HashMap嵌套ArrayList
ArrayList嵌套HashMap
HashMap嵌套HashMap嵌套HashMap

package com.momo.demo;

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

/*
* HashMap嵌套HashMap
*
*   前端班级：
*       默默   18
*       小宝   22
*       小倩   20
*
*   java班级：
*       哈尼   16
*       迪丽   26
*       古力   22
* */
public class Demo22 {
    public static void main(String[] args) {
        //创建一个大集合
        HashMap<String,HashMap<String,Integer>> big = new HashMap<>();

        //创建前端班级集合
        HashMap<String,Integer> qd = new HashMap<>();
        //添加元素
        qd.put("默默",18);
        qd.put("小宝",22);
        qd.put("小倩",20);

        //创建java班级集合
        HashMap<String,Integer> java = new HashMap<>();
        //添加元素
        java.put("哈尼",16);
        java.put("迪丽",26);
        java.put("古力",22);

        //把前端班级和java班级存储大集合
        big.put("前端",qd);
        big.put("后端",java);

        //遍历
        Set<String> keys = big.keySet();
        for(String key:keys){
            HashMap<String, Integer> hm = big.get(key);
            Set<String> skeys = hm.keySet();
            for(String skey:skeys){
                Integer value = hm.get(skey);
                System.out.println(key+":"+skey+":"+value);
            }
        }
    }
}

6.3 小问题

-问：HashMap和HashTable的区别？
-问：List，Set，Map等接口是否都继承Collection呢？
-问：常用的集合类有哪些？各自的特点是什么？常用的方法？

7 COllections类

7.1 概述

针对集合操作的工具类
注意：Collection和Collections的区别？

7.2 成员方法

static boolean addAll(Collection<? super T> c, T… elements) 将所有指定的元素添加到指定的集合
static int binarySearch(List<? extends Comparable<? super T>> list, T key) 使用二叉搜索算法搜索指定对象的指定列表
static void reverse(List<?> list) 反转指定列表中元素的顺序
static <T extends Comparable<? super T>> void sort(List list) 根据其元素的natural ordering对指定的列表进行排序
static void shuffle(List<?> list) 使用默认的随机源随机排列指定的列表
static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) 根据其元素的自然顺序返回给定集合的最大元素

package com.momo.demo;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/*
* Collections:集合操作工具了欸
* */
public class Demo23 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
       /* list.add(11);
        list.add(22);*/

        Collections.addAll(list,33,55,22,66,11,44);
        System.out.println(list);

       // Collections.sort(list);
       // System.out.println(list);

        //int i = Collections.binarySearch(list, 22);
      //  System.out.println(i);

       // System.out.println(Collections.max(list));

       /* Collections.reverse(list);
        System.out.println(list);*/

      /* Collections.shuffle(list);
        System.out.println(list);*/

       // List<Integer> list1 = Collections.synchronizedList(list);
    }
}

-练习：使用集合存储自定义对象并使用Collections种的方法进行排序查找。

7.3 练习

使用集合编写代码。模拟斗地主的洗牌，发牌，看牌。
要求：进行排序
2种写法：
一种是用单列集合做
一种是用双列集合做

package com.momo.demo;

import java.util.ArrayList;
import java.util.Collections;

/*
* -练习：使用集合编写代码。模拟斗地主的 洗牌，发牌，看牌。
	要求：进行排序
	2种写法：
		一种是用单列集合做
		一种是用双列集合做
   分析：
   *   牌怎么来？ 牌花色分为：黑红梅方  大小：A 2 3 .  JQK   大王小王
* */
public class Demo3 {
    public static void main(String[] args) {
        //创建一个集合用来存放组装的牌
        ArrayList<String> list = new ArrayList<>();

        //拼接组装一副牌
        //花色  ♠   ♥  ♣  ♦
        String[] colors = {"♠","♥","♣","♦"};
        //大小  A  2  3  .... J   Q  K
        String[] nums = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};

        for(String color:colors){
            for(String num:nums){
                //list.add(color.concat(num));
                list.add(num.concat(color));
            }
        }
        list.add("大🃏");
        list.add("小🃏");

       // System.out.println(list);

        //洗牌
        Collections.shuffle(list);
       // System.out.println(list);

        //发牌：如何一人一张的发牌
        // 把每个人的牌保存起来
        ArrayList<String> 底牌 = new ArrayList<>();
        ArrayList<String> 发哥 = new ArrayList<>();
        ArrayList<String> 刀仔 = new ArrayList<>();
        ArrayList<String> 龙五 = new ArrayList<>();

        for(int i=0;i<list.size();i++){
            if(i>=list.size()-3){
                底牌.add(list.get(i));
            }else if(i%3==0){
                发哥.add(list.get(i));
            }else if(i%3==1){
                刀仔.add(list.get(i));
            }else if(i%3==2){
                龙五.add(list.get(i));
            }
        }

        //排序
        Collections.sort(发哥);
        Collections.sort(刀仔);
        Collections.sort(龙五);
        Collections.sort(底牌);

        //看牌
        System.out.println("发哥:"+发哥);
        System.out.println("刀仔:"+刀仔);
        System.out.println("龙五:"+龙五);
        System.out.println("底牌:"+底牌);
    }
}

Tony-1fan

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Map接口-HashMap、HashTable＜K,V＞、LinkedHashMap、TreeMap。Collections类-概述、成员方法、练习斗地主

Map接口-HashMap、HashTable<K,V>、LinkedHashMap、TreeMap
复制链接

扫一扫

专栏目录