I/O--3(字节流)

最新推荐文章于 2024-08-06 15:50:37 发布
最新推荐文章于 2024-08-06 15:50:37 发布
阅读量181 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011739800/article/details/77621761
版权

字节流：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;


public class ByteStreamDemo {


/**
* @param args
* @throws IOException 
*/
public static void main(String[] args) throws IOException {



demo_read();
}


public static void demo_read() throws IOException {

//1，创建一个读取流对象。和指定文件关联。
FileInputStream fis = new FileInputStream("bytedemo.txt");

// System.out.println(fis.available());
// byte[] buf = new byte[fis.available()];//available()获取文件大小，多少字节。慎用，万一一下2g内存的电影，内存就爆了。
// fis.read(buf);
// System.out.println(new String(buf));/'/数组变成字符串一打印。


//建议使用这种读取数据的方式
// byte[] buf = new byte[1024];
// int len = 0;
//
// while((len=fis.read(buf))!=-1){
// System.out.println(new String(buf,0,len));
// }


// int ch = 0;
// while((ch=fis.read())!=-1){
// System.out.println((char)ch);
// }

//一次读取一个字节。一次读不出来一个文字，因为一个字符两个字节。
// int ch = fis.read();
// System.out.println(ch);

fis.close();

}


public static void demo_write() throws IOException {

//1，创建字节输出流对象。用于操作文件.
FileOutputStream fos = new FileOutputStream("bytedemo.txt");

//2,写数据。直接写入到了目的地中。  字节流的文件是不需要临时存储缓冲的，他会直接将数据写入目的地中，因为写的都是源码，所以不用flush（）。
fos.write("abcdefg".getBytes());

// fos.flush();
fos.close();//关闭资源动作要完成。 
}


}

===========================================

CopyMp3Test：

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;


public class CopyMp3Test {


/**
* @param args
* @throws IOException 
*/
public static void main(String[] args) throws IOException {


copy_4();

}
// 千万不要用，效率没有！
public static void copy_4() throws IOException {
FileInputStream fis = new FileInputStream("c:\\0.mp3");
FileOutputStream fos = new FileOutputStream("c:\\4.mp3");


int ch = 0;

while((ch =fis.read())!=-1){
fos.write(ch);
}

fos.close();
fis.close();
}


//不建议。 
public static void copy_3() throws IOException {
FileInputStream fis = new FileInputStream("c:\\0.mp3");
FileOutputStream fos = new FileOutputStream("c:\\3.mp3");

byte[] buf = new byte[fis.available()];//创建一个刚刚好的 数组。
fis.read(buf);
fos.write(buf);
fos.close();
fis.close();
}


public static void copy_2() throws IOException {//封装类的缓冲区。

FileInputStream fis = new FileInputStream("c:\\0.mp3");
BufferedInputStream bufis = new BufferedInputStream(fis); //利用缓冲区 ，提高效率

FileOutputStream fos = new FileOutputStream("c:\\2.mp3");
BufferedOutputStream bufos = new BufferedOutputStream(fos);//利用缓冲区 ， 提高效率



int ch = 0;

while((ch=bufis.read())!=-1){//从缓冲区中一个一个取。
bufos.write(ch);
}

bufos.close();//关闭的时候应该是缓冲区。
bufis.close(); //关闭的时候应该是缓冲区。
}


public static void copy_1() throws IOException {//自定义缓冲区

FileInputStream fis = new FileInputStream("c:\\0.mp3");
FileOutputStream fos = new FileOutputStream("c:\\1.mp3");

byte[] buf = new byte[1024];

int len = 0;

while((len=fis.read(buf))!=-1){
fos.write(buf,0,len);
}

fos.close();
fis.close(); 
}


}

=======================================

键盘录入：

import java.io.IOException;
import java.io.InputStream;


/*
 * 读取一个键盘录入的数据，并打印在控制台上。
 * 
 * 键盘本身就是一个标准的输入设备。
 * 对于java而言，对于这种输入设备都有对应的对象。
 * 
 * 
 */
