16 集合

数组的不足

初始化时必须指定长度，有可能不足，有可能浪费

List接口的实现类

ArrayList实现了长度可变的数组，在内存中分配连续的空间。遍历元素和随机访问元素的效率比较高
LinkedList采用链表存储方式。插入、删除元素时效率比较高

image.png

如何存储多条狗狗信息，获取狗狗总数，逐条打印出各条狗狗信息？

请输入一条狗的名字，no退出
aa
请输入一条狗的名字，no退出
bb
请输入一条狗的名字，no退出
cc
请输入一条狗的名字，no退出
dd
请输入一条狗的名字，no退出
no
aa
bb
cc
dd
no
退出了

通过List接口的实现类ArrayList实现该需求

    Scanner scanner = new Scanner(System.in);
//    String[] arrays = new String[100000000];
        List<String> listDogs = new ArrayList<>();//创建List集合对象

        while (true)
        {
            System.out.println("请输入一条狗的名字，no退出");
            String dogName = scanner.next();
            listDogs.add(dogName);//向List中添加元素

            if(dogName.equals("no"))
            {
                break;
            }
        }

        //遍历数组
        //listDogs.size()获得集合当前元素的个数
        for(int i = 0; i < listDogs.size(); i++)
        {
            System.out.println(listDogs.get(i));//listDogs.get(i)获得集合中第i个元素的值
        }

        System.out.println("退出了");

扩充以下几部分功能
删除指定位置的狗狗，如第一个狗狗
删除指定的狗狗，如删除feifeiDog对象
判断集合中是否包含指定狗狗

image.png

使用List接口提供的remove()、contains()方法

  Scanner scanner = new Scanner(System.in);
//    String[] arrays = new String[100000000];
        List<String> listDogs = new ArrayList<>();//创建List集合对象

        while (true)
        {
            System.out.println("请输入一条狗的名字，no退出");
            String dogName = scanner.next();

            if(dogName.equals("no"))
            {
                break;
            }
            //判断集合中是否有名字是dogName的狗狗了，如果没有才加，有的话不加
            if(!listDogs.contains(dogName))
            {
                listDogs.add(dogName);//向List中添加元素
            }

        }

        //删除2条狗
        //1.根据位置删除remove
//        listDogs.remove(1);
        //2.根据对象删除remove
        listDogs.remove("abc");

        //遍历数组
        //listDogs.size()获得集合当前元素的个数
        for(int i = 0; i < listDogs.size(); i++)
        {
            System.out.println(listDogs.get(i));//listDogs.get(i)获得集合中第i个元素的值
        }

        System.out.println("退出了");

image.png

List中存放Dog对象

public class Dog {
    private String name;
    private int 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;
    }
}

 public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        List<Dog> dogList = new ArrayList<Dog>();

        while(true)
        {
            System.out.println("请输入一条狗的名字，no退出");
            String dogName = scanner.next();

            if(dogName.equals("no"))
            {
                break;
            }

            Dog dog = new Dog();
            dog.setName(dogName);
            dogList.add(dog);
        }

        //遍历List
        //listDogs.size()获得集合当前元素的个数
        for(int i = 0; i < dogList.size(); i++)
        {
            Dog dog = dogList.get(i);
            System.out.println(dog.getName());//listDogs.get(i)获得集合中第i个元素的值
        }

        System.out.println("退出了");
    }

Map接口

建立国家英文简称和中文全名间的键值映射，并通过key对value进行操作，应该如何实现数据的存储和操作呢？

image.png

Map接口专门处理键值映射数据的存储，可以根据键实现对值的操作
最常用的实现类是HashMap

image.png

Map接口常用方法

image.png

遍历List和Map

for(元素类型t  元素变量x : 数组或集合对象){
         引用了x的java语句
}

练习

1.第一题（Map）利用Map，完成下面的功能：

从命令行读入一个字符串，表示一个年份，输出该年的世界杯冠军是哪支球队。如果该年没有举办世界杯，则输出：没有举办世界杯。

历届世界杯冠军
届数举办年份举办地点冠军
第一届 1930年乌拉圭乌拉圭
第二届 1934年意大利意大利
第三届 1938年法国意大利
第四届 1950年巴西乌拉圭
第五届 1954年瑞士西德
第六届 1958年瑞典巴西
第七届 1962年智利巴西
第八届 1966年英格兰英格兰
第九届 1970年墨西哥巴西
第十届 1974年前西德西德
第十一届 1978年阿根廷阿根廷
第十二届 1982年西班牙意大利
第十三届 1986年墨西哥阿根廷
第十四届 1990年意大利西德
第十五届 1994年美国巴西
第十六届 1998年法国法国
第十七届 2002年韩日巴西
第十八届 2006年德国意大利
第十九届 2010年南非西班牙
第二十届 2014年巴西德国

