文档章节

Java基础进阶_day11_(IO,字符流,递归)

S
 Sunmos
发布于 2017/05/13 00:19
字数 3046
阅读 3
收藏 0

Java基础进阶_day11_(IO,字符流,递归)

1. 字符流

字符流的本质是:字符流=字节流+编码表.
编码表:由字符及其对应的数值组成的一张表.

# 字符串编码:
 构造方法:public String(byte[] bytes,String charsetName):使用指定的字符集解码字节数组;
 成员方法:public byte[] getBytes(String charsetName):使用指定的字符集编码字符串.
# 编码:将字符解析为字节数据,String --> byte[]
# 解码:将字节数据解析为字符串,byte[] --> String
# 注意事项:编解码的规则要一致.
  • 字符流:是在字节流的基础之上添加了编码表,字符流也称为转换流(不同编码规则间的转换)
    • 字符输入流:Reader抽象类是所有字符输入流的根类;
    • 字符输出流:Writer抽象类是所有字符输出流的根类.
    • 字符输出流写数据是先将数据写到缓冲区,需要使用flush方法将数据刷新到文件.
    • 复制文件时,一般使用字节流,不使用字符流(先将读取的字节转换为字符,再将字符转换为字节写出),单独读取文件或写出文件时使用字符流.字符流只能赋值纯文本文件,复制图片等其他格式会出现文件损坏.

2. OutputStreamWriter类

OutputStreamWriter类:是字符输出流Writer的实现类,是在字节输出流OutputStream的基础上增加字符编码.

2.1 构造方法

public OutputStreamWriter(OutputStream out):创建使用默认字符编码(依据平台)的字符输出流对象;
public OutputStreamWriter(OutputStream out, String charsetName):创建使用指定字符编码的字符输出流对象;

2.2 成员方法

public void write(int c):一次写一个字符;
public void write(char[] cbuf):一次写入一个字符数组;
public void write(char[] cbuf,int off,int len):一次写一个字符数组的一部分;
public void write(String str):一次写一个字符串;
public void write(String str,int off,int len):一次写一个字符串的一部分.

3. InputStreamReader类

InputStreamReader类:字符输入流Reader的实现类,是在字节输入流InputStream的基础上增加字符编码.

3.1 构造方法

public InputStreamReader(InputStream in):创建使用默认字符编码的字符输入流对象;
public InputStreamReader(InputStream in,String charsetName):创建使用指定字符编码的字符输入流对象;

3.2 成员方法

public int read():一次读取一个字符,没有则返回-1;
public int read(char[] chs):一次读取一个字符数组返回是每次实际读取的字符长度,没有数据返回-1.

4. 字符流便捷类

# 字符流的便捷类:由于大多数的IO操作均是在本地实现,则字符流提供了使用默认编码的子类作为便捷类使用.

4.1 FileWriter类

FileWriter类:是字符输出流OutputStreamWriter类便捷类,也是其子类.其成员方法方法和父类完全相同.

4.1.1 构造方法

FileWriter(String FileName):传递一个文件名;
FileWriter(String FileName,boolean append):参数是一个文件名,并设置是否是追加写数据的方式,append为true时,追加方式,默认是false.

4.1.2 成员方法

void write(String str):写一个字符串
void write(String str,int index,int len):写字符串中部分数据
    注意:其中的index不能索引越界,len也不能超过可以截取的字符串的长度
void write(int ch):写一个字符数据,可以使用字符'A',也可以是字符对应的ASCII值
void wirte(char[] chs):写一个字符数组
void write(char[] chs,int index,int len):写一个字符数组的一部分
   注意:其中的index不能索引越界,len也不能超过可以截取的字符串的长度
flush():刷新内存缓冲区,将要写入的字符串写入到文件;可以继续使用流对象写数据
close():
    a.关闭输出流,先缓冲区的数据flush方法,
    b.然后通知系统释放和该文件相关的系统资源
    c.流对象关闭后,不能再继续使用(不能再写数据到文件)
close和flush方式将数据写入文件的区别:
    前者是关闭了流对象,后续无法再向文件中写数据
    后者只是将缓冲区中数据写到文件,还可以再向文件写数据,然后再执行此方法将数据写到文件.

4.2 FileReader类