public class ReadKey {


/**
* @param args
* @throws IOException 
*/
public static void main(String[] args) throws IOException {


// readKey();
// System.out.println((int)'\r');
// System.out.println((int)'\n');

readKey2();

}


public static void readKey2() throws IOException {

/*
* 获取用户键盘录入的数据，
* 并将数据变成大写显示在控制台上，
* 如果用户输入的是over，结束键盘录入。
* 
* 思路：
* 1，因为键盘录入只读取一个字节，要判断是否是over，需要将读取到的字节拼成字符串。
* 2，那就需要一个容器。StringBuilder.
* 3，在用户回车之前将录入的数据变成字符串判断即可。 
* 
*/

//1，创建容器。
StringBuilder sb = new StringBuilder();

//2，获取键盘读取流。
InputStream in = System.in;//读取的字节流

//3，定义变量记录读取到的字节，并循环获取。
int ch = 0;

while((ch=in.read())!=-1){

// 在存储之前需要判断是否是换行标记 ,因为换行标记不存储。 
if(ch=='\r')
continue;
if(ch=='\n'){
String temp = sb.toString();
if("over".equals(temp))
break;
System.out.println(temp.toUpperCase());
sb.delete(0, sb.length());
}
else
//将读取到的字节存储到StringBuilder中。
sb.append((char)ch);

// System.out.println(ch);
}

}


public static void readKey() throws IOException {

InputStream in = System.in;

int ch = in.read();//阻塞式方法。没数据就就一直等，在控制台上等，这就是阻塞式。
System.out.println(ch);
int ch1 = in.read();//阻塞式方法。
System.out.println(ch1);
int ch2 = in.read();//阻塞式方法。
System.out.println(ch2);

// in.close();

// InputStream in2 = System.in;//流关了之后再new个对象就抛异常了，从系统过来这个流就一个，关了就没了，随着系统的关闭而关闭随着系统的出现而出现。所以这个流不需要关的，默认的输入和输出的流都不用关。
// int ch3 = in2.read();



}



}

\r\n的ARC码被读出来。


====================================================================================

字符流Reader的由来就是字节流加编码表：

字节流加编码表（解码）就是转换流：OuputStreamReader，InputStreamReader，

转换流：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;


public class TransStreamDemo {


/**
* @param args
* @throws IOException 
*/
public static void main(String[] args) throws IOException {


//字节流。 
InputStream in = System.in;
// int ch = in.read();
// System.out.println(ch);
// int ch1 = in.read();
// System.out.println(ch1);

//将字节转成字符的桥梁。装换流。 
InputStreamReader isr = new InputStreamReader(in);

// int ch = isr.read();
// System.out.println((char)ch);

//字符流。
BufferedReader bufr = new BufferedReader(isr);

OutputStream out = System.out;

OutputStreamWriter osw = new OutputStreamWriter(out);

BufferedWriter  bufw = new BufferedWriter(osw);



String line = null;

while((line=bufr.readLine())!=null){
if("over".equals(line))
break;
// System.out.println(line.toUpperCase());
// osw.write(line.toUpperCase()+"\r\n");
// osw.flush();

bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}


}


}

转换流的过程图：


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;


public class TransStreamDemo2 {

/**
* @param args
* @throws IOException 
*/
public static void main(String[] args) throws IOException {


/*
* 1,需求：将键盘录入的数据写入到一个文件中。 


* 
* 2,需求：将一个文本文件内容显示在控制台上。


* 
* 3,需求：将一个文件文件中的内容复制到的另一个文件中。
*/

BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("b.txt")));


String line = null;

while((line=bufr.readLine())!=null){
if("over".equals(line))
break;

bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}

}

}

================================================================


转换流：
InputStreamReader ：字节到字符的桥梁。解码。
OutputStreamWriter：字符到字节的桥梁。编码。


流的操作规律：
之所以要弄清楚这个规律，是因为流对象太多，开发时不知道用哪个对象合适。


想要知道开发时用到哪些对象。只要通过四个明确即可。


1，明确源和目的(汇)
源：InputStream  Reader
目的：OutputStream  Writer


2，明确数据是否是纯文本数据。
源：是纯文本：Reader
否：InputStream
目的：是纯文本 Writer
否：OutputStream

到这里，就可以明确需求中具体要使用哪个体系。

3，明确具体的设备。
源设备：
硬盘：File
键盘：System.in
内存：数组
网络：Socket流

目的设备：
硬盘：File
控制台：System.out
内存：数组
网络：Socket流


4，是否需要其他额外功能。
1，是否需要高效(缓冲区);
是，就加上buffer.
2，转换。





需求1：复制一个文本文件。
1,明确源和目的。
源：InputStream Reader
目的：OutputStream  Writer
2,是否是纯文本？
是！
源：Reader
目的：Writer

