JAVASE02-Unit08： 文本数据IO操作 、 异常处理

　　　　Unit08： 文本数据IO操作 、 异常处理　　　　

* java.io.ObjectOutputStream
 * 对象输出流，作用是进行对象序列化

package day08;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

/**
 * java.io.ObjectOutputStream
 * 对象输出流，作用是进行对象序列化
 * 对象序列化:将一个java中的对象转换为一组字节的
 *           过程
 * 对象流是高级流。
 * @author adminitartor
 *
 */
public class ObjectOutputStream_WriteObject {
    public static void main(String[] args) throws Exception {
        Person person = new Person();
        person.setName("苍老师");
        person.setAge(18);
        person.setGender("女");

        List<String> otherInfo
            = new ArrayList<String>();
        otherInfo.add("是一名演员");
        otherInfo.add("爱好是写大字");
        otherInfo.add("促进中日文化交流");
        otherInfo.add("是广大男性同胞的启蒙老师");
        person.setOtherInfo(otherInfo);

        System.out.println(person);

        /*
         * 将Person对象写入文件
         */
        FileOutputStream fos
            = new FileOutputStream("person.obj");

        ObjectOutputStream oos
            = new ObjectOutputStream(fos);
        /*
         * void writeObject(Object obj)
         * 将给定的对象转换为一组字节后写出
         *
         * 若想将一个对象序列化，要求该对象所属的
         * 类必须实现可序列化接口，否则会抛出异常。
         */
        oos.writeObject(person);
        System.out.println("对象写出完毕!");

        oos.close();

    }
}

ObjectOutputStream_WriteObject.java

* 该类用于测试对象流的读写对象操作

package day08;

import java.io.Serializable;
import java.util.List;

/**
 * 该类用于测试对象流的读写对象操作
 * @author adminitartor
 *
 */
public class Person implements Serializable{
    private String name;
    private int age;
    private String gender;
    /*
     * transient关键字
     * 被该关键字修饰的属性在进行对象序列化的时候
     * 值会被忽略。将无需保存的属性用该关键字修饰
     * 可以达到对象序列化时的"瘦身"工作,减少资源
     * 开销
     * 除此之外，该关键字没有其他任何作用。
     */
    private transient List<String> otherInfo;

    Person(){

    }

    public Person(String name, int age, String gender, List<String> otherInfo) {
        super();
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.otherInfo = otherInfo;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    /**
     * 通常一个方法内部抛出什么异常，方法上就要
     * 使用throws声明该异常的抛出，以通知调用者
     * 这里可能出现什么问题，要求其处理。
     * 只有一类异常抛出时可以不声明，
     * 就是RuntimeException及其子类异常
     * @param age
     * @throws Exception
     */
    public void setAge(int age) throws Exception{
        if(age<0||age>100){
            throw new Exception("年龄不合法!");
        }
        this.age = age;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    public List<String> getOtherInfo() {
        return otherInfo;
    }
    public void setOtherInfo(List<String> otherInfo) {
        this.otherInfo = otherInfo;
    }

    @Override
    public String toString() {
        return name+","+age+","+gender+","+
               otherInfo;
    }
}

Person.java

* java.io.ObjectInputStream
 * 对象输入流，用于进行:对象返序列化

package day08;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

/**
 * java.io.ObjectInputStream
 * 对象输入流，用于进行:对象返序列化
 *
 * @author adminitartor
 *
 */
public class ObjectInputStream_ReadObject {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        /*
         * 将person.obj文件中的对象读取出来
         */
        FileInputStream fis
            = new FileInputStream("person.obj");

        ObjectInputStream ois
            = new ObjectInputStream(fis);

        Person person = (Person)ois.readObject();
        System.out.println("读取对象完毕!");
        System.out.println(person);

        ois.close();
    }
}

ObjectInputStream_ReadObject.java

* java.io.OutputStreamWriter
 * 该流也叫做转换流，是字符输出流的一个常用实现类。

package day08;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

/**
 * Writer，Reader
 * 这俩个流是所有字符流的父类
 * 字符流:以字符为单位读写数据。
 *
 * java.io.OutputStreamWriter
 * 该流也叫做转换流，是字符输出流的一个常用
 * 实现类。
 * @author adminitartor
 *
 */
public class OutputStreamWriter_Write {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos
            = new FileOutputStream("osw.txt");

