Java常用工具_API
API简介
(浏览器搜 java api 11)
Application Programming Interface,应用程序编程接口,这里指的是API文档,通常叫“Java文档”,是Java中提供
的类的使用说明书。Java中的类和方法几乎全部都添加了文档注释(/* 文档注释内容 */),这些文档注释就被Java
的命令(javadoc.exe,在JDK安装的bin目录下)编译成了Java文档,即API。
发挥面向对象思想,找到Java提供的对象来实现功能,学习API文档就是学习Java中的类的使用方法。开发Java程序的
过程中,想要使用Java提供的类的功能,就需要通过API文档来查找并使用。API是程序员和Java语言之间沟通的桥
梁。
使用步骤
- 搜索类
在搜索框里按类名模糊查询,或者通过文档顶部提供的层级结构查找。 - 查看类的包名
很多类在使用之前需要导包,所以要知道该类所属的包。每一个类都默认导入 java.lang 包,所以如果你使用的是该包下的类,则无须手动导包。 - 查看类的注释
使用一个类前,要知道该类的大致功能和它的定位,要知道一个类的能力边界,以便快速确定该类是不是你真正需要的。 - 查看构造方法(如有)
使用类之前要创建类的对象。如果是静态类或者一些工具类如 java.lang.Math 类,则不需要这么做。 - 查找需要的方法并使用
根据标识符的命名规则,可以快速定位方法的位置。仔细阅读方法的注释,注意区分重载方法的使用有何不同。如果找不到想要的方法,可能该方法在父类,或者更高的父类中。
moudle–>package–>class
Object类
类层次结构最顶层的基类,所有类都直接或间接的继承自Object类,所以,所有的类都是一个Object(对象)。
Java是严格的面向对象的语言,所以,所有的函数和数据都封装到类中(并非所有的编程语言都这样),通过类的对象来调用这些功能或实现某个算法。
构造方法
Object():
构造一个对象。所有子类对象初始化时都会优先调用该方法
public Object()
成员方法
int hashCode()
返回对象的哈希码值,该方法通过对象的地址值进行计算,不同对象的返回值一般不同
Class<?> getClass()
返回调用此方法对象的运行时类对象(调用者的字节码文件对象)
String toString()
返回该对象的字符串表示
boolean equals()
返回其它某个对象是否与此对象“相等”。默认情况下比较两个对象的引用(地址值),建议重写
public class Test {
public static void main(String[] args) {
Object obj1 = new Object();
Object obj2 = new Object();
int code1=obj1.hashCode();
System.out.println(code1); //189568618
Class cl1=obj1.getClass();
System.out.println(cl1); //class java.lang.Object
String s1=obj1.toString();
System.out.println(s1); //java.lang.Object@b4c966a
boolean b1=obj1.equals(obj2);
System.out.println(b1); //false
}
}
重写Object类的方法: alt+insert快捷生成(一般都会重写 toString() 和 equals())
Scanner类
扫描器。能够解析字符串(String)和基本数据类型的数据
构造方法
Scanner(InputStream): 构造一个扫描器对象,从指定输入流中获取数据参数System.in,对应键盘录入
成员方法
hasNextXxx()
判断是否还有下一个输入项,其中Xxx可能是任意基本数据类型,返回结果为布尔类型
nextXxx()
获取下一个输入项,其中Xxx可能是任意基本数据类型,返回对应类型的数据
String nextLine()
获取下一行数据。以换行符作为分隔符。
String next()
获取下一个输入项,以空白字符作为分隔符 空白字符:空格、tab、回车等
开发最常用:sc.nextInt(),sc.nextLine()
public class Test2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//接收整数
// System.out.println("输入整数");
// if(sc.hasNextInt()){ //判断录入的是否是整数
// int num = sc.nextInt();
// System.out.println("num:" + num);
//接收字符串类型数据
System.out.println("输入字符串");
// String str1 = sc.nextLine(); //(结束标记:换行符) //abc bcd e
// System.out.println("str1:" + str1); //abc bcd e
String str2 = sc.next(); // (结束标记:空白字符(空格,tab,换行符)) //abc bcd e
System.out.println("str2:" + str2); //abc
}
}
String类
字符串。每一个字符串对象都是常量。
构造方法
String(byte[]):
构造一个String对象,将指定字节数组中的数据转化成字符串
String(char[]):
构造一个String对象,将指定字符数组中的数据转化成字符串
成员方法
判断方法
boolean equals(String)
判断当前字符串与给定字符串是否相同,区分大小写
boolean equalsIgnoreCase(String)
判断当前字符串与给定字符串是否相同,不区分大小写
boolean startWith(String)
判断是否以给定字符串开头
public class Test3 {
public static void main(String[] args) {
byte[] bys = {97, 98};
String s1 = new String(bys);
System.out.println(s1); //ab
char[] cha = {'h', 'e'};
String s2 = new String(cha);
System.out.println(s2); //he
//免new操作
String s3 = new String("abc");
String s4 = "abc";
String str1 = "abc";
String str2 = "ABC";
boolean b1 = str1.equals(str2);
System.out.println("equals():" + b1); //equals()false
boolean b2 = str1.equalsIgnoreCase(str2);
System.out.println("equalsIgnoreCase():" + b2);//equalsIgnoreCase()true
System.out.println(s1.startsWith("a"));//true
System.out.println(s1.isEmpty()); //false
}
}
获取方法
int length():
获取当前字符串的长度
char charAt(int index):
获取指定索引位置的字符
int indexOf(String):
获取指定字符(串)第一次出现的索引
int lastIndexOf(String):
获取指定字符(串)最后一次次出现的索引
String substring(int):
获取指定索引位置(含)之后的字符串
String substring(int, int):
获取从索引start位置(含)起至索引end位置(不含)的字符串
public class Test4 {
public static void main(String[] args) {
String str="我 aa今年b 18岁b了";
System.out.println(str.length());
System.out.println(str.charAt(5));
System.out.println(str.indexOf("a"));
System.out.println(str.lastIndexOf("b"));
System.out.println(str.substring(5,11)); //[ , )
}
}
13
年
2
11
年b 18岁
转换方法
byte[] getBytes():
将字符串转换成字节数组
char[] toCharArray():
将字符串转换成字符数组
static String valueOf(…) :
将指定类型数据转换成字符串
String replace(old, new):
将指定字符(串)替换成新的字符(串)
String[] split(String):
切割字符串,返回切割后的字符串数据,原字符串不变
String trim():
去掉字符串两端的空白字符
public class Test5 {
public static void main(String[] args) {
String s1 = "abc";
byte[] bys = s1.getBytes();
for (int i = 0; i < bys.length; i++) {
System.out.println(bys[i]);
}
char[] ch = s1.toCharArray();
for (int i = 0; i < ch.length; i++) {
System.out.println(ch[i]);
}
String s2 = String.valueOf(123);
System.out.println(s2 + 4);
String s3 = "" + 123;
System.out.println(s3 + 4);
String s4="abc abc";
String s5=s4.replace('b','d');
System.out.println(s5);
String[] arr=s4.split(" ");
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
String s6=" a b c ";
System.out.println(s6.trim()); //两端空格
}
}
97
98
99
a
b
c
1234
1234
adc adc
abc
abc
a b c
StringBuilder和StringBuffer类
可变字符序列,用于构造字符串对象。内部使用自动扩容的数组操作字符串数据。StringBuilder和StringBuffer使用
相同的API
构造方法
StringBuilder()
构造一个空的StringBuilder容器
StringBuilder(String)
构造一个StringBuilder容器,并添加指定字符串
成员方法
StringBuilder append(…)
将任意数据添加到StringBuilder容器中
String toString()
将当前StringBuilder容器转成字符串
public class Test6 {
public static void main(String[] args) {
//测试构造方法
StringBuilder sb = new StringBuilder();
sb.append("abc"); //返回自身
// StringBuilder sb2= sb.append("abc");
System.out.println("sb:" + sb);
// System.out.println("sb2:"+ sb2);
StringBuilder sb3 = new StringBuilder("abc");
System.out.println("sb3:" + sb3);
//测试成员方法
StringBuilder sb4 = new StringBuilder();
sb4.append("a");
sb4.append("b");
System.out.println("sb4:" + sb4);
String s = sb4.toString();
System.out.println("s:" + s);
}
}
sb:abc
sb3:abc
sb4:ab
s:ab
Date和Calendar类
日期和日历类,用于操作日期相关信息。
构造方法
Date():
构造一个日期对象,当前系统时间,精确到毫秒
Date(long):
构造一个日期对象,时间为自“1970年1月1日00:00:00 GMT”起,至指定参数的毫秒数
成员方法
long getTime():
将日期对象转换成对应时间的毫秒值
static Calendar getInstance():
根据当前系统时区和语言环境获取日历对象
int get(int field):
返回给定日历字段的值
void set(int field, int value)
将给定的日历字段设置为指定的值
public class Test7 {
public static void main(String[] args) {
Date date1 = new Date();
System.out.println(date1); //Fri Nov 13 16:50:11 CST 2020
long time = date1.getTime();
System.out.println(time); //1605257411315
Calendar c = Calendar.getInstance();
System.out.println(c);
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH);
int day = c.get(Calendar.DATE);
System.out.println(year+"年"+month +"月"+ day); //2020年10月13
c.set(2020, 4, 4);
int year2 = c.get(Calendar.YEAR);
int month2 = c.get(Calendar.MONTH);
int day2 = c.get(Calendar.DATE);
System.out.println(year2+"年"+month2 +"月"+ day2); //2020年4月4
}
}
基本类型的包装类
基本数据类型不是对象,所以Java针对基本类型提供了对应的包装类,以对象的形式来使用。
装箱
基本类型转包装类型(对象类型)
拆箱
包装类型(对象类型)转基本类型
成员方法
基本类型 parseXxx(String):
将字符串类型的数据转换成对应的基本类型
public class Test8 {
public static void main(String[] args) {
//a属于基本类型。不能通过 对象名. 的形式调用
int a = 10;
//基本类型转引用类型(装箱) (已过时)
Integer i1 = new Integer(20);
//拆箱 (已过时)
int b = i1.intValue();
System.out.println(i1); //20
System.out.println(b); //20
//基本类型转引用类型(装箱)
Integer i2 = 30;
//拆箱
int c = i2;
//字符串类型10 转int 10
String s = "10";
int num = Integer.parseInt(s);
System.out.println(num); //10
//除了Character类以外,剩下的7种包装类都有型 parseXxx方法
//字符串转char类型,可通过String类中的方法 toCharArray(),charAt()
}
}
Java常用工具_集合
集合简介
什么是集合?
简称集,是用来存储多个元素的容器
集合和数组的区别
元素类型
集合:引用类型(存储基本类型时自动装箱)
数组:基本类型、引用类型
元素个数
集合:不固定,可任意扩容
数组:固定,不能改变容量
集合的好处
不受容器大小限制,可以随时添加、删除元素
提供了大量操作元素的方法(判断、获取等)
Java的集合体系
单列集合(Collection)
List
ArrayList
Set
HashSet
双列集合(Map: key,value )
Map
HashMap
List集合的特点和应用
特点:
可重复、有序(存取顺序相同)
List是接口, 所以可以通过创建其子类ArrayList对象来完成该接口的实例化.
List list = new ArrayList();
List接口中的成员方法:
public boolean add(E e); //将数据添加到集合的末尾, 这里的E是泛型的意思, 目前可以先理解为Object类型.
public E get(int index); //根据索引, 索取其对应的元素.
public int size(); //获取集合的长度.
使用集合的步骤:
1. 创建集合对象.
2. 创建元素对象.
3. 将元素对象添加到集合对象中.
4. 遍历集合.
public class Test {
public static void main(String[] args) {
//需求: 往List集合中添加3个学生对象, 然后遍历.
//1. 创建集合对象.
List list = new ArrayList();
//2. 创建元素对象.
Student s1 = new Student("乔峰",41);
Student s2 = new Student("乔峰",41);
Student s3 = new Student("虚竹",38);
Student s4 = new Student("段誉",26);
//3. 将元素对象添加到集合对象中.
/*boolean b1 = list.add(s1); System.out.println(b1);
boolean b2 = list.add(s1); System.out.println(b2);*/
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
//直接打印集合
System.out.println(list);
//获取索引为2的元素
Object obj = list.get(2);
System.out.println("索引为2的元素是: " + obj);
//获取集合中的元素个数
System.out.println("集合的长度为: " + list.size());
//4. 遍历集合.
for (int i = 0; i < list.size(); i++) {
//i表示的就是集合中每个元素的索引
//获取元素
Object obj2 = list.get(i);
System.out.println("索引为 " + i + "的元素是: " + obj2 );
}
}
}
[Student{name='乔峰', age=41}, Student{name='乔峰', age=41}, Student{name='虚竹', age=38}, Student{name='段誉', age=26}]
索引为2的元素是: Student{name='虚竹', age=38}
集合的长度为: 4
索引为 0的元素是: Student{name='乔峰', age=41}
索引为 1的元素是: Student{name='乔峰', age=41}
索引为 2的元素是: Student{name='虚竹', age=38}
索引为 3的元素是: Student{name='段誉', age=26}
增强for循环和迭代器
增强for循环:简化数组和集合的遍历
快捷键:iter
for(数据类型 变量名 : 数组或者集合对象) {
// 循环体,变量即元素
}
for (Object obj : list) {
System.out.println(obj);
}
迭代器:对过程的重复,称为迭代。
迭代器是遍历 Collection 集合的通用方式,可以在对集合遍历的同时进行添加、删除等操作。
迭代器的常用方法
E next(): 返回迭代的下一个元素对象
boolean hasNext(): 如果仍有元素可以迭代,则返回true
注意:
列表迭代器是List体系独有的遍历方式, 可以在对集合遍历的同时进行添加、删除等操作。
但是必须通过调用列表迭代器的方法来实现.
使用步骤:
1. 根据集合对象获取其对象的迭代器对象.
2. 判断迭代器中是否有元素.
3. 如果有就获取元素.
总结:
普通的迭代器在遍历集合的同时不能添加或者删除元素, 否则会报: 并发修改异常.
列表迭代器在遍历集合的同时可以修改集合中的元素(添加, 删除等), 必须使用列表迭代器中的方法.
public class Test {
public static void main(String[] args) {
//需求: 通过迭代器遍历List集合.
//1. 创建集合对象.
List list = new ArrayList();
//2. 创建元素对象.
//3. 将元素对象添加到集合对象中.
list.add("a");
list.add("b");
list.add("c");
//4. 遍历集合.
//迭代器的用法
//1. 根据集合对象获取其对象的迭代器对象.
Iterator it = list.iterator();
//2. 判断迭代器中是否有元素.
while(it.hasNext()) { //如果迭代器中有元素, 就一直迭代.
//3. 如果有就获取元素.
String s = (String)it.next();
System.out.println(s);
}
//需求: 判断集合中如果有字符串"b", 就在其后边添加一个新的字符串: java
//1. 根据集合对象获取列表迭代器对象.
ListIterator lit = list.listIterator();
//2. 判断迭代器中是否有元素.
while(lit.hasNext()) {//如果迭代器中有元素, 就一直迭代.
//3. 有就获取元素即可.
String s = (String)lit.next();
if ("b".equals(s)) { //这样写可以规避: 空指针异常
//list.add("java"); //这样写不行, 必须调用列表迭代器的方法来实现.
lit.add("java");
}
System.out.println(s);
}
//打印新的集合中的值
System.out.println(list);
}
}
a
b
c
[a, b, java, c]
泛型简介
泛指任意类型,又叫参数化类型(ParameterizedType),对具体类型的使用起到辅助作用,类似于方法的参数。
集合类泛型的解释:表示该集合中存放指定类型的元素
(给List集合加上泛型Student)
List<Student> list = new ArrayList<>();
泛型的好处:
类型安全
避免了类型转换
泛型一般只和集合类相结合使用.
泛型是JDK5的新特性, 但是从JDK7开始,后边的泛型可以不用写具体的数据类型了(菱形泛型.)
List<String> list2 = new ArrayList<>();
public class Test3 {
public static void main(String[] args) {
//不使用泛型的集合
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
//list1.add(10); 会报类型转换异常(ClassCastException)
for (Object obj : list) {
String s = (String) obj;
System.out.println(s);
}
//需求: 演示泛型
List<String> list2 = new ArrayList<String>();
list2.add("abc");
list2.add("b");
list2.add("c");
// list2.add(14); //直接会标红 //类型安全
for (String s : list2) { //避免了类型转换
System.out.println(s);
}
}
}
Collections工具类
针对集合进行操作的工具类。
成员方法
根据比较器规则对列表进行排序
sort(List<T>,Comparator<T>)
返回集合的最大元素
max(Collection<T>)
反转List集合元素
reverse(List<T>)
根据自然顺序返回最大元素
shuffle(List<T>)
public class Test4 {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(3);
list.add(3);
list.add(5);
list.add(2);
list.add(2);
list.add(4);
System.out.println("没有操作以前, 集合中的数据是: " + list);
Integer max = Collections.max(list);
System.out.println("集合中的最大元素为: " + max);
Collections.sort(list);
System.out.println("升序排列后的结果为: " + list);
Collections.reverse(list);
System.out.println("反转以后集合中的数据为: " + list);
Collections.shuffle(list);
System.out.println("随机置换后的结果为: " + list);
}
}
没有操作以前, 集合中的数据是: [1, 3, 3, 5, 2, 2, 4]
集合中的最大元素为: 5
升序排列后的结果为: [1, 2, 2, 3, 3, 4, 5]
反转以后集合中的数据为: [5, 4, 3, 3, 2, 2, 1]
随机置换后的结果为: [5, 4, 2, 2, 1, 3, 3]
Set集合的特点
特点:不可重复、无序
Set<T> set = new HashSet<>();
Set集合保证元素的唯一性,依赖 equals(), hashCode()两个方法.
public class Test5 {
public static void main(String[] args) {
Set<Student> set = new HashSet<>();
Student s1 = new Student("乔峰", 41);
Student s2 = new Student("虚竹", 38);
Student s3 = new Student("段誉", 26);
Student s4 = new Student("乔峰", 41);
Student s5 = new Student("虚竹", 38);
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
set.add(s5);
System.out.println(set);
//4. 遍历集合.
/*
为什么Set集合没有"去重"?
因为Set集合保证元素的唯一性依赖: equals() 和 hashCode()两个方法.
你没有在Student类中重写这两个方法, 默认调用的是Object类中的这两个方法.
而Object类中的equals()方法默认比较的是地址值是否相同.
解决方案: 在Student类中重写equals()和hashCode()方法.
*/
//通过迭代器遍历Set集合
//A. 通过集合对象获取其对应的迭代器对象.
Iterator<Student> it= set.iterator();
//B. 判断迭代器中是否有元素.
while(it.hasNext()) {
//C. 如果有, 就获取元素.
Student s = it.next();
System.out.println(s);
}
//通过增强for遍历Set集合
for (Student student : set) {
System.out.println(student);
}
}
}
public class Student {
//成员变量
private String name;
private int age;
//有参,无参构造
//get(),set()
//快捷键alt+insert 重写equals() 和 hashCode()
}
Map集合的特点和应用
双列集合,元素由键值对(Entry)构成: key – value key不可以重复,value可以重复
Map<T1, T2> map = new HashMap<>(); // T1: 表示键的数据类型., T2: 表示值的数据类型
public class Test6 {
public static void main(String[] args) {
//需求: 往Map集合中添加3个学生对象, 然后打印.
//1. 创建集合对象.
Map<Integer, Student> map = new HashMap<>();
//2. 创建元素对象.
Student s1 = new Student("张三", 23);
Student s2 = new Student("李四", 24);
Student s3 = new Student("张三", 23);
/* Student stu1 = map.put(1, s1);
// V put(K key,V value); 添加元素(键值对的形式),
// 元素第一次添加, 返回null,
// 重复添加, 会用新值覆盖旧值, 并返回旧值.
System.out.println("stu1: " + stu1); //stu1: null
Student stu2 = map.put(1, s2);
System.out.println("stu2: " + stu2); //stu2: Student{name='张三', age=23}
System.out.println(map); //{1=Student{name='李四', age=24}}*/
//3. 将元素对象添加到集合中.
map.put(1, s1);
map.put(2, s2);
map.put(3, s3);
System.out.println(map);//{1=Student{name='张三', age=23}, 2=Student{name='李四', age=24}, 3=Student{name='张三', age=23}}
//根据键,获取值
Student stu3 = map.get(2);
System.out.println("key" + 2 + ",value" + stu3);
//4. 遍历集合.
//4.1. 获取所有键的集合. keySet()
Set<Integer> keys = map.keySet();
// 4.2. 遍历所有的键, 获取到每一个键. 迭代器/增强for.
//获取迭代器对象
Iterator<Integer> it = keys.iterator();
while (it.hasNext()) {
//如果迭代器中有数据, 就获取.
Integer key = it.next();
// 4.3. 根据键, 获取指定的值. get()
Student value = map.get(key);
System.out.println("key" + key + "...value" + value);
}
//通过增强for实现
Set<Integer> keys = map.keySet();
for (Integer key : keys) {
Student value = map.get(key);
System.out.println(key + "..." + value);
}
}
}
1...Student{name='张三', age=23}
2...Student{name='李四', age=24}
3...Student{name='张三', age=23}
案例:模拟斗地主发牌
public class SendPockerTest {
public static void main(String[] args) {
//1. 买牌.
//1.1 定义一个双列集合, 键: 表示牌的编号, 值: 表示具体的牌. 规则: 编号越小, 牌越小.
Map<Integer, String> pokers = new HashMap<>();
//1.2 定义一个单列集合, 用来存储所有牌的编号
List<Integer> list = new ArrayList<>();
//1.3 具体的买牌动作.
//普通牌, 52.
String[] colors = {"♠", "♥", "♣", "♦"};
String[] numbers = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
int num = 0; //表示牌的编号
for (String number : numbers) { //外循环, 获取所有的点数
for (String color : colors) {//内循环, 获取所有的花色
String poker = color + number;
//将牌的编号, 具体的牌放到双列集合中.
pokers.put(num, poker);
//将牌的编号放到单列集合中.
list.add(num);
//每添加一张牌, 编号要自增1.
num++;
}
}
//大小王.
//添加小王
pokers.put(num, "小王");
list.add(num++);
//添加大王
pokers.put(num, "大王");
list.add(num);
//打印牌就可以了.
System.out.println("所有的牌: " + pokers);
System.out.println("牌的编号:" + list);
//2. 洗牌
Collections.shuffle(list);
System.out.println("洗好牌后, 编号为: " + list);
//3. 发牌
//3.1 定义4个集合, 分别表示3个玩家, 底牌.
List<Integer> liuyifei = new ArrayList<>();
List<Integer> zhaoliying = new ArrayList<>();
List<Integer> xiaohei = new ArrayList<>();
List<Integer> dipai = new ArrayList<>();
//3.2 具体的发牌动作, 将索引和3取模, 决定发给谁.
for (int i = 0; i < list.size(); i++) {
//获取编号
Integer pokerNum = list.get(i); //i索引
if (i >= list.size() - 3) {
//底牌
dipai.add(pokerNum);
} else if (i % 3 == 0) {
liuyifei.add(pokerNum);
} else if (i % 3 == 1) {
zhaoliying.add(pokerNum);
} else if (i % 3 == 2) {
xiaohei.add(pokerNum);
}
}
/*//3.3 查看玩家, 底牌的编号.
System.out.println("liuyifei: " + liuyifei);
System.out.println("zhaoliying: " + zhaoliying);
System.out.println("xiaohei: " + xiaohei);
System.out.println("dipai: " + dipai);*/
//4. 查看具体的牌
/*String str = printPoker(liuyifei, pokers);
System.out.println("liuyifei: " + str);*/
System.out.println("liuyifei: " + printPoker(liuyifei, pokers));
System.out.println("zhaoliying: " + printPoker(zhaoliying, pokers));
System.out.println("xiaohei: " + printPoker(xiaohei, pokers));
System.out.println("dipai: " + printPoker(dipai, pokers));
}
/*
4. 定义一个方法, 用来看牌
方法名: printPoker
参数列表: List<Integer>, Map<Integer, String>
返回值: String
*/
public static String printPoker(List<Integer> nums, Map<Integer, String> pokers) {
//1. 对牌的编号进行升序排列.
Collections.sort(nums);
//2. 遍历牌的编号集合, 获取到每一个编号.
StringBuilder sb = new StringBuilder();
for (Integer num : nums) {
//num就是要查找的具体牌的 编号.
//3. 根据编号去双列集合中查找该编号对应的具体牌.
String poker = pokers.get(num);
//4. 将获取到的牌进行拼接.
sb.append(poker + " ");
}
//5. 将最后拼接结果返回即可.
String str = sb.toString();
return str.trim();
}
}