IO流

# io流

#### 什么是io

> i input 输入
>
> o output 输出

#### 1流介绍

~~~
一切皆为字节
一切文件数据（文本、图片、视频）在存储时，都以二进制数字的形式保存，都一个一个的字节，那么传输时一样

所以，字节流可以传输任意文件数据。无论什么流对象，底层传输的始终为一个二进制数据
~~~

#### 2.流的意义

流的概念使得文件、网络、内存设备可以被统一处理

#### 以下 流的File都是JavaAPI提供的一个类

# File

## 文件

1 byte=8 bit

1kb=1024 byte

1mb= 1024kb

##### 目录处理

​ ■mkdir()
​ ■list()
​ ■listFiles()

##### File类的静态方法

​ ■createTempFile()
​ ■listRoots()-返回文件系统的root名，windows 系
​ 统上，例如c:\，d:\

~~~Java
import java.io.File;
import java.time.LocalDateTime;
import java.time.ZoneOffset;

public class FileText {
public static void main(String[] args) {

read();
deleteText();
create();
listText();

}
static void read(){
String pall="E:\\廖银玥图片\\1.jpg";
File file=new File(pall);
long length=file.length();//读取文件的大小，单位是字节；变成mb的话/1024.0/1024
System.out.println(length/1024.0/1024);
long last=file.lastModified();//1970.1.1以来的毫秒数,文件最后修改时间。
LocalDateTime localDateTime=LocalDateTime.ofEpochSecond(last/1000,0, ZoneOffset.of("+8") );
System.out.println("时间最后输出"+localDateTime);
System.out.println(File.separator);//File.separator路径分割辨识
}
static void deleteText(){//删除文件，不可被找回
File file=new File("E:\\廖银玥图片\\1.jpg");
boolean delete=file.delete();
System.out.println(delete);
}
static void create(){
File file=new File("E:\\01_test\\02");//创建目录
boolean mkdir= file.mkdirs();//加s
System.out.println("创建目录结果："+mkdir);
}
static void listText(){
File file=new File("E://");
File[] files = file.listFiles();//访问文件数组
for(File f:files){
if (f.isDirectory()){//判断是否是目录；
System.out.println(f.getName()+"\t<dri>");
}else {
System.out.println(f.getName()+"\t<file>");
}
}
}
}
~~~

Ctrl+F12查看构造方法

##### File对象的名称取得

**File b = new Fil(".." + File.separator + "examples" +File.separator + "xanadu.txt");**

 

# 字节流

### InputStream 输入流的抽象类 磁盘到程序

#### InputStream

字节输入流的抽象类

**常用操作**

- read():输入一个字节

- read(byte[]):读入多个字节
- close（）：关闭此输入流

**异常**

- IO类库的大部分方法都会抛出一些异常IOException

#### FileInpitStream

- 将磁盘上的文件变成输入流
- 构造方法
- FileInpitStream（String fileName）
- FileInpitStream(File file)

~~~java
InputStream is=new FileInputStream("E:\\01_test\\1.jpg");
~~~

 

### OutputStream输出流 程序到磁盘

 


#### OutputStream

字节输出流的抽象类

**常用操作**

- write(int):向输出流写一个字节

- write(byte[]):向输出流写一个字节多个字节
- close（）：关闭此输出流

#### FileOutpitStream

- 将磁盘上的文件变成输出流

- 构造方法

- FileOutpitStream（String fileName）
- FileOutpitStream（String fileName，boolean append）
- FileOutpitStream(File file)

~~~Java
OutputStream os=new FileOutputStream("E:\\01_test\\02\\1.jpg");
OutputStream os=new FileOutputStream("E:\\01_test\\02\\1.jpg"，true);
~~~

#### 8 byte构成一个字节，计算机存储的最小单位为字节

### 字节流的

### 复制粘贴案例

~~~java
package com.cqyti.stx.Java高级.io.bytedemo;

import java.io.*;