FileReader类:是字符输入流InputStreamReader类的便捷类,也是其子类,成员方法和父类完全相同.

4.2.1 构造方法

FileReader(String filename):filename不能为空,否则会报异常.

4.2.2 成员方法

int read():一次读取一个字符,读完当前字符后,下次就读取下一个字符,没有数据时返回-1,读取字符时需要将结果强制类型转换为char类型,否则显示的是字符对应的值;
int read(char[] chs):一次读取一个字符数组,读完当前字符后,下次就读取下一个字符,没有数据时返回-1,返回的是每次实际读取的字符的个数;
注意事项:如果要读取的文件不存在,这会报错,系统找不到指定文件

5. 字符缓冲流

字符缓冲流:是在基本的字符流的基础上增加缓冲区.

5.1 BufferedWriter类

# BufferedWriter:将文本写入字符输出流,缓冲各个字符,从而提供单个字符、数组和字符串的高效写入.
 是在FileWriter类的基础上加强功能,因此创建本类的对象需要FileWriter的实例对象作为参数.

5.1.1 构造方法

public BufferedWriter(Writer out)创建一个使用默认大小输出缓冲区的缓冲字符输出流.

5.1.2 成员方法(特殊方法)

void newLine():写一个换行符,由系统决定是那个换行符

5.2 BufferedReader类

# BufferedReader:从字符输入流中读取文本,缓冲各个字符,从而实现字符、数组和行的高效读取.
 是在FileReader类的基础上加强功能,因此创建本类的对象需要FileReader的实例对象作为参数.

5.2.1 构造方法

public BufferedReader(Reader in)创建一个使用默认大小输入缓冲区的缓冲字符输入流.

5.2.2 成员方法(特殊方法)

String readLine():一次读一行数据,但是不读取换行符,没有数据时返回null

6. 字符流案例

public class MyIODemo03 {
    public static void main(String[] args) throws IOException {
        // 字符输入流和输出流测试,文件复制
        test01();
        // 字符输入流和输出流的便捷类测试,文件复制
        test02();
        // 字符缓冲流复制文件
        test03();
    }
    public static void test03() throws IOException, FileNotFoundException {
        // 创建输入输出缓冲流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("java2.java"));
        BufferedReader br = new BufferedReader(new FileReader("java1.java"));
        // 赋值文本
        /*int ch; while((ch=br.read())!=-1) { // 将文本写入文件 bw.write(ch); }*/
        // 赋值文本
        String line;
        // 每次读取一行数据
        while((line=br.readLine()) != null) {
            // 每次写一个字符串
            bw.write(line);
            // 写完一行要写一个换行
            bw.newLine();
            // 刷新数据到文件
            bw.flush();
        }
        // 释放资源
        bw.close();
        br.close();
    }
    public static void test02() throws IOException {
        // 创建输入输出流对象
        FileReader fr = new FileReader("java.java");
        FileWriter fw = new FileWriter("java1.java");
        // 复制文件
        char[] chs = new char[1024]; // 数组的长度一般是1024及其整数倍
        int len = 0; // 每次实际读取的字符的个数
        // 读取数据,当数据读取完毕,会返回-1
        /*while((len = fr.read(chs)) != -1) { // 每次读取几个字符,就从字符数组中取出几个字符 System.out.println(new String(chs,0,len)); }*/
        // 赋值文本
        while((len = fr.read(chs)) != -1) {
            // 赋值文本,将本次实际读取的字符个数,复制到文本文件
            fw.write(chs, 0, len);
        }
        // 刷新缓冲区,将数据写入到文件,可以不写此方法,
        // 后面的close方法释放系统资源时会将缓冲区中数据写入到文件
        // fw.flush();
        // 释放资源
        fw.close();
        fr.close();
    }
    public static void test01() throws FileNotFoundException, IOException {
        // 字符输入流和输出流测试,文件复制
        InputStreamReader isr = new InputStreamReader(new FileInputStream("Demo.java"));
        OutputStreamWriter osr = new OutputStreamWriter(new FileOutputStream("Demo2.txt"));
        // 复制文件,方式1
        /*int by; while((by = isr.read()) != -1) { osr.write(by); }*/
        // 复制文件,方式2
        char[] chs = new char[1024];
        int len;
        while((len = isr.read(chs)) != -1) {
            osr.write(chs, 0, len);
            osr.flush();
        }
        // 释放资源
        isr.close();
        osr.close();
    }
}

