Android应用开发----异常处理、文件操作及重定向

一.异常处理
二.文件操作、流处理、对象序列化与随机读写
三.重定向

一.异常处理

程序难免会在运行时出现各种问题,出现问题时,用户无法自己解决或无需自己解决时,这时可以使用程序中的一些异常处理机制帮助解决或忽视异常。

Exception类是所有异常类的父类。

image.png

捕获异常

语法如下:

try{
  待测语句;
}catch(出现异常类型){
  出现该异常后的解决方法;
}

1.try-catch支持嵌套,但不建议使用嵌套;要捕获多个异常时,使用如下语法:

try{
  待测语句一;
  待测语句二;
  待测语句三;
}
catch(语句一会出现的异常类型){
  出现异常后的解决办法;
}catch(语句二会出现的异常类型){
  出现异常后的解决办法;
}catch(语句三会出现的异常类型){
  出现异常后的解决办法;
}

2.捕获异常有顺序,try里面先执行的出现异常先被捕获,若先执行的语句的异常是后执行的语句的异常的父类,两句都出现异常时,只捕获父类出现的异常,反之两者都捕获。

try{
  异常语句;
}catch(Exception e){
  e.printStackTrace();
  System.out.println("异常");
}catch(RuntimeException e){
  e.prinStackTrace();
  System.out.println("运行异常");
}

异常语句出现异常时,将直接打印“异常”,不会打印“运行异常”。

3.若try里面先执行的语句有异常,后执行的语句无异常,catch里只捕获有异常的语句,异常出现时,无异常的语句将不会执行

try{
  会出现异常的语句一;
  不会出现异常的语句二;
}catch(一出现异常的类型){
  异常处理;
}

这种情况下,语句二不会被执行。

4.不管有没有异常都要执行的语句,使用finally关键字

try{
  待测语句;
}catch(异常类型){
  处理语句;
}finally{
   不管有没有异常都会执行的语句;
 }

5.不关心具体异常是什么时,catch里面用所有异常的父类Exception类

try{
  待测语句;
}catch(Excption e){
  e.printStackTrace();//打印异常出现的栈
  异常处理;
}

6.某个语句执行出现异常时,这种异常需要由调用者自己处理时,使用throws抛出异常

public class Test{
  public void show() throws Exception{
     ...
     ...
  }
}

二.文件操作与流处理

文件操作

1.创建文件
使用File类创建一个文件对象,File()构造器中,参数可以是文件路径与文件名在一起的字符串,也可以将文件路径与文件名分开两个字符串,还可以是文件对象和字符串类型的文件名

    //createfiel()创建一个文件
    public void createfile() {
        String filename = "D:\\Dreamcatcher\\桌面\\test.txt";
        File file = new File(filename);//使用File定义一个文件指针,filename是文件所在路径

//或者:
//File file = new File("D:\\Dreamcatcher\\桌面","test.txt")
        if(!file.exists()){
            try {
                file.createNewFile();//当路径下不存在该文件时,就创建文件
                System.out.println("文件创建成功!");
            }catch (IOException e){
                e.printStackTrace();
            }
        }else{
            System.out.println("文件存在!");
            return;
        }
    }

2.创建文件夹

   public void createDir() {
        String filename = "D:\\Dreamcatcher\\桌面\\java学习";
        File file = new File(filename);
        if(!file.exists()){
            try {
                file.mkdir();
                System.out.println("目录创建成功!");
            }catch (NullPointerException e){
                e.printStackTrace();
            }
        }else{
            System.out.println("文件存在!");
            return;
        }
    }
image.png

3.File类的一些常用方法:
isDirectory(),判断是否是文件夹;
isFile(),判断是否是文件;
getAbsolutePath(),获取绝对路径
list(),(无参数)查看文件夹里面的文件名或文件夹名,返还字符串数组;
list(),(有参数,参数为含过滤的对象)
delete(),删除文件或文件夹

流处理

字符输入流与字符输出流

这类流是Reader流类和Writer流类的子类,用该类实例化的对象是以字符形式处理文件(不能,用于处理文本文件)