        OutputStreamWriter osw
            = new OutputStreamWriter(fos,"UTF-8");

        osw.write("我爱北京天安门");
        osw.write("天安门上太阳升");

        System.out.println("写出完毕!");
        osw.close();
    }
}

OutputStreamWriter_Write.java

* java.io.InputStreamReader
 * 转换流

package day08;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * java.io.InputStreamReader
 * 转换流
 * @author adminitartor
 *
 */
public class InputStreamReader_Read {
    public static void main(String[] args) throws IOException {
        FileInputStream fis
            = new FileInputStream("osw.txt");

        InputStreamReader isr
            = new InputStreamReader(fis,"UTF-8");

        int d = -1;
        while((d = isr.read())!=-1){
            System.out.print((char)d);
        }

        isr.close();
    }
}

InputStreamReader_Read.java

* java.io.PrintWriter
 * 常用的缓冲字符输出流
 * 特点是:可以按行写出字符串，并且具有自动行刷新

package day08;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;

/**
 * java.io.PrintWriter
 * 常用的缓冲字符输出流
 * 特点是:可以按行写出字符串，并且具有自动行刷新
 * PrintWriter内部嵌套java.io.BufferedWriter
 * 所以缓冲功能是靠内部的BW实现的。
 * @author adminitartor
 *
 */
public class PrintWriter_Println {
    public static void main(String[] args) throws IOException {
        /*
         * PrintWriter提供了多种构造方法
         * 方便快速创建。
         * 其中有直接针对文件写操作的构造方法:
         * PrintWriter(String path)
         * PrintWriter(File file)
         */
        PrintWriter pw
            = new PrintWriter("pw.txt","utf-8");

        pw.println("锄禾日当午");
        pw.println("清明上河图");

        System.out.println("写出完毕!");
        pw.close();
    }
}

PrintWriter_Println.java

* 当使用PrintWriter处理其他流的时候，
 * 可以指定自动行刷新，即:每当使用println方法
 * 写出内容后，会自动flush

package day08;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

/**
 * 当使用PrintWriter处理其他流的时候，
 * 可以指定自动行刷新，即:每当使用println方法
 * 写出内容后，会自动flush
 * @author adminitartor
 *
 */
public class PrintWriter_AutoFlush {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos
            = new FileOutputStream("pw1.txt");
        //若需要按照指定字符集，需要加上转换流
        OutputStreamWriter osw
            = new OutputStreamWriter(fos,"UTF-8");
        /*
         * 当创建PrintWriter时第一个参数为流，
         * 那么就支持传入第二个参数，该参数为
         * boolean值，表示是否自动行刷新。当
         * 该值为true则具备自动行刷新
         */
        PrintWriter pw
            = new PrintWriter(osw,true);
        /*
         * 具备自动行刷新的PW在调用println方法
         * 写出一行字符串后会自动flush。
         * 注意，调用print方法不会自动刷新
         */
        pw.println("随便吧");
        pw.println("我已经不知道该写啥了");

        System.out.println("写出完毕!");
        pw.close();
    }
}

PrintWriter_AutoFlush.java

* java.io.BufferedReader
 * 缓冲字符输入流，特点:使用它可以按行读取字符串

package day08;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * java.io.BufferedReader
 * 缓冲字符输入流，特点:使用它可以按行读取字符串
 * @author adminitartor
 *
 */
public class BufferedReader_ReadLine {
    public static void main(String[] args) throws IOException {
        FileInputStream fis
            = new FileInputStream(
                "src"+File.separator+
                "day08"+File.separator+
                "BufferedReader_ReadLine.java"
            );

        InputStreamReader isr
            = new InputStreamReader(fis);

        BufferedReader br
            = new BufferedReader(isr);

        /*
         * String readLine()
         * 按行读取字符串
         * 连续读取若干字符，直到遇见换行符为止，
         * 然后将换行符之前的内容以一个字符串返回
         * 但是返回的字符串中不含有最后的换行符
         * 当返回值为NULL时，表示读取到末尾了
         */
        String line = null;
        while( (line = br.readLine()) != null  ){
            System.out.println(line);
        }

        br.close();
    }
}

BufferedReader_ReadLine.java

* 异常捕获机制中的try-catch

package day08;
/**
 * 异常捕获机制中的try-catch
 * @author adminitartor
 *
 */