（Map）在原有世界杯Map 的基础上，增加如下功能：读入一支球队的名字，输出该球队夺冠的年份列表。例如，读入“巴西”，应当输出 1958 1962 1970 1994 2002 读入“荷兰”，应当输出没有获得过世界杯

image.png

package com.company;

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

/**
 * Created by ttc on 2018/1/10.
 */
public class WorldCupDemo {
    public static void main(String[] args) {

        Map<Integer,String> year2country = new HashMap<>();

        year2country.put(1930,"乌拉圭");
        year2country.put(1934,"意大利");
        year2country.put(1938,"意大利");
        year2country.put(1950,"乌拉圭");
        year2country.put(1954,"西德");
        year2country.put(1958,"巴西");
        year2country.put(1962,"巴西");
        year2country.put(1966,"英格兰");
        year2country.put(1970,"巴西");
        year2country.put(1974,"西德");
        year2country.put(1978,"阿根廷");
        year2country.put(1982,"意大利");
        year2country.put(1986,"阿根廷");
        year2country.put(1990,"西德");
        year2country.put(1994,"巴西");
        year2country.put(1998,"法国");
        year2country.put(2002,"巴西");
        year2country.put(2006,"意大利");
        year2country.put(2010,"西班牙");
        year2country.put(2014,"德国");

        Scanner scanner = new Scanner(System.in);
        System.out.println("输入年份");
        int year = scanner.nextInt();

        if(year2country.containsKey(year))
        {
            System.out.println("该年的冠军是" + year2country.get(year));
        }
        else
        {
            System.out.println("该年没有举行世界杯");
        }

        System.out.println("请输入国家名");
        String countryName = scanner.next();
        //遍历map集合，考察每一个元素的value，是否和用户输入的国家一样
        //如果一样，输出和value对应key
        boolean bFind = false;//没有在map中找到该国家
        for(Integer key : year2country.keySet())
        {
            String country = year2country.get(key);
            if(country.equals(countryName))
            {
                System.out.println(key);
                bFind = true;
            }
        }
        //如果前面map遍历一遍之后，bFind的值依然是false，说明map集合中不存在用户输入的国家名
        if(bFind == false)
        {
            System.out.println("该国家没有获得过世界杯冠军");
        }
    }
}

2.第二题已知有十六支男子足球队参加2008 北京奥运会。写一个程序，把这16 支球队随机分为4 个组。采用List集合和随机数

2008 北京奥运会男足参赛国家：

科特迪瓦，阿根廷，澳大利亚，塞尔维亚，荷兰，尼日利亚，日本，美国，中国，新西兰，巴西，比利时，韩国，喀麦隆，洪都拉斯，意大利

提示：分配一个，删除一个

image.png

 public static void main(String[] args) {

        //map，保存最终分组结果
        //key保存的是第几组，value是该组对应的国家集合
        Map<Integer,List<String>> groupNum2Countrys = new HashMap<>();

        List<String> stringList = new ArrayList<>();

        String strCountrys = "科特迪瓦，阿根廷，澳大利亚，塞尔维亚，荷兰，尼日利亚，日本，美国，中国，新西兰，巴西，比利时，韩国，喀麦隆，洪都拉斯，意大利";
        String[] countrys = strCountrys.split("，");

        for(String str : countrys)
        {
            stringList.add(str);
        }

        //分组，分4组

        //分第1组
        //随机从集合中选出一个国家，放到第1组里；然后将这个选出的国家，从原来集合中干掉（删除）
        //重复以上步骤4次

        for(int j = 0; j < 4; j++)
        {
            List<String> lstGroup = new ArrayList<>();

            for(int i = 0; i < 4; i++)
            {
                Random random = new Random();
                int index = random.nextInt(stringList.size());
                String selectCountry = stringList.get(index);//从大集合中选出一个随机的国家
                //把这个国家加入到第一组

                lstGroup.add(selectCountry);
                //然后将这个选出的国家，从原来集合中干掉（删除）
                stringList.remove(selectCountry);
            }

            //以上已经给第一组分配完国家
            //将该组加入到map中
            groupNum2Countrys.put(j+1,lstGroup);
        }
        //输出分组情况
        //遍历map，输出key-value
        for(Integer integer : groupNum2Countrys.keySet())
        {
            System.out.println("第" + integer + "组" );
            List<String> lstCountrys = groupNum2Countrys.get(integer);
            //输出第一组的所有国家名字
           for(String str : lstCountrys)
           {
               System.out.print(str + "\t");
           }
            System.out.println();
        }


        //分第2组
        //随机从集合中选出一个国家，放到第2组里；然后将这个选出的国家，从原来集合中干掉（删除）
        //重复以上步骤4次

        //分第3组
        //随机从集合中选出一个国家，放到第3组里；然后将这个选出的国家，从原来集合中干掉（删除）
        //重复以上步骤4次

        //分第4组
        //随机从集合中选出一个国家，放到第4组里；然后将这个选出的国家，从原来集合中干掉（删除）
        //重复以上步骤4次


    }

