java修饰符
访问控制修饰符 : default, public , protected, private
| 修饰符 | 说明 |
|---|---|
| default (即缺省，什么也不写） | 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。 |
| private | 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类） |
| public | 对所有类可见。使用对象：类、接口、变量、方法 |
| protected | 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。 |
非访问控制修饰符 : final, abstract, strictfp
| 修饰符 | 说明 |
|---|---|
| final | 用来修饰类方法和类变量 |
| abstract | 用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。abstract 修饰符，用来创建抽象类和抽象方法。 |
| synchronized | synchronized 和 volatile 修饰符，主要用于线程的编程。 |
synchronized 修饰符
synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。
实例
public synchronized void showDetails(){
.......
}
transient 修饰符
序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。
实例
public transient int limit = 55; // 不会持久化
public int b; // 持久化
volatile 修饰符
volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
一个 volatile 对象引用可能是 null。
实例
public class MyRunnable implements Runnable
{
private volatile boolean active;
public void run()
{
active = true;
while (active) // 第一行
{
// 代码
}
}
public void stop()
{
active = false; // 第二行
}
}
通常情况下，在一个线程调用 run() 方法（在 Runnable 开启的线程），在另一个线程调用 stop() 方法。 如果 第一行 中缓冲区的 active 值被使用，那么在 第二行 的 active 值为 false 时循环不会停止。
但是以上代码中我们使用了 volatile 修饰 active，所以该循环会停止。
Java包
包主要用来对类和接口进行分类。当开发Java程序时，可能编写成百上千的类，因此很有必要对类和接口进行分类。
Import语句
在Java中，如果给出一个完整的限定名，包括包名、类名，那么Java编译器就可以很容易地定位到源代码或者类。Import语句就是用来提供一个合理的路径，使得编译器可以找到某个类。
例如，下面的命令行将会命令编译器载入java_installation/java/io路径下的所有类
import java.io.*;
内置数据类型
byte：数据类型是8位、有符号的，以二进制补码表示的整数；
最小值是 -128（-2^7）；
最大值是 127（2^7-1）；
short：short 数据类型是 16 位、有符号的以二进制补码表示的整数
最小值是 -32768（-2^15）；
最大值是 32767（2^15 - 1）；
long 数据类型是 64 位、有符号的以二进制补码表示的整数；
最小值是 -9,223,372,036,854,775,808（-2^63）；
最大值是 9,223,372,036,854,775,807（2^63 -1）；
这种类型主要使用在需要比较大整数的系统上；
默认值是 0L；
float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
float 在储存大型浮点数组的时候可节省内存空间；
默认值是 0.0f；
浮点数不能用来表示精确的值，如货币；
例子：float f1 = 234.5f。
double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
浮点数的默认类型为double类型；
double类型同样不能表示精确的值，如货币；
默认值是 0.0d；
例子：double d1 = 123.4。
Java 常量
在 Java 中使用 final 关键字来修饰常量，
final double PI = 3.1415927;
Java 循环结构
while 循环
while是最基本的循环，它的结构为：
while( 布尔表达式 ) {
//循环内容
}
do…while 循环
对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。
do {
//代码语句
}while(布尔表达式);
for循环
虽然所有循环结构都可以用 while 或者 do...while表示，但 Java 提供了另一种语句 —— for 循环，使一些循环结构变得更加简单。
for循环执行的次数是在执行前就确定的。语法格式如下：
for(初始化; 布尔表达式; 更新) {
//代码语句
}
实例
public class Test {
public static void main(String args[]) {
for(int x = 10; x < 20; x = x+1) {
System.out.print("value of x : " + x );
System.out.print("
");
}
}
}
Java 增强 for 循环
Java5 引入了一种主要用于数组的增强型 for 循环。
Java 增强 for 循环语法格式如下:
for(声明语句 : 表达式)
{
//代码句子
}
声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
表达式：表达式是要访问的数组名，或者是返回值为数组的方法
break 关键字
break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。
break 跳出最里层的循环，并且继续执行该循环下面的语句。
continue 关键字
continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
在 for 循环中，continue 语句使程序立即跳转到更新语句。
在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。
日期时间
// 初始化 Date 对象
Date date = new Date();
日期比较
Java使用以下三种方法来比较两个日期：
使用 getTime() 方法获取两个日期（自1970年1月1日经历的毫秒数值），然后比较这两个值。
使用方法 before()，after() 和 equals()。例如，一个月的12号比18号早，则 new Date(99, 2, 12).before(new Date (99, 2, 18)) 返回true。
使用 compareTo() 方法，它是由 Comparable 接口定义的，Date 类实现了这个接口。
使用 SimpleDateFormat 格式化日期
SimpleDateFormat 是一个以语言环境敏感的方式来格式化和分析日期的类。SimpleDateFormat 允许你选择任何用户自定义日期时间格式来运行。例如：
import java.util.*;
import java.text.*;
public class DateDemo {
public static void main(String args[]) {
Date dNow = new Date( );
SimpleDateFormat ft = new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");
System.out.println("Current Date: " + ft.format(dNow));
}
}
使用printf格式化日期
| 转 换 符 | 说 明 | 示 例 |
|---|---|---|
| c | 包括全部日期和时间信息 | 星期六 十月 27 14:21:20 CST 2007 |
| F | "年-月-日"格式 | 2007-10-27 |
| D | "月/日/年"格式 | 10/27/07 |
| r | "HH:MM:SS PM"格式（12时制） | 02:25:51 下午 |
| T | "HH:MM:SS"格式（24时制） | 14:28:16 |
| R | "HH:MM"格式（24时制） | 14:28 |
字符串转时间 parse
SimpleDateFormat 类有一些附加的方法，特别是parse()，它试图按照给定的SimpleDateFormat 对象的格式化存储来解析字符串。例如：
import java.util.*;
import java.text.*;
public static void main(String args[]) {
SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd");
String input = args.length == 0 ? "1818-11-11" : args[0];
System.out.print(input + " Parses as ");
Date t;
try {
t = ft.parse(input);
System.out.println(t);
} catch (ParseException e) {
System.out.println("Unparseable using " + ft);
}
}
//结果：2015-11-11 Parses as Wed Nov 11 00:00:00 UTC 2015
Calendar类
我们现在已经能够格式化并创建一个日期对象了，但是我们如何才能设置和获取日期数据的特定部分呢，比如说小时，日，或者分钟? 我们又如何在日期的这些部分加上或者减去值呢? 答案是使用Calendar 类。
Calendar类的功能要比Date类强大很多，而且在实现方式上也比Date类要复杂一些。
Calendar类对象字段类型
| 常量 | 描述 | 取值 |
|---|---|---|
| Calendar.YEAR | 年份 | |
| Calendar.MONTH | 月份 | 0-11 |
| Calendar.DATE | 日期 | |
| Calendar.HOUR | 12小时制的小时 | |
| Calendar.HOUR_OF_DAY | 24小时制的小时 | |
| Calendar.MINUTE | 分钟 | |
| Calendar.SECOND | 秒 | |
| Calendar.DAY_OF_WEEK | 星期几 | 0-6 |
| Calendar.DAY_OF_MONTH | 这个月第几天 | |
| Calendar.DAY_OF_YEAR | 今年的第几天 | |
| Calendar.WEEK_OF_YEAR | 今年第几个星期 | |
| Calendar.WEEK_OF_MONTH | 这个月第几个星期 |
Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明的，只需要使用getInstance方法创建即可。
创建一个代表系统当前日期的Calendar对象
Calendar c = Calendar.getInstance();//默认是当前日期
创建一个指定日期的Calendar对象
使用Calendar类代表特定的时间，需要首先创建一个Calendar的对象，然后再设定该对象中的年月日参数来完成。
Calendar类对象信息的设置
1.get获取
public static void main(String[] args) {
Calendar c = Calendar.getInstance();
int year = c.get(Calendar.YEAR); //年份
int month = c.get(Calendar.MONTH)+1; //月数
int day = c.get(Calendar.DATE); //天数
System.out.printf("%d-%d-%d",year,month,day);
}
//2018-8-3
2.Set设置
| 返回值 | Set 方法 | |
|---|---|---|
| void | set(int field, int value) 将给定的日历字段设置为给定的值。 |
c1.set(Calendar.MONTH , 9); |
| void | set(int year, int month, int date) 设置日历字段中的值 YEAR ， MONTH和 DAY_OF_MONTH 。 |
|
| void | set(int year, int month, int date, int hourOfDay, int minute) 设置日历字段中的值 YEAR ， MONTH ， DAY_OF_MONTH ， HOUR_OF_DAY和 MINUTE 。 |
|
| void | set(int year, int month, int date, int hourOfDay, int minute, int second) 设置字段中的值 YEAR ， MONTH ， DAY_OF_MONTH ， HOUR_OF_DAY ， MINUTE和 SECOND 。 |
//创建一个代表2009年6月12日的Calendar对象
Calendar c1 = Calendar.getInstance();
c1.set(2009, 6 - 1, 12);
int year1 = c1.get(Calendar.YEAR); //年份
int month1 = c1.get(Calendar.MONTH)+1; //月数
int day1 = c1.get(Calendar.DATE); //天数
System.out.printf("%d-%d-%d",year1,month1,day1);
//2009-6-12
3.add偏移量
Calendar c2 = Calendar.getInstance(); //2018-8-3
//c2.add(Calendar.DATE, -9); //2018-7-25
//c2.add(Calendar.DATE, 9); //2018-8-12
//c2.add(Calendar.DAY_OF_MONTH, 9); //2018-8-12
c2.add(Calendar.DAY_OF_YEAR, -9); //2018-8-12
GregorianCalendar类
Calendar类实现了公历日历，GregorianCalendar是Calendar类的一个具体实现。
Calendar 的getInstance（）方法返回一个默认用当前的语言环境和时区初始化的GregorianCalendar对象。GregorianCalendar定义了两个字段：AD和BC。这是代表公历定义的两个时代。
import java.util.*;
public class GregorianCalendarDemo {
public static void main(String args[]) {
String months[] = {
"Jan", "Feb", "Mar", "Apr",
"May", "Jun", "Jul", "Aug",
"Sep", "Oct", "Nov", "Dec"};
int year;
// 初始化 Gregorian 日历
// 使用当前时间和日期
// 默认为本地时间和时区
GregorianCalendar gcalendar = new GregorianCalendar();
// 显示当前时间和日期的信息
System.out.print("Date: ");
System.out.print(months[gcalendar.get(Calendar.MONTH)]);
System.out.print(" " + gcalendar.get(Calendar.DATE) + " ");
System.out.println(year = gcalendar.get(Calendar.YEAR));
System.out.print("Time: ");
System.out.print(gcalendar.get(Calendar.HOUR) + ":");
System.out.print(gcalendar.get(Calendar.MINUTE) + ":");
System.out.println(gcalendar.get(Calendar.SECOND));
// 测试当前年份是否为闰年
if(gcalendar.isLeapYear(year)) {
System.out.println("当前年份是闰年");
}
else {
System.out.println("当前年份不是闰年");
}
}
}
/*
结果：
Date: Nov 9 2016
Time: 8:44:54
当前年份是闰年
*/
继承
类继承：类 extends 类
接口继承：类 implements 接口
public interface ICar {
/**
* 接口中的成员特点
* 1.成员变量的特点，没有变量，都是常量
* final 最终固定住变量的值
* 相当于 const
*/
public static final int x = 3;
}
super 与 this 关键字
super关键字（相当于C#的base）：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
this关键字：指向自己的引用。
instanceof 关键字（比较引用类型）
数据类型判断。
instanceof 的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。
/*
author by runoob.com
Main.java
*/
import java.util.ArrayList;
import java.util.Vector;
public class Main {
public static void main(String[] args) {
Object testObject = new ArrayList();
displayObjectClass(testObject);
}
public static void displayObjectClass(Object o) {
if (o instanceof Vector)
System.out.println("对象是 java.util.Vector 类的实例");
else if (o instanceof ArrayList)
System.out.println("对象是 java.util.ArrayList 类的实例");
else
System.out.println("对象是 " + o.getClass() + " 类的实例");
}
}
//对象是 java.util.ArrayList 类的实例
包
为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。
通常，一个公司使用它互联网域名的颠倒形式来作为它的包名.例如：互联网域名是 runoob.com，所有的包名都以 com.runoob 开头。包名中的每一个部分对应一个子目录。
例如：有一个 com.runoob.test 的包，这个包包含一个叫做 Runoob.java 的源文件，那么相应的，应该有如下面的一连串子目录：
....com
unoob estRunoob.java
StringBuffer 和 StringBuilder 类
StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。
StringBuffer 方法
| 描述 | |
|---|---|
| 1 | public StringBuffer reverse() 将此字符序列用其反转形式取代。 |
| 2 | public StringBuffer append(String s) 将指定的字符串追加到此字符序列。 |
| 3 | public delete(int start, int end) 移除此序列的子字符串中的字符。 |
| 4 | public insert(int offset, int i) 将 int 参数的字符串表示形式插入此序列中。 |
| 5 | replace(int start, int end, String str) 使用给定 String 中的字符替换此序列的子字符串中的字符 |
正则表达式
java.util.regex 包主要包括以下三个类：
Pattern 类：
pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。
Matcher 类：
Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern 类一样，Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。
PatternSyntaxException：
PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误。
//匹配 返回true或false
public boolean matches(String regex) {
return Pattern.matches(regex, this);
}
//regex 正则
//replacement 替换内容
public String replaceAll(String regex, String replacement) {
return Pattern.compile(regex).matcher(this).replaceAll(replacement);
}
//使用正则将字符串切割
public String split(String regex)
Arrays数组工具类
binarySearch
使用二进制搜索算法搜索指定值的指定字节数组。 在进行此调用之前，数组必须按照sort(byte[])方法进行排序。 如果没有排序，结果是未定义的。 如果数组包含具有指定值的多个元素，则不能保证将找到哪个元素。
int[] array = {1,4,7,9,11,13,15,18};
/**
* 数组的二分搜索法
* 返回元素在数组中的索引
* 元素不存在。返回 (-(插入点) - 1)
*/
// Integer index = Arrays.binarySearch(array,11); //4
Integer index = Arrays.binarySearch(array,10); // (-4-1)=-5
System.out.println(index);
数组复制
System.arraycopy(src, srcPos, dest, destPos, length)方法,推荐使用
public static void main(String[] args) {
int[] arr = {90,70,80,60,64,57,85,76,74,88};
int[] result = test(arr);
System.out.println(Arrays.toString(result));
// 结果：[57, 60, 64]
}
public static int[] test(int[] array){
Arrays.sort(array);
/**
* arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
将指定源数组中的数组从指定位置复制到目标数组的指定位置。
src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目的地数据中的起始位置。
length - 要复制的数组元素的数量。
*/
int[] result = new int[3];
System.arraycopy(array,0,result,0,3);
return result;
}
数据集合框架
ArrarList数组
该类也是实现了List的接口，实现了可变大小的数组，随机访问和遍历元素时，提供更好的性能。该类也是非同步的,在多线程的情况下不要使用。ArrayList 增长当前长度的50%，插入删除效率低。
LinkedList链表（增删快，查询慢）
该类实现了List接口，允许有null（空）元素。主要用于创建链表数据结构，该类没有同步方法，如果多个线程同时访问一个List，则必须自己实现访问同步，解决方法就是在创建List时候构造一个同步的List。例如：
Listlist=Collections.synchronizedList(newLinkedList(...));
LinkedList 查找效率低。
public static void main(String[] args) {
LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("abc");
linkedList.add("bcd");
linkedList.add("cde");
System.out.println(linkedList); //[abc, bcd, cde]
//addFirst 在该列表开头插入指定的元素。
linkedList.addFirst("1");
linkedList.addFirst("2");
System.out.println(linkedList); //[2, 1, abc, bcd, cde]
//addLast 将指定的元素追加到此列表的末尾。
linkedList.addLast("haha1");
linkedList.addLast("haha2");
System.out.println(linkedList); //[2, 1, abc, bcd, cde, haha1, haha2]
if (!linkedList.isEmpty()) {
//getFirst() 返回此列表中的第一个元素。
String first = linkedList.getFirst();
//getLast() 返回此列表中的最后一个元素。
String last = linkedList.getLast();
System.out.println(first); //2
System.out.println(last); //haha2
}
//pop 删除并返回此列表的第一个元素 此方法相当于removeFirst() 。
linkedList.pop();
System.out.println(linkedList);
//push 在该列表的前面插入元素 此方法相当于addFirst(E) 。
linkedList.push("ccc");
System.out.println(linkedList);
}
Vector （淘汰）
该类和ArrayList非常相似，但是该类是同步的，可以用在多线程的情况，该类允许设置默认的增长长度，默认扩容方式为原来的2倍。
特点：
- 线程安全
- 运行速度慢
HashSet（存储快，查询快）
- 该类实现了Set接口，不允许出现重复元素，不保证集合中元素的顺序，允许包含值为null的元素，但最多只能一个。
- 这个类提供了基本操作（add，remove，contains和size）固定的时间性能，假定哈希函数将分散的桶中正确的元素。 迭代此集合需要与HashSet实例的大小（元素数量）和后台HashMap实例（桶数）的“容量”的总和成比例的时间。 因此，如果迭代性能很重要，不要将初始容量设置得太高（或负载因子太低）是非常重要的。
- 初始数组长度：16. 加载因子：0.75.
- 如果数组长度>16*0.75=12，数组就要扩容（复制）
LinkedHashSet
具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。
- 继承自HashSet。
- 线程不安全。
- 有序的。
HashMap
HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。
该类实现了Map接口，根据键的HashCode值存储数据，具有很快的访问速度，最多允许一条记录的键为null，不支持线程同步。
| 返回值 | 方法 | 描述 |
|---|---|---|
| V | put(K key, V value) | 将指定的值与此映射中的指定键相关联 返回值：一般为null,存在重复键，返回覆盖前的值 |
| V | get(Object key) | 返回到指定键所映射的值。 |
| V | remove(Object key) | 从该地图中删除指定键的映射（如果存在）。 |
Set<K> |
keySet() | 返回此地图中包含的键的Set视图。 |
Set<Map.Entry<K,V>> |
entrySet() | 返回此地图中包含的映射的Set视图。 |
Map的遍历方式：
- 键查找：
1.keySet() 得到所有键。
2.遍历Set<K>集合。
3.get() 根据键得到value。
Map<Integer, String> map = new HashMap<Integer, String>();
map.put(1,"a");
map.put(2,"b");
map.put(3,"c");
Set<Integer> set = map.keySet();
Iterator<Integer> it = set.iterator();
while (it.hasNext()){
int key = it.next();
String value = map.get(key);
System.out.print(value + " ");
}
Map.Entry<K,V>通过键值对，找键，找值
1.调用entrySet() 将集合映射关系存储到Set集合Set<Map.Entry<K,V>>
2.迭代Set集合
3.通过getKey，getValue获取键值对
public static void main(String[] args) {
Map<Integer, String> map = new HashMap<>();
map.put(1, "a");
map.put(2, "b");
map.put(3, "c");
Set<Map.Entry<Integer, String>> setlist = map.entrySet();
for (Map.Entry<Integer, String> set : setlist ) {
System.out.println(set.getKey()+":"+set.getValue());
}
// 1:a
// 2:b
// 3:c
}
斗地主案例：
public class PuKe {
public static void main(String[] args) {
String[] numbers = {"2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3"};
String[] colors = {"♠", "♥", "♣", "♦"};
ArrayList<Integer> plaer1 = new ArrayList();
ArrayList<Integer> plaer2 = new ArrayList();
ArrayList<Integer> plaer3 = new ArrayList();
ArrayList<Integer> bottom = new ArrayList();
//key 序号 value 牌
//完成数字与纸牌的映射关系：使用双列Map(HashMap)集合，完成一个数字与字符串纸牌的对应关系(相当于一个字典)。
HashMap<Integer, String> pooker = new HashMap<>();
ArrayList<Integer> arrayList = new ArrayList();
int index = 2;
for (String number : numbers
) {
for (String color : colors
) {
//从2开始，0：大王，1：小王
pooker.put(index, color + number);
arrayList.add(index);
index++;
}
}
pooker.put(0, "大王");
pooker.put(1, "小王");
arrayList.add(0);
arrayList.add(1);
//
System.out.println("hasMap映射的数字数组（单独）："+arrayList);
//洗牌
Collections.shuffle(arrayList);
System.out.println("洗牌后，hasMap映射的数字数组（单独）："+arrayList);
//发牌
bottom.add(arrayList.get(arrayList.size() - 1));
bottom.add(arrayList.get(arrayList.size() - 2));
bottom.add(arrayList.get(arrayList.size() - 3));
for (int i = 0; i < arrayList.size() - 3; i++) {
switch (i % 3) {
case 0:
plaer1.add(arrayList.get(i));
break;
case 1:
plaer2.add(arrayList.get(i));
break;
case 2:
plaer3.add(arrayList.get(i));
break;
}
}
System.out.println("=====分配到玩家手里的牌====");
System.out.println(plaer1);
System.out.println(plaer2);
System.out.println(plaer3);
System.out.println(bottom);
Collections.sort(plaer1);
Collections.sort(plaer2);
Collections.sort(plaer3);
System.out.println("=====玩家手里的牌，排序后====");
System.out.println(plaer1);
System.out.println(plaer2);
System.out.println(plaer3);
System.out.println(bottom);
System.out.println("====查看手里的牌在hasMap映射后的结果=====");
System.out.print("plaer1:");
look(plaer1, pooker);
System.out.print("plaer2:");
look(plaer2, pooker);
System.out.print("plaer3:");
look(plaer3, pooker);
System.out.print("bottom:");
look(bottom, pooker);
}
//看牌
public static void look(ArrayList<Integer> arrayList, HashMap<Integer, String> pooker) {
for (Integer key : arrayList
) {
String value = pooker.get(key);
System.out.print(value + " ");
}
System.out.println();
}
hasMap映射的数字数组（单独）：[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, 0, 1]
洗牌后，hasMap映射的数字数组（单独）：[44, 19, 39, 16, 34, 32, 24, 35, 7, 18, 8, 17, 26, 23, 29, 47, 48, 4, 12, 51, 15, 6, 0, 46, 50, 30, 43, 22, 36, 42, 33, 1, 27, 53, 13, 38, 49, 41, 21, 10, 40, 14, 20, 37, 3, 25, 28, 9, 31, 45, 52, 2, 5, 11]
=====分配到玩家手里的牌====
[44, 16, 24, 18, 26, 47, 12, 6, 50, 22, 33, 53, 49, 10, 20, 25, 31]
[19, 34, 35, 8, 23, 48, 51, 0, 30, 36, 1, 13, 41, 40, 37, 28, 45]
[39, 32, 7, 17, 29, 4, 15, 46, 43, 42, 27, 38, 21, 14, 3, 9, 52]
[11, 5, 2]
=====玩家手里的牌，排序后====
[6, 10, 12, 16, 18, 20, 22, 24, 25, 26, 31, 33, 44, 47, 49, 50, 53]
[0, 1, 8, 13, 19, 23, 28, 30, 34, 35, 36, 37, 40, 41, 45, 48, 51]
[3, 4, 7, 9, 14, 15, 17, 21, 27, 29, 32, 38, 39, 42, 43, 46, 52]
[11, 5, 2]
====查看手里的牌在hasMap映射后的结果=====
plaer1:♠A ♠K ♣K ♣Q ♠J ♣J ♠10 ♣10 ♦10 ♠9 ♥8 ♦8 ♣5 ♥4 ♦4 ♠3 ♦3
plaer2:大王 小王 ♣A ♦K ♥J ♥10 ♣9 ♠8 ♠7 ♥7 ♣7 ♦7 ♣6 ♦6 ♦5 ♣4 ♥3
plaer3:♥2 ♣2 ♥A ♦A ♠Q ♥Q ♦Q ♦J ♥9 ♦9 ♣8 ♠6 ♥6 ♠5 ♥5 ♠4 ♣3
bottom:♥K ♦2 ♠2
LinkedHashSet
具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。
Hashtable（淘汰）
Hashtable 是 Dictionary(字典) 类的子类，位于 java.util 包中。
- 线程安全。
- 不能存null。
Properties
Properties 继承于 Hashtable，表示一个持久的属性集，属性列表中每个键及其对应值都是一个字符串。
可变参数
数据类型...变量
1.一个方法中，可变参只能有1个
2.可变参数，必须写在参数列表的最后一位
System.out.println(Sum(1,2,3,5,6));
public static int Sum(int...a){
int result= 0;
for (int model: a
) {
result +=model;
}
return result;
}
//2.可变参数，必须写在参数列表的最后一位
public static int Del(int a,int b,int...c)
异常处理
要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常：
洒洒水
- 检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
- 运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。（不能发生，如果发生必须修改源代码）
- 错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。
throws/throw 关键字：
如果一个方法没有捕获一个检查性异常，那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。
也可以使用 throw 关键字抛出一个异常，无论它是新实例化的还是刚捕获到的。
public static void main(String[] args) throws Exception {
// Method implementation
throw new RemoteException();
}
异常方法
下面的列表是 Throwable 类的主要方法:
| 方法 | 说明 |
|---|---|
| public String getMessage() | 返回关于发生的异常的详细信息。这个消息在Throwable 类的构造函数中初始化了。 |
| public Throwable getCause() | 返回一个Throwable 对象代表异常原因。 |
| public String toString() | 使用getMessage()的结果返回类的串级名字。 |
| public void printStackTrace() | 打印toString()结果和栈层次到System.err，即错误输出流。 |
| public StackTraceElement [] getStackTrace() | 返回一个包含堆栈层次的数组。下标为0的元素代表栈顶，最后一个元素代表方法调用堆栈的栈底。 |
| public Throwable fillInStackTrace() | 用当前的调用栈层次填充Throwable 对象栈层次，添加到栈层次任何先前信息中。 |