public class Exception_Try_Catch {
    public static void main(String[] args) {
        System.out.println("程序开始了");

        try{

            String str = "a";
            System.out.println(str.length());

            System.out.println(str.charAt(0));

            System.out.println(Integer.parseInt(str));

            //try中出错代码之下的代码都不会被执行
            System.out.println("!!!!!!!!");

        }catch(NullPointerException e){
            System.out.println("出现了空指针!");

        }catch(StringIndexOutOfBoundsException e){
            System.out.println("字符串下标越界了!");
        /*
         * 应当有一个好习惯，在最后一个catch中捕获
         * Exception.
         * 并且多个catch捕获异常时，子类异常在上先
         * 捕获，而父类异常在下后捕获。
         */
        }catch(Exception e){
            System.out.println("反正就是出了个错!");
        }

        System.out.println("程序结束了");
    }
}

Exception_Try_Catch.java

* 异常捕获机制中的finally块

package day08;
/**
 * 异常捕获机制中的finally块
 * finally块只能定义在异常捕获机制的最后
 * finally块可以保证其中的代码一定被执行，无论
 * try块中的代码是否抛出异常，甚至return。
 *
 * 通常会将诸如释放资源等一类的代码定义在finally中
 * 比如:使用流后的close工作可以放在finally中确保
 *      一定可以关闭流。
 * @author adminitartor
 *
 */
public class Exception_Finally {
    public static void main(String[] args) {
        System.out.println("程序开始了");

        try {
            String str = "";
            System.out.println(str.length());
            return;
        } catch (Exception e) {
            System.out.println("出错了");
        } finally{
            System.out.println("finally代码执行了!");
        }            

        System.out.println("程序结束了");
    }
}

Exception_Finally.java

* finally在流处理中的应用

package day08;

import java.io.PrintWriter;

/**
 * finally在流处理中的应用
 * @author adminitartor
 *
 */
public class Exception_Finally2 {
    public static void main(String[] args) {
        PrintWriter pw = null;
        try {
            pw = new PrintWriter("pw.txt");
            pw.println("hello");
        } catch (Exception e) {
            System.out.println("出错了!");
        } finally{
            if(pw != null){
                pw.close();
            }
        }
    }
}

Exception_Finally2.java

* throw关键字

package day08;
/**
 * throw关键字
 * 用于将一个异常抛出
 * 通常两种情况下会主动抛出异常:
 * 1:遇到满足语法要求，但是不满足业务逻辑要求时，
 *   可以当作异常对待抛出，通知调用者这是非法操作。
 * 2:当遇到了一个异常，但是当前代码不应当解决该
 *   异常时，可以将其抛出交给调用者解决。
 * @author adminitartor
 *
 */
public class Exception_Throw {
    public static void main(String[] args) {
        Person p = new Person();
        try{
            /*
             * 当调用一个含有throws声明异常抛出
             * 的方法时，编译器要求必须有处理该
             * 异常的手段，有两种:
             * 1:使用try-catch捕获
             * 2:在当前方法上继续使用throws声明
             *   这个异常的抛出
             * 具体用哪个取决于异常应该归谁处理。
             */
            p.setAge(10);
        }catch(Exception e){
            System.out.println("出错了!");
        }
        System.out.println(p.getAge());
    }
}

Exception_Throw.java

时间： 2024-10-07 00:02:52

JAVASE02-Unit08： 文本数据IO操作 、 异常处理的相关文章

JAVASE02-Unit07： 基本IO操作 、 文本数据IO操作

