IO流(输入流、输出流)
一、字节流
- InputStream抽象了应用程序读取数据的方式 OutputStream抽象了应用程序写出数据的方式
- EOF=End 读到-1就读到结尾
- 输入流基本方法 (1) int b=in.read();读取一个字节无符号填充到int低八位。-1是EOF (2) int.read(byte[] buf) 读取数据填充到字节数组buf (3) int.read(byte[] buf,int start,int size)
- 输出流基本方法 (1) out.write(int b)写出一个byte到流,b的低八位 (2) out.write(byte[] buf)将buf字节数组都写入到流 (3) out.write(byte[] buf,int start,int size) 字节数组buf从start位置开始写size长度的字节到流
- (1) FileInputStream 子类,具体实现了在文件上读取数据,继承了InputStream类 (2) FileOutputStream 子类,具体实现向文件中写出byte数据的方法,继承 了OutputStream类 (3) DataInputStream&DataOutputStream,对流功能的扩展,可以更方便的读取int,long,字符等类型的数据 (4) BufferedInputStream& BufferedOutputStream ,这两个流类为IO提供了带缓冲区的操作,一般打开文件进行写入或读取操作时,都会加上缓冲,这种流模式提高了IO的性能,从应用程序中把输入放入文件,相当于一缸水倒入到另外一缸水。 FileOutputStream使用write()方法相当于一滴一滴的把水转移过去。 DataOutputStream使用writeXXX()方法方便一些,相当于一瓢一瓢把水转移过去。 BufferedOutputStream使用writeXXX()方法更方便一些,相当于一瓢一瓢把水放在一个桶中,再用桶倒入到另外一缸中。
FileInputStream 子类
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class IOUtil {
/*
读取指定文件内容,按照16进制输出到控制台
并且每输出10个byte换行
* */
public static void printHex(String fileName) throws IOException {
//把文件作为字节流进行读操作
FileInputStream in = new FileInputStream(fileName);
int b;
int i = 1;
while ((b = in.read()) != -1) {
if (b <= 0xf) {
//单位数前面补0
System.out.print("0");
}
System.out.print(Integer.toHexString(b) + " "); //将整型b转换为16进制表示的字符串
if (i++ % 10 == 0) {
System.out.println();
}
}
in.close();
}
public static void printHexByByteArray(String fileName) throws IOException {
FileInputStream in = new FileInputStream(fileName);
byte[] buf = new byte[20 * 1024];
/*
从int中批量读取字节,放入到buf这个字节数组中,
从第0个位置开始放,最多放buf.length个
返回的是读到的字节个数
* */
/* int bytes = in.read(buf, 0, buf.length); //一次性读完,说明字节数组足够大
int j=1;
for (int i = 0; i < bytes; i++) {
if(buf[i]<=0xf){
System.out.print("0");
}
System.out.print(Integer.toHexString(buf[i])+" ");
if(j++%10==0){
System.out.println();
}
}*/
//当字节数组一次未必能容纳下的时候
int bytes=0;
int j=1;
while ((bytes=in.read(buf,0,buf.length))!=-1){
for (int i = 0; i < bytes; i++) {
System.out.print(Integer.toHexString(buf[i]&0xff)+" ");//buf[i]&0xff byte类型8位,int类型32位
if(j++%10==0){ //为了避免数据转换错误,通过&0xff将高24位清零
System.out.println();
}
}
}
}
/*==========================================================*/
public class IOUtilTest1 {
public static void main(String[] args) {
try {
IOUtil.printHex("D:\\code\\IO\\demo\\新建文本文档.txt");
System.out.println();
System.out.println("============================================");
IOUtil.printHexByByteArray("D:\\code\\IO\\demo\\新建文本文档.txt");
} catch (IOException e) {
e.printStackTrace();
}
}
}
/*输出:
30 20 31 20 32 20 33 20 34 20
35 20 36 20 37 20 38 20 39 20
31 30 20 31 31 20 31 32 20 31
33 20 31 34 20 31 35 20
============================================
30 20 31 20 32 20 33 20 34 20
35 20 36 20 37 20 38 20 39 20
31 30 20 31 31 20 31 32 20 31
33 20 31 34 20 31 35 20
Process finished with exit code 0
*/
FileOutputStream子 类
public class FileOutDemo1 {
public static void main(String[] args) throws IOException {
//如果该文件不存在,则直接创建,如果存在,删除后创建
FileOutputStream out=new FileOutputStream("D:\\code\\IO\\demo\\新建文本文档1.txt");
out.write('A'); //写出了A的低八位
out.write('B'); //写出了B的低八位
int a=10;//write 只能写八位,那么写一个int需要写4次 每次8位
out.write(a>>>24);
out.write(a>>>16);
out.write(a>>>8);
out.write(a);
byte[] gbk="中国".getBytes("gbk");
out.write(gbk);
out.close();
IOUtil.printHex("D:\\code\\IO\\demo\\新建文本文档1.txt");
}
}
编译运行后:
public class IOUtil {
/*
读取指定文件内容,按照16进制输出到控制台
并且每输出10个byte换行
* */
public static void printHex(String fileName) throws IOException {
//把文件作为字节流进行读操作
FileInputStream in = new FileInputStream(fileName);
int b;
int i = 1;
while ((b = in.read()) != -1) {
if (b <= 0xf) {
//单位数前面补0
System.out.print("0");
}
System.out.print(Integer.toHexString(b) + " "); //将整型b转换为16进制表示的字符串
if (i++ % 10 == 0) {
System.out.println();
}
}
in.close();
}
//复制方法
public static void copyFile(File scrFile, File desFile) throws IOException{
if(!scrFile.exists()){
throw new IllegalArgumentException("文件"+scrFile+"不存在");
}
if(!scrFile.isFile()){
throw new IllegalArgumentException(scrFile+"不是文件");
}
FileInputStream in=new FileInputStream(scrFile);
FileOutputStream out=new FileOutputStream(desFile);
byte[] buf=new byte[8*1024];
int b;
while ((b=in.read(buf,0,buf.length))!=-1){
out.write(buf,0,b);
out.close();
}
in.close();
out.close();
}
public static void printHexByByteArray(String fileName) throws IOException {
FileInputStream in = new FileInputStream(fileName);
byte[] buf = new byte[20 * 1024];
/*
从int中批量读取字节,放入到buf这个字节数组中,
从第0个位置开始放,最多放buf.length个
返回的是读到的字节个数
* */
/* int bytes = in.read(buf, 0, buf.length); //一次性读完,说明字节数组足够大
int j=1;
for (int i = 0; i < bytes; i++) {
if(buf[i]<=0xf){
System.out.print("0");
}
System.out.print(Integer.toHexString(buf[i])+" ");
if(j++%10==0){
System.out.println();
}
}*/
//当字节数组一次未必能容纳下的时候
int bytes=0;
int j=1;
while ((bytes=in.read(buf,0,buf.length))!=-1){
for (int i = 0; i < bytes; i++) {
System.out.print(Integer.toHexString(buf[i]&0xff)+" ");//buf[i]&0xff byte类型8位,int类型32位
if(j++%10==0){ //为了避免数据转换错误,通过&0xff将高24位清零
System.out.println();
}
}
}
}
}
/*====================================================*/
public class IOUtilTest2 {
public static void main(String[] args) {
try {
IOUtil.copyFile(new File("D:\\code\\IO\\demo\\d.txt"),
new File("D:\\code\\IO\\demo\\d1.txt"));
} catch (IOException e) {
e.printStackTrace();
}
}
}
编译运行后:
DataInputStream/DataOutputStream
public class DosDemo {
public static void main(String[] args) throws IOException {
String file="D:\\code\\IO\\demo\\Data1.dat";
DataOutputStream dos=new DataOutputStream(new FileOutputStream(file));
dos.writeInt(10); //要是用write()就需要写四次
dos.writeLong(-10);
dos.writeLong(10L);
dos.writeDouble(10.5);
dos.writeUTF("中国"); //采用utf-8编码
dos.writeChars("中国");//采用utf-16be编码
IOUtil.printHex(file);
}
}
/*输出:
00 00 00 0a ff ff ff ff ff ff
ff f6 00 00 00 00 00 00 00 0a
40 25 00 00 00 00 00 00 00 06
e4 b8 ad e5 9b bd 4e 2d 56 fd
Process finished with exit code 0
*/
/*==========================================================*/
public class DisDemo {
public static void main(String[] args) throws IOException {
String file="D:\\code\\IO\\demo\\Data1.dat";
IOUtil.printHex(file);
DataInputStream dis=new DataInputStream(new FileInputStream(file));
int i=dis.readInt();
System.out.println(i);
i=dis.readInt();
System.out.println(i);
long l=dis.readLong();
System.out.println(l);
double d=dis.readDouble();
System.out.println(d);
String s=dis.readUTF();
System.out.println(s);
dis.close();
}
}
/*输出:
00 00 00 0a ff ff ff ff ff ff
ff f6 00 00 00 00 00 00 00 0a
40 25 00 00 00 00 00 00 00 06
e4 b8 ad e5 9b bd 4e 2d 56 fd
10
-1
-42949672960
2.17516548836E-313
Process finished with exit code 0
*/
BufferedInputStream& BufferedOutputStream
public class IOUtil {
/*
进行文件拷贝,字节批量读取
* */
public static void copyFile(File scrFile, File desFile) throws IOException{
if(!scrFile.exists()){
throw new IllegalArgumentException("文件"+scrFile+"不存在");
}
if(!scrFile.isFile()){
throw new IllegalArgumentException(scrFile+"不是文件");
}
FileInputStream in=new FileInputStream(scrFile);
FileOutputStream out=new FileOutputStream(desFile);
byte[] buf=new byte[8*1024];
int b;
while ((b=in.read(buf,0,buf.length))!=-1){
out.write(buf,0,b);
out.close();
}
in.close();
out.close();
}
/*
进行文件的拷贝,利用带缓冲的字节流
* */
public static void copyFileByBuffer(File scrFile,File destFile) throws IOException{
if(!scrFile.exists()){
throw new IllegalArgumentException("文件"+scrFile+"不存在");
}
if(!scrFile.isFile()){
throw new IllegalArgumentException(scrFile+"不是文件");
}
BufferedInputStream bis=new BufferedInputStream(new FileInputStream(scrFile));
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(destFile));
int c;
while ((c=bis.read())!=-1){
bos.write(c);
bos.flush();//刷新缓冲区
}
bis.close();
bos.close();
}
/*
单字节不带缓冲,进行文件拷贝
* */
public static void copyFileByByte(File scrFile,File desFile)throws IOException{
if(!scrFile.exists()){
throw new IllegalArgumentException("文件"+scrFile+"不存在");
}
if(!scrFile.isFile()){
throw new IllegalArgumentException(scrFile+"不是文件");
}
FileInputStream in=new FileInputStream(scrFile);
FileOutputStream out=new FileOutputStream(desFile);
int c;
while ((c=in.read())!=-1){
out.write(c);
out.flush();
}
in.close();
out.close();
}
}
/*==========================================================*/
/*
测试类
*/
public class IOUtilTest4 {
public static void main(String[] args) {
try {
long start=System.currentTimeMillis();
/*IOUtil.copyFileByByte(new File("D:\\code\\IO\\demo\\新建文本文档.txt"),
new File("D:\\code\\IO\\demo\\aa.txt")); 81毫秒 */
/*IOUtil.copyFileByBuffer(new File("D:\\code\\IO\\demo\\新建文本文档.txt"),
new File("D:\\code\\IO\\demo\\aa.txt")); 12毫秒*/
IOUtil.copyFile(new File("D:\\code\\IO\\demo\\新建文本文档.txt"),
new File("D:\\code\\IO\\demo\\aa.txt"));//2毫秒
long end=System.currentTimeMillis();
System.out.println(end-start);//计算操作的时间
} catch (IOException e) {
e.printStackTrace();
}
}
}
编译运行后对文件的操作结果: