android 重定向 参数无6,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();

}

}