扑克牌案列，异常，File
来源：互联网 发布：sql数据库怎么用 编辑：程序博客网 时间：2024/04/29 04:47
一 .键盘录入学生案列
熟练运用TreeMap的排序方式：
需求：键盘录入5个学生信息，并按总成绩从大到小的顺序排序
1.创建一个标准的学生类 package com.edu01;public class Student implements Comparable<Student>{ private String name; private int chinese; private int math; private int english; private int allScore; public Student() { super(); // TODO Auto-generated constructor stub } public Student(String name, int chinese, int math, int english, int allScore) { super(); this.name = name; this.chinese = chinese; this.math = math; this.english = english; this.allScore = allScore; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getChinese() { return chinese; } public void setChinese(int chinese) { this.chinese = chinese; } public int getMath() { return math; } public void setMath(int math) { this.math = math; } public int getEnglish() { return english; } public void setEnglish(int english) { this.english = english; } public int getAllScore(){ return chinese + math + english; } @Override public int compareTo(Student s) { // TODO Auto-generated method stub int num = this.getAllScore() - s.getAllScore(); int num2 = num==0?this.name.compareTo(s.name):num; return num2; }}package com.edu01;import java.util.Scanner;import java.util.TreeSet;public class Test { public static void main(String[] args) { //4:键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台 //创建一个TreeSet集合 TreeSet<Student> ts = new TreeSet<Student>(); for (int i = 0; i < 5; i++) { Scanner sc = new Scanner(System.in); System.out.println("请输入你的姓名"); String name = sc.nextLine(); System.out.println("请输入你的语文成绩"); int chinese = sc. nextInt(); System.out.println("请输入你的数学成绩"); int math = sc.nextInt(); System.out.println("请输入你的英语成绩"); int english = sc.nextInt(); //将上面所有信息封装成一个对象 int allScore = chinese+math+english; //创建学生对象 Student s = new Student(name, chinese, math, english, allScore); ts.add(s); } //遍历集合 for (Student s : ts) { System.out.println(s.getName()+" "+s.getAllScore()); } }}二. 斗地主案例（一）
熟悉List集合，完成斗地主案例
package com.edu03;import java.util.ArrayList;import java.util.Collections;public class Poker { public static void main(String[] args) { //创建牌盒 ArrayList<String> al = new ArrayList<String>(); String []colors = {"梅花","方片","红桃","黑桃"}; String []numbers = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"}; for (String c : colors) { for (String n : numbers) { al.add(c+n); } } al.add("小王"); al.add("大王"); Collections.shuffle(al); ArrayList<String> zhangsan = new ArrayList<String>(); ArrayList<String> lisi = new ArrayList<String>(); ArrayList<String> wangwu = new ArrayList<>(); ArrayList<String> dipai = new ArrayList<>(); //发牌 for (int i = 0; i < al.size(); i++) { if(i>=al.size()-3){ dipai.add(al.get(i)); }else if(i%3==0){ zhangsan.add(al.get(i)); }else if(i%3==1){ lisi.add(al.get(i)); }else if(i%3==2){ wangwu.add(al.get(i)); } } lookpoker("张三",zhangsan); lookpoker("李四",lisi); lookpoker("王五",wangwu); lookpoker("底牌",dipai); } private static void lookpoker(String string, ArrayList<String> al) { // TODO Auto-generated method stub System.out.println(string+"的牌是："); for (String string2 : al) { System.out.print(string2+" "); } System.out.println(); } }案例二：由于TreeMap集合低层机构为二叉树结构，所以我们可以利用TreeMap集合的有序性来改进上面的程序：
package com.edu03;import java.util.ArrayList;import java.util.Collections;import java.util.TreeMap;import java.util.TreeSet;public class PokerDemo2 { public static void main(String[] args) { //利用TreeMap集合 TreeMap<Integer, String> tm = new TreeMap<Integer,String>(); String []colors = {"红桃","黑桃","方片","梅花",}; String []numbers = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"}; ArrayList<Integer> list = new ArrayList<Integer>(); int index= 0; for (String string : numbers) { for (String c : colors) { tm.put(index, string+c); list.add(index); index++; } } tm.put(index, "小王"); list.add(index); index++; tm.put(index,"大王" ); list.add(index); Collections.shuffle(list); //由于每个个人的拍都要排好序，所以我们选择TreeSet集合 TreeSet<Integer> zhangsan = new TreeSet<Integer>(); TreeSet<Integer> lisi = new TreeSet<Integer>(); TreeSet<Integer> wangwu = new TreeSet<Integer>(); TreeSet<Integer> dipai = new TreeSet<Integer>(); //发牌 for (int i = 0; i < list.size(); i++) { if(i>= list.size()-3){ dipai.add(list.get(i)); }else if(i%3==0){ zhangsan.add(list.get(i)); }else if(i%3==1){ lisi.add(list.get(i)); }else if(i%3==2){ wangwu.add(list.get(i)); } } lookpoker("张三",zhangsan,tm); lookpoker("李四",lisi,tm); lookpoker("王五",wangwu,tm); lookpoker("底牌",dipai,tm); } private static void lookpoker(String string, TreeSet<Integer> list, TreeMap<Integer, String> tm) { // TODO Auto-generated method stub System.out.println(string+"的牌是："); for (Integer integer : list) { System.out.print(tm.get(integer)+" "); } System.out.println(); }}一：
异常：
1.1
异常：就是程序出现的不正常的情况。
举例：
* 异常：
* 错误：这是非常严重的问题，一般我们处理不了,一般在这里指的是硬件问题。
* 异常：
* 编译时期异常 开始就必须要处理的，如果不处理，后面就走不了。
* 运行时期异常 开始可以不用处理。这种问题一旦发生，就是我们的程序问题，需要我们修改程序。
*
* 体系结构：
* Throwable：
* Error：
* Exception：
* 非RuntimeException：编译时期异常
* RuntimeException：运行时期异常
- 比如除数不能为0
- java.lang.ArithmeticException: / by zero
public class ExceptionDemo2 { public static void main(String[] args) { System.out.println("start"); int a = 10; int b = 0; System.out.println(a/b);//java.lang.ArithmeticException: / by zero System.out.println("end"); }}针对异常，JVM默认的处理方案：
* 一旦遇到程序出现了问题，就会把问题的类名，错误原因，错误的位置等信息打印在控制台，以便我们观察。并且，会自动从当前出问题的地方停止掉。
* 这种处理方案虽然可以，但是不够好。 哪里不好呢?
*其实程序出问题，不应该直接停止，因为我们的程序可能是由多部分组成的，其中一个部分出问题了，不应该影响其他部分的执行。
* 所以，我们应该让其他的部分能够执行下去。
1.2
对于上面的问题我们有以下方案：
* 两种方案：
* A:try…catch…finally
* B:throws
*
* try…catch…finally:
* try{
* 可能出现异常的代码
* }catch(异常类名 变量名) {
* 针对异常的代码处理
* }finally {
* 释放资源的地方
* }
*
* 简化一下第一个：
* try{
* 可能出现异常的代码
* }catch(异常类名 变量名) {
* 针对异常的代码处理
* }
public class ExceptionDemo3 { public static void main(String[] args) { System.out.println("start"); int a= 10; int b = 0; try{ //可能出现异常的代码 System.out.println(a/b);//当除数为0的时候会抛出ArithmeticException这个异常 //接着程序会拿着这个异常和catch里面的异常类已经对比 }catch(ArithmeticException e){ //当程序抛出ArithmeticException这个异常之后给出的具体的处理方法 System.out.println("你的除数不能为0"); } System.out.println("end"); }}
1.3
* 多个异常的处理
* A:针对每一个出现问题的地方写一个try…catch语句
* B:针对多个异常，采用一个try，多个catch的情况。
* try…catch…catch…
* 注意：有多个catch时候，运行时，只能运行出一个错误，而程序不会返回到try
例如下面的程序运行结果：
不能运行出除数为0的结果
*
* 遇到try里面的问题，就自动和catch里面进行匹配。
* 一旦匹配就执行catch里面的内容，执行完毕后，接着执行后面的代码。
*
* 注意：
* 如果异常间有子父关系，父必须在最后。（因为如果异常放在前面，则发生异常的时候都会被父类异常接受，后面会报错）
package com.edu_01;public class ExceptionDemo4 { public static void main(String[] args) { //多个异常处理的第一种解决方案 //A：给每一个可能出现异常的代码全部加上try..catch../* try{ System.out.println(10/0); }catch(ArithmeticException e){ System.out.println("除数不能为0"); } int[] arr = {1,2,3}; try{ System.out.println(arr[3]);//抛出IndexOutOfBoundsException这个异常 }catch(IndexOutOfBoundsException e){ System.out.println("数组越界了"); }*/ //B:针对多个异常，采用一个try，多个catch的情况。 //当存在多个catch情况下，如果异常类之间存在子父关系，那么父类应该放到最后 int[] arr = {1,2,3}; try{ System.out.println(arr[3]);//抛出IndexOutOfBoundsException System.out.println(10/0);//抛出ArithmeticException arr = null; System.out.println(arr[2]);//抛出空指针异常NullpointerException }catch(IndexOutOfBoundsException e){//Exception e = new IndexOutOfBoundsException(); System.out.println("数组越界了"); }catch(ArithmeticException e){ System.out.println("除数不能为0"); }catch(Exception e){//当前面的异常类都没有匹配到之后，会自动匹配这个异常 System.out.println("出现了其他异常"); } }}1.4
* 编译时期异常和运行时期异常的区别:
* 编译时期异常：Java程序必须显示处理，否则程序就会发生错误，无法通过编译
* FileNotFoundException（文件未找到异常）
* 运行时期异常：无需显示处理，也可以和编译时异常一样处理
* ArithmeticException
1.5
* Throwable中的方法：
* printStackTrace():打印异常信息，程序从出问题的地方开始就会打印创建一个该异常对应的对象，
该对象直接调用打印方法
public class ExceptionDemo6 { public static void main(String[] args) { try{ System.out.println(10/0);//当程序出问题了之后会抛出一个ArithmeticException的对象 //new ArithmeticException() }catch(ArithmeticException e){//ArithmeticException e = new ArithmeticException(); e.printStackTrace();//打印异常信息 //java.lang.ArithmeticException: / by zero //at com.edu_01.ExceptionDemo6.main(ExceptionDemo6.java:12) } }}1.6
* try…catch 是直接进行了处理。
* 而throws则是把异常处理的事情交给了调用者。
*
* throws用在方法上，声明方法有异常，交给调用者处理。
* 但是呢，如果是编译时期异常，调用就必须处理。
* 如果是运行时期异常，调用者可以处理，也可以不处理。
*
1.7
* throws *
* 用在方法声明后面，跟的是异常类名
* 可以跟多个异常类名，用,号隔开
* 表示抛出异常，由该方法的调用者来处理
* throws表示出现异常的一种可能，并不一定会发生这些异常
1.8
* 异常处理：
* try…catch…finally
*
* finally:一般用于释放资源。在数据库操作或者IO流比较常见。
*
* 特点：
* 被finally控制的语句体一定会执行
*
* 特殊情况：在执行到finally之前jvm退出了(比如System.exit(0))
public class ExceptionDemo8 { public static void main(String[] args) { try{ System.out.println(10/0); }catch(ArithmeticException e){ System.out.println("除数为0了"); //在执行finally语句体之前jvm虚拟机退出了，那么就不会被执行 System.exit(0); }finally{ //这个代码块里面的代码一定会被执行的 System.out.println("我是finally我一定会被执行"); } }}1.9
* final,finally的区别?
* final:最终的意思。可以修饰类，方法，变量。
* 修饰类，类不能被继承
* 修饰方法，方法不能被重写
* 修饰变量，变量是常量
* finally:
* 异常处理的一部分。被finally控制的代码一定会执行。
* 特殊情况：在执行到finally之前，jvm退出了。
1.9.1
* 注意：
* A:子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了,儿子不能比父亲更坏)
* B:如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常
C:如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws
上述仅仅针对编译时期异常
与运行时期异常无关。
1.9.2
throw和throws的区别？
* throws:
* 用在方法声明后面，跟的是异常类名
* 可以跟多个异常类名，用逗号隔开
* 表示抛出异常，由该方法的调用者来处理
* throws表示出现异常的一种可能性，并不一定会发生这些异常
*
* throw:
* 用在方法体内，跟的是异常对象名
* 只能抛出一个异常对象名
* 表示抛出异常，由方法体内的语句处理
* throw则是抛出了异常，执行throw则一定抛出了某种异常！
- throw:
- 如果throw的是编译时期异常，在方法声明上必须用throws进行标记
- 如果throw的是运行时期异常，在方法声明上可以用throws进行标记，也可以不用。
public class ThrowDemo { public static void main(String[] args) { method(); try { method2(); } catch (FileNotFoundException e) { e.printStackTrace(); } } private static void method2() throws FileNotFoundException{ try{ FileInputStream fis = new FileInputStream("D://a.txt"); }catch(FileNotFoundException e){ //当遇见这个异常之后，直接抛出(这就是我给出的处理方法) //如果【抛出的是编译时期异常的话，必须在方法声明上给予声明 throw new FileNotFoundException(); } } private static void method() throws ArithmeticException{ int a = 10; int b = 2; if (b==0) { //在这里抛出的是运行时期异常，抛出这个异常的同时，可以在方法声明上给予声明，也可以不声明 throw new ArithmeticException(); }else { System.out.println(a/b); } }}1.1
File:文件和目录(文件夹)路径名的抽象表示形式。
1.2
File的构造方法：
File(String pathname):把一个路径名称封装成File对象
File(String parent, String child):把一个父路径和一个子路径封装成一个File对象
File(File parent, String child):把一个父路径File对象和一个子路径封装成一个File对象
public class FileDemo { public static void main(String[] args) throws IOException { //File(String pathname):把一个路径名称封装成File对象 //File file = new File("D://a.txt"); //System.out.println(file.createNewFile());//当文件不存在的时候，创建文件，如果文件存在，不创建 System.out.println("------------"); //File(String parent, String child):把一个父路径和一个子路径封装成一个File对象 File file = new File("D://test", "a.txt"); //java.io.IOException: 系统找不到指定的路径, //创建文件的时候一定要保证路径存在 System.out.println(file.createNewFile()); System.out.println("-----------------"); //File(File parent, String child):把一个父路径File对象和一个子路径封装成一个File对象// File file = new File("D://test");// File file2 = new File(file, "a.txt");// System.out.println(file2.createNewFile()); }}1.3
创建功能：
A:创建文件
public boolean createNewFile():如果文件不存在，就创建。否则，不创建。
需求：D盘下造一个文件a.txt
B:创建目录
public boolean mkdir():如果目录不存在，就创建。否则，不创建。
需求：D盘下造一个文件夹test
public boolean mkdirs():如果目录不存在，就创建。否则，不创建。
即时父目录不存在，也可以连父目录一起创建。
需求：D盘下造一个文件夹("D:\\ddd\\eee\\f.txt");public class FileDemo { public static void main(String[] args) { //public boolean mkdir():如果目录不存在，就创建。否则，不创建。 //需求：D盘下造一个文件夹test //File file = new File("D://test"); //System.out.println(file.mkdir()); System.out.println("----------"); //public boolean mkdirs():如果目录不存在，就创建。否则，不创建。 //即时父目录不存在，也可以连父目录一起创建。 //File file = new File("D://aa//bb//a.txt"); //System.out.println(file.mkdirs()); }}1.4
删除功能：
public boolean delete():既可以删除文件，又可以删除目录。
路径问题：
A:绝对路径 就是以盘符开始的路径(d:\test\aaa\b.txt)
B:相对路径 就是不以盘符开始的路径(a.txt)
一般都是相对应当前的项目而言的。
注意事项：
A:Java程序的删除不走回收站。
B:如果目录内还有内容就不能删除。
1.5
判断功能
public boolean isDirectory():是否是目录
public boolean isFile():是否是文件
public boolean exists():是否存在
public boolean canRead():是否可读
public boolean canWrite():是否可写
public boolean isHidden():是否隐藏
public class FileDemo3 { public static void main(String[] args) throws IOException { //在D://a.txt File file = new File("D://a.txt"); System.out.println(file.createNewFile()); System.out.println("是否是目录:"+file.isDirectory()); System.out.println("是否是文件:"+file.isFile()); System.out.println("是否存在:"+file.exists()); System.out.println("是否可读:"+file.canRead()); System.out.println("是否可写:"+file.canWrite()); System.out.println("是否隐藏:"+file.isHidden()); }}1.6获取功能
public String getAbsolutePath():获取绝对路径
public String getPath():获取相对路径
public String getName():获取名称
public class FileDemo4 { public static void main(String[] args) throws IOException { //创建一个文件 File file = new File("a.txt"); //创建一个文件 //System.out.println(file.createNewFile()); // public String getAbsolutePath():获取绝对路径 System.out.println(file.getAbsolutePath());//D:\workspace\十二天_File\a.txt //public String getPath():获取相对路径 System.out.println(file.getPath());//a.txt //public String getName():获取名称 System.out.println(file.getName()); }}- 扑克牌案列，异常，File
- 异常#File
- 扑克牌
- 扑克牌
- 扑克牌
- 扑克牌
- 扑克牌
- 扑克牌
- 扑克牌
- 扑克牌
- 扑克牌
- 扑克牌
- 异常,IO-File笔记
- IO-异常、File、递归
- day19（异常，File）
- 异常、file类
- day19<异常&File类>
- 异常和File类
- linux上安装redis（单节点）
- hdu1166题解
- 究竟能菜到什么程度？—SSH（1）
- AOJ-problem-829
- TX1上挂载SD卡
- 扑克牌案列，异常，File
- 基于proteus的51单片机仿真实例六十、8位数码管显示实例
- Java面试题
- TypeError: not all arguments converted during string formatting
- 算法提高 最小方差生成树 （kruskal）
- 最近过的不太顺心
- 通过sqoop将MySQL数据库中的数据导入Hbase
- 第一章数据结构
- Jquery内容选择器选择元素