基本IO操作 . 文本数据IO操作 java标准IO(input/output)操作 package day07; import java.io.FileOutputStream; import java.io.IOException; /** * java标准IO(input/output)操作 * 输入流InputStrean:用于从数据源读取数据到程序中 * 输出流OutputStream:用于将数据发送至目标 * * 流划分为:节点流,处理流 * 节点流:又叫做低级流,特点:数据源明确,

文本数据IO操作--字符流

一.Reader和Writer 1. 字符流原理 Reader是所有字符输入流的父类而Writer是所有字符输出流的父类.字符流是以字符(char)为单位读写数据的.一次处理一个unicode.字符流都是高级流,其底层都是依靠字节流进行读写数据的,所以底层仍然是基于字节读写数据的.2. 常用方法 Reader的常用方法:int read()读取一个字符,返回的int”值低16”位有效. 其实返回的是char 若返回的是-1 则读取到末尾 int read(char[] chs)从该流中读取一个字

黑马程序员--Java基础--文件数据IO操作

文件数据IO操作 1. Reader和Writer 1.1. 字符流原理 Reader是所有字符输入流的父类而Writer是所有字符输出流的父类.字符流是以字符(char)为单位读写数据的.一次处理一个unicode.字符流都是高级流,其底层都是依靠字节流进行读写数据的,所以底层仍然是基于字节读写数据的. 1.2. 常用方法 Reader的常用方法: int read() 读取一个字符,返回的int"值低16"位有效. int read(char[] chs) 从该流中读取一个字符数组

Java 之 IO操作—— 文本数据的编码和解码

一.解码 当要读取指定编码的纯文本数据时,可以使用 InputStreamReader 进行解码.所谓解码,即把二进制的字节序列按照指定字符编码解码为可以被正确识别的字符内容. Demo:当前系统平台的字符编码方式是:GBK,需要读取一个UTF-8 的文件内容,到当前系统中. 1 import java.io.BufferedReader; 2 import java.io.FileInputStream; 3 import java.io.IOException; 4 import java.

机器学习入门-文本数据-构造词频词袋模型 1.re.sub(进行字符串的替换) 2.nltk.corpus.stopwords.words(获得停用词表) 3.nltk.WordPunctTokenizer(对字符串进行分词操作) 4.np.vectorize(对函数进行向量化) 5. CountVectorizer(构建词频的词袋模型)

函数说明: 1. re.sub(r'[^a-zA-Z0-9\s]', repl='', sting=string)  用于进行字符串的替换,这里我们用来去除标点符号 参数说明:r'[^a-zA-Z0-9\s]' 配对的模式,^表示起始位置,\s表示终止位置,[]表示取中间部分,这个的意思是找出除字符串大小写或者数字组成以外的东西,repl表示使用什么进行替换,这里使用'',即直接替换,string表示输入的字符串 2. stopwords = nltk.corpus.stopwords.word

python之协程与IO操作

协程 协程,又称微线程,纤程.英文名Coroutine. 协程的概念很早就提出来了,但直到最近几年才在某些语言(如Lua)中得到广泛应用. 子程序,或者称为函数,在所有语言中都是层级调用,比如A调用B,B在执行过程中又调用了C,C执行完毕返回,B执行完毕返回,最后是A执行完毕. 所以子程序调用是通过栈实现的,一个线程就是执行一个子程序. 子程序调用总是一个入口,一次返回,调用顺序是明确的.而协程的调用和子程序不同. 协程看上去也是子程序,但执行过程中,在子程序内部可中断,然后转而执行别的子程序,

java的IO操作：字节流与字符流操作

流的概念 程序中的输入输出都是以流形式,流中保存的实际上都是字节文件. 字节流与字符流 字节流的操作: 1)输入:inputStream, 2)输出:outPutStream; 字符流的操作: 1)输入主要使用:write类. 2)输出主要使用:reader类. 内容操作就四个类. 操作流程: 使用File类操作一定有路径问题,注意分隔符: 实际上四个操作类都是抽象类(区别接口,抽象类的成员都是抽象,并且只能单继承,接口可以有全局变量,但是接口可以多继承) IO操作属于资源操作,对于资源操作,操

C# IO操作（四）大文件拷贝（文件流的使用）、文件编码

     大文件拷贝(文件流的使用).文件编码 首先说一下大文件拷贝和文件流,因为计算机的内存资源是有限的,面对几个G甚至更大的文件,需要通过程序来完成拷贝,就需要用到文件流(因为我们无法做到把文件一次性加载到内存中:事实上,内存也不允许这么干),所以在C#中出现了内存流这个东西.先看下面的内容,File类中的常用读取文件方法会将文件内容一次性全部加载到内存中: 1 string sPath = @"C:\Users\Chens-PC\Desktop\Nginx.txt"; 2 //F

读写文本数据

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 17.0px Helvetica; color: #29556f } 使用其他分隔符或行终止符打印 问题: 你想使用print() 函数输出数据,但是想改变默认的分隔符或者行尾符. 解决方案: 可以使用在print() 函数中使用sep 和end 关键字参数,以你想要的方式输出.比如: 1 #正常输出 2 print('dmeon', 89 , 8, 23) 3 4 #指定分隔符, 5 print('dm