黑马程序员—Java基础—IO流—字节流

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------ 

字节流

IO流概述：IO流用来处理设备之间的数据传输

上传文件和下载文件

IO流分类

按照数据流向

输入流   读入数据

输出流   写出数据

按照数据类型

字节流

字符流

IO流常用基类

字节流的抽象基类：

InputStream ，OutputStream。

字符流的抽象基类：

Reader ， Writer。

注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。如：InputStream的子类FileInputStream。如：Reader的子类FileReader。

字节流写数据

OutputStream 被abstract修饰，是抽象类，所以使用其子类

FileOutputStream

FileOutputStream的构造方法

FileOutputStream(File file)

FileOutputStream(String name)

字节流写数据的方式

public void write(int b)

public void write(byte[] b)

public void write(byte[] b,int off,int len)

 字节流写入数据的方式 32行 Java

Raw

  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo {
public static void main(String[] args) throws IOException {
// 创建字节输出流对象
// FileOutputStream(File file)
// File file = new File("fos.txt");
// FileOutputStream fos = new FileOutputStream(file);
// FileOutputStream(String name)
FileOutputStream fos = new FileOutputStream("fos.txt");
/*
 * 创建字节输出流对象了做了几件事情：
 * A:调用系统功能去创建文件
 * B:创建fos对象
 * C:把fos对象指向这个文件
 */
//写数据
fos.write("hello,IO".getBytes());
fos.write("java".getBytes());
//释放资源
//关闭此文件输出流并释放与此流有关的所有系统资源。
fos.close();
//java.io.IOException: Stream Closed
//fos.write("java".getBytes());
}
}

数据写成功后，为什么要close()?

答：让流对象变成垃圾，这样就可以被垃圾回收器回收了；通知系统去释放跟该文件相关的资源。

如何实现数据的换行?

答：写入换行符号即可

如何实现数据的追加写入?

答：用构造方法带第二个参数是true的情况即可

字节流读取数据

InputStream ，通OutputStream一样是抽象类，使用其子类

FileInputStream

FileInputStream的构造方法

FileInputStream(Filefile)

FileInputStream(Stringname)

FileInputStream的成员方法

public int read()

public int read(byte[] b)

 字节输入流构造方法及读入数据发送 30行 Text

Raw

  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

import java.io.FileInputStream;
import java.io.IOException;

/*
 * 字节输入流操作步骤：
 * A:创建字节输入流对象
 * B:调用read()方法读取数据，并把数据显示在控制台
 * C:释放资源
 * 
 * 读取数据的方式：
 * A:int read():一次读取一个字节
 * B:int read(byte[] b):一次读取一个字节数组
 */
public class FileInputStreamDemo {
public static void main(String[] args) throws IOException {
// FileInputStream(String name)
// FileInputStream fis = new FileInputStream("fis.txt");
FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");

int by = 0;
// 读取，赋值，判断
while ((by = fis.read()) != -1) {
System.out.print((char) by);
}

// 释放资源
fis.close();
}
}

字节流复制数据练习

把e:\\K歌之王.mp4复制到当前项目目录下的copy.mp4中

 字节流复制文件练习 30行 Java

Raw

  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 需求：把e:\\K歌之王.mp4复制到当前项目目录下的copy.mp4中
 * 
 * 数据源：
 * e:\\K歌之王.mp4--读取数据--FileInputStream
 * 目的地：
 * copy.mp4--写出数据--FileOutputStream
 */
public class CopyMp4Demo {
public static void main(String[] args) throws IOException {
// 封装数据源
FileInputStream fis = new FileInputStream("e:\\K歌之王.mp4");
// 封装目的地
FileOutputStream fos = new FileOutputStream("copy.mp4");

// 复制数据
int by = 0;
while ((by = fis.read()) != -1) {
fos.write(by);
}

// 释放资源
fos.close();
fis.close();
}
}

字节流缓冲区：

1、读写特点：

       read()：会将字节byte型值提升为int型值

       write()：会将int型强转为byte型，即保留二进制数的最后八位。

2、原理：将数据拷贝一部分，读取一部分，循环，直到数据全部读取完毕。

       1）先从数据中抓取固定数组长度的字节，存入定义的数组中，再通过然后再通过read()方法读取数组中的元素，存入缓冲区。

       2）循环这个动作，直到最后取出一组数据存入数组，可能数组并未填满，同样也取出包含的元素。

       3）每次取出的时候，都有一个指针在移动，取到数组结尾就自动回到数组头部，这样指针在自增。

       4）取出的时候，数组中的元素在减少，取出一个，就减少一个，直到减到0即元素取完。

       5）当文件中的全部数据都被读取出时，read()方法就返回-1。

3、自定义读取字节流缓冲区

        需求：根据字节流缓冲区的原理，自定义一个字节流缓冲区。

注意：

       1、字节流的读一个字节的read方法为什么返回值类型不是byte，而是int。

       因为有可能会读到连续8个二进制1的情况，8个二进制1对应的十进制是-1.那么就会数据还没有读完，就结束的情况。因为我们判断读取结束是通过结尾标记-1来确定的。

       所以，为了避免这种情况将读到的字节进行int类型的提升。并在保留原字节数据的情况前面了补了24个0，变成了int类型的数值。而在写入数据时，只写该int类型数据的最低8位。

        2、byte类型的-1提升为int类型时还是-1。原因：因为在bit8个1前面补的全是1导致的。如果在bit8个1前面补0，即可以保留原字节数据不变，又可以避免-1的出现。这时将byte型数据&0xff即255即可

 高效字节流写出数据 27行 Text

Raw

  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 
 * 缓冲区类(高效类)
 * 写数据：BufferedOutputStream
 * 读数据：BufferedInputStream
 * 
 */
public class BufferedOutputStreamDemo {
public static void main(String[] args) throws IOException {
// BufferedOutputStream(OutputStream out)
// FileOutputStream fos = new FileOutputStream("bos.txt");
// BufferedOutputStream bos = new BufferedOutputStream(fos);
// 简单写法
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream("bos.txt"));
// 写数据
bos.write("hello".getBytes());
// 释放资源
bos.close();
}
}

 高效字节流读取数据 28行 Java

Raw

  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class BufferedInputStreamDemo {
public static void main(String[] args) throws IOException {
// BufferedInputStream(InputStream in)
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
"bos.txt"));
// 读取数据
// int by = 0;
// while ((by = bis.read()) != -1) {
// System.out.print((char) by);
// }
// System.out.println("---------");
byte[] bys = new byte[1024];
int len = 0;
while ((len = bis.read(bys)) != -1) {
System.out.print(new String(bys, 0, len));
}
// 释放资源
bis.close();
}
}

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------