- 浏览: 36926 次
- 性别:
- 来自: 济南
-
文章分类
最新评论
字节流--IO学习笔记（二）
IO流：
包括字节流和字符流。
在这里解释一下我对于流的理解,其实流就相当于一个用来运输字节或者字符的管道，一开始会把所有的数据存放到流中，然后我们再从流中取出数据（进行读取或者写出操作），每读或者写一次就会从管道中把读或者写的数据取出来，管道中就没有了你刚才读到或者写出的数据了。比如：
FileInputStream fis = new FileInputStream(String filename);
就会把文件名为filename的文件内容全部存放到管道中去，然后我们进行fis.read(),就会从管道中读取出内容，读到的内容就会从管道中消失。
字节流：
（1）InputStream:抽象了应用程序读取数据的方式
OutputStream : 抽象了应用程序写出数据的方式
（2）输入流的基本方法：
InputStream in = new InputStream();
int b = in.read();
读取一个字节无符号填充到int的最后8位，返回的是读到的字节（转换成int类型的值的）内容，当读到-1时，标识读取到最后结束了。
in.read(byte[] buf):读取的数据填充到字节数组buf中，返回的是读到的字节的个数。
in.read(byte[] buf,int start ,int size):读取数据到字节数组buf,并且是从buf的start位置开始，最多存放size长度的数据，返回的是读到的字节的个数。
（3）输出流的基本方法：
OutputStream out = new OutputStream();
out.write(int b):写出一个字节到流，写的是int的最后的8位
out.write(byte[] buf):将buf字节数组都写入到流
out.write(byte[] buf,int start,int size):字节数组buf从start位置开始写size长度的字节到流
下面介绍字节流基本的读取方法的使用（注意：FileInputStream继承了InputStream）
package com.test.FileInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class FileInputStreamTest {
public static void main(String[] args) {
try {
System.out.println("方式一：字节数组的长度足够存储读取的内容");
ReadFile1("C:\\Users\\Administrator\\Desktop\\javaIO\\读取的测试文件.txt");
System.out.println();
System.out.println("方式二：字节数组的长度不足以存储读取的内容");
ReadFile2("C:\\Users\\Administrator\\Desktop\\javaIO\\读取的测试文件.txt");
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 当字节数组的大小足够存储读取的内容的时候
* 只读取一次，然后打印出来就可以了
*/
public static void ReadFile1(String filename) throws IOException{
FileInputStream fis = new FileInputStream(filename);
byte[] buf = new byte[1024];
//从fis中批量读取字节，放入到buf这个字节数组中，
//从第0个位置开始放，最多放buf.length个
//返回的是读到的字节的个数
int bytes = fis.read(buf, 0, buf.length);
int j = 1;
for(int i=0;i<bytes;i++){
//byte类型8位，int类型32位，为了避免数据转换错误，通过&0xff将高24位清零
System.out.print(Integer.toHexString(buf[i]&0xff)+" ");
if(j++%10==0){//每读取10个字节就换行
System.out.println();
}
}
fis.close();
}
/**
* 当数组的大小没法存储读取的全部的字节的时候，
* 就要对该字节数组进行重复利用，
* 每读取字节数组的长度的内容的时候就打印出来，
* 然后再次读取该字节数组长度的内容，
* 直到把所有的内容读取出来
*/
public static void ReadFile2(String filename) throws IOException{
FileInputStream fis = new FileInputStream(filename);
byte[] buf = new byte[1024];
int bytes = 0;
int j = 1;
while((bytes = fis.read(buf, 0, buf.length))!=-1){//如果数组不是足够大,要进行多次的读取操作
for(int i = 0;i<bytes;i++){
System.out.print(Integer.toHexString(buf[i]&0xff)+" ");
if(j++%10==0){
System.out.println();
}
}
}
fis.close();
}
}
读取的文件内容：
读取结果截图：
下面对比下单字节读取与批量读取文件的效率：
package com.test.FileInputStream;
import java.io.FileInputStream;
import java.io.IOException;
/**
* 对比单字节读取与批量读取同样的文件的所用的时间
* 2015年8月8日 下午9:24:31
*
*/
public class FileInputStreamTest1 {
public static void main(String[] args) {
try {
ReadFile1("C:\\Users\\Administrator\\Desktop\\javaIO\\问尘 - 洛天依.mp3");
ReadFile2("C:\\Users\\Administrator\\Desktop\\javaIO\\问尘 - 洛天依.mp3");
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 单字节读取文件的方式
* @param filename
* @throws IOException
*/
public static void ReadFile1(String filename) throws IOException{
FileInputStream fis = new FileInputStream(filename);
int b;
int i = 1;
long start = System.currentTimeMillis();
while((b = fis.read())!=-1){
// System.out.print(Integer.toHexString(b&0xff)+" ");
if(i++%10==0){
// System.out.println();
}
}
long end = System.currentTimeMillis();
System.out.println("单字节读取所用的时间："+(end-start));
fis.close();
}
/**
* 批量字节读取的方式
* @param filename
* @throws IOException
*/
public static void ReadFile2(String filename) throws IOException{
FileInputStream fis = new FileInputStream(filename);
byte[] buf = new byte[1024];
int b;
int j = 1;
long start = System.currentTimeMillis();
while((b = fis.read(buf, 0, buf.length))!=-1){
for(int i = 0;i<b;i++){
// System.out.print(Integer.toHexString(buf[i]&0xff)+" ");
if(j++%10==0){
// System.out.println();
}
}
}
long end = System.currentTimeMillis();
System.out.println("批量读取所用的时间："+(end-start));
fis.close();
}
}
所以，批量读取，对于大文件而言效率高，也是我们最常见的读文件的方式。单字节读取不适合大文件，大文件读取的效率很低。
下面介绍字节流基本的写出方法的使用（注意：FileOutputStream继承了OutputStream,实现了向文件中写出byte数据的方法）
package com.test.FileOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamTest {
public static void main(String[] args) {
try {
WriteFile("C:\\Users\\Administrator\\Desktop\\javaIO\\写入测试文件.txt");
} catch (IOException e) {
e.printStackTrace();
}
}
public static void WriteFile(String filename) throws IOException{
//如果该文件不存在，则直接创建，如果存在，删除后创建
FileOutputStream fos = new FileOutputStream(filename);
// //如果该文件不存在，则直接创建，如果存在，直接在文件中追加内容
// FileOutputStream fos = new FileOutputStream(filename,true);
/*
* 写一个字符的方法（可以写一个字符）
*/
fos.write('A');//写出了‘A’的字节所占位的最后八位
fos.write('B');
/*
* 写一个整数的方法
*/
int i = 10;//write()方法只能写八位，那么写一个int需要写4次，每次8位
fos.write(i>>>24);
fos.write(i>>>16);
fos.write(i>>>8);
fos.write(i);
/*
*写一个字节数组的方法 (可以直接写一个字节数组)
*/
byte[] gbk = "小灰灰".getBytes("gbk");
fos.write(gbk);
fos.close();
}
}
基本的字节输入流和字节输出流的整合运用：（以Copy文件为例）
package com.test.FileOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyFile {
public static void main(String[] args) {
File srcFile = new File("C:\\Users\\Administrator\\Desktop\\javaIO\\被copy的文件.txt");
File destFile = new File("C:\\Users\\Administrator\\Desktop\\javaIO\\copy的文件.txt");
try {
copyFile(srcFile, destFile);
} catch (IOException e) {
e.printStackTrace();
}
}
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 fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile);
byte[] buf = new byte[3*1024];
int i;
while((i = fis.read(buf,0,buf.length))!=-1){
fos.write(buf, 0, i);
fos.flush();
}
fis.close();
fos.close();
}
}
DataOutputStream/DataInputStream的使用：
作用：
对“流”功能的扩展，可以更加方便的读取int,long,字符等基本类型的数据。
构造方法：
DataOutputStream dos = new DataOutputStream(OutputStream out);
DataInputStream dis = new DataInputStream(InputStream in);
从构造方法中可以看到这两种流就是对普通流进行了包装，方便读取基本类型的数据。
DataOutputStream多出来的写出的方法：
writeInt()
writeDouble()
writeLong()
writeChars()//采用UTF-16BE编码写出
writeUTF()//采用UTF-8编码写出
……
writeInt():
write()方法一次只可以写出最后的8位，但是int类型的数据是32位（4个字节），所以要write()四次才能写出一个int类型的数据。
int i = 10;//write()方法只能写八位，那么写一个int需要写4次，每次8位
fos.write(i>>>24);
fos.write(i>>>16);
fos.write(i>>>8);
fos.write(i);这是我们写一个int类型数据的方法。
writeInt()方法可以只写一次就可以写出一个int类型的数据，其实查看源码可以知道其实也是write()了四次。
writeInt()方法的源码：
public final void writeInt(int v) throws IOException {
out.write((v >>> 24) & 0xFF);
out.write((v >>> 16) & 0xFF);
out.write((v >>> 8) & 0xFF);
out.write((v >>> 0) & 0xFF);
incCount(4);
}writeLong(),writeDouble()……也是这样的原理。
所以可以看出DataOutputStream就是对基本类型的数据的写出方法进行了包装，方便我们写出基本类型的数据。
BufferedInputStream/BufferedOutputStream的使用：
这两个流为IO提供了带缓冲区的操作，一般打开文件进行写入或者读取操作时，都会加上缓冲，这种流模式提高了IO的性能。
解释：
从应用程序中把数据放入文件，相当于将一缸水倒入另一个缸中。
FileOutputStream—–>write()方法相当于一滴水一滴水的把水转过去
DataOutputStream—>writeXxx()方法会方便一些，相当于一瓢一瓢的转移过去
BufferedOutputStream—>write()方法更方便，相当于一瓢一瓢先放入桶中，再从桶中倒入到另个缸中，性能提高了。
注意：当使用BufferedOutputStream的时候，当写完一次后要进行冲刷缓冲区（flush()），否则下次进行写入的时候就没法向缓冲区中存放了。
下面比较一下这些流读取和写入操作的效率：
package com.test.FileInputStream;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
/**
* 对比单字节读取与批量读取同样的文件的所用的时间
* 2015年8月8日 下午9:24:31
*
*/
public class FileInputStreamTest1 {
public static void main(String[] args) {
try {
ReadFile1("C:\\Users\\Administrator\\Desktop\\javaIO\\问尘 - 洛天依.mp3");
ReadFile2("C:\\Users\\Administrator\\Desktop\\javaIO\\问尘 - 洛天依.mp3");
ReadFile3("C:\\Users\\Administrator\\Desktop\\javaIO\\问尘 - 洛天依.mp3");
ReadFile4("C:\\Users\\Administrator\\Desktop\\javaIO\\问尘 - 洛天依.mp3");
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 单字节读取文件的方式
* @param filename
* @throws IOException
*/
public static void ReadFile1(String filename) throws IOException{
FileInputStream fis = new FileInputStream(filename);
int b;
int i = 1;
long start = System.currentTimeMillis();
while((b = fis.read())!=-1){
// System.out.print(Integer.toHexString(b&0xff)+" ");
if(i++%10==0){
// System.out.println();
}
}
long end = System.currentTimeMillis();
System.out.println("单字节读取所用的时间："+(end-start));
fis.close();
}
/**
* 批量字节读取的方式
* @param filename
* @throws IOException
*/
public static void ReadFile2(String filename) throws IOException{
FileInputStream fis = new FileInputStream(filename);
byte[] buf = new byte[1024];
int b;
int j = 1;
long start = System.currentTimeMillis();
while((b = fis.read(buf, 0, buf.length))!=-1){
for(int i = 0;i<b;i++){
// System.out.print(Integer.toHexString(buf[i]&0xff)+" ");
if(j++%10==0){
// System.out.println();
}
}
}
long end = System.currentTimeMillis();
System.out.println("批量读取所用的时间："+(end-start));
fis.close();
}
/**
* 字节缓冲流读取文件
* @param filename
* @throws IOException
*/
public static void ReadFile3(String filename) throws IOException{
FileInputStream fis = new FileInputStream(filename);
BufferedInputStream bis = new BufferedInputStream(fis);
long start = System.currentTimeMillis();
int b;
int j = 1;
while((b=bis.read())!=-1){
for(int i=0;i<b;i++){
// System.out.println(Integer.toHexString(b&0xff)+" ");
if(j++%10==0){
// System.out.println();
}
}
}
long end = System.currentTimeMillis();
System.out.println("字节缓冲流读取所用的时间："+(end-start));
bis.close();
}
/**
* 字节缓冲流批量读取文件
* @param filename
* @throws IOException
*/
public static void ReadFile4(String filename) throws IOException{
FileInputStream fis = new FileInputStream(filename);
BufferedInputStream bis = new BufferedInputStream(fis);
byte[] buf = new byte[1024*3];
long start = System.currentTimeMillis();
int b;
int j = 1;
while((b= bis.read(buf, 0, buf.length))!=-1){
for(int i = 1;i<b;i++){
// System.out.println(Integer.toHexString(buf[i]&0xff)+" ");
if(j++%10==0){
// System.out.println();
}
}
}
long end = System.currentTimeMillis();
System.out.println("字节缓冲流批量读取所用的时间"+(end-start));
bis.close();
}
}
所用时间结果截图：
由此可以看出：
批量读取文件的效率>字符缓冲流读取文件的效率>单字节读取文件的效率
版权声明：本文为博主原创文章，未经博主允许不得转载。
发表评论
相关推荐
2024码表IO流-字节流-HM
字节流---马克-to-win java视频的详细介绍与描述 stream
【IT十八掌徐培成】Java基础第13天-04.字节流-FileInputStream-FileOutputStream.zip
javaIO操作各种文件，筛选文件，拷贝文件，上传下载，字符流和字节流都有，根据实际项目情况直接贴就可以了，根据文件类型选择不同的testclss就可以。全部使用效率最高的流
IO流学习（字节流 字符流 文本流）！
Java IO 体系 - Java IO 体系 ...Java IO 是一个庞大的知识体系，很多人学着学着就会学懵了，包括我在内也是如此，所以本文将会从 Java 的 BIO 开始，一步一步深入学习，引出 JDK1.4 之后出现的 NIO
5-字节跳动-字节跳动智能化服务端接口测试解决方案-刘璐辰.pdf
Java IO字符流和字节流，讲述了字符传输流和字节传输流的不同和作用
4-字节跳动-智能化的精准测试实践-刘杰、王孟飞.pdf
2、常用21个IO流：FileWriter、FileReader、CharArrayReader、CharArrayWriter、CharSequence、OutputStreamWriter、FileOutputStream、InputStreamReader、PrintWriter、BufferedReader、InputStream、...
Java 流在处理上分为字符流和字节流。字符流处理的单元为 2 个字节的 Unicode 字符，分别操作字符、字符数组或字符串，而字节流处理单元为 1 个字节，操作字节和字节数组。 Java 内用 Unicode 编码存储字符，字符流...
File 类、RandomAccessFile 类、字节流（文件字节流、缓冲字节流、基本数据类型字节流、打印流、对象序列化流、字节数组流）、字符流（缓冲字符流、文件字符流、转换流、格式化输出流、字符数组流） 这份代码源码...
主要描述了常用字节流的用法，附上一些代码！
图片转换成字节流先要转换的IMage对象，转换之后返回字节流。字节流转换成图片，要转换的字节流，转换得到的Image对象，根据图片路径返回图片的字节流，感兴趣的朋友看下下面的代码。 C#将图片和字节流相互转换代码...
这是一个关于io流的文件，里面包括代码和图片截图。详细的说明了io流的内在
NULL 博文链接：https://xiongjiajia.iteye.com/blog/1683399
JAVA输入输出流--字节流篇(什么时候用哪个).doc
这是本人写的以RS73编码来模拟CMMB的RS编码及字节交织-RS编码和字节交织.rar 小弟对matlab还不熟悉，写的这个程序还望大家指正一下:loveliness:
1.2 文件流 1.2.1 FileInputStream(文件字节输入流) 1.2.2 FileOutputStream(文件字节输出流)
java IO流学习笔记——(1) IO流总述 • 输入流：数据源到程序(InputStream、Reader读进来) • 输出流：程序到目的地(OutputStream、Writer写出去) 流分类 : • 节点流：可以直接从数据源或目的地读写数据 • 处理...