목차
1. IO 소개
Java IO 스트림은 Java에서 입력 및 출력을 처리하는 메커니즘입니다. 프로그램과 외부 장치(예: 파일, 네트워크 연결, 콘솔) 간에 데이터를 전송하는 데 사용되는 데이터 전송 방법입니다. Java IO 스트림은 데이터를 읽고 쓰는 유연한 방법을 제공하며 텍스트, 바이너리 및 개체 데이터를 포함한 다양한 유형의 데이터를 처리할 수 있습니다. Java IO 스트림에는 입력 스트림과 출력 스트림의 두 가지 유형이 포함됩니다. 여기서 입력 스트림은 데이터를 읽는 데 사용되고 출력 스트림은 데이터를 쓰는 데 사용됩니다. Java에서 IO 스트림은 클래스와 인터페이스를 통해 구현됩니다.
Java IO 스트림은 바이트 스트림 및 문자 스트림을 포함하여 여러 유형의 스트림을 제공합니다. 바이트 스트림은 이진 데이터를 처리하고 모든 유형의 파일에서 작동할 수 있는 반면, 문자 스트림은 텍스트 데이터를 처리하고 일반 텍스트 파일에서만 작동할 수 있습니다. 일반 텍스트 파일은 Windows 시스템과 함께 제공되는 메모장으로 열어서 사용할 수 있습니다. txt 파일, md 파일, xml 파일, lrc 파일 등과 같은 파일을 읽으십시오
. 바이트 스트림에는 InputStream 및 OutputStream이 포함되고 문자 스트림에는 Reader 및 Writer가 포함됩니다. 또한 Java IO 스트림은 데이터 처리를 용이하게 하기 위해 버퍼 스트림, 데이터 스트림, 개체 스트림 및 기타 유형의 스트림도 제공합니다.
IO 스트림 시스템
바이트 스트림
바이트 출력 스트림: FileoutputStream
로컬 파일의 바이트 출력 스트림을 조작하여 프로그램의 데이터를 로컬 파일에 쓸 수 있습니다.
작성 단계:
1. 바이트 출력 스트림 객체 생성
2. 데이터 쓰기
3. 자원 공개
File f1 = new File( "D:\\a.txt" );
boolean b1 = false;
FileOutputStream fos = null;
try {
//在D盘创建文件
b1 = f1.createNewFile();
//创建输出流对象，数据传输通道
fos = new FileOutputStream("D:\\a.txt" );
//写入数据
fos.write(97);
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fos != null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
System.out.println(b1);세부사항 1: 매개변수는 문자열 또는 File 객체로 표시되는 경로입니다.
FileOutputStream fos = null;
try {
//创建输出流对象，数据传输通道
fos = new FileOutputStream(new File( "D:\\a.txt" ) );
//写入数据
fos.write(97);
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fos != null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
세부 사항 2: 파일이 존재하지 않으면 새 파일이 생성되지만 상위 경로가 존재하는지 확인하십시오.
세부사항 3: 파일이 이미 존재하는 경우 파일이 삭제됩니다
세부사항: 쓰기 메소드의 매개변수는 정수이지만 로컬 파일에 실제로 쓰여지는 것은 정수에 해당하는 ASCII 문자입니다.
FileOutputStream을 사용하여 데이터를 쓰는 3가지 방법
| 메소드 이름 | 설명하다 |
| 무효 쓰기(int b) | 한 번에 1바이트씩 데이터 쓰기 |
| 무효 쓰기(바이트[ ] b) | 한 번에 하나씩 바이트 배열 데이터 쓰기 |
| 무효 쓰기(바이트[ ] b, int off， int len) | 한 번에 1바이트 배열로 데이터의 일부 쓰기 |
방법 1:
public static void main(String[] args) {
FileOutputStream fos = null;
try {
//创建输出流对象，数据传输通道
fos = new FileOutputStream(new File( "D:\\aa\\a.txt" ) );
//写入数据
fos.write(97);
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fos != null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}방법 2:
public static void main(String[] args) {
FileOutputStream fos = null;
try {
//创建输出流对象，数据传输通道
fos = new FileOutputStream(new File( "D:\\a.txt" ) );
byte[] bytes = {97, 98, 99, 100};
//写入数据
fos.write(bytes);
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fos != null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}방법 3:
public static void main(String[] args) {
FileOutputStream fos = null;
try {
//创建输出流对象，数据传输通道
fos = new FileOutputStream(new File( "D:\\a.txt" ) );
byte[] bytes = {97, 98, 99, 100};
//写入数据
//参数一：数组 参数二：起始索引 参数三：写入的个数
//b c
fos.write(bytes,1,2);
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fos != null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}새 줄에 쓰세요:
public static void main(String[] args) {
FileOutputStream fos = null;
try {
//创建输出流对象，数据传输通道
fos = new FileOutputStream(new File( "D:\\a.txt" ) );
String str = "zhangsan";
byte[] bytes1 = str.getBytes();
fos.write(bytes1);
String str2 = "\r\n";
byte[] bytes2 = str2.getBytes();
fos.write(bytes2);
String str3 = "666";
byte[] byte3 = str3.getBytes();
fos.write(byte3);
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fos != null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}계속:
public static void main(String[] args) {
FileOutputStream fos = null;
try {
//创建输出流对象，数据传输通道
//参数1：文件1路径 参数2：续写开关，ture续写，false文件清空从新写入
fos = new FileOutputStream(new File( "D:\\a.txt" ),true);
String str = "zhangsan";
byte[] bytes1 = str.getBytes();
fos.write(bytes1);
String str2 = "\r\n";
byte[] bytes2 = str2.getBytes();
fos.write(bytes2);
String str3 = "666";
byte[] byte3 = str3.getBytes();
fos.write(byte3);
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fos != null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}바이트 입력 스트림 FilelnputStream
로컬 파일의 바이트 입력 스트림을 작동함으로써 로컬 파일의 데이터를 프로그램으로 읽을 수 있습니다.
작성 단계:
1. 바이트 입력 스트림 객체 생성
2. 데이터 읽기
3. 자원 공개
public static void main(String[] args) {
FileInputStream fis = null;
try {
//创建输入流对象，数据传输通道
fis = new FileInputStream("D:\\a.txt" );
//读取数据
int read = fis.read();
System.out.println((char) read);
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}세부사항 1: 파일이 존재하지 않으면 오류가 직접 보고됩니다.
세부사항 2: 한 번에 한 바이트씩 데이터를 읽습니다. 읽는 것은 ASCII 데이터에 해당하는 숫자 세부사항입니다. 파일의 끝에 도달하면 읽기 메소드는 -1을 반환합니다.
루프에서 파일 읽기
public static void main(String[] args) {
FileInputStream fis = null;
try {
//创建输入流对象，数据传输通道
fis = new FileInputStream("D:\\a.txt" );
//读取数据
int b;
while ((b = fis.read()) != -1){
System.out.print((char) b);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}파일 복사
public static void main(String[] args) {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
//创建输入流对象，数据传输通道
fis = new FileInputStream("D:\\a.txt" );
//创建输出流对象，数据传输通道
fos = new FileOutputStream("D:\\b.txt");
//读取数据,边读编写
int b;
while ((b = fis.read()) != -1){
fos.write(b);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fos != null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}한 번에 여러 바이트의 데이터 읽기
public static void main(String[] args) {
FileInputStream fis = null;
try {
//创建输入流对象，数据传输通道
fis = new FileInputStream("D:\\a.txt" );
byte[] bytes = new byte[2];
//读取数据,返回读取元素的个数
int len = fis.read(bytes);
System.out.println(len);
//从当前数组中，从第0个元素开始，读取len个元素
String str = new String(bytes,0,len);
System.out.println(str);
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}문자 스트림
문자 스트림은 텍스트 데이터를 처리하는 데 사용되는 Java IO 스트림 유형입니다. 바이트 스트림과 달리 문자 스트림은 문자 지향적이며 유니코드 문자 집합의 문자를 처리할 수 있습니다. Java에는 Reader와 Writer라는 두 가지 주요 문자 스트림 클래스가 있습니다.
Reader 클래스는 문자 데이터를 읽기 위한 다양한 메서드를 제공하는 추상 클래스입니다. 일반적으로 사용되는 하위 클래스에는 FileReader, InputStreamReader, CharArrayReader 등이 포함됩니다. 그 중 FileReader는 파일의 문자 데이터를 읽는 데 사용되고, InputStreamReader는 바이트 스트림을 읽어 문자 스트림으로 변환하는 데 사용되며, CharArrayReader는 문자 배열의 데이터를 읽는 데 사용됩니다.
Writer 클래스는 문자 데이터를 쓰기 위한 다양한 메서드를 제공하는 추상 클래스이기도 합니다. 일반적으로 사용되는 하위 클래스에는 FileWriter, OutputStreamWriter, CharArrayWriter 등이 포함됩니다. 그 중 FileWriter는 문자 데이터를 파일에 쓰는 데 사용되고, OutputStreamWriter는 문자 스트림을 바이트 스트림으로 변환하여 출력 스트림에 쓰는 데 사용되고, CharArrayWriter는 문자 배열에 데이터를 쓰는 데 사용됩니다.
바이트 스트림과 달리 문자 스트림은 문자 세트 인코딩 및 디코딩을 자동으로 처리할 수 있으므로 텍스트 데이터를 더 편리하고 안전하게 처리할 수 있습니다. 동시에 문자 스트림은 버퍼 및 변환기와 같은 기능도 제공하여 데이터 전송 효율성을 향상시킬 수 있습니다.
간단히 말해서, 문자 스트림은 텍스트 데이터를 처리하는 데 사용되는 일종의 Java IO 스트림입니다. 문자 세트 인코딩 및 디코딩을 자동으로 처리하는 기능이 있고 버퍼 및 변환기와 같은 기능을 제공하며 텍스트 데이터 처리를 위한 첫 번째 선택입니다.
특징:
입력 스트림: 한 번에 한 바이트를 읽고, 중국어를 만날 때 한 번에 여러 바이트를 읽습니다.
출력 스트림: 맨 아래 레이어는 지정된 인코딩 방법에 따라 데이터를 인코딩하고 이를 바이트로 변환한 다음 파일에 씁니다.
문자 입력 스트림
작성 단계:
1. 문자 입력 스트림 객체 생성
2. 데이터 읽기
3. 자원 공개
public static void main(String[] args) throws IOException {
/*
第一步:创建对象
public FileReader(File file) 创建字符输入流关联本地文件
public FileReader(String pathname) 创建字符输入流关联本地文件
第二步:读取数据
public int read() 读取数据，读到末尾返回-1
public int read(char[] buffer) 读取多个数据，读到末尾返回-1
第三步:释放资源
public void close( ) 释放资源/关流
*/
FileReader fr = new FileReader("D:\\a.txt");
int ch;
while ((ch = fr.read()) != -1){
System.out.print((char) ch);
}
fr.close();
}read() 세부사항:
1.read(): 기본적으로 바이트 단위로 읽습니다. 중국어를 만나면 한 번에 여러 개씩 읽습니다.
2. 읽은 후 메소드의 맨 아래 레이어도 디코딩되어 십진수로 변환됩니다. 마지막으로 이 소수는 반환 값으로 사용됩니다.
한 번에 여러 문자 읽기
public static void main(String[] args) throws IOException {
/*
第一步:创建对象
public FileReader(File file) 创建字符输入流关联本地文件
public FileReader(String pathname) 创建字符输入流关联本地文件
第二步:读取数据
public int read() 读取数据，读到末尾返回-1
public int read(char[] buffer) 读取多个数据，读到末尾返回-1
第三步:释放资源
public void close( ) 释放资源/关流
*/
FileReader fr = new FileReader("D:\\a.txt");
char[] chars = new char[2];
int len;
//read(chars):读取数据，解码，强转三步合并了，把强转之后的字符放到数组当中
//相当于空参的read +强转类型转换
while ((len = fr.read(chars)) != -1){
System.out.print(new String(chars,0,len));
}
fr.close();
}문자 출력 스트림
| 공법 | 설명하다 |
| 공용 파일라이터(파일 파일) | 로컬 파일과 연결된 문자 출력 스트림 생성 |
| 공개 파일라이터(문자열 경로명) | 로컬 파일과 연결된 문자 출력 스트림 생성 |
| 공용 Filewriter(파일 파일, 부울 추가) | 로컬 파일과 연관된 문자 출력 스트림을 생성하고 계속해서 쓰기 |
| 공용 Filewriter(문자열 경로명, 부울 추가) | 로컬 파일과 연관된 문자 출력 스트림을 생성하고 계속해서 쓰기 |
회원 방법
| 회원 방법 | 설명하다 |
| 무효 쓰기(int c) | 문자를 쓰다 |
| 무효 쓰기(문자열 str) | 문자열을 쓰다 |
| 무효 쓰기(문자열 str, int off, int len) | 문자열의 일부 쓰기 |
| 무효 쓰기(문자[ ] cbuf) | 문자 배열 작성 |
| 무효 쓰기(char[ ] cbuf, int off, int len) | 문자 배열의 일부 쓰기 |
작성 단계:
1. 문자 출력 스트림 객체 생성
2. 데이터 쓰기
3. 자원 공개
public static void main(String[] args) throws IOException {
//创建字符输出流对象
FileWriter fw = new FileWriter("D:\\a.txt");
//void write(int c) 写出一个字符
fw.write(97);
//void write(string str) 写出一个字符串
fw.write("你好张三");
//void write(String str， int off， int len) 写出一个字符串的一部分
fw.write("你好张三",2,2);
//void write(char[ ] cbuf) 写出一个字符数组
char[] chars = {'1','2','3','你'};
fw.write(chars);
//void write(char[ ] cbuf, int off, int len) 写出字符数组的一部分
fw.write(chars,2,2);
fw.close();
}세부사항 1: 매개변수는 문자열 또는 File 객체로 표현되는 경로입니다
세부사항 2: 파일이 존재하지 않는 경우 새 파일이 생성되지만 상위 경로가 존재해야 합니다.
상세 3: 파일이 이미 존재하는 경우 파일을 삭제하며, 삭제를 원하지 않는 경우 계속 스위치를 켜면 됩니다. 상세 4:
쓰기 메소드의 매개변수가 정수인 경우, 실제로는 무엇입니까? 로컬 파일에 기록되는 문자는 문자 집합의 정수에 해당하는 문자입니다.
문자 스트림 원리 분석
문자 입력 스트림 객체 생성:
하단 레이어: 파일 연결 및 버퍼 생성(길이 8192의 바이트 배열)
데이터 읽기:
1. 버퍼에 읽을 수 있는 데이터가 있는지 확인
2. 버퍼에 데이터가 없음 : 파일에서 데이터를 가져와서 버퍼에 로드하고, 매번 버퍼를 최대한 채워 파일에 데이터가 없으면 -1을 반환
3. 버퍼에 데이터가 있습니다. 버퍼에서 읽습니다.
빈 매개변수가 있는 읽기 메소드: 한 번에 한 바이트를 읽고, 중국어를 만날 때 한 번에 여러 바이트를 읽고, 바이트를 디코딩하여 10진수로 변환하고 반환합니다.
매개변수가 있는 읽기 방법: 바이트 읽기, 디코딩, 강제 변환의 세 단계를 결합하고 강제 변환 후 문자를 배열에 넣습니다.
폴더 복사(하위 폴더 포함)
public static void main(String[] args) throws IOException {
//拷贝一个文件夹
//创建对象表示数据源
File src = new File("D:\\aaa\\src");
//创建对象表示拷贝目的地
File temp = new File("D:\\aaa\\temp");
//掉方法
copyFile(src,temp);
}
/**
* 拷贝文件
* @param src 数据源
* @param temp 目的地
*/
private static void copyFile(File src, File temp) throws IOException {
//创建文件夹
temp.mkdirs();
//递归
//进入数据源
File[] files = src.listFiles();
//遍历数组
for (File file : files) {
if (file.isFile()){
//拷贝文件
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(new File(temp,file.getName()));
byte[] bytes = new byte[1024];
int len;
while ((len = fis.read(bytes)) != -1){
fos.write(bytes,0,len);
}
fos.close();
fis.close();
}else {
//文件夹递归
//new File(temp,file.getName()) 创建文件夹，名字file.getName()
copyFile(file,new File(temp,file.getName()));
}
}
}버퍼링된 스트림
버퍼링된 스트림은 I/O(입력 및 출력) 작업을 스트리밍하는 방법입니다. 일반적으로 버퍼링된 스트림은 메모리에 버퍼를 생성하고, 버퍼에 데이터를 임시로 저장한 후, 버퍼에 있는 데이터를 한꺼번에 파일이나 네트워크에 쓰거나, 파일이나 네트워크에서 일정량의 데이터를 읽는다. 데이터를 버퍼에 넣은 다음 버퍼에서 데이터를 읽습니다.
버퍼링된 스트림의 기능은 I/O 작업의 효율성을 향상시키는 것입니다. I/O 작업을 수행할 때 바이트나 문자를 읽거나 쓸 때마다 디스크나 네트워크 액세스가 포함되므로 I/O 작업이 매우 비효율적입니다. 버퍼링된 스트림을 사용하면 여러 I/O 작업을 하나의 작업으로 결합할 수 있으므로 I/O 작업의 효율성이 향상됩니다.
Java에는 BufferedInputStream과 BufferedOutputStream이라는 두 가지 유형의 버퍼링 스트림이 있습니다. 그 중 BufferedInputStream은 입력 스트림에서 데이터를 읽는 효율성을 향상시킬 수 있는 InputStream의 하위 클래스이고, BufferedOutputStream은 출력 스트림에 데이터를 쓰는 효율성을 향상시킬 수 있는 OutputStream의 하위 클래스입니다. 버퍼링된 스트림을 사용하는 경우 리소스 누출 및 데이터 손실을 방지하기 위해 스트림을 제 시간에 닫는 데 주의해야 합니다.
바이트 버퍼 스트림
바이트 버퍼링된 스트림 복사 파일
public static void main(String[] args) throws IOException {
//创建缓冲流对象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\a.txt"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\b.txt"));
//循环读取文件
int len;
while ((len = bis.read()) != -1){
bos.write(len);
}
//释放资源
bos.close();
bis.close();
}한 번에 여러 바이트 읽기
public static void main(String[] args) throws IOException {
//创建缓冲流对象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\a.txt"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\b.txt"));
byte[] bytes = new byte[1024];
//循环读取文件
int len;
while ((len = bis.read(bytes)) != -1){
bos.write(bytes,0,len);
}
//释放资源
bos.close();
bis.close();
}문자 버퍼 스트림
| 문자 버퍼 입력 스트림별 메서드 | 설명하다 |
| 공개 문자열 readLine() | 데이터 행을 읽습니다. 읽을 데이터가 없으면 null이 반환됩니다. |
| 문자 버퍼링된 출력 스트림별 메서드 | 설명하다 |
| 공공 무효 newLine() | 플랫폼 간 줄바꿈 |
문자 버퍼링된 입력 스트림
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new FileReader("D:\\a.txt"));
//读取数据,一次读一行
String line = br.readLine();
System.out.println(line);
br.close();
}문자 버퍼링된 출력 스트림
public static void main(String[] args) throws IOException {
//创建字符缓冲输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\a.txt"));
//写入数据
bw.write("123");
//写入换行
bw.newLine();
bw.write("456");
bw.close();
}직렬화 및 역직렬화 스트림
Java의 직렬화 및 역직렬화는 ObjectOutputStream 및 ObjectInputStream을 사용하여 구현할 수 있습니다. ObjectOutputStream은 객체를 바이트 스트림으로 직렬화하고 이를 출력 스트림에 쓸 수 있는 OutputStream의 하위 클래스이고, ObjectInputStream은 입력 스트림에서 바이트 스트림을 읽고 이를 객체로 역직렬화할 수 있는 InputStream의 하위 클래스입니다.
직렬화 및 역직렬화의 기능은 네트워크 전송 또는 영구 저장 중에 전송 또는 저장을 위해 객체를 바이트 스트림으로 변환하여 필요할 때 객체를 복원할 수 있도록 하는 것입니다.
직렬화/객체 작업 출력 스트림
| 공법 | 설명하다 |
| 공용 객체출력스트림(출력스트림 출력) | 기본 스트림을 고급 스트림으로 래핑 |
| 회원 방법 | 설명하다 |
| 공개 최종 무효 writeobject(객체 obj) | 객체를 파일로 직렬화(쓰기) |
알아채다:
-
직렬화된 객체는 직렬화 가능 인터페이스를 구현해야 합니다. 그렇지 않으면 NotSerializedException이 발생합니다.
-
직렬화된 객체의 속성도 직렬화 가능해야 합니다. 그렇지 않으면 NotSerializedException이 발생합니다.
-
직렬화된 스트림과 역직렬화된 스트림은 동일한 JVM에 있어야 합니다. 그렇지 않으면 ClassNotFoundException이 발생합니다.
-
리소스 누출을 방지하려면 직렬화 및 역직렬화 스트림을 제때에 닫아야 합니다.
-
직렬화 및 역직렬화 프로세스 중에 버전 비호환성이 발생할 수 있으며, 이는 serialVersionUID를 사용하여 해결해야 합니다.
public static void main(String[] args) throws IOException {
//创建对象
Student student = new Student("张三",20);
//创建序列化流对象/对象操作输出流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\a.txt"));
//写入数据
oos.writeObject(student);
//释放资源
oos.close();
}역직렬화/객체 조작 입력 스트림
로컬 파일로 직렬화된 개체를 프로그램으로 읽을 수 있습니다.
| 공법 | 설명하다 |
| 공용 objectInputstream(입력스트림 출력) | 기본 흐름을 고급 흐름으로 변환 |
| 회원 방법 | 설명하다 |
| 공용 객체 readobject() | 로컬 파일에 직렬화된 객체를 프로그램으로 읽어옵니다. |
public static void main(String[] args) throws IOException, ClassNotFoundException {
//创建反序列化流对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\a.txt"));
//读取数据
Student student = (Student)ois.readObject();
//
System.out.println(student);
//释放资源
ois.close();
}인쇄 스트림
인쇄 스트림(PrintStream 및 PrintWriter)은 Java에서 텍스트 정보를 출력하는 데 사용되는 스트림입니다. 콘솔, 파일, 네트워크 등에 텍스트 정보를 출력할 수 있습니다.
PrintStream은 텍스트 정보를 바이트 스트림으로 출력할 수 있는 OutputStream의 하위 클래스로, 다양한 유형의 데이터를 출력할 수 있는 print, println, printf 등과 같은 다양한 인쇄 방법을 제공합니다. PrintStream은 또한 자동으로 버퍼를 새로 고치는 기능을 제공하여 각 출력 후에 버퍼를 자동으로 새로 고칠 수 있습니다.
PrintWriter는 텍스트 정보를 문자 스트림으로 출력할 수 있는 Writer의 하위 클래스이며, 다양한 유형의 데이터를 출력할 수 있는 print, println, printf 등과 같은 다양한 인쇄 메서드를 제공합니다. PrintWriter는 또한 자동으로 버퍼를 새로 고치는 기능을 제공하여 각 출력 후에 버퍼를 자동으로 새로 고칠 수 있습니다.
인쇄 스트림을 사용하면 다양한 유형의 데이터를 쉽게 출력할 수 있고, 버퍼를 자동으로 새로 고칠 수 있어 불완전한 출력 데이터 문제를 피할 수 있다는 장점이 있습니다. 동시에 인쇄 스트림은 필요에 따라 형식을 지정할 수 있는 형식화된 출력 기능도 제공합니다.
인쇄 스트림을 사용할 때 리소스 누출 및 데이터 손실을 방지하려면 스트림을 제때 닫는 데 주의해야 합니다. 또한 잘못된 위치와 대상으로 출력되지 않도록 인쇄 스트림의 출력 위치와 대상에 주의를 기울여야 합니다.
바이트 인쇄 스트림
| 공법 | 설명하다 |
| 공개 Printstream(출력 스트림/파일/문자열) | 연관된 바이트 출력 스트림/파일/파일 경로 |
| 공개 Printstream(문자열 파일 이름, 문자 집합 문자 집합) | 문자 인코딩 지정 |
| 공개 Printstream(출력 스트림 출력, 부울 autoFlush) | 자동 새로고침 |
| 공개 Printstream(출력 스트림 출력, 부울 autoFlush, 문자열 인코딩) | 문자 인코딩을 지정하고 자동으로 새로 고침 |
| 회원 방법 | 설명하다 |
| 공개 무효 쓰기(int b) | 기존 방법: 규칙은 이전과 동일하며 지정된 바이트를 기록합니다. |
| 공공 무효 println( Xxx Xx) | 고유한 방법: 임의의 데이터 인쇄, 자동 새로 고침 및 자동 줄 바꿈 |
| public void print(Xxx xx) | 特有方法:打印任意数据，不换行 |
| public void printf(String format，0Object. .. args) | 特有方法:带有占位符的打印语句，不换行 |
public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {
//创建字节打印流对象
PrintStream ps = new PrintStream(new FileOutputStream("D:\\a.txt"),true,"UTF-8");
//写成数据
ps.println(97);
ps.print(true);
ps.printf("%s爱上了%s","阿珍","阿强");
//释放资源
ps.close();
}字符打印流
| 构造方法 | 说明 |
| public Printwriter(write/File/string) | 关联字节输出流/文件/文件路径 |
| public Printwriter( String fileName，Charset charset) | 指定字符编码 |
| public Printwriter(write w, boolean autoFlush) | 自动刷新 |
| public PrintWriter(outputStream out，boolean autoFlush，Charset charset) | 指定字符编码且自动刷新 |
| 成员方法 | 说明 |
| public void write(....) | 常规方法:规则跟之前一样，写出字节或字符串 |
| public void println( Xxx Xx) | 特有方法:打印任意数据类型且换行 |
| public void print(Xxx xx) | 特有方法:打印任意数据，不换行 |
| public void printf(String format，Object. .. args) | 特有方法:带有占位符的打印语句 |
public static void main(String[] args) throws IOException {
//创建字符打印流的对象
PrintWriter pw = new PrintWriter(new FileWriter("D:\\a.txt"),true);
//写数据
pw.println("张三");
//释放资源
pw.close();
}解压缩流
解压流
解压本质:把每一个ZipEntry按照层级拷贝到本地另一个文件夹中
public static void main(String[] args) throws IOException {
//创建一个file表示要解压的压缩包
File src = new File("D:\\aaa.zip");
//创建一个File表示解压的目的地
File dest = new File("D:\\");
//掉方法
unzip(src,dest);
}
//定义一个解压方法
private static void unzip(File src, File dest) throws IOException {
//解压的本质:把压缩包里面的每一个文件或者文件夹读取出来，按照层级拷贝到目的地当中
//创建一个解压缩流用来读取压缩包中的数据
ZipInputStream zip = new ZipInputStream(new FileInputStream(src));
//要先获取到压缩包里面的每一个zipentry对象
// 表示当前在压缩包中获取到的文件或者文件夹
ZipEntry entry;
while ((entry = zip.getNextEntry()) != null){
System.out.println(entry);
if (entry.isDirectory()){
//文件夹:需要在目的地dest处创建一个同样的文件夹
File file = new File(dest,entry.toString());
file.mkdirs();
}else {
//文件:需要读取到压缩包I的文件，并把他存放到目的地dest文件夹中（按照层级目录进行存放)
FileOutputStream fos = new FileOutputStream(new File(dest,entry.toString()));
int b;
while ((b = zip.read()) != -1){
//写到目的地
fos.write(b);
}
//表示在压缩包中的一个文件处理完毕了。
fos.close();
zip.closeEntry();
}
}
zip.close();
}压缩流
压缩本质:把每一个(文件/文件夹）看成ZipEntry对象放到压缩包中
压缩单个文件
public static void main(String[] args) throws IOException {
//创建一个file表示要解压的压缩包
File src = new File("D:\\a.txt");
//创建一个File表示解压的目的地
File dest = new File("D:\\");
//掉方法
tozip(src,dest);
}
/**
* 压缩
* @param src 要压缩的文件
* @param dest 压缩包的位置
* @throws IOException
*/
private static void tozip(File src, File dest) throws IOException {
//创建压缩流关联对象
ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(new File(dest,"a.zip")));
//2.创建ZipEntry对象，表示压缩包里面的每一个文件和文件夹
ZipEntry entry = new ZipEntry("a.txt");
//.把ZipEntry对象放到压缩包当中
zos.putNextEntry(entry);
//把src文件中的数据写到压缩包当中
FileInputStream fis = new FileInputStream(src);
int b;
while ((b = fis.read()) != -1){
zos.write(b);
}
zos.closeEntry();
zos.close();
}压缩文件夹
public static void main(String[] args) throws IOException {
//创建File对象表示要压缩的文件夹
File src = new File("D:\\aaa");
//创建File对象表示压缩包放在哪里（压缩包的父级路径)
File destParent = src.getParentFile();
//创建File对象表示压缩包的路径
File dest = new File(destParent,src.getName() + ".zip");
//创建压缩流关联压缩包
ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(dest));
//获取src里面的每一个文件，变成ZipEntry对象，放入到压缩包当中
tozip(src,zos,src.getName());
zos.close();
}
/**
* 获取src里面的每一个文件，变成ZipEntry对象，放入到压缩包当中
* @param src 数据源
* @param zos 压缩流
* @param name 压缩包内部的路径
*/
private static void tozip(File src, ZipOutputStream zos, String name) throws IOException {
//
File[] files = src.listFiles();
for (File file : files) {
if (file.isFile()){
//
ZipEntry entry = new ZipEntry(name + "\\" + file.getName());
zos.putNextEntry(entry);
//
FileInputStream fis = new FileInputStream(file);
int b;
while ((b = fis.read()) != -1){
zos.write(b);
}
fis.close();
zos.closeEntry();
}else {
tozip(file,zos,name + "\\" + file.getName());
}
}
}IO流工具
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.4</version>
</dependency>
常见方法：
| FileUtils类(文件/文件夹相关) | 说明 |
| static void copyFile(File srcFile，File destFile) | 复制文件 |
| static void copyDirectory(File srcDir，File destDir) | 复制文件夹 |
| static void copyDirectoryToDirectory(File srcDir， File destDir) | 复制文件夹 |
| static void deleteDirectory(File directory) | 删除文件夹 |
| static void cleanDirectory(File directory) | 清空文件夹 |
| static string readFileToString(File file，Charset encoding) | 读取文件中的数据变成成字符串 |
| static void write(File file，CharSequence data，string encoding) | 写出数据 |
| IOUtils类（流相关相关) | 说明 |
| public static int copy(InputStream input，outputStream output) | 复制文件 |
| public static int copyLarge(Reader input，writer output) | 复制大文件 |
| public static string readLines(Reader input) | 读取数据 |
| public static void write(String data，outputstream output) | 写出数据 |