This article brings you relevant knowledge about java, which mainly organizes issues related to O flow principles and flow classification, including node flow, buffer flow, conversion flow, and output. Streaming and other content, let’s take a look at it below, I hope it will be helpful to everyone.
Recommended learning: "java Video Tutorial"
## 1. Overview
I/O
is the abbreviation ofInput/Output,I/Otechnology is a very practical technology for processing Data transfer between devices. Such as reading/writing files, network communication, etc.Input
- input
Output: Read external data (data from storage devices such as disks and optical disks) into the program (memory).- output
: Output program (memory) data to storage devices such as disks and optical disks.
In Java programs, data input/output operations are performed in the form of "stream (stream
)".
java.io
package provides various "stream" classes and interfaces to obtain different types of data and input or output through standard methods data.
According to different operation data units, it is divided into: words Throttling (8## According to the different flow directions of the data stream, it is divided into: input stream, output stream Streambit
), character stream (16bit)
According to the different roles of the stream, it is divided into: node stream, processing stream
Java’s IO stream involves more than 40 classes, which are actually very regular and are derived from the above 4 abstract base classes. Yes, the names of subclasses derived from these four classes are all suffixed with the name of the parent class.Node stream: read directly from the data source or destination Write data
- Processing flow: not directly connected to the data source or destination, but "connected" to an existing flow (node flow or processing flow) On top of that, it provides the program with more powerful reading and writing functions through data processing.
| Byte stream | Character stream | |
|---|---|---|
| InputStream | | Reader |
| OutputStream | | Writer |
IO stream system: 
2. InputStream
Typical implementation:
FileInputStreamMethod
| Description | |
|---|---|
| int byte value in the range 0 to 255. If no bytes are available because the end of the stream has been reached, the value -1 is returned. |
| b.length bytes from this input stream The data is read into a byte array. If no bytes are available because the end of the stream has been reached, the value -1 is returned. Otherwise the actual number of bytes read is returned as an integer. |
|
|
|
| Method | Description |
|---|---|
int read() |
Read a single character. Character read as an integer in the range 0 to 65535 (0x00-0xffff) (2-byte Unicode code), or -1 |
##int read(char[] cbuf) | Read characters into an array. If the end of the stream has been reached, -1 is returned. Otherwise, return the number of characters read this time. |
int read(char[] cbuf,int off,int len) | Read characters into a certain part of the array. Store it in the array cbuf, starting from off, and read up to len characters. If the end of the stream has been reached, -1 is returned. Otherwise, return the number of characters read this time. |
public void close() throws IOException | Closes this input stream and releases all system resources associated with the stream.
Typical implementation class: FileReader
@Test
public void testFileReader(){
FileReader fr = null;
try {
//1.实例化File类的对象，指明要操作的文件
File file = new File("hello.txt");//相较于当前Module
//2.提供具体的流
fr = new FileReader(file);
//3.数据的读入
//read():返回读入的一个字符。如果达到文件末尾，返回-1
//方式一：// int data = fr.read();// while(data != -1){// System.out.print((char)data);// data = fr.read();// }
//方式二：语法上针对于方式一的修改
int data;
while((data = fr.read()) != -1){
System.out.print((char)data);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//4.流的关闭操作// try {// if(fr != null)// fr.close();// } catch (IOException e) {// e.printStackTrace();// }
//或
if(fr != null){
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//对read()操作升级：使用read的重载方法
@Test
public void testFileReader1() {
FileReader fr = null;
try {
//1.File类的实例化
File file = new File("hello.txt");
//2.FileReader流的实例化
fr = new FileReader(file);
//3.读入的操作
//read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1
char[] cbuf = new char[5];
int len;
while((len = fr.read(cbuf)) != -1){
//方式一：
//错误的写法// for(int i = 0;i 4. OutputStream<h3></h3><p> Overview<strong></strong></p><blockquote>Typical implementation: <p>FileOutputStream<code></code></p>
</blockquote><p> Method <strong></strong></p>| Description | |
|---|---|
void write(int b) | Write the specified bytes this output stream. The general contract of write is: write one byte to the output stream. The bytes to be written are the eight low-order bits of parameter b. The 24 high-order bits of b are ignored. That is, the range of 0~255 is written. |
void write(byte[] b) | Write b.length bytes from the specified byte array to this output stream. The general contract of write(b) is that it should have exactly the same effect as calling write(b, 0, b.length). |
void write(byte[] b,int off,int len) | Will start from offset off in the specified byte array len bytes are written to this output stream. |
public void flush()throws IOException | Flushes this output stream and forces all buffered output bytes to be written out. Call this method to indicate These bytes should be written immediately to their intended destination. |
public void close() throws IOException | Closes this output stream and releases all system resources associated with the stream.
Main implementation class: FileInputOutputStream
/*
实现对图片的复制操作
*/
@Test
public void testFileInputOutputStream() {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
//
File srcFile = new File("爱情与友情.jpg");
File destFile = new File("爱情与友情2.jpg");
//
fis = new FileInputStream(srcFile);
fos = new FileOutputStream(destFile);
//复制的过程
byte[] buffer = new byte[5];
int len;
while((len = fis.read(buffer)) != -1){
fos.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fos != null){
//
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}Overview
Typical implementation:FileWriter
Method
| Description | |
|---|---|
void write(int c) | Write a single character. The character to be written is contained in the 16 low-order bits of the given integer value, the high-order 16 bits are ignored. That is, write a Unicode code between 0 and 65535. |
void write(char[] cbuf) | Write character array. |
void write(char[] cbuf,int off,int len) | Write a certain part of the character array. Starting from off, write len characters |
void write(String str) | Write string. |
void write(String str,int off,int len) | Write a certain part of the string. |
void flush() | Flushes the buffers for this stream, immediately writing them to the intended destination. |
public void close() throws IOException | Closes this output stream and releases all system resources associated with the stream.
public InputStreamReader(InputStream in) |
public InputSreamReader(InputStream in,String charsetName) |
概述
- 实现将字符的输出流按指定字符集转换为字节的输出流。
- 需要和
OutputStream“套接”。
（2）构造器
public OutputStreamWriter(OutputStream out) |
public OutputSreamWriter(OutputStream out,String charsetName) |
代码演示1：
@Test
public void test1() throws IOException {
FileInputStream fis = new FileInputStream("dbcp.txt");// InputStreamReader isr = new InputStreamReader(fis);//使用系统默认的字符集
//参数2指明了字符集，具体使用哪个字符集，取决于文件dbcp.txt保存时使用的字符集
InputStreamReader isr = new InputStreamReader(fis,"UTF-8");//使用系统默认的字符集
char[] cbuf = new char[20];
int len;
while((len = isr.read(cbuf)) != -1){
String str = new String(cbuf,0,len);
System.out.print(str);
}
isr.close();
}代码演示2：
@Test
public void test2() throws Exception {
//1.造文件、造流
File file1 = new File("dbcp.txt");
File file2 = new File("dbcp_gbk.txt");
FileInputStream fis = new FileInputStream(file1);
FileOutputStream fos = new FileOutputStream(file2);
InputStreamReader isr = new InputStreamReader(fis,"utf-8");
OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
//2.读写过程
char[] cbuf = new char[20];
int len;
while((len = isr.read(cbuf)) != -1){
osw.write(cbuf,0,len);
}
//3.关闭资源
isr.close();
osw.close();
}}
System.in和System.out分别代表了系统标准的输入和输出设备
默认输入设备是：键盘，输出设备是：显示器
System.in的类型是InputStream，System.out的类型是PrintStream，其是OutputStream的子类，FilterOutputStream的子类
重定向：通过System类的setIn，setOut方法对默认设备进行改变。
public static void setIn(InputStream in)public static void setOut(PrintStream out)
/*
从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续进行输入操作，
直至当输入“e”或者“exit”时，退出程序。
方法一：使用Scanner实现，调用next()返回一个字符串
方法二：使用System.in实现。System.in ---> 转换流 ---> BufferedReader的readLine()
*/
public static void main(String[] args) {
BufferedReader br = null;
try {
InputStreamReader isr = new InputStreamReader(System.in);
br = new BufferedReader(isr);
while (true) {
System.out.println("请输入字符串：");
String data = br.readLine();
if ("e".equalsIgnoreCase(data) || "exit".equalsIgnoreCase(data)) {
System.out.println("程序结束");
break;
}
String upperCase = data.toUpperCase();
System.out.println(upperCase);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (br != null) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}实现将基本数据类型的数据格式转化为字符串输出
打印流：
PrintStream和PrintWriter
提供了一系列重载的
print()和println()方法，用于多种数据类型的输出
PrintStream和PrintWriter的输出不会抛出IOException异常
PrintStream和PrintWriter有自动flush功能
PrintStream打印的所有字符都使用平台的默认字符编码转换为字节。 在需要写入字符而不是写入字节的情况下，应该使用PrintWriter类。
System.out返回的是PrintStream的实例
/*
2. 打印流：PrintStream 和PrintWriter
2.1 提供了一系列重载的print() 和 println()
2.2 练习：
*/
@Test
public void test2() {
PrintStream ps = null;
try {
FileOutputStream fos = new FileOutputStream(new File("D:\\IO\\text.txt"));
// 创建打印输出流,设置为自动刷新模式(写入换行符或字节 '\n' 时都会刷新输出缓冲区)
ps = new PrintStream(fos, true);
if (ps != null) {// 把标准输出流(控制台输出)改成文件
System.setOut(ps);
}
for (int i = 0; i <h2>八、数据流</h2><blockquote><p> 为了方便地操作Java语言的基本数据类型和String的数据，可以使用数据流。</p></blockquote><blockquote>
<p> 数据流有两个类：(用于读取和写出基本数据类型、String类的数据）</p>
<ol>
<li><code>DataInputStream</code></li>
<li><code>DataOutputStream</code></li>
</ol>
<p>分别“套接”在 <code>InputStream</code> 和 <code>OutputStream</code> 子类的流上</p>
</blockquote><blockquote><p><code>DataInputStream</code>中的方法：</p></blockquote>boolean readBoolean() |
byte readByte() char |
readChar() |
float readFloat() |
double readDouble() |
long readLong() |
int readInt() |
short readShort() |
String readUTF() |
void readFully(byte[] b) |
Supplement: Method in DataOutputStream: Change the read of the above method to the corresponding write
Recommended learning: "java video tutorial"
The above is the detailed content of Java summarizes the principles of IO streams and the classification of streams. For more information, please follow other related articles on the PHP Chinese website!
![JavaScript core tutorial [DOM BOM operations that JS must know]](https://img.php.cn/upload/course/000/000/041/61c56ae28d02a390.jpg)
![TypeScript introductory video [can be understood even without learning JavaScript]](https://img.php.cn/upload/course/000/000/068/6242c0fc4be39373.png)
![Practical development of imitation Meituan APP [A must-have JavaScript project for front-end programmers]](https://img.php.cn/upload/course/000/000/068/6242bebc05ca9210.png)
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
