数组的不足
初始化时必须指定长度，有可能不足，有可能浪费
List接口的实现类
ArrayList实现了长度可变的数组，在内存中分配连续的空间。遍历元素和随机访问元素的效率比较高
LinkedList采用链表存储方式。插入、删除元素时效率比较高
image
如何存储多条狗狗信息，获取狗狗总数，逐条打印出各条狗狗信息 ？
请输入一条狗的名字，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
使用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
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
package com.company;
import java.util.HashMap;
import java.util.Map;
/**
* Created by ttc on 2018/1/10.
*/
public class MapReview {
public static void main(String[] args) {
//创建map对象
//key-value
Map<String,String> words = new HashMap<>();
//增删改查
//增
words.put("dog","狗");//2个参数，第一个是key，第二个是value
words.put("cat","猫");
//遍历map
for(String key : words.keySet())
{
System.out.println(key + "----" + words.get(key));
}
//删
String str = words.remove("dog");
System.out.println(str + "被删除了");
//遍历map
for(String key : words.keySet())
{
System.out.println(key + "----" + words.get(key));
}
//改
words.put("cat","小猫");
//遍历map
for(String key : words.keySet())
{
System.out.println(key + "----" + words.get(key));
}
//判断map中是否包含某个key
if(words.containsKey("cat"))
{
System.out.println("包含猫");
}
else
{
System.out.println("不包含猫");
}
//遍历map的第2种方法
for(Map.Entry entry : words.entrySet())
{
System.out.println(entry.getKey() + "----" + entry.getValue());
}
}
}
List独立
package collection;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
/**
* 集合里放字符串
*/
public class ListDemo
{
public static void main(String[] args)
{
//List是个接口，定义实现这个接口的类ArrayList
List<String> listDog=new ArrayList();
Scanner scanner=new Scanner(System.in);
while (true)
{
String dogName=scanner.next();
if (dogName.equals("no"))
{
break;
}
if(!listDog.contains("ergouzi"))
{
listDog.add(dogName);
}
//listDog.add(dogName);
//listDog.contain() ; listDog.remove(1), listDog.remove("abc")
}
listDog.remove(1);
// for(int i=0;i<listDog.size();i++)
// {
// System.out.println(listDog.get(i));
// }
//也可以用增强for循环
for(String dogName1:listDog)
{
System.out.println(dogName1);
}
}
}
Map接口
建立国家英文简称和中文全名间的键值映射，并通过key对value进行操作，应该如何实现数据的存储和操作呢？
image
Map接口专门处理键值映射数据的存储，可以根据键实现对值的操作
最常用的实现类是HashMap
image
Map接口常用方法
image
遍历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
image
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
package com.company;
import java.util.*;
/**
* Created by ttc on 2018/1/10.
*/
public class WorldCupGroup {
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
ublic 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());
}
}
}
正确答案
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,77,"class04"));
studentList.add(new Student("Owen",30,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"));
int totalAGe = 0;
for(Student student : studentList)
{
totalAGe+= student.getAge();
}
System.out.println("平均年龄"+totalAGe/studentList.size());
Map<String,List<Integer>> className2scoreList = new HashMap<>();
for (Student student: studentList)
{
String className = student.getClassNum();
int score = student.getScore();
if(className2scoreList.containsKey(className))
{
List<Integer>lstScores = new ArrayList<>();
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/className2scoreList.size());
}
}
}
第四题 （List）写一个函数reverseList，该函数能够接受一个List，然后把该List 倒序排列。 例如：
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);
}
}
UUID
public static void main(String[] args) {
Set<String >stringSetUUID = new HashSet<>();
for (int i = 0; i<10000;i++)
{
UUID uuid = UUID.randomUUID();
stringSetUUID.add(uuid.toString());
}
System.out.println(stringSetUUID.size());
}
}
image
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
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”); } }
@Override // Alt+insert选择tosering
public String toString() {
return "Worker{" +
"age=" + age +
", name='" + name + '\'' +
", salary=" + salary +
'}';
完成下面的要求
- 创建一个List，在List 中增加三个工人，基本信息如下：
姓名 年龄 工资
zhang3 18 3000
li4 25 3500
wang5 22 3200
在li4 之前插入一个工人，信息为：姓名：zhao6，年龄：24，工资3300
删除wang5 的信息
利用for 循环遍历，打印List 中所有工人的信息
利用迭代遍历，对List 中所有的工人调用work 方法。
image
public static void main(String[] args) {
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.toString();
}
}
经典练习
一篇英文文章，单词间用空格分割，统计出现了哪些单词，以及每个单词出现的次数。
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，判断是否有重复的？
扑克模拟问题续
随机发出5张牌，判断牌型
image
image
image
image
image
package com.company;
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);
}
}