3.第三题有如下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）计算各个班级的平均分

image.png

public class Student {
    private String name;

    private int age;

    private int score;

    private String classNum;

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

package com.company;

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

/**
 * Created by ttc on 2018/1/10.
 */
public class StudentList {
    public static void main(String[] args) {

        List<Student> studentList = new ArrayList<>();

        studentList.add(new Student("Tom", 18, 100, "class05"));
        studentList.add(new Student("Jerry", 22, 70, "class04"));
        studentList.add(new Student("Owen", 25, 90, "class05"));
        studentList.add(new Student("Jim", 30,80 , "class05"));
        studentList.add(new Student("Steve", 28, 66, "class06"));
        studentList.add(new Student("Kevin", 24, 100, "class04"));


        //遍历list
        int totalAge = 0;
        for(Student student : studentList)
        {
            totalAge += student.getAge();
        }

        //算平均年龄
        System.out.println("平均年龄"+totalAge/studentList.size());

        //创建一个map保存班级名称和平均分的对应关系
        Map<String,List<Integer>> className2scoreList = new HashMap<>();
//        ["class05":(100,90,80)]
//        ["class04":(70,100)]
//        ["class06":(66)]
        //将学生数据从list结构转变为保存到map结构中

        //遍历list
        for(Student student : studentList)
        {
            //map中是否包含当前班级名称，如果包含，累计该班级分数；否则，将该班级名称和学生分数加入到Map中
            String className = student.getClassNum();
            int score = student.getScore();
            if(className2scoreList.containsKey(className))
            {
                List<Integer> lstScores = className2scoreList.get(className);
                lstScores.add(score);
            }
            else//不包含
            {
                List<Integer> lstScores = new ArrayList<>();
                lstScores.add(score);
                className2scoreList.put(className,lstScores);
            }
        }

        //输出结果
        for(String strName : className2scoreList.keySet())
        {
            System.out.println("班级" + strName);
            //计算该班级的平均分
            List<Integer> lstScores = className2scoreList.get(strName);
            int totalScore = 0;
            for(Integer score:lstScores)
            {
                totalScore += score;
            }

            System.out.println("平均分" + totalScore/lstScores.size());
        }

    }
}

第四题（List）写一个函数reverseList，该函数能够接受一个List，然后把该List 倒序排列。例如：

image.png

 package com.company;

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

/**
 * Created by ttc on 2018/1/11.
 */
public class ReverseList {

    public static void reverseList(List<String> stringList)
    {
        //新建一个list
        List<String> stringList1 = new ArrayList<>();

        int index2 = 1;
        for(String string : stringList)
        {
            //得到倒数第index2个元素
            String strLast = stringList.get(stringList.size() - index2);
            //加到新的list
            stringList1.add(strLast);

            index2++;
        }

        int index3 = 0;
        for(String string : stringList1)
        {
            stringList.set(index3, string);
            index3++;
        }
    }

    public static void printList(List<String> stringList)
    {
        int index = 1;
        for(String string : stringList)
        {
            System.out.print("第" + index + "个元素：");
            System.out.println(string);
            index++;
        }
    }


    public static void main(String[] args) {

        List<String> stringList = new ArrayList<>();

        stringList.add("zhangsan");
        stringList.add("lisi");
        stringList.add("wangwu");
        stringList.add("liuliu");

        System.out.println("反转之前");
        printList(stringList);

        reverseList(stringList);
//        Collections.reverse(stringList);
//        Collections.shuffle(stringList);//随机打乱list集合中的数据


        System.out.println("反转之后");
        printList(stringList);

    }
}

5.第五题（Map）设计Account 对象如下：