public class Demo {
public static void main(String[] args) {
demo1();
//demo2();
}
static void demo1(){
InputStream inputStream=null;
OutputStream os=null;
int b=0;
try {
inputStream= new FileInputStream("E:\\01_test\\1.jpg");
//创建一个输出流
os=new FileOutputStream("E:\\01_test\\02\\1.jpg");
while (true){
b=inputStream.read();
if (b==-1)
{
break;
} //往输出流写一个字节
os.write(b);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
inputStream.close();
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
static void demo2(){
File file=new File("E:\\01_test\\1.jpg");
long length = file.length();
byte[] bt=new byte[(int)length]; //前提：必须知道文件的子节有多大
InputStream is=null;
OutputStream os=null;
try {
is= new FileInputStream(file);
is.read(bt);
os=new FileOutputStream("E:\\01_test\\02\\1.jpg");
//往输出流写一个字节
os.write(bt);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
is.close();
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
} catch (IOException e) {
e.printStackTrace();
}

}

}
}

~~~

# 字符流：专门针对汉字的（处理中文的流）


#### Reader

- 字节输入流的抽象类
- 常用操作
- read():读入一个字符
- read（char[]）:读入多个字符
- close（）：关闭此输入流

#### Writer

- 字节输出想流的抽象类
- 常用操作
- write():向输出流写入一个字符
- read（char[]）:向输出流写入多个字符
- close（）：关闭此输入流

#### 例子

```java
package com.cqyti.stx.Java高级.io.File;

import java.io.*;

public class Character {
public static void main(String[] args) throws IOException {
//read();
write();
read2();
}
static void read() throws IOException {//一个一个的读
Reader reader=new FileReader("E:\\text.txt");
while (true){
int ch = reader.read();
if (ch==-1){
break;
}
System.out.println(ch+"------>"+(char)ch);
}
reader.close();
}
static void read2() throws IOException {
File file=new File("E:\\text.txt");
InputStream is=new FileInputStream(file);
byte[] bytes=new byte[(int)file.length()];
is.read(bytes);
String str=new String(bytes);
System.out.println("文件内容是"+str);
}
static void write() throws IOException {
Writer writer=new FileWriter("E:\\text.txt");
writer.write("双体软件经验学院");
writer.close();
}
}
```

# 缓冲流

#### BufferedInputStream

■为输出流提供缓冲区

###### 构造方法

■BufferedInputStream(OutputStream);
■BufferedInputStream(OutputStream,int);

#### BufferedOutputStream

■为输出流提供缓冲区

###### 构造方法

■BufferedOutputStream(OutputStream);
■BufferedOutputStream(OutputStream,int);

 

```java
package com.cqyti.stx.Java高级.io.File;

import java.io.*;

public class Buffer {
public static void main(String[] args) throws IOException {
long l = System.currentTimeMillis();//时间开始
text();
long l1 = System.currentTimeMillis();//时间结束
System.out.println(l1-l);
}
static void text() throws IOException {
//创建输入流、输出流、缓冲输入流、缓冲输出流
//创建缓存区
//循环读写和写入
InputStream is=new FileInputStream("E:\\01_test\\1.jpg");
OutputStream os=new FileOutputStream("E:\\01_test\\02\\1.jpg");
BufferedInputStream bis=new BufferedInputStream(is);//创建缓冲区输入流
BufferedOutputStream bos=new BufferedOutputStream(os);//创建缓冲区输出流
byte[] bytes=new byte[4096];//缓冲区，引用数据类型,默认8192
while (true){
int len=bis.read(bytes);//
if (len==-1){
break;
}
bos.write(bytes);
}
bis.close();
bos.close();
}
}

```

> 本身没有读取文件，只是对文件进行了处理。
>
> int 表示缓存的大小。

## 字符流缓冲区

##### BufferedReader

- 为字符输入流增加缓存
- 构造方法参数为Reader
- 新增操作。
- readLine 读入一行，返回String

##### BufferedWriter

■为输出流提供缓存支持
■构造方法参数为Writer
■BufferedWriter(Writer out)

 

 

# 转换流

#### 字符编码

计算机中储存的信息都是用二进制数表示的,而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制
数转换之后的结果。按照某种规则，将字符存储到计算机中，称为编码。反之，将存储在计算机中的二进制数据按
照某种规则解析显示出来，称为解码。比如说，按照A规则存储，同样按照A规则解析,那么就能显示正确的文本
符号。反之，按照A规则存储,再按照B规则解析,就会导致乱码现象。
**编码:字符(能看懂的) -->字节(看不懂的)**
**解码:字节(看不懂的) -->字符(能看懂**的)

指定编码进行读写

# 其他流

#### 基本数据类型

- **DataInputStream**
- **DataOutputStream**

#### 对象类型

- **ObjectInputStream**
- **ObjectInputStream**

#### 对象序列化

**Java的对象的序列化将那些实现了Serializable接口的对象转换成一个字节序列，并能够在以后将这个字**
**节序列完全恢复为原来的对象**

#### Serializable接口

- 标志着一个类的对象可以被序列化
- 需要序列化的状态必须可被序列化
- 基类型
- 其他可序列化类型(实现Serializable接口)
- 用transient关键字标志不进行序列化的状态
- 静态变量不被序列化

#### 对象输入输出流.

##### ObjectInputStream

■构造方法ObjectInputStream(InputStream)
■readObject方法

##### ObjectOutputStream

- 构造方法ObjectOutputStream(OutputStream);
- writeObject方法