黑马程序员——JAVA基础------IO流（二）----字节流

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——

一、IO流概述

IO流：输入输出流（Input/Output）

流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据传输特性将流抽象为各种类，方便更直观的进行数据操作。

IO流的分类

根据处理数据类型的不同分为：字符流和字节流

根据数据流向不同分为：输入流和输出流

字节流分为字节输出流（OutputStream）和字节输入流（InputStream）

字节输出流(OutputStream)定义

public abstract class OutputStream extands Object implements Closable,Flushable

此类抽象类是表示输出字节流的所有类的超累。输出流接受输出字节并将这些字节发送到某个接收器。





代码演示：

package com.joe.io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
/**
* 字节输出流格式：
* OutputStream out = new FileOutputStream()
* try{}
* catch{}
* finally{}
*
* 思路：
* 1、创建输出流对象
* 2、创建字节数组接收写入数据
* 3、将数组中的数据遍历输出
* 4、关闭流对象
*
* 注意事项：一定要关闭流
* @author joe
*
*/

public class OutputStreamDemo {

public static void main(String[] args) {
// write1();
write2();
System.out.println("success");
}

/**
* 字节输出流的方式一：每次输出一个字节
*/
public static void write1() {
OutputStream out = null;
try {
// 创建一个文件字节输出流对象
out = new FileOutputStream("d:\\1.txt");

String info = "hello,IO";
byte[] bytes = info.getBytes();
for (int i = 0; i < bytes.length; i++) {
// 向文件中输出
out.write(bytes[i]);
}

} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
// 关闭流
if (out != null)
out.close();
} catch (IOException e) {
System.out.println(e.toString());
}
}
}

/**
* 字节输出流的方式二：每次输出指定大小的字节
*/
public static void write2() {
OutputStream out = null;
try {
// 创建一个文件字节输出流对象(参数true表示追加输出)
out = new FileOutputStream("d:\\1.txt", true);

String info = "i love java!";
byte[] bytes = info.getBytes();
out.write(bytes);// 输出一个字节数组
// out.write(bytes,0,5);//输出一个字节数组中的指定范围的字节

} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 关闭流
try {
if (out != null)
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

}

字节输入流(InputStream)定义

public abstract class InputStream extends Object implements Closeable

代码演示：

package com.joe.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

/**
* 字节输入流格式： InputStream in = new FileInputStream()
*              try{}
*              catch{}
*              finally{}
*
* 思路：
* 1、创建输入流对象
* 2、定义一个字节，用来保存实际读取的字节数，-1表示没有数据
* 3、创建一个字节数组，用来每次读取数据
* 4、创建一个StringBuilder缓冲区，用来接收数据
* 5、输出读取数据
* 6、关闭流对象
*
* 注意事项：一定要关闭流
*
* @author joe
*
*/

public class InputStreamDemo {

public static void main(String[] args) {
read1();
read2();
read3();
}

/**
* 字节输入流的读取方式一：每次读取一个字节
*/
public static void read1() {
InputStream in = null;
try {
// 构造一个字节输入流对象
in = new FileInputStream("d:\\1.txt");
int b = -1;// 用于保存实际读取字节数，－1表示没有数据
while ((b = in.read()) != -1) {
System.out.print((char) b);
}

} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 关闭流
try {
if (in != null)
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

/**
* 字节输入流的读取方式二：一次性读取所有字节
*/
public static void read2() {

File f = new File("d:\\1.txt");
// 构造一个字节输入流对象
InputStream in = null;
try {
in = new FileInputStream(f);
// 根据文件的大小构造字节数组
byte[] bytes = new byte[(int) f.length()];
int len = in.read(bytes);
System.out.println(new String(bytes));
System.out.println("len=" + len);

} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 关闭流
try {
if (in != null)
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

/**
* 字节输入流的读取方式三：每次读取指定大小的字节（常用）
*/
public static void read3() {
File f = new File("d:\\1.txt");
// 构造一个字节输入流对象
InputStream in = null;
try {
in = new FileInputStream(f);
// 指定每次要读取的字节数组
// 创建一个长度为10的数组，每次至多只能存进10个字节
byte[] bytes = new byte[10];
int len = -1;// 每次读取的实际长度
StringBuilder sb = new StringBuilder();
while ((len = in.read(bytes)) != -1) {
sb.append(new String(bytes, 0, len));
}
// 输出
System.out.println(sb);

} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 关闭流
try {
if (in != null)
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

}