7. 递归

递归:方法定义中调用方法本身的现象

注意事项

# A:要有出口,否则就是死递归;
# B:次数不能太多,否则就内存溢出;
# C:构造方法不能递归使用.

案例

public class MyDiGuiDemo {
    public static void main(String[] args) {
        // 递归获取指定文件夹下所有的以.java结尾的文件
        File file = new File("E:\\develop");
        // 调用递归 方法
        getAllFiles(file);
    }
    /* * 输出指定目录下的所有符合条件的文件 */
    public static void getAllFiles(File file) {
        if(file.isDirectory()) {
            File[] listFiles = file.listFiles();
            for (File file2 : listFiles) {
                if(file2.isDirectory()) {
                    getAllFiles(file2);
                } else {
                    if(file2.getName().endsWith(".java")) {
                        System.out.println(file2.getAbsolutePath());
                    }
                }
            }
        }else {
            if(file.getName().endsWith(".java")) {
                System.out.println(file.getAbsolutePath());
            }
        }
    }
}

8. IO流小结

8.1 IO流小结

8.2 字节流和字符流注意事项

# 字节流可以是复制任意格式的文件;
# 字节流复制中文(占2个字节)输出时会出现显示半个中文的情况;
# 字符流只能赋值纯文本文件格式的文件,不能复制和读取图片和视频等其他非纯文本的文件,因为字符流复制读取会将每次读取到的2个字节转换为字符(当读取的2个字节组合在码表中不存在时,系统会给出?代替),输出写数据时是将1个字符根据码表转换为2个字节,当遇到?时,由于不知道?代表的字符,则转换后的2个字节和读取的有误差,导致文件损坏.

8.3 IO流复制文本文件的9中方式

/* * 9种复制文件的方式 */
public class MyIOTest05 {
    public static void main(String[] args) throws IOException {
        String srcFile = "a.txt";
        String desFile = "b1.txt";
        /** * 字节流复制文件 */
        method01(srcFile, desFile);
        method02(srcFile, desFile);
        method03(srcFile, desFile);
        method04(srcFile, desFile);
        /** * 字符流复制文件 */
        method05(srcFile, desFile);
        method06(srcFile, desFile);
        method07(srcFile, desFile);
        method08(srcFile, desFile);
        method09(srcFile, desFile);
    }
    public static void method09(String srcFile, String desFile)
            throws FileNotFoundException, IOException {
        BufferedReader br = new BufferedReader(new FileReader(srcFile));
        BufferedWriter bw = new BufferedWriter(new FileWriter(desFile));
        String line = null;
        while((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine();
        }
        bw.close();
        br.close();
    }
    public static void method08(String srcFile, String desFile)
            throws FileNotFoundException, IOException {
        BufferedReader br = new BufferedReader(new FileReader(srcFile));
        BufferedWriter bw = new BufferedWriter(new FileWriter(desFile));
        char[] chs = new char[1024];
        int len = 0;
        while((len = br.read(chs)) != -1) {
            bw.write(chs, 0, len);
        }
        bw.close();
        br.close();
    }
    public static void method07(String srcFile, String desFile)
            throws FileNotFoundException, IOException {
        BufferedReader br = new BufferedReader(new FileReader(srcFile));
        BufferedWriter bw = new BufferedWriter(new FileWriter(desFile));
        int ch = 0;
        while((ch = br.read()) != -1) {
            bw.write(ch);
        }
        bw.close();
        br.close();
    }
    public static void method06(String srcFile, String desFile)
            throws FileNotFoundException, IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream(srcFile));
        OutputStreamWriter osr = new OutputStreamWriter(new FileOutputStream(desFile));

