第八节 Java IO流

java IO简介

Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。

Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。

Java输入输出流



IO的分类

1. java.io包中阻塞型IO

2. java.nio包中的非阻塞型IO——>new IO

IO类

1. 流式部分——>IO的主体

2. 非流式部分——>辅助流式部分

文件操作

class FileOpreator{
public static void main(String[] args) throws IOException {

//获取文件或者文件夹引用
File file = new File("D:/百度脑图/abc");
//创建文件
file.createNewFile();

//创建文件夹
new File("D:/百度脑图/新建文件夹").mkdirs();

//获取文件列表
File[] files = new File("D:/百度脑图").listFiles();
for (int i = 0; i < files.length; i++) {
System.out.println(files[i].getName());
}
}
}

字节流

class FileCopy{
/**
* 使用字节流，单字节复制
*/
public static void byteStreamCopy(String src,String des) throws IOException {
FileInputStream inputStream = new FileInputStream(new File(src));
FileOutputStream outputStream = new FileOutputStream(new File(des));
int value=0;
while ((value=inputStream.read())!=-1){//获取字节
outputStream.write(value);
}
inputStream.close();
outputStream.close();
System.out.println("单字节复制成功!");
}
/**
* 使用字节流，字节数组复制
*/
public static void bytesStreamCopy(String src,String des) throws IOException {

FileInputStream inputStream = new
4000
FileInputStream(new File(src));
FileOutputStream outputStream = new FileOutputStream(new File(des));

byte[] bytes = new byte[1024];
int len;
while((len=inputStream.read(bytes))!=-1){
outputStream.write(bytes,0,len);
}
inputStream.close();
outputStream.close();
System.out.println("字节数组复制成功");
}
}

字符流

public FileCopy{
/**
* 字符流复制，单个字符复制
* 字符流不能拷贝流媒体，因为，字符流是先读取字节，然后转码，再输出，转码之后就不是媒体文件了。
*/
public static void charStreamCopy(String src,String des) throws IOException {

FileWriter fileWriter = new FileWriter(new File(des));
FileReader fileReader = new FileReader(new File(src));
int value;
while ((value = fileReader.read()) != -1) {
fileWriter.write(value);
fileWriter.flush();
}
fileReader.close();
fileWriter.close();
}
/**
* 使用字符流复制，数组复制
*/
public static void charsStreamCopy(String src,String des) throws IOException {
FileReader fileReader = new FileReader(new File(src));
FileWriter fileWriter = new FileWriter(new File(des));
int len;
char[] chars=new char[1024];
while((len=fileReader.read(chars))!=-1){
fileWriter.write(chars,0,len);
}
fileReader.close();
fileWriter.close();

}
}

字符流和字节流总结

package java基础;

import java.io.*;

public class 文件复制 {
public static void main(String[] args) {
String src="D:\\百度脑图\\Java语言编程\\JavaIO.png";
String des="D:\\百度脑图\\JavaIO.png";
//单字节复制
//        try {
//            FileCopy.byteStreamCopy(src,des);
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
//字节数组赋值
//        try {
//            FileCopy.bytesStreamCopy(src,des);
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
//单字符复制
try {
FileCopy.charStreamCopy(src,des);
} catch (IOException e) {
e.printStackTrace();
}
//字符数组复制
try {
FileCopy.charsStreamCopy(src,des);
} catch (IOException e) {
e.printStackTrace();
}
}
}

class FileCopy{
/**
* 使用字节流，单字节复制
*/
public static void byteStreamCopy(String src,String des) throws IOException {
FileInputStream inputStream = new FileInputStream(new File(src));
FileOutputStream outputStream = new FileOutputStream(new File(des));
int value=0;
while ((value=inputStream.read())!=-1){//获取字节
outputStream.write(value);
}
inputStream.close();
outputStream.close();
System.out.println("单字节复制成功!");
}
/**
* 使用字节流，字节数组复制
*/
public static void bytesStreamCopy(String src,String des) throws IOException {

FileInputStream inputStream = new FileInputStream(new File(src));
FileOutputStream outputStream = new FileOutputStream(new File(des));

byte[] bytes = new byte[1024];
int len;
while((len=inputStream.read(bytes))!=-1){
outputStream.write(bytes,0,len);
}
inputStream.close();
outputStream.close();
System.out.println("字节数组复制成功");
}

/**
* 字符流复制，单个字符复制
* 字符流不能拷贝流媒体，因为，字符流是先读取字节，然后转码，再输出，转码之后就不是媒体文件了。
*/
public static void charStreamCopy(String src,String des) throws IOException {

FileWriter fileWriter = new FileWriter(new File(des));
FileReader fileReader = new FileReader(new File(src));
int value;
while ((value = fileReader.read()) != -1) {
fileWriter.write(value);
fileWriter.flush();
}
fileReader.close();
fileWriter.close();
}
/**
* 使用字符流复制，数组复制
*/
public static void charsStreamCopy(String src,String des) throws IOException {
FileReader fileReader = new FileReader(new File(src));
FileWriter fileWriter = new FileWriter(new File(des));
int len;
char[] chars=new char[1024];
while((len=fileReader.read(chars))!=-1){
fileWriter.write(chars,0,len);
}
fileReader.close();
fileWriter.close();

}
}

文件压缩

class FileZip{
/**
* 单个文件压缩
*/
public static void singleFileZip(File srcFile,File desZipFile) throws IOException {
//获取文件输入流
FileInputStream inputStream = new FileInputStream(srcFile);
//获取压缩文件输出流
ZipOutputStream zipOutputStream = new ZipOutputStream(new FileOutputStream(desZipFile));
//向文件中写入条目
zipOutputStream.putNextEntry(new ZipEntry(srcFile.getName()));
//写入文件
byte[] bytes = new byte[1024];
int len;
while((len=inputStream.read(bytes))!=-1){
zipOutputStream.write(bytes,0,len);
}
System.out.println("单文件压缩完成");
inputStream.close();
zipOutputStream.close();

}

/**
* 多个文件压缩
*/
public static void filesZip(File[] srcFiles, File zipFile) throws IOException {
ZipOutputStream outputStream = new ZipOutputStream(new FileOutputStream(zipFile));

for (int i = 0; i < srcFiles.length; i++) {
FileInputStream inputStream = new FileInputStream(srcFiles[i]);

//为压缩文件添加条目
outputStream.putNextEntry(new ZipEntry(srcFiles[i].getName()));

byte[] bytes = new byte[1024];
int len;
while((len=inputStream.read(bytes))!=-1) {
outputStream.write(bytes, 0, len);
}
outputStream.closeEntry();
inputStream.close();
}
System.out.println("压缩完成。");
outputStream.close();

}

/**
* 文件夹及其文件压缩
*/
public static void singleDirFileZip(File srcDir,File zipFile) throws IOException {
File[] files = srcDir.listFiles();
for (int i = 0; i < files.length; i++) {
filesZip(files,zipFile);
}
}

/**
* 多个文件夹组合压缩
*/
public static void dirsFileZip() throws IOException {

}

}