Java工具类-输入输出流
输入输出流
1.概念
输入输出流：文件复制，上传
输出流： System.out.println() 写操作，程序将字符流写入到“目的地”，比如打印机和文件等
输入流 ：Scanner sc =new Scanner(System.in) 读操作
2.File类
文件：相关记录或放在一起的数据集合
java.io.File类
package FileDemo;
import java.io.File;
import java.io.IOException;
public class FileDemo {
public static void main(String[] args) {
// 创建对象
File file1=new File("E:\\JavaProject\\FileProj\\imooc\\io\\abc.txt");
//File file2=new File("E:\\JavaProject\\FileProj","imooc\\io\\score.txt");
//判断是文件还是目录
System.out.println("是否是目录: "+ file1.isDirectory());
System.out.println("是否是文件: "+ file1.isFile());
//创建目录
// File file3=new File("E:\\JavaProject\\FileProj\\imooc\\set\\HashSet");
// if(!file3.exists()){
// file3.mkdirs();
// }
//创建文件
if(!file1.exists()) {
try {
file1.createNewFile();
//是否是绝对路径
System.out.println(file1.isAbsolute());
//获取相对路径
System.out.println(file1.getPath());
//获取绝对路径
System.out.println(file1.getAbsolutePath());
//获取文件名
System.out.println(file1.getName());
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
3.字节流
3.1 输入字节
FileInputStream 适用于 二进制
-
从文件系统中的某个文件中获得输入字节
-
用于读取诸如图像数据之类的原始字节流
read() read(byte[] b) read(byte[] b int off, int len) close()
package FileDemo;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class FileInputDemo2 {
public static void main(String[] args) {
try{
FileInputStream fis=new FileInputStream("imooc.txt"); //这个是放在该Project当前目录下的
//1.一个一个读取
int n=0;
while((n=fis.read())!=-1) {
System.out.println((char)n);
}
fis.close();
//2.存放到数组中
byte[] b=new byte[100];
fis.read(b,0,9);
//System.out.println(b);
for(byte bb:b){
System.out.println((char) bb);
}
System.out.println(new String(b));
fis.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e){
e.printStackTrace();
}
}
}
3.2 输出字节类
write(int b) write(byte[] b) write(byte[] b,int off,int len) close()
3.2.1 读取字节
package FileDemo;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputDemo {
public static void main(String[] args) {
FileOutputStream fos;
FileInputStream fis;
try{
fos=new FileOutputStream("imooc.txt",false); // append追加
fis=new FileInputStream("imooc.txt");
fos.write(50);
fos.write('a');
System.out.println(fis.read());
System.out.println((char)fis.read());
fos.close();
fis.close();
} catch(FileNotFoundException e){
e.printStackTrace();
} catch(IOException e) {
}
}
}
3.2.2 复制文件
package FileDemo;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputDemo2 {
// 复制文件使用输出字节流
public static void main(String[] args) {
try {
FileInputStream fis = new FileInputStream("happy.jpg");
FileOutputStream fos=new FileOutputStream("happycopy2.jpg");
int n=0;
byte[] b=new byte[1024];
while((n=fis.read(b))!=-1) {
//System.out.println(n); 图片二进制流
fos.write(b,0,n); //保证文件复制前后数据大小一致
}
fis.close();
fos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
3.2.3 缓冲字节流
BufferInputStream BufferOutputStream。搭配FileInputStream/OutputStream使用，加快读写速度，先从文件读取，然后通过缓冲流都入到程序中
比较下面两个程序的运行时间：
常规复制，测试文件为200M的视频文件
package FileDemo;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputDemo2 {
// 复制文件使用输出字节流
public static void main(String[] args) {
try {
long startTime=System.currentTimeMillis();
FileInputStream fis = new FileInputStream("test.mp4");
FileOutputStream fos=new FileOutputStream("testcopy1.mp4");
int n=0;
byte[] b=new byte[2048];
while((n=fis.read(b))!=-1) {
//System.out.println(n); 图片二进制流
fos.write(b,0,n); //保证文件复制前后数据大小一致
}
fis.close();
fos.close();
long endTime=System.currentTimeMillis();
System.out.println(endTime-startTime); // 742
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
缓冲字节流复制
package FileDemo;
import java.io.*;
public class BufferedCopyFile {
public static void main(String[] args) {
try {
long startTime=System.currentTimeMillis();
FileOutputStream fos=new FileOutputStream("test.mp4");
BufferedOutputStream bos=new BufferedOutputStream(fos);
FileInputStream fis = new FileInputStream("testcopy2.mp4");
BufferedInputStream bis = new BufferedInputStream(fis);
int n=0;
byte[] b=new byte[2048];
while((n=bis.read(b))!=-1) {
//System.out.println(n); 图片二进制流
bos.write(b,0,n); //保证文件复制前后数据大小一致
bos.flush();
}
fos.close();
bos.close();
fis.close();
bis.close();
long endTime=System.currentTimeMillis();
System.out.println(endTime-startTime); // 640
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
742 vs 640
4.字符流
适用于处理字符
字节字符转换流 字符输入流 Reader 字符输出流 Writer 缓冲字符流
package Charstream;
import java.io.*;
public class BufferedReaderDemo {
public static void main(String[] args) {
try {
FileInputStream fis=new FileInputStream("imooc2.txt");
InputStreamReader isr=new InputStreamReader(fis,"GBK");
BufferedReader br=new BufferedReader(isr);
FileOutputStream fos=new FileOutputStream("imooc3.txt");
OutputStreamWriter osw=new OutputStreamWriter(fos,"GBK"); //isr && osw编码保持一致，默认UFT-8
BufferedWriter bw=new BufferedWriter(osw);
int n=0;
char[] cbuf=new char[10];
while((n=br.read(cbuf))!=-1) {
//String s=new String(cbuf,0,n);
//System.out.println(s);
bw.write(cbuf,0,n);
bw.flush();
}
fis.close();
isr.close();
br.close();
fos.close();
osw.close();
bw.close();
} catch(FileNotFoundException e) {
e.printStackTrace();
} catch(IOException e) {
e.printStackTrace();
}
}
}
-
1bit（位）表示一个二进制位，0/1
-
byte（字节) ，有8个bit位，首位是符号位
-
1 char = 2 byte = 16 bit
00000001 = 1 10000000 = -1 二进制区间[127~-128] 0111111 = 127 1111111 =-128在Java中，程序中所有的数据都是以流的方式进行传输或保存的，流中保存的实际上是字节文件，程序需要数据的时候要使用输入流读取数据，而当程序需要将一些数据保存起来的时候，就要使用输出流完成。
虽然1 bit是数据真正的最小单位，但是保存信息太少，System.out.println(ois.readBoolean());
5.对象的序列化和反序列化
创建一个类，继承Serializable接口→创建对象→将对象写入文件→从文件读取对象信息
对象输入流：ObjectInputStream 对象输出流：ObjectOutputStream
序列化：把Java对象转换成字节序列的过程，写
反序列化：把字节序列恢复为Java对象的过程，读
Goods.java
package ObjectSerizable;
import java.io.Serializable;
public class Goods implements Serializable {
private String goodsId;
private String goodsName;
private double price;
public Goods(String goodsId,String goodsName,double price) {
this.goodsId=goodsId;
this.goodsName=goodsName;
this.price=price;
}
public String getGoodsId() {
return goodsId;
}
public void setGoodsId(String goodsId) {
this.goodsId = goodsId;
}
public String getGoodsName() {
return goodsName;
}
public void setGoodsName(String goodsName) {
this.goodsName = goodsName;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "商品信息[编号：" + goodsId + ", 名称: " + goodsName
+ "，价格； " + price + "]";
}
}
GoodsTest.java
package ObjectSerizable;
import java.io.*;
public class GoodsTest {
public static void main(String[] args) {
Goods goods1=new Goods("gd001","电脑",3000);
try {
FileOutputStream fos=new FileOutputStream("imooc.txt");
ObjectOutputStream oos=new ObjectOutputStream(fos);
FileInputStream fis=new FileInputStream("imooc.txt");
ObjectInputStream ois=new ObjectInputStream(fis);
//将Goods对象信息写入文件
oos.writeObject(goods1);
oos.writeBoolean(true);
oos.flush();
// System.out.println(ois.readBoolean()); 不要后写先读，无法匹配上
try {
Goods goods=(Goods)ois.readObject();
System.out.println(goods);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//System.out.println(ois.readBoolean()); //写入什么，读入什么，顺序要一致
//先写先读
fos.close();
oos.close();
fis.close();
ois.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
6.字节流 VS 字符流
1 char = 2 byte = 16 bit
二进制的数据都是以字节作为基本存储单位，一切都是字节流，其实没有字符流，字符知识根据编码集对字节流翻译之后的产物
例如 Java中的8中基本数据类型，Java使用Unicode，用char这个数据类型表示一个多字节的字符
字节流就是普通的二进制流，都出来的是bit，字符流就是在字节流的基础按照字符编码处理，处理的是 char，前者可以表达所有东西，后者只能是字符。