java中package io_Java中IO流 字节流实例详解

Java中IO流 字节流实例详解

IO流(输入流、输出流)，又分为字节流、字符流。

流是磁盘或其它外围设备中存储的数据的源点或终点。

输入流：程序从输入流读取数据源。数据源包括外界(键盘、文件、网络…)，即是将数据源读入到程序的通信通道。

输出流：程序向输出流写入数据。将程序中的数据输出到外界(显示器、打印机、文件、网络…)的通信通道。

字节流

1.InputStream、OutputStream

InputStream抽象了应用程序读取数据的方式

OutputStream抽象了应用程序写出数据的方式

2.读到文件结尾，称为EOF = end，读到-1就读到结尾

3.输入流基本方法

int b = in.read();读取一个字节，无符号填充到int的低八位.-1是EOF

int.read(byte[] buf)读取数据填充到字节数组buf

int.read(byte[] buf, int start, int size)读取数据填充到字节数组buf，从buf的start位置开始存储size长度的数据

4.输出流基本方法

out.write(int b);写出一个byte到流，b的低八位

out.write(byte[] buf);将buf字节数组都写入到流

out.write(byte[] buf, int start, int size);字节数组buf从start位置开始写size长度的字节到流

5.FileInputStream是InputStream的子类，具体实现了在文件上读取数据

6.FileOutputStream是OutputStream的子类，实现了向文件中写出字节数据的方法

FileInputStream的demo：

package com.test.io;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class IOUtils {

/**

* 读取指定文件内容，按照十六进制输出到控制台

* 并且每输出10个byte换行

* @param fileName

* @throws IOException

*/

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) {

System.out.print("0");

}

System.out.print(Integer.toHexString(b) + " ");

if (i % 10 == 0) {

System.out.println("");

}

i++;

}

in.close();

}

public static void printHexByByteArray(String fileName) throws IOException {

FileInputStream in = new FileInputStream(fileName);

byte[] buf = new byte[20*1024];

//如果字节数组够大，可以一次性读完

//从in中批量读取字节，放入到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] & 0xff) + " ");

if (j % 10 == 0) {

System.out.println("");

}

j++;

} */

//如果字节数组不够大，不能一次性读完

int bytes = 0;

int j = 1;

while ((bytes = in.read(buf, 0, buf.length)) != -1) {

for (int i = 0; i

if (buf[i] <= 0xf) {

System.out.print("0");

}

System.out.print(Integer.toHexString(buf[i] & 0xff) + " ");

if (j % 10 == 0) {

System.out.println("");

}

j++;

}

}

}

}

FileOutputStream的demo：

package com.test.io;

import java.io.FileOutputStream;

import java.io.IOException;

public class FileOutputDemo {

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

//如果该文件不存在，则直接创建，如果存在，删除后创建。(如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。)

FileOutputStream out = new FileOutputStream("F:\\javaio\\out.dat");

out.write('A');//写入了‘A'的低八位(一次只写入一个字节)

int a = 10;

out.write(a >>> 24);

out.write(a >>> 16);

out.write(a >>> 8);

out.write(a);

byte[] b = "10".getBytes();

out.write(b);

out.close();

IOUtils.printHex("F:\\javaio\\out.dat");

}

}

7.DataOutputStream和DataInputStream，对流功能的扩展，可以更加方便的读取int，long，字符等类型数据。

package com.test.io;

import java.io.DataOutputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class DataOutputDemo {

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

String file = "F:\\javaio\\b.txt";

DataOutputStream dos = new DataOutputStream(new FileOutputStream(file));

dos.writeInt(10);

dos.writeInt(-10);

dos.writeLong(10l);

dos.writeDouble(10.5);

dos.writeUTF("你好");

dos.writeChars("中国");

dos.close();

IOUtils.printHex(file);

}

}

运行结果：

00 00 00 0a ff ff ff f6 00 00

00 00 00 00 00 0a 40 25 00 00