3,明确具体设备。
源：
硬盘：File
目的：
硬盘：File

FileReader fr = new FileReader("a.txt");
FileWriter fw = new FileWriter("b.txt");

4,需要额外功能吗？
需要，需要高效。
BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));
BufferedWriter bufw = new BufferedWriter(new FileWriter("b.txt"));

================================================


需求2：读取键盘录入信息，并写入到一个文件中。

1,明确源和目的。
源：InputStream Reader
目的：OutputStream  Writer
2，是否是纯文本呢？
是，
源：Reader
目的：Writer
3，明确设备
源：
键盘。System.in
目的：
硬盘。File

InputStream in = System.in;
FileWriter fw = new FileWriter("b.txt");
这样做可以完成，但是麻烦。将读取的字节数据转成字符串。再由字符流操作。
4，需要额外功能吗？
需要。转换。 将字节流转成字符流。因为名确的源是Reader，这样操作文本数据做便捷。
所以要将已有的字节流转成字符流。使用字节-->字符 。InputStreamReader
InputStreamReader isr = new InputStreamReader(System.in);
FileWriter fw = new FileWriter("b.txt");

还需要功能吗？
需要：想高效。
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw = new BufferedWriter(new FileWriter("b.txt"));



===================================================

需求3：将一个文本文件数据显示在控制台上。
1,明确源和目的。
源：InputStream Reader
目的：OutputStream  Writer
2，是否是纯文本呢？
是，
源：Reader
目的：Writer
3，明确具体设备
源：
硬盘：File
目的：
控制台：System.out

FileReader fr = new FileReader("a.txt");
OutputStream out = System.out;//PrintStream
4，需要额外功能吗？
需要，转换。
FileReader fr= new FileReader("a.txt");
OutputStreamWriter osw = new OutputStreamWriter(System.out);
需要，高效。 
BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

================================================================


需求4：读取键盘录入数据，显示在控制台上。
1,明确源和目的。
源：InputStream Reader
目的：OutputStream  Writer
2，是否是纯文本呢？
是，
源：Reader
目的：Writer
3，明确设备。
源：
键盘：System.in
目的：
控制台：System.out

InputStream in = System.in;
OutputStream out = System.out;

4，明确额外功能？
需要转换，因为都是字节流，但是操作的却是文本数据。
所以使用字符流操作起来更为便捷。
InputStreamReader isr = new InputStreamReader(System.in);
OutputStreamWriter osw = new OutputStreamWriter(System.out);

为了将其高效。
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));


============================================================


5，将一个中文字符串数据按照指定的编码表写入到一个文本文件中.

1，目的。OutputStream，Writer
2，是纯文本，Writer。
3，设备：硬盘File 
FileWriter fw = new FileWriter("a.txt");
fw.write("你好"); 

注意：既然需求中已经明确了指定编码表的动作。
那就不可以使用FileWriter，因为FileWriter内部是使用默认的本地码表。
只能使用其父类。OutputStreamWriter.
OutputStreamWriter接收一个字节输出流对象，既然是操作文件，那么该对象应该是FileOutputStream

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("a.txt"),charsetName);

需要高效吗？
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("a.txt"),charsetName));


什么时候使用转换流呢？


1，源或者目的对应的设备是字节流，但是操作的却是文本数据，可以使用转换作为桥梁。
提高对文本操作的便捷。
2，一旦操作文本涉及到具体的指定编码表时，必须使用转换流 。

====================================================================

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;


public class TransStreamDemo3 {


/**
* @param args
* @throws IOException 
*/
public static void main(String[] args) throws IOException {


readText_2();
}


public static void readText_2() throws IOException, FileNotFoundException {


InputStreamReader isr = new InputStreamReader(new FileInputStream("gbk_1.txt"),"utf-8");
char[] buf = new char[10];
int len = isr.read(buf);
String str = new String(buf,0,len);
System.out.println(str);

isr.close();
}


public static void readText_1() throws IOException {

FileReader fr = new FileReader("gbk_1.txt");

char[] buf = new char[10];
int len = fr.read(buf);
String str = new String(buf,0,len);
System.out.println(str);

fr.close();


}

public static void writeText_3() throws IOException {

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("u8_1.txt"),"UTF-8");

osw.write("你好");
osw.close();

}