        char[] chs = new char[1024];
        int len = 0;
        while((len = isr.read(chs)) != -1) {
            osr.write(chs, 0, len);
        }
        osr.close();
        isr.close();
    }
    public static void method05(String srcFile, String desFile)
            throws FileNotFoundException, IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream(srcFile));
        OutputStreamWriter osr = new OutputStreamWriter(new FileOutputStream(desFile));

        int ch = 0;
        while((ch = isr.read()) != -1) {
            osr.write(ch);
        }
        osr.close();
        isr.close();
    }
    public static void method04(String srcFile, String desFile)
            throws FileNotFoundException, IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desFile));

        byte[] bys = new byte[1024];
        int len = 0;
        while((len = bis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }
        bos.close();
        bis.close();
    }
    public static void method03(String srcFile, String desFile)
            throws FileNotFoundException, IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desFile));
        int by = 0;
        while((by = bis.read()) != -1) {
            bos.write(by);
        }
        bos.close();
        bis.close();
    }
    public static void method02(String srcFile, String desFile)
            throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(desFile);
        byte[] bys = new byte[1024];
        int len = 0;
        while((len = fis.read(bys)) != -1) {
            fos.write(bys, 0, len);
        }
        fos.close();
        fis.close();
    }
    public static void method01(String srcFile, String desFile)
            throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(desFile);
        int by = 0;
        while((by = fis.read()) != -1) {
            fos.write(by);
        }
        fos.close();
        fis.close();
    }
}

本文转载自:http://blog.csdn.net/l631106040120/article/details/70188523

S
粉丝 0
博文 34
码字总数 0
作品 0
成都
私信 提问
JAVA基础再回首(二十一)——递归、IO流概述、字节流写数据、读取数据、复制数据、字节缓冲流

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/m366917/article/details/52433489 JAVA基础再回首(二十一)——递归、IO流概述、字节流写数据、读取数据、复...

Aduroidpc
2016/09/04
0
0
java基础io流——配角也风流(不求甚解)

本章简单介绍几个常见的io流派生。 1:数据操作流(操作基本类型数据的流)(理解) 代码示例: 2:内存操作流(理解) 用于处理临时存储信息的,程序结束,数据就从内存中消失。 代码示例: 注:查看...

潇潇漓燃
2018/05/30
0
0
JAVA基础再回首(三十)——JAVA基础再回首完美结束,感概万千!

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/m366917/article/details/52724939 JAVA基础再回首(三十)——JAVA基础再回首完美结束,感概万千! 经过了几...

Aduroidpc
2016/10/02
0
0
Java进阶之路——从初级程序员到架构师,从小工到专家

前言:此文章之前大号发过 后被恶意举报封号然此文章被发到博客 在此不计较那些人品有问题之人 再发一遍 怎样学习才能从一名Java初级程序员成长为一名合格的架构师,或者说一名合格的架构师应...

慕安
2017/06/28
652
4
【目录导航】JAVA零基础进阶之路

【JAVA零基础入门系列】(已完结)导航目录 Day1 开发环境搭建 Day2 Java集成开发环境IDEA Day3 Java基本数据类型 Day4 变量与常量 Day5 Java中的运算符 Day6 Java字符串 Day7 Java输入与输出...

MFrank
2018/06/21
0
0

没有更多内容

加载失败,请刷新页面

加载更多

PostgreSQL 11.3 locking

rudi
今天
5
0
Mybatis Plus sql注入器

一、继承AbstractMethod /** * @author beth * @data 2019-10-23 20:39 */public class DeleteAllMethod extends AbstractMethod { @Override public MappedStatement injectMap......

一个yuanbeth
今天
13
1
一次写shell脚本的经历记录——特殊字符惹的祸

本文首发于微信公众号“我的小碗汤”,扫码文末二维码即可关注,欢迎一起交流! redis在容器化的过程中,涉及到纵向扩pod实例cpu、内存以及redis实例的maxmemory值,statefulset管理的pod需要...

码农实战
今天
4
0
为什么阿里巴巴Java开发手册中不建议在循环体中使用+进行字符串拼接?

之前在阅读《阿里巴巴Java开发手册》时,发现有一条是关于循环体中字符串拼接的建议,具体内容如下: 那么我们首先来用例子来看看在循环体中用 + 或者用 StringBuilder 进行字符串拼接的效率...

武培轩
今天
9
0
队列-链式(c/c++实现)

队列是在线性表功能稍作修改形成的,在生活中排队是不能插队的吧,先排队先得到对待,慢来得排在最后面,这样来就形成了”先进先出“的队列。作用就是通过伟大的程序员来实现算法解决现实生活...

白客C
今天
87
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部