Java的String类、Date、IO综合练习、异常

淡忘728

已于 2022-12-16 10:21:39 修改

阅读量134

点赞数

文章标签： java jvm servlet

于 2022-12-14 13:37:07 首次发布

本文链接：https://blog.csdn.net/weixin_65824274/article/details/128314447

版权

案例练习：读取D盘的a.txt文档，把文档中的数据封装在学生信息中

1.创建一个Student类，其中包括属性和方法

package Test11;

import java.util.Date;

public class Student {
    private String name;
    private String sex;
    private Date birthday;
    private String address;

    //无参数的构造方法
    public Student() {
    }

    //含参数的构造方法
    public Student(String name, String sex, Date birthday, String address) {
        this.name = name;
        this.sex = sex;
        this.birthday = birthday;
        this.address = address;
    }

    //set和get方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    //toString方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", birthday=" + birthday +
                ", address='" + address + '\'' +
                '}'+'\n';
    }
}

2.读取D盘的a.txt文档，把文档中的数据封装在学生信息中

1.定义File对象，关联映射磁盘文件；创建带路径的文件及目录

2.定义缓冲字符流；便于读取

3.无限循环，对文档进行读取，用BufferedRead中的readLine()读取一行数据，然后判断是否为空，否则Break结束

4.解析字符串，用String中的split(String regex)分割数据，存入数组

5.实例化一个Student对象，封装数据，其中日期要创建一个SimpleDateFormat对象使用parse()方法把日期字符串转化为对应日期；封装数据，使用ArrayList中的add()添加到数组中；最后在循环外打印输出；

public class Test01 {
    public static void main(String[] args) throws IOException, ParseException {
        //1.定义File对象，关联映射磁盘文件
        File f1 = new File("D:/a.txt");
        //2.定义缓冲字符流
        FileReader fr = new FileReader(f1);
        BufferedReader br = new BufferedReader(fr);
        //BufferedReader br = new BufferedReader(new FileReader(f1));
        //3.对文档进行读取，每次读取一行数据
        ArrayList<Student> list = new ArrayList<>();
        SimpleDateFormat sd = new SimpleDateFormat("yyyy/MM/dd");
        String temp;
        while(true){
            temp = br.readLine();//读取一行数据
            if(temp!=null){
                //System.out.println(temp);//张三-男-2000/08/15-河南南阳
                String [] split = temp.split("-");//把字符串按照-解析出4个数据，存入数组中，[张三,男,2000/08/15,河南南阳]
                //System.out.println(Arrays.toString(split));
                Student s = new Student();
                //每一行内容对应的数组元素取出封装到Student对象中
                s.setName(split[0]);
                s.setSex(split[1]);
                s.setBirthday(sd.parse(split[2]));//取出数组中第3个元素，是一个日期字符串，给她转换为对应的日期
                s.setAddress(split[3]);
                //使用JDBC存入数据库
                list.add(s);
            }else{
                break;
            }
        }
        System.out.println(list);
    }
}

异常

常见的异常有：
1、算术异常类:ArithmeticException
2、空指针异常类:NullpointerException
3、类型强制转换异常:ClassCastException
4、数组下标越界异常:ArrayindexOutOfBoundsException
5、文件未找到异常:FileNotFoundException
6、操作数据库异常:SQLException
7、I/0 异常的根类:IOException
8、线程中断:InterruptedException
9、java.lang.ClassFormatError类格式错误。当Java 虚拟机试图从一个文件中读取Java 类，面检测到该文件的内容不符合类的有效格式时抛出。
10、java.lang.NoClassDefFoundError未找到类定义错误。当Java虚拟机或者类装载器试图实例化某个类，而找不到该类的定义时抛出该错误。
11、java.lang.illegetStateException 违法的状态异常。当在lava 环境和应用尚来处于某个方法的合法调用状态，而调用了该方法时，抛出该异常。