00 00 00 00 00 06 e4 bd a0 e5

a5 bd 4e 2d 56 fd

其中，00 06两个字节是“你好”这两个中文的字节个数。

package com.test.io;

import java.io.DataInputStream;

import java.io.FileInputStream;

import java.io.IOException;

public class DataInputDemo {

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

String file = "F:\\javaio\\b.txt";

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();

}

}

运行结果：

10

-10

10

10.5

你好

8.BufferedInputStream&BufferedOutputStream，这两个流类为IO提供了带缓冲区的操作，一般打开文件进行写入或读取操作时，都会加上缓冲，这种流模式提高了IO的性能。

文件的拷贝：

package com.test.io;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class IOUtils {/**

* 拷贝文件,字节批量读取

* @param srcFile 源文件

* @param destFile 目标文件

* @throws IOException

*/

public static void copyFile(File srcFile, File destFile) throws IOException {

if (!srcFile.exists()) {

throw new IllegalArgumentException("文件" + srcFile + "不存在");

}

if (!srcFile.isFile()) {

throw new IllegalArgumentException(srcFile + "不是文件");

}

FileInputStream in = new FileInputStream(srcFile);

FileOutputStream out = new FileOutputStream(destFile);

byte[] buf = new byte[10*1024];

int b;

while ((b = in.read(buf, 0, buf.length)) != -1) {

out.write(buf,0,b);

out.flush();//最好加上，刷新此输出流并强制写出所有缓冲的输出字节。

}

in.close();

out.close();

}

/**

* 拷贝文件，利用带缓冲的字节流

* @param srcFile

* @param destFile

* @throws IOException

*/

public static void copyFileByBuffer(File srcFile, File destFile) throws IOException {

if (!srcFile.exists()) {

throw new IllegalArgumentException("文件" + srcFile + "不存在");

}

if (!srcFile.isFile()) {

throw new IllegalArgumentException(srcFile + "不是文件");

}

FileInputStream in = new FileInputStream(srcFile);

FileOutputStream out = new FileOutputStream(destFile);

BufferedInputStream bis = new BufferedInputStream(in);

BufferedOutputStream bos = new BufferedOutputStream(out);

int c;

while ((c = bis.read()) != -1) {

bos.write(c);

bos.flush();

}

bis.close();

bos.close();

}

/**

* 拷贝文件，通过单字节读取

* @param srcFile

* @param destFile

* @throws IOException

*/

public static void copyFileByByte(File srcFile, File destFile) throws IOException {

if (!srcFile.exists()) {

throw new IllegalArgumentException("文件" + srcFile + "不存在");

}

if (!srcFile.isFile()) {

throw new IllegalArgumentException(srcFile + "不是文件");

}

FileInputStream in = new FileInputStream(srcFile);

FileOutputStream out = new FileOutputStream(destFile);

int c;

while ((c = in.read()) != -1) {

out.write(c);

out.flush();

}

in.close();

out.close();

}

}

测试文件拷贝：

package com.test.io;

import java.io.File;

import java.io.IOException;

public class IOUtilsTest {

public static void main(String[] args) {

//IOUtils.printHex("D:\\javaProgram\\Hello.java");

try {

long start = System.currentTimeMillis();

//IOUtils.copyFile(new File("F:\\javaio\\1.mp3"), new File("F:\\javaio\\2.mp3"));//211ms

//IOUtils.copyFileByBuffer(new File("F:\\javaio\\1.mp3"), new File("F:\\javaio\\3.mp3"));//18583ms

IOUtils.copyFileByByte(new File("F:\\javaio\\1.mp3"), new File("F:\\javaio\\4.mp3"));//37822ms

long end = System.currentTimeMillis();

System.out.println(end - start);

} catch (IOException e) {

e.printStackTrace();

}

}

}

根据以上测试看出，文件拷贝，最快的方式是通过字节的批量读取。

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！