文件字符输入流和文件字符输出流
//文件字符输出流
    public static void writeToFile(String des) {
        String text = "这是一段文本";//待写入字符串
        FileWriter fw  = null;//选择以字符流写入数据
        try {
            fw = new FileWriter(des);
            fw.write(text);//写入字符串
        } catch (IOException e) {
            e.printStackTrace();
        }finally {//关闭保存已写入文本
            try {
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
//文件字符输入输出流
public static void copyTxtFile(String src,String des){
        try (FileReader fr = new FileReader(src);
            FileWriter fw = new FileWriter(des);){
            char[] buffer = new char[1024];
            int ch;
            while (true){
                ch = fr.read(buffer);
                if(ch == -1){
                    break;
                }
                fw.write(buffer);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
缓冲字符输入流与缓冲字符输出流
 public static void buffered_io_ch(String src,String des){
        try(FileInputStream fis = new FileInputStream(src);
             InputStreamReader isr = new InputStreamReader(fis);
             BufferedReader br = new BufferedReader(isr);//用缓冲字符输入流实例化对象
            FileOutputStream fos =  new FileOutputStream(des);
            OutputStreamWriter osw = new OutputStreamWriter(fos);
            BufferedWriter bw = new BufferedWriter(osw)){

            int b = 0;
            while ( (b = br.read()) != -1){
                bw.write(b);
            }
            bw.flush();
        }catch (Exception e){
            e.printStackTrace();
        }
    }

字节输入流与字节输出流

这类流是InputStream流类和OutputStream流类的子类,用该类实例化的对象将以二进制的形式处理文件(可以处理二进制文件,也可以处理文本文件)

文件字节输入流与文件字节输出流

该类读写文件时可以是一次读一个字节,写一个字节,也可以是一次读多个字节,写多个字节

//文件字节输入输出流
  public static void copyImage(String src,String des){

        try(FileInputStream fis = new FileInputStream(src);
            FileOutputStream fos = new FileOutputStream(des)){//当同时打开的文件数目较多,关闭文件麻烦时可以用这种语法实现自动关闭
            int b = 0;
            while(true){
                b = fis.read();//一个字节一个字节的读写,速度较慢
                if(b == -1){
                    break;
                }
                fos.write(b);
            }
            System.out.println();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
//文件字节输入输出流,批量读写
    public static void copymove_buf(String src,String des){
        try(FileInputStream fis = new FileInputStream(src);
            FileOutputStream fos = new FileOutputStream(des);
            ){
            byte[] buffer = new byte[1024];
            int len = 0;
            while(true){
                len = fis.read(buffer);//多个字节以数组形式读写,速度相对较快
                if(len == -1){
                    break;
                }
                fos.write(buffer);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        
    }
缓冲字节输入流与缓冲字节输出流

缓冲字节输入流相对于文件字节输入流较快,它是将文件一次性读入缓冲区,再由缓冲区一次性写入文件

 public static void buffered_io_by(String src,String des){
        //字节缓冲输出输出流
        try(FileInputStream fis = new FileInputStream(src);
            BufferedInputStream bis = new BufferedInputStream(fis);//用缓冲字节输入流类实例化对象
            FileOutputStream fos = new FileOutputStream(des);
            BufferedOutputStream bos = new BufferedOutputStream(fos);
            ){

            byte[] buff = new byte[1024];
            int ch = 0;
            while ((ch = bis.read(buff)) != -1){
                bos.write(buff);
            }
            bos.flush();
        }catch (Exception e){
            e.printStackTrace();
        }
    }

对象序列化

当我们需要将一个对象以文件形式保存时(方便传输和储存),就要将对象序列化后写进文件。能实现对象序列化的类必须实现Serializable接口,且属性都是可序列化的或用transient声明。

public class Person implements Serializable {
    String name;
    int age;

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

将对象序列化,写进文本

public static void saveObject(String des){
        try (FileOutputStream fos = new FileOutputStream(des);
             ObjectOutputStream oos = new ObjectOutputStream(fos)){
            Person p = new Person("jake",23);
            oos.writeObject(p);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

将文本反序列化,恢复为对象

public static void readObject(String src){
        try (FileInputStream fis = new FileInputStream(src);
             ObjectInputStream ois = new ObjectInputStream(fis)){
            Person p = (Person) ois.readObject();//反序列化的对象为Object类,需强转
            System.out.println(p);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

随机读写

用RandomAccessFile类实例化对象,构造方法中应该传入读写文件地址和打开文件模式
使用seek方法设置文件指针位置,从设置位置开始读写,写入时文件将被覆盖。

public static void randomAccess(String src){
        try{
            RandomAccessFile raf = new RandomAccessFile(src,"rw");//“rw”为打开模式,为可读可写
            raf.seek(1);
            raf.writeChars("hello");
        }catch(Exception e){
            e.printStackTrace();
        }
    }

三.重定向

将流中的结果输入或输出到指定的位置。

//输入重定向
public static void redirect_in(String src){
        try {
            FileInputStream fis = new FileInputStream(src);
            Scanner scanner = new Scanner(fis);
            while(scanner.hasNext()){
                System.out.println(scanner.next());
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
//输出重定向
public static void redirect_out(String des){
        try (FileOutputStream fos = new FileOutputStream(des);
        PrintStream ps = new PrintStream(fos);){
            System.setOut(ps);
            System.out.println("HEllO");//重定向输出的内容,输出内容需在setOut()方法后,且内容不再打印到屏幕上。
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

你可能感兴趣的:(Android应用开发----异常处理、文件操作及重定向)