public static void writeText_2() throws IOException {

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk_3.txt"),"GBK");

// OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk_3.txt"),"GBK");
// FileWriter fw = new FileWriter("gbk_1.txt");

/*
* 这两句代码的功能是等同的。 
* FileWriter：其实就是转换流指定了本机默认码表的体现。而且这个转换流的子类对象，可以方便操作文本文件。
*             简单说：操作文件的字节流+本机默认的编码表。
* 这是按照默认码表来操作文件的便捷类。
* 
* 如果操作文本文件需要明确具体的编码。FileWriter就不行了。必须用转换流。 
* 
*/


osw.write("你好");

osw.close();


}
public static void writeText_1() throws IOException {

FileWriter fw = new FileWriter("gbk_1.txt");

fw.write("你好");

fw.close();
}


}




david_lian
关注
Java使用I/O流读取文件内容的方法详解
08-25
Java使用I/O流读取文件内容的方法详解 Java使用I/O流读取文件内容的方法是Java编程中常用的文件读取方式。该方法可以将文件内容读取到程序中，并对其进行处理和分析。在Java中，I/O流是指数据流向某个对象的数据...
java基础之I/O流
10-12
I/O流分为两大类：字符流（Character Stream）和字节流（Byte Stream），每类又分为输入流（Input Stream）和输出流（Output Stream）。下面将详细解释这些概念以及它们在Java中的应用。 1. 字节流： - 输入流：...
IO流——(6) 字节流——操作文件
真香号
01-03 257
一、字节流的两个父类： InputStream : OutputStream: 二、首先看：OutputStream: 1、API: 2、继承体系： 媒体数据也是以文件形式存在。 3、方法： 4、代码演示： private static void demo_writer() throws IOException { //1、创建字节输出流...
字节流练习
weixin_41874888的博客
02-19 210
一、复制文件 原理：读取一个已有的数据，并将这些读到的数据写入到另一个文件中。 public class CopyFileTest { public static void main(String[] args) throws IOException { //1,明确源和目的。 File srcFile = new File("c:\\Y...
I/O - 理解Java中字符流与字节流的区别
YellowStar的博客
09-09 1412
1. 什么是流 Java中的流是对字节序列的抽象，我们可以想象有一个水管，只不过现在流动在水管中的不再是水，而是字节序列。和水流一样，Java中的流也具有一个“流动的方向”，通常可以从中读入一个字节序列的对象被称为输入流；能够向其写入一个字节序列的对象被称为输出流。 2. 字节流 Java中的字节流处理的最基本单位为单个字节，它通常用来处理二进制数据。Java中最基本的两个字节流类是In...
I/O文件---字节流，字符流：InputStream、OutputStream 、Reader、Writer
qq_44641527的博客
09-14 2798
一、I/O基本概念 1、输入和输出---完成硬盘文件的读和写 （1）向内存输入文件---input， read---输入流 InputStream 硬盘--->内存 （2）从内存输出文件---output，write---输入流 OutputStream 内存--->硬盘 2、I/O流分类 （1）流的方向 输入流InputStream -----read 输出流OutputStream ----write （2）读取数据的方式 ...
Java之I/O流（最详细的I/O流总结）
熊凯瑞的博客
05-15 8099
I/O流I/O流1、定义2、分类2.1 字节流和字符流2.2 输入流和输出流2.3 节点流和处理流3、结构4、字节流4.1 定义4.2 说明4.3 字节流概述4.4 InputStream的常用方法4.5 OutputStream的常用方法5、字节流读写文件5.1 说明5.2 注意5.3 字节输入流——相关代码5.4 字节输出流——相关代码6、文件的拷贝6.1 需求6.2 分析6.3 注意6.4 快捷键6.5 相关代码7、字节流的缓冲区7. 相关代码8、字节缓冲流8.1 说明8.2 特点8.3 相关代码8.
Java——I/O流之字节、字符流
程序员阿龙的博客
07-27 985
Java——I/O流之字节、字符流
Java-Java I/O流解读之基于字节的I / O和字节流
小工匠
09-06 6202
概述 File and Directory Class javaioFile Pre-JDK 7 Verifying Properties of a FileDirectory List Directory List Directory with Filter Class javaniofilePath JDK 7 Stream IO in Standard IO javaio Package 标准
JAVA I/O流(超详细)
wu_ry的博客
03-08 1626
File类能够实现对文件和目录的创建、删除等基础性操作，但是无法实现对文件内容的操作，也就是无法实现对文件的读写。而java中的I/O流能够方便地实现数据的输入和输出，是实现文件读写的基础。流，是指一连串流动的字符，是以先进先出的方式发送和接收数据的通道。既然是流，必然有源端和目的的端，它们可以是计算机内存的某些区域，也可以是磁盘、文件等，甚至可以是Internet上的某个统一资源定位符。所谓I/O流就是实现数据输入和输出的流，在I/O流的基础上，可以实现对文件的读写操作。那么文件的读写指什么？
Java——I/O流（一）：字节流（概念理解+应用举例）
热门推荐
★★光亭★★
07-19 1万+
Java——I/O流（一）：字节流（概念理解+应用举例）
Java I/O (Input/Output)——文件字节流
窗外风景随心变幻
08-06 3887
Java I/O（输入/输出）是 Java 程序中用于处理数据输入和输出的重要部分。输入流（Input Streams）：用于从数据源读取数据。常见的输入流包括（从文件读取）、（提高读取效率）等。输出流（Output Streams）：用于将数据写入到目的地。例如（向文件写入）、（提高写入效率）。字符流（Reader 和 Writer）：处理字符数据，更适合处理文本。如FileReader和FileWriter。缓冲流（Buffered Streams）：通过缓冲区来减少实际的 I/O 操作次数，提高性能。
Java课程设计报告书-学生版-1_I/O流与文件课程设计_
09-30
I/O流分为字符流和字节流两大类，分别处理文本和二进制数据。又可以根据流向分为输入流和输出流，输入流用于读取数据，输出流用于写入数据。 二、文件对象与流类 1. 文件对象：`java.io.File` 类是Java中用于文件和...
多台三相逆变器并联（本模型为三台并联，市面上多为两台并联）matlab simulink仿真 功能：实现并联系统中各逆变器输出
最新发布
10-09
多台三相逆变器并联（本模型为三台并联，市面上多为两台并联）matlab simulink仿真。 功能：实现并联系统中各逆变器输出功率均分。 （有能力的话还可以研究下垂特性、功率指令以及静态功工作点三者之间的联系） 控制策略：VSG控制策略（同步机控制） 逆变器主电路：三相逆变器，LCL滤波电路，VSG控制模块。 VSG控制模块：定、转子方程，dq变，电压电流双闭环，预同步，pwm发生器。
Ringtones波点音乐-《Lightning Moment》.mp3
10-09
Ringtones波点音乐-《Lightning Moment》.mp3
onnx2onnx-0.3.1.tar.gz
10-09
onnx2onnx-0.3.1.tar
网页商城系统 SSM毕业设计 源码+数据库+论文（JAVA+SpringBoot+Vue.JS）.zip
10-09
网页商城系统 SSM毕业设计 源码+数据库+论文（JAVA+SpringBoot+Vue.JS） 启动教程：https://www.bilibili.com/video/BV1GK1iYyE2B
实现卡尔曼滤波器,扩展卡尔曼滤波器,双卡尔曼滤波器和平方根卡尔曼滤波器Matlab代码.rar
10-09
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
RATIONALYST：预训练过程监督改进推理机制
10-09
内容概要：RATIONALYST 是一种预训练推理模型，旨在改进大型语言模型（LLMs）在处理数学、常识、科学和逻辑推理等多种任务时的表现。通过对来自大规模未标注数据集中提取的隐含推理论据进行训练，解决了传统模型在模拟日常沟通中的逻辑跳跃而带来的推理由不足的问题。相较于现有的同类系统，如GPT-4及其他相同大小或更大的验证模型，RATIONALYST 在七个典型的基准测试上表现得更好。 适合人群：自然语言处理研究员与高级工程师。 使用场景及目标：研究者可以利用 RATIONALYST 提高对复杂语言和逻辑的理解能力，从而在不同的应用场景下提升系统的准确度和稳定性。 其他说明：本论文还附带发布了 GitHub 上该项目的所有代码，可供下载用于继续探索或者作为教学材料帮助相关人员更好地理解这一新的方法和技术路径。
程序设计课件：文件与流I/O-二进制文件操作
"本课程内容聚焦于文件和流I/O，特别是二进制文件的读取和写入。文件被视为数据的集合，存在于磁盘或其他存储设备上，并通过流进行读写操作。流提供了向存储设备写入和从设备读取字节的途径。在.NET Framework的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值