 private long id;  

 private double balance;  

 private String password;

要求完善设计，使得该Account 对象能够自动分配id。给定一个List 如下：

List list = new ArrayList(); 

list.add(new Account(10.00, “1234”)); 

list.add(new Account(15.00, “5678”)); 

list.add(new Account(0, “1010”));

要求把List 中的内容放到一个Map 中，该Map 的键为id，值为相应的Account 对象。最后遍历这个Map，打印所有Account 对象的id 和余额。

image.png

package com.company;

import java.util.UUID;

/**
 * Created by ttc on 2018/1/11.
 */
public class Account {
    private String sid;//使用UUID来生成

    private double balance;

    private String password;


    public Account(double balance, String password)
    {
        this.balance = balance;
        this.password = password;
        //自动分配账号
        this.sid = UUID.randomUUID().toString();

    }


    public String getSid() {
        return sid;
    }

    public void setSid(String sid) {
        this.sid = sid;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

package com.company;

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

/**
 * Created by ttc on 2018/1/11.
 */
public class TestAccount {
    public static void main(String[] args) {
        List<Account> accountList = new ArrayList<>();

        accountList.add(new Account(100,"123"));
        accountList.add(new Account(10,"456"));
        accountList.add(new Account(80,"111"));

        //将数据转移到map结构
        Map<String,Account> accountMap = new HashMap<String,Account>();

        for(Account account : accountList)
        {
            accountMap.put(account.getSid(),account);
        }

        for(Map.Entry<String,Account> entry: accountMap.entrySet())
        {
            System.out.println(entry.getKey() + "   " + entry.getValue().getSid());
        }
    }
}

Account的id自增长版本

package com.company;

import java.util.UUID;

/**
 * Created by ttc on 2018/1/11.
 */
public class Account {
//    private String sid;//使用UUID来生成
    private long sid;
    private double balance;

    private String password;

    private static int object_count = 0;

    public Account(double balance, String password)
    {
        this.balance = balance;
        this.password = password;
        //自动分配账号
        //this.sid = UUID.randomUUID().toString();
        //先获得当前本类已经创建了多少个对象
        this.sid = Account.object_count + 1;
        Account.object_count++;

    }


    public long getSid() {
        return sid;
    }

    public void setSid(long sid) {
        this.sid = sid;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

  public static void main(String[] args) {
        List<Account> accountList = new ArrayList<>();

        accountList.add(new Account(100,"123"));//A
        accountList.add(new Account(10,"456"));//B
        accountList.add(new Account(80,"111"));
        accountList.add(new Account(330,"333"));

        //将数据转移到map结构
        Map<Long,Account> accountMap = new HashMap<Long,Account>();

        for(Account account : accountList)
        {
            accountMap.put(account.getSid(),account);
        }

        for(Map.Entry<Long,Account> entry: accountMap.entrySet())
        {
            System.out.println(entry.getKey() + "   " + entry.getValue().getSid());
        }
    }

6.第六题（List）已知有一个Worker 类如下：

public class Worker

 { private int age; 

private String name; 

private double salary; 

public Worker (){} 

public Worker (String name, int age, double salary)

{ this.name = name; 

this.age = age; 

this.salary = salary; } 

public int getAge() { return age; } 

public void setAge(int age) { this.age = age; } 

public String getName() { return name; } 

public void setName(String name) { this.name = name; } 

public double getSalary(){ return salary; } 

public void setSalary(double salary){ this.salary = salary; } 

public void work(){ 

System.out.println(name + “ work”); } }

完成下面的要求

创建一个List，在List 中增加三个工人，基本信息如下：

姓名年龄工资

zhang3 18 3000

li4 25 3500

wang5 22 3200

在li4 之前插入一个工人，信息为：姓名：zhao6，年龄：24，工资3300
删除wang5 的信息
利用for 循环遍历，打印List 中所有工人的信息
利用迭代遍历，对List 中所有的工人调用work 方法。

image.png

List<Worker> workerList = new ArrayList<>();
        workerList.add(new Worker("zhangsan",12,2445));
        workerList.add(new Worker("lisi",32,5445));
        workerList.add(new Worker("wangwu",22,7445));

        Worker worker = new Worker("zhaoliu",33,5645);
        workerList.add(1,worker);

        workerList.remove(3);

        for(int i = 0; i < workerList.size();i++)
        {
            System.out.println(workerList.get(i));
        }

        for(Worker worker1 : workerList){
            worker1.work();
        }

经典练习

一篇英文文章，单词间用空格分割，统计出现了哪些单词，以及每个单词出现的次数。

       public static void main(String[] args) {
        //问题结果

//        this----------2
//        is------------2
//        a-------------2
//        book----------1
//        that----------1
//        desk----------1
        String article = "this this is a book that is a desk";//问题的开始，问题的输入
        String[] words = article.split(" ");
        //Map<String,Integer> key保存的是单词，value保存的是该单词出现的次数
        Map<String,Integer> map = new HashMap<>();

        //this----2
        //考察单词数组中的每一个单词,
        for(int i = 0; i < words.length; i++)
        {
            //考察每一个单词，
            if(map.containsKey(words[i]))//如果map的key中存在该单词,将该单词出现的次数加1
            {
               int count = map.get(words[i]);
               count++;
               map.put(words[i],count);
            }
            else//如果map的key中不存在该单词，将该单词添加到map中
            {
                map.put(words[i],1);
            }
        }

        for(String word : map.keySet())
        {
            System.out.println(word+"--------"+map.get(word));
        }

    }

Set

和LIst类似，主要区别是不能保存重复元素
生成100000个UUID，判断是否有重复的？

 Set<String> stringSetUUID = new HashSet<>();
        for(int i = 0; i < 10000000; i++)
        {
            UUID uuid = UUID.randomUUID();
            stringSetUUID.add(uuid.toString());
        }

        System.out.println(stringSetUUID.size());

扑克模拟问题续

随机发出5张牌，判断牌型

image.png

package com.company;

/**
 * Created by ttc on 2017/12/28.
 */
public class Card {
    private int value;//牌值
    private String color;//花色

    public Card(int value, String color) {
        this.value = value;
        this.color = color;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String toString()
    {
        String str = "";
        if(value == 11)
        {
            str = "J";
        }
        else if(value == 12)
        {
            str = "Q";
        }
        else if(value == 13)
        {
            str = "K";
        }
        else if(value == 1)
        {
            str = "A";
        }
        else
        {
            str = value+"";
        }
        return color+str;
    }

}

package com.company;

import java.util.*;


/**
 * Created by ttc on 2017/12/28.
 */
public class Poker {
    List<Card> cards = new ArrayList<Card>();
    private String[] colors = {"红桃", "方片", "黑桃","草花"};
    private int[] values = {1,2,3,4,5,6,7,8,9,10,11,12,13};

    public Poker()
    {
        //初始化，创建52张扑克牌
        //红桃13张 1，2，3...
        //方片13张
        //外层循环生成花色
        //里层循环生成牌值

        for(int i = 0; i < colors.length; i++)
        {
            for(int j = 0; j < values.length; j++)
            {
                Card  card = new Card(values[j],colors[i]);
//                card.setColor(colors[i]);
//                card.setValue(values[j]);

                cards.add(card);
            }
        }
    }

    //洗牌方法
    public void shuffle()
    {
        Collections.shuffle(cards);
    }

    //打印扑克中的每一张牌
    public void output()
    {
        System.out.println(cards);

    }
    //发一手牌
    public List<Card> takeHands()
    {
        List<Card> cardList = new ArrayList<>();

        //把cards的前5张牌放到cardList里
        int count = 0;
        for(Card card : cards)
        {
            cardList.add(card);
            count++;
            if(count == 5)
            {
                break;
            }
        }

        return cardList;
    }

    //判断牌型
    public String judgeType(List<Card> cardList)
    {
        boolean isSameColor = false;//是否同花
        boolean isShunZi = false;//是否顺子

        String strType = "";

        Set<String> setColors = new HashSet<>();

        for(Card card : cardList)
        {
            setColors.add(card.getColor());
        }

        if(setColors.size() == 1)
        {
            isSameColor = true;
//            System.out.println("同花");
        }


        //5张牌，排好序，（最后一张减去第一张 == 4 && 把5张牌放到set中，set.size（）== 5）
        Set<Integer> setValues = new HashSet<>();
        List<Integer> listValues = new ArrayList<>();

        for(Card card : cardList)
        {
            int value = card.getValue();
            setValues.add(value);
            listValues.add(value);
        }

        Collections.sort(listValues);

        int between = listValues.get(4) - listValues.get(0);
        if(between == 4 && setValues.size() == 5)
        {
            isShunZi = true;
//            System.out.println("顺子");
        }

        if(isSameColor == true && isShunZi == true)
        {
            strType = "同花顺";
//            System.out.println("同花顺");
        }
        else if(isSameColor == true)
        {
            strType = "同花";
//            System.out.println("同花");
        }
        else if(isShunZi == true)
        {
            strType = "顺子";
//            System.out.println("顺子");
        }
        else if(setValues.size() == 5)
        {
            strType = "杂牌";
//            System.out.println("杂牌");
        }
        else if(setValues.size() == 4)
        {
            strType = "一对";
//            System.out.println("一对");
        }
        else if(setValues.size() == 3)
        {
//            System.out.println("两对或3条");

//            System.out.println("四带一或三带二");
            Map<Integer, Integer> mapCardValue2Counts = new HashMap<>();
            //将5张牌从list结构转化到map中
            for(Card card: cardList)
            {
                //map的key中是否包含当前牌的值，如果包含,拿出当前牌值已经出现的次数
                if(mapCardValue2Counts.containsKey(card.getValue()))
                {
                    int count = mapCardValue2Counts.get(card.getValue());
                    count++;
                    mapCardValue2Counts.put(card.getValue(),count);
                }
                else//不包含
                {
                    mapCardValue2Counts.put(card.getValue(),1);
                }
            }
//            (9,3),(5,1),(3,1)
//            (13,2),(5,2),(2,1)
            for(Map.Entry<Integer, Integer> entry : mapCardValue2Counts.entrySet())
            {
                if(entry.getValue() == 3)
                {
                    strType = "三带一";
//                    System.out.println("三带一");
                    break;

                }
                else if(entry.getValue() == 2)
                {
                    strType = "两对";
//                    System.out.println("两对");
                    break;
                }
            }
        }
        else if(setValues.size() == 2)
        {
//            System.out.println("四带一或三带二");
            Map<Integer, Integer> mapCardValue2Counts = new HashMap<>();
            //将5张牌从list结构转化到map中
            for(Card card: cardList)
            {
                //map的key中是否包含当前牌的值，如果包含,拿出当前牌值已经出现的次数
                if(mapCardValue2Counts.containsKey(card.getValue()))
                {
                   int count = mapCardValue2Counts.get(card.getValue());
                   count++;
                   mapCardValue2Counts.put(card.getValue(),count);
                }
                else//不包含
                {
                    mapCardValue2Counts.put(card.getValue(),1);
                }
            }
//            (4,4),(9,1)
//            (3,3),(10,2)
            for(Map.Entry<Integer, Integer> entry : mapCardValue2Counts.entrySet())
            {
                if(entry.getValue() == 4)
                {
                    strType = "四带一";
//                    System.out.println("四带一");
                    break;
                }
                else if(entry.getValue() == 3)
                {
                    strType = "三带二";
//                    System.out.println("三带二");
                    break;
                }
            }

        }



        return strType;
    }




}

package com.company;

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

public class Main {

    public static void main(String[] args) {
    // write your code here

        Poker poker = new Poker();
        poker.output();


//        poker.shuffle();//洗牌
        System.out.println();
        poker.output();

//        List<Card> cardList = poker.takeHands();

        List<Card> cardList = new ArrayList<>();
        Card card = new Card(5,"黑桃");
        cardList.add(card);
        card = new Card(5,"红桃");
        cardList.add(card);
        card = new Card(9,"草花");
        cardList.add(card);
        card = new Card(8,"草花");
        cardList.add(card);
        card = new Card(8,"方片");
        cardList.add(card);

        System.out.println(cardList);

        String type = poker.judgeType(cardList);
        System.out.println(type);
    }

}

最后编辑于：2020.09.17 18:37:19

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 203,098评论 5赞 476
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 85,213评论 2赞 380
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 149,960评论 0赞 336
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 54,519评论 1赞 273
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 63,512评论 5赞 364
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,533评论 1赞 281
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 37,914评论 3赞 395
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,574评论 0赞 256
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 40,804评论 1赞 296
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,563评论 2赞 319
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,644评论 1赞 329
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,350评论 4赞 318
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 38,933评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,908评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,146评论 1赞 259
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 42,847评论 2赞 349
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,361评论 2赞 342

16 集合

数组的不足

List接口的实现类

List中存放Dog对象

Map接口

Map接口常用方法

遍历List和Map

练习

经典练习

Set

扑克模拟问题续

推荐阅读更多精彩内容