public class Test{
    public static void main(String[] args) throws ClassNotFoundException {
        //算术异常
        int a=5;
        int b=0;
        System.out.println(a/b);

        //数组下标越界异常
        int[] nums={12,4,6};
        System.out.println(nums[-1]);

        //空指针异常
        String name=null;
//        System.out.println(name.equals("tom"));
//        System.out.println("tom".equals(name)); //两者的区别

        //类型转换异常
//        Object obj = new Object();
//        String str=(String) obj;

        //数字格式异常
//        int a = Integer.parseInt("abc");

        //类找不到异常
//        Class.forName("java.lang.Str"); //加载指定的类

        //解析异常
//		DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
//		df.parse("2019/2/14");
        
    }
}

运行时异常和非运行时异常的区别：
非运行时异常也叫作编译时异常，如果不对这种异常进行捕获则无法编译，java 编译器要求程序员必须对这种异常 catch，lava 认为这种异常都是可以被修复的异常，所以 java 程序要求显式处理这种异常。
常见的非运行异常: IOException 、FileNotfoundExcetion 、SQLException
运行时异常是不用进行捕获的，当这种异常发生时，JVM 会进行处理。值得一提的是这种异常是十分普遍的异常，如果对其捕获会影响代码的可读性。
常见的运行时异常:
ClassCastException(类转换异常)

IndexQutOfBoundsException(数组越界)

NullPointerException(空指针)

异常产生的原理：当异常发生时，jvm会立即创建一个异常类的对象，并将此对象发生的所有信息封装给此对象，将此对象以依赖注入的方式提供给调用者。

处理异常用到的关键字：try catch finally throws throw

throw与throws的区别：1.使用的位置不同一个在方内部，一个在方法声明处使用。 2.throw抛出一个异常对象。throws⽤来声明⼀个⽅法可能产⽣的所有异常，不做任何处理⽽是将异常往上传，谁调⽤我我就抛给谁。

异常的处理方式：

1.throws

2.try......catch

格式：
 try{
     可能出现异常的代码
 }catch(Exception e){
     异常处理的代码
 }finally{
     资源的释放或者是不管正常还是异常都必须执行的代码
 }

注意：try不能单独使用；try finally可以联合使用；放在finally语句块中的代码是一定会执行的。

代码演示

public class ExceptionTest01 {
    public static void main(String[] args) {
        File f1 = new File("D:/a.txt");
        FileReader fr = null;
        BufferedReader br = null;
        try {
            System.out.println("1.程序开始，获取资源");
            //在try里面放入可能出现异常的代码进行监控
                fr = new FileReader(f1);
                br = new BufferedReader(fr);
                String temp;
                while (true) {
                    temp = br.readLine();
                    if (temp != null) {
                        System.out.println(temp);
                    } else {
                        break;
                    }
                }
                return;
            } catch (FileNotFoundException e){
                //如果出现了匹配的异常，则在catch中执行
                System.out.println("出现了文件找不到异常");
            } catch (IOException e) {
                //如果出现了匹配的异常，则在catch中执行
                System.out.println("出现了文件找IO异常");
            } catch (Exception e){
                //最后一般使用Exception 基类 兜底
                System.out.println("出现了预期外的异常");
                e.printStackTrace();
            }finally{
            //程序必然会执行的代码，放在finally中，一般做资源的释放
            System.out.println("2.程序结束，资源释放");
            try{
                fr.close();
                br.close();
            }catch(IOException e){
                throw new RuntimeException(e);
            }
        }
        System.out.println("========最终结束！！！");
    }
}

自定义异常

public class MyException extends Exception{

}

public class Test02 {
    //该方法定义的位置只能使用 throws 关键字抛出异常，目的是让调用该方法时要么解决异常，要么继续跑出
    public static void main(String[] args)throws MyException{
        System.out.println("1--------");
        fun(5);
        System.out.println("2--------");
    }
    public static void fun(int n) throws MyException{
        System.out.println("=======1");
        //在方法中抛出异常，只能使用throw关键字，可以抛出自定义异常 或者 系统异常
        if(n<0){
            throw new MyException();
        }
        System.out.println("=======2");
    }
}