字节流和字符流

最新推荐文章于 2024-11-01 20:08:05 发布
最新推荐文章于 2024-11-01 20:08:05 发布
阅读量84 收藏
点赞数
文章标签： python java
原文链接：http://www.cnblogs.com/xidian2014/p/10327240.html
版权

 

 

package com.test;

import org.junit.Test;

import java.io.*;

public class TestIO {
    @Test
    public void test() {
        InputStream in = null;
        try {
            in = new FileInputStream("/Users/lina/Desktop/work/path.py");
            byte[] buf = new byte[1024];
            int bytesRead = 0;
            while ((bytesRead = in.read(buf)) != -1) {
                for (int i = 0; i < bytesRead; ++i) {
                    System.out.print((char) buf[i]);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    public void test2() {
        File file = null;
        InputStream in = null;
        try {
            file = new File("/Users/lina/Desktop/work/path.py");
            in = new FileInputStream(file);
            byte[] buf = new byte[1024];
            int bytesRead = 0;
            while ((bytesRead = in.read(buf)) != -1) {
                for (int i = 0; i < bytesRead; ++i) {
                    System.out.print((char) buf[i]);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    public void test3() {
        InputStream in = null;
        try {
            in = new BufferedInputStream(new FileInputStream("/Users/lina/Desktop/work/path.py"));
            byte[] buf = new byte[1024];
            int bytesRead = 0;
            while ((bytesRead = in.read(buf)) != -1) {
                for (int i = 0; i < bytesRead; ++i) {
                    System.out.print((char) buf[i]);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    public void test4() {
        InputStream in = null;
        OutputStream out = null;
        try {
            in = new FileInputStream("/Users/lina/Desktop/work/path.py");
            out = new FileOutputStream("/Users/lina/Desktop/work/out.py");
            byte[] buf = new byte[1024];
            int bytesRead = 0;
            while ((bytesRead = in.read(buf)) != -1) {
                out.write(buf, 0, bytesRead);
                out.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }


    @Test
    public void test5() {
        BufferedReader fr = null;
        try {
            fr = new BufferedReader(new FileReader("/Users/lina/Desktop/work/path.py"));
            String str = null;
            while ((str = fr.readLine()) != null) {
                System.out.println(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    public void test6() {
        InputStreamReader isr = null;
        try {
            isr = new InputStreamReader(new FileInputStream("/Users/lina/Desktop/work/path.py"));
            char[] ch = new char[1024];
            int len = 0;
            while ((len = isr.read(ch)) != -1) {
                System.out.println(new String(ch, 0, len));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (isr != null) {
                try {
                    isr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    public void test7() {
        FileReader fr = null;
        try {
            fr = new FileReader("/Users/lina/Desktop/work/path.py");
            char[] ch = new char[1024];
            int len = 0;
            while ((len = fr.read(ch)) != -1) {
                System.out.println(new String(ch, 0, len));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    public void test8() {
        OutputStreamWriter osw = null;
        try {
            osw = new OutputStreamWriter(new FileOutputStream("/Users/lina/Desktop/test/d.txt"));
            char[] ch = new char[]{'我', '爱', '中', '国'};
            osw.write(ch);
            osw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (osw != null) {
                try {
                    osw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    public void test9() {
        FileWriter fw = null;
        try {
            fw = new FileWriter("/Users/lina/Desktop/test/d.txt");
            String str = "爱我中华";
            fw.write(str);
            fw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    public void test10() {
        BufferedWriter bw = null;
        try {
            bw = new BufferedWriter(new FileWriter("/Users/lina/Desktop/test/d.txt"));
            bw.write("爱我");
            bw.newLine();
            bw.write("中华");
            bw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bw != null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    public void test11() {
        InputStreamReader isr = null;
        OutputStreamWriter osw = null;
        try {
            isr = new InputStreamReader(new FileInputStream("/Users/lina/Desktop/test/d.txt"));
            osw = new OutputStreamWriter(new FileOutputStream("/Users/lina/Desktop/test/f.txt"), "utf-8");
            char[] ch = new char[1024];
            int len = 0;
            while ((len = isr.read(ch)) != -1) {
                osw.write(ch, 0, len);
                osw.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (isr != null) {
                try {
                    isr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (osw != null) {
                try {
                    osw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    public void test12() {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            fr = new FileReader("/Users/lina/Desktop/test/d.txt");
            fw = new FileWriter("/Users/lina/Desktop/test/c.txt");
            char[] ch = new char[1024];
            int len = 0;
            while ((len = fr.read(ch)) != -1) {
                fw.write(ch, 0, len);
                fw.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    public void test13() {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new InputStreamReader(new FileInputStream("/Users/lina/Desktop/test/d.txt")));
            bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("/Users/lina/Desktop/test/abc.txt")));
            char[] ch = new char[1024];
            int len = 0;
            while ((len = br.read(ch)) != -1) {
                bw.write(ch, 0, len);
                bw.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bw != null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    public void test14() {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new FileReader("/Users/lina/Desktop/test/d.txt"));
            bw = new BufferedWriter(new FileWriter("/Users/lina/Desktop/test/ab.txt"));
            String str = null;
            while ((str = br.readLine()) != null) {
                bw.write(str);
                bw.newLine();
                bw.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bw != null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 

转载于:https://www.cnblogs.com/xidian2014/p/10327240.html

weixin_30821731
关注
【字节流、字符流】
weixin_45156610的博客
07-13 144
day09【字节流、字符流】 主要内容 IO流 字节流 字符流 异常处理 Properties 教学目标 能够说出IO流的分类和功能 字节流：字节输入流，字节输出流 字符流：字符的输入流，字符的输出流 能够使用字节输出流写出数据到文件 write public void write(int b) public void write(byte[] bytes) public ...
关于字节流和字符流
weixin_43874447的博客
08-12 272
分别使用字节流和字符流完成以下程序： 在指定的路径下新建一个 txt 文件 “aura.txt”，利用程序在文件中写入如下内容： “Hadoop（hdfs、mapreduce、yarn） 元老级大数据处理技术框架，擅长离线数据分析,Hbase 分布式海量数据库，离线分析和在线业务通吃,Hive sql 数据仓库工具，使用方便，功能丰富，基于MR延迟大,Sqoop数据导入导出工具,Flume...
java存入文件6,在Java 6中将InputStream写入文件的有效方法
weixin_39975900的博客
02-26 116
I will get input stream from third party library to my application.I have to write this input stream to a file.Following is the code snippet I tried:private void writeDataToFile(Stub stub) {OutputStre...
java_字节流、字符流、Properties的使用
Itmei的博客
09-08 394
生活中，你肯定经历过这样的场景。当你编辑一个文本文件，忘记了ctrl+s，可能文件就白白编辑了。当你电脑上插入一个U盘，可以把一个视频，拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢？键盘、内存、硬盘、外接设备等等。我们把这种数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为输入input和输出output，即流向内存是输入流，流出内存的输出流。Java中I/O操作主要是指使用java.io包下的内容，进行输入、输出操作。输入也叫做读取数据，输出也叫做作写出数据。继承于。
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 15万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
字节流和字符流详解
wkh18891843165的博客
03-30 2万+
1.流的概念 在编程中是一种抽象的概念，就好比“水流”，从一段流向另一端 在程序中所有的数据都是以流的方式进行传输或保存的，程序需要数据的时候要使用输入流读取数据，而当程序需要将一些数据保存起来的时候，就要使用输出流完成。 程序中的输入输出都是以流的形式保存的，流中保存的实际上全都是字节文件。 2.流的分类 按照流向可以分为：输入流（如：键盘，麦克风），输出流（如：显示器，音箱） 按照传输单位可以分为：字节流和字符流 3.什么是字节流，什么是字符流 字节流： 它处理单元为1个字节（byte），操作字节和
python字节流和字符流_字符流与字节流
weixin_39548787的博客
12-04 2344
[一]写在前面简单总结一下分别用(一直混淆的)字节流or字符流读写文件。[二]字节流2.1 字节流介绍程序中的输入输出都是以流的形式保存的(输入流or输出流),流中保存的实际上全都是字节(一个字节等于一个Byte占8个bit)文件。Java提供了OutputStream、InputStream两个专门操作字节流的类。知识补充1：计算机能存储的唯一东西就是 bytes,为了在计算机中存储东西,我们首...
java 字节流和字符流的区别详解
08-25
Java 字节流和字符流的区别详解 Java 中的字节流和字符流是两种不同的输入 / 输出流，它们之间的区别是非常重要的。在本文中，我们将详细介绍 Java 中的字节流和字符流的区别，并通过示例代码来演示它们的使用。 ...
详解JAVA 字节流和字符流
08-19
Java字节流和字符流是Java I/O流处理中非常基础且重要的概念，它们是用于文件读写操作的两大类型。Java字节流主要包括InputStream和OutputStream两个基类及其子类，字符流则包括Reader和Writer两个基类及其子类。 ...
IO流中数据传递的字节流和字符流
01-03
IO的字符和字节流的运用字符流(适用于中文内容读入写出)读入：FileReader\BufferedReader写出：FileWriter\BufferedWriter字节流(适用于少量中文；主用图片，视频)第一种：用 FIle类搭配 FIleOutputStream的方法进行...
【python】极简教程14-文件
每日出拳老爷子的博客
10-28 247
可以使用相对路径或绝对路径来访问文件。模式可以将内容写入文件，如果文件不存在会自动创建。捕获文件读取或写入时可能出现的异常。循环逐行读取文件，或者使用。模块可以帮助处理文件路径。函数打开文件，并通过。
196.245.124.255.236.194.0.0.0.0.0.0.0.0.9 用python截取最后一个点后面的数据
qq_44534541的博客
10-30 130
这个方法从字符串的右边开始分割，并且可以指定分割的最大次数。在Python中，如果你想要截取字符串中最后一个点（，因为它是最后一个点后面的数据。这段代码会处理没有点的情况（）和点的后面不是数字的情况（）后面的数据，你可以使用。
植物病害图像分割系统：智能化检测
prchen818的博客
10-30 945
数据集信息展示在现代农业生产中，植物病害的早期识别与处理至关重要。为了提升植物病害的自动检测与分割能力，本研究选用了名为“new_plant_diseases”的数据集，旨在训练和改进YOLOv8-seg模型，以实现高效、准确的植物病害图像分割。
安装python时Install launcher for all users灰色无法选中解决方法
夏末蝉未鸣的博客
10-30 207
解决办法：可能是上一次卸载python没卸载干净，在控制面板中卸载，把Python Launcher卸载掉。卸载完后，就可以正常安装了。
pandas——DataFrame
最新发布
qq_53256193的博客
11-01 292
file.csv生成的file1.csv2,B3,C4,D。
PySpark 本地开发环境搭建与实践
天冬忘忧的博客
11-01 913
本文详细介绍了 PySpark 本地开发环境的搭建过程，包括 JDK、Hadoop、Anaconda、PySpark 的安装以及 Pycharm 工程的创建。同时，深入讲解了代码编写、本地开发案例（如 WordCount、处理特殊分隔符、读取 hdfs 数据、获取外部变量）、Spark 程序的监控和 local 模式下结果文件数量问题等内容。通过掌握这些知识和技能，读者可以在 Windows 本地环境中高效地进行 PySpark 开发，处理大规模数据，解决实际业务中的数据分析和处理问题。
字节流和字符流得区别
04-29
字节流和字符流是Java中用于处理输入输出的两种不同的流类型。 1. 字节流（Byte Stream）： 字节流以字节为单位进行读写操作，适用于处理二进制数据或者字节流形式的数据。字节流主要包括InputStream和OutputStream...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值