1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
package poker2;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;
import javax.swing.LookAndFeel;
public class Poker {
public static void main(String[] args) {
// TODO Auto-generated method stub
//牌盒 k存储编号	v存储牌
HashMap<Integer,String> hm=new HashMap<Integer,String>();
//存储编号
ArrayList<Integer> array=new ArrayList<Integer>();
//点数和花色数组
String[] num= {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
String[] colors= {"♠","♥","♣","♦"};
int index=0;
//装牌,装编号
for (String n : num) {
for (String c : colors) {
String str=c.concat(n);
hm.put(index, str);
array.add(index);
index++;
}
}
hm.put(52, "小王");
hm.put(53, "大王");
array.add(52);
array.add(53);
//洗牌
Collections.shuffle(array);
//发牌
TreeSet<Integer> player1=new TreeSet<Integer>();
TreeSet<Integer> player2=new TreeSet<Integer>();
TreeSet<Integer> player3=new TreeSet<Integer>();
TreeSet<Integer> dipai=new TreeSet<Integer>();
for(int i=0;i<array.size();i++) {
if(i>=array.size()-3) {
dipai.add(array.get(i));
}else if(i%3==0){
player1.add(array.get(i));
}else if(i%3==1){
player2.add(array.get(i));
}else if(i%3==2){
player3.add(array.get(i));
}
}
look("张三", player1, hm);
look("李四", player2, hm);
look("王五", player3, hm);
look("底牌", dipai, hm);
}
public static void look(String name,TreeSet<Integer> ts,HashMap<Integer,String> hs) {
System.out.print(name+"的牌是: ");
for (Integer i : ts) {
System.out.print(hs.get(i)+" ");
}
System.out.println();
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 * 什么是异常
*
程序出现了问题,使用"异常"来描述问题
* 举例:
*
生活中一些问题
*
*
班长骑车去旅行
*
1)在骑行的过程中,路面塌陷了,导致不能骑行了!----- 不可抗力的因素!(严重问题)
*
2)在准备骑行的时候,车胎没气了,导致不能骑行了!----
*
在骑行前应该检查的工作(可以检查维修,可以解决的)
*
3)在骑行过程中,中间路面是平坦的,两边是石子,就在两边上骑行,导致车胎没气了
*
-----
*
在骑行的时候,no zuo no die (自己的原因导致)
*
* java.lang.Throwable:异常类( Java 语言中所有错误或异常的超类(父类))
*
error:严重错误(严重问题)
*
比如:内存异常!OOM(Out Of Memory)
*
通过加入内存条...或者将Linux虚拟机的内存空间设置小一点!
*
*
Exception: 可以捕获合理的程序!
*
编译时期异常:只要不是RuntimeException中的子类都是属于编译时期
*
必须要处理的,不处理编译通不了,没有办法运行的!
*
运行时期异常RuntimeException:
*
程序在执行过程中出现的问题
*
代码逻辑不够严谨导致的!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
* 异常的处理方案有哪些:
*
*
1)try...catch...finally:标准格式
捕获异常
*
2)throws:抛出异常 (抛出到方法上)
*
* 方式1:捕获异常的变形格式
*
try...catch...
*
try...catch...catch...
*
try...finally...
(线程中:Lock锁)
*
* 格式:流程
*
try{
*
...
*
...
*
可能出现问题代码
*
}catch(异常类名 变量名){//具体异常的类
*
//处理异常
*
//自己手动处理
*
//Throwable类中一些方:处理方式(jvm将异常信息输出在控制台并且可以跟踪异常类源码)
*
}

1
2
3
4
5
6
7
8
9
10
11
12
* 如果try中存在多个异常,如何处理
*
1)一个一个try...catch...
*
2)一个try多个catch...
* try...catch...finally(标准格式)
* 变形格式:
*
try...catch...
*
try...catch...catch...(推荐)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
* 编译时期异常和运行时期的区别?
*
*
编译时期的异常:
*
举例:
*
String---Date---解析的方法parse(String source) throws ParseException{}
*
*
IO流:IOException
*
...
*
开发者必须要进行显示处理,否则编译通过不了!
*
*
运行时期异常:
*
1)代码逻辑的问题,不进行显示处理,在代码中加入一些逻辑判断
*
2)也可以进行显示处理:try...catch...

1
2
3
4
5
6
7
8
9
10
11
12
* 关于Throwable中的一些方法
*
* public String getMessage():获取异常的消息字符串
*
* public String toString():获取异常信息的简单描述
*
异常的全限定名称:包名.类名: 调用该异常对象的getMessage()详细的消息字符串
*
* public void printStackTrace():
*
将此对象的信息追踪到堆栈中,具体获取到具体源码中哪一块出问题了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
* 针对异常处理的另一种方式:
*
*
throws:抛出异常
*
抛出在方法声明上,如果方法中的语句体出现了异常,将异常交给jvm,jvm将异常信息输出
* 控制台上...
*
*
* 面试题
*
throws和throw的区别
*
* throws:抛出
*
1)书写位置是在方法声明上
*
2)throws的后面跟的异常类名,而且可以跟多个异常类名,中间使用逗号隔开
*
3)对于throws它是由调用者进行处理,必须要对带throws的方法进行处理!
*
4)throws表示抛出异常的一种肯能性(这个方法可能出现问题/可能没有问题!)
* throw:抛出
*
1)书写位置是在方法体中
*
2)throw的后面跟的异常对象,一般都是匿名对象 new XXXException()
*
而且只能跟一个异常对象
*
3)由方法中逻辑判断进行处理(由方法体中语句进行处理)
*
4)throw:表示抛出异常一种肯定性(执行到逻辑的时候,一定会执行这个异常!)