字符串的不变性！

如：

String s1="你好"；

String s2="你好"；

s1=s2;//是正确的。

但是String s3= new String("你好")；

s1=s3;//是错误的，s3开辟的新的内存地址。

用equals()方法，比较s1和s3相等是正确的。//只比较值是否相等。

indexOf(java),如果序列中没有相等的对象会返回-1

判断字符是否相同时，用“==”，不需要用equals();

使用equals()方法比较两个字符串的内容是否相同，并且使用indexOf方法时，O一定要大写，

这里需要以后再看

Java中的泛型

集合中的元素，可以是任意类型的对象（对象的引用）；

如果把某个对象放入集合，集合会忽略它的类型，将它当中Object类型处理；

泛型规定了某个集合只可以存放特定类型的对象，并且会在编译期间进行类型检查，而在取出集合中的对象时可以直接按指定类型获取；

public class HelloWorld {    public static void main(String[] args) {        // Java文件名		String fileName = "HelloWorld.java";         // 邮箱		String email = "laurenyang@imooc.com";				// 判断.java文件名是否正确：合法的文件名应该以.java结尾        /*        参考步骤：        1、获取文件名中最后一次出现"."号的位置        2、根据"."号的位置，获取文件的后缀        3、判断"."号位置及文件后缀名        */        //获取文件名中最后一次出现"."号的位置		int index = fileName.lastIndexOf(".");                // 获取文件的后缀		String pr =fileName.substring(index);        		// 判断必须包含"."号，且不能出现在首位，同时后缀名为"java"		if ( index > 1 && pr.equals(".java")  ) {			System.out.println("Java文件名正确");		} else {			System.out.println("Java文件名无效");		}        // 判断邮箱格式是否正确：合法的邮箱名中至少要包含"@", 并且"@"是在"."之前         /*        参考步骤：        1、获取文件名中"@"符号的位置        2、获取邮箱中"."号的位置        3、判断必须包含"@"符号，且"@"必须在"."之前        */	    // 获取邮箱中"@"符号的位置		int index2 = email.indexOf("@");                // 获取邮箱中"."号的位置		int index3 = email.indexOf('.');        		// 判断必须包含"@"符号，且"@"必须在"."之前		if (index2 != -1 && index3 > index2) {			System.out.println("邮箱格式正确");		} else {			System.out.println("邮箱格式无效");		}	}}

1. 处理运行时异常，采用逻辑去合理规避同时辅助try-catch处理。

2. 在多重catch快后面，可以加一个catch（Exception）来处理可能会被遗漏的异常。

3. 对于不确定的代码，也可以加上try-catch，处理潜在的异常。

4. 尽量去处理异常，切记只是简单的调用printStackTrace（）去打印输出。尽量加上业务回滚之类的异常。

5. 集体如何处理异常，要根据不同的业务需求和异常类型去决定。

6. 尽量添加finally语句块去释放占用的资源。
   

import java.util.ArrayList;
import java.util.List;
public class player {
String name;
int id;
List<puke> pukes;//拿到的牌的列表
public player(String newname,int newid){
this.name=newname;
this.id=newid;
pukes=new ArrayList<puke>();
}
}

public class puke {
public String name;
public int h_id;//花色的ID，0-3，为了对比花的大小
public int s_id;//数的ID，为了对比数的大小，0-12
public  puke(String newname, int newh_id, int news_id) {
// TODO Auto-generated constructor stub
this.name=newname;
this.h_id=newh_id;
this.s_id=news_id;
}
public puke(){
}
}
/*
 * 主方法
 */
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.Scanner;
public class test {
List<puke> pukelist=new ArrayList<puke>();//扑克牌列表
List<player> pList=new ArrayList<player>();//玩家列表
//创建扑克牌
public void createpukelist(){
String[] huastr={"方片","梅花","红桃","黑桃"};
String[] sustr={"2","3","4","5","6","7","8","9","10","J","Q","K","A"};
System.out.println("---------------创建扑克牌-----------------");
for(int i=0;i<=3;i++){
for(int j=0;j<13;j++){
puke puke=new puke(huastr[i]+sustr[j], i, j);
pukelist.add(puke);
}
}
System.out.println("--------------创建扑克牌成功---------------");
String pkString="";
for (puke pk1 : pukelist) {
pkString=pkString+pk1.name+",";
}
System.out.println("扑克牌为："+pkString);
System.out.println("--------------开始洗牌---------------");
Collections.shuffle(pukelist);//对List随机排序
System.out.println("--------------洗牌结束---------------");
}
//创建玩家
public void createplayer(){
Scanner scanner=new Scanner(System.in);
int i=0;
System.out.println("--------------创建玩家---------------");
while (i<2) {
System.out.println("请输入玩家ID：");
if(scanner.hasNextInt()==true){
int playerid=scanner.nextInt();
System.out.println("请输入玩家姓名：");
String playername=scanner.next();
player pl=new player(playername, playerid);
pList.add(pl);
System.out.println("欢迎玩家:"+pl.name);
i++;
}else{
System.out.println("ID类型错误");
scanner=new Scanner(System.in);//如果不加该语句Scanner输入的值并不会刷新，所以就会出现无限死循环。
continue;
}
}
}
//发牌
public void putpuke(){
System.out.println("---------发牌开始-------------");
int k=0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
pList.get(j).pukes.add(pukelist.get(k));
System.out.println("玩家："+pList.get(j).name+"拿牌");
k++;
}
}
System.out.println(k);
System.out.println("---------发牌结束-------------");
}
public void contrastpuke(){
List<Integer> maxplids=new ArrayList<Integer>();
puke p1,p2,maxpuke=new puke();
p1=contrastPuke(pList.get(0).pukes.get(0),pList.get(0).pukes.get(1));
p2=contrastPuke(pList.get(1).pukes.get(0),pList.get(1).pukes.get(1));
System.out.println("玩家"+pList.get(0).name+"最大手牌为："+p1.name);
System.out.println("玩家"+pList.get(1).name+"最大手牌为："+p2.name);
maxpuke=contrastPuke(p1,p2);
if(maxpuke==p1){
System.out.println("玩家"+pList.get(0).name+"胜利");
}else{
System.out.println("玩家"+pList.get(1).name+"胜利");
}
for (player player : pList) {
System.out.println("玩家"+player.name+"的牌为：");
for(int i=0;i<player.pukes.size();i++){
System.out.println(player.pukes.get(i).name);
}
}
}
//比较两个牌的大小，先按照牌的数进行比较，如果数一样，则比较花色大小
public puke contrastPuke(puke pk1,puke pk2){
if (pk1.s_id>pk2.s_id) {
return pk1;
}else if (pk1.s_id==pk2.s_id) {
if(pk1.h_id>pk2.h_id){
return pk1;
}else{
return pk2;
}
}else {
return pk2;
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
test test=new test();
test.createpukelist();//创建扑克牌
test.createplayer();//创建玩家列表
test.putpuke();//发牌
test.contrastpuke();//对比
}
}

try{//一些会抛出异常的方法}catch（Exception e）{//处理该异常的代码块}

处理多个catch异常注意：顺序问题，先小后大【子类-->父类】

                                      善后工作-->finally{//最终将要执行的一些代码。}

异常处理的作用：Java异常体系结构简介。

处理异常：①try-catch以及try-catch-finally②抛出异常③自定义异常④异常链。

异常是：有异于常态，和正常情况不一样，有错误出现，阻止当前方法或作用域，称之为异常。

异常称之为：Throwable分为Erro和Exception。

int c = 10;
        //将基本类型转换为字符串类型
        //调用toString方法
        String str= Integer.toString(c);
        //System.out.println(str);
        //拼接字符串
        String str1 =c+"";
        System.out.println(str1);
        //通过valueOf方法
        String str2 = String.valueOf(c);
        System.out.println(str2);
        
        //将字符串类型转换为基本类型
        //通过Integer.parseInt(方法)
        String str3 = "a";
        int parseInt = Integer.parseInt(str3);
        System.out.println(str3);
        //可以通过valueOf方法
        Integer valueOf = Integer.valueOf(str3);
        System.out.println(str3);

基本类型是不能调用方法的，而其包装类具有很多方法

Java中的集合

Java中的集合类：是一种工具类，就像是容器，存储任意数量的具有共同属性的对象。

集合的作用：

1、在类的内部，对数据进行组织；

2、简单而快速的搜索大数量的条目；

3、有的集合接口，提供了一系列排列有序的元素，并且可以在序列中间快速的插入或者删除有关元素；

4、有的集合接口，提供了映射关系，可以通过关键字(key)去快速查找到对应的唯一对象，而这个关键字可以是任意类型。

与数组的对比：

数组的长度固定，集合长度可变；

数组只能通过下标访问元素，类型固定，而有的集合可以通过任意类型查找所映射的具体对象；

Java中的集合主要有两种(根接口)： Collection和Map；

Cellection有三个子接口：List(序列)、Queue(队列)和Set(集)

其中List和Queue存储的元素是排列有序的，并且可以重复，而Set中的元素是无序且不可重复的；

    List中有一个中有一个重要的实现类：ArrayList(数组序列)

    Queue中也有一个重要的实现类：LinkedList(链表)他同时也是List接口的实现类

    Set中也有一个重要的实现类：HashSet

Map也有很多子接口，但最常用的是它的实现类HashMap(哈希表)；

Collection中存储的就是一个一个的对象，而Map类中会以<Key,Value>的形式存储数据，这种形式是Entry类的实例，这个Entry类是Map中的一个类，叫做键值对；Key和Value都可以是任意类型的对象；

每一个元素存储在集合中时都被看作是Object类型，当它们被取出时要进行类型转换。

集合中的元素可以是任意类型的对象（对象的引用）；

Java中的Calendar类

Date 类最主要的作用就是获得当前时间，同时这个类里面也具有设置时间以及一些其他的功能，但是由于本身设计的问题，这些方法却遭到众多批评，不建议使用，更推荐使用 Calendar 类进行时间和日期的处理。

java.util.Calendar 类是一个抽象类，可以通过调用 getInstance() 静态方法获取一个 Calendar 对象，此对象已由当前日期时间初始化，即默认代表当前时间，如 Calendar c = Calendar.getInstance();

其中，调用 Calendar 类的 getInstance() 方法获取一个实例，然后通过调用 get() 方法获取日期时间信息，参数为需要获得的字段的值， Calendar.Year 等为 Calendar 类中定义的静态常量。

Calendar 类提供了 getTime() 方法，用来获取 Date 对象，完成 Calendar 和 Date 的转换，还可通过 getTimeInMillis() 方法，获取此 Calendar 的时间值，以毫秒为单位。如下所示：