1.一次读取多个字节
public int read(byte[] b)
参数: 读取的字节存放到数组 数据类似于缓冲区
返回值:表示读取的有效的字节个数
2.代码
package day18;
import java.io.FileInputStream;
import java.io.IOException;
public class Test04 {
public static void main(String[] args) throws IOException {
byte[] b = new byte[2];
FileInputStream fis = new FileInputStream("E:\\admin01\\d.txt");
//调用读的方法
int leng = fis.read(b);
System.out.println(new String(b));
System.out.println(leng);
int leng1 = fis.read(b);
System.out.println(new String(b));
System.out.println(leng1);
int leng2 = fis.read(b);
System.out.println(new String(b));
System.out.println(leng2);
int leng3 = fis.read(b);
System.out.println(new String(b));
System.out.println(leng3);
int leng4 = fis.read(b);
System.out.println(new String(b));
System.out.println(leng4);
//关闭资源
fis.close();
}
}
结果图
最后读取字节数组，不够时往回读，但返回的是准确的数字，当读完所有再读时返回-1；
一、字符缓冲流
1.BufferedInputStream 输入缓冲区流 读取 加快读取速度(高效流)
2.BufferedOutputStream 输出缓冲区流 写入 加快写入速度(高效流)
3.注意点：
BufferedInputStream 与BufferedOutputStream 没有读写的功能 只是对InputStream 与
OutputStream
的封装 提供了一个缓冲区的数组 加快读写操作的速度
4.构造方法
5.高效流 高效的原因
BufferedInputStream 高效流的底层提供了一个缓冲的数组 这个数组的长度是8127个字节
使用高效流进行读取的时候 一次读取8127的字节的数据放入到缓冲区的数组,再进行读取数据的时候
就从缓冲区中获取数据(内存中) 如果8127字节的数据全部读取完毕之后 又从新读取8127个字节
填入到
缓冲区中 可以避免反复与磁盘来进行交互 从内存中获取数据 数据会更加快 所以高效
BufferedOutputStream 高效的原因与上面的一样
理解：即再内存与磁盘交互之间 在内存中开辟一个专门读取的空间，这个空间与磁盘交互更快，这个空间一次读取8127个字节，内存往这个空间读取数据，数据不够时这个空间再去磁盘读取
package day18;
import java.io.*;
public class Test03 {
public static void main(String[] args) throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(new
File("E:\\admin01\\d.txt")));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(new
File("E:\\admin01\\b\\b.txt")));
int leng =-1;
while ((leng=bis.read())!= -1){
bos.write(leng);
}
bos.close();
bis.close();
}
}
flush()与close()
1.flush() 刷新缓冲区 将缓冲区中的数据 刷入到硬盘中(文件)
2.close() 关闭的流资源
3.close() 在关闭流资源之前会自动调用flush() 方法
4.区别：
flush() 调用 之后 流资源可以正常的使用
close() 调用之后 流资源是不能正常使用
建议完成写入操作后都flush 一下
5.代码
package day18;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class Test02 {
public static void main(String[] args) throws IOException {
//高效读的流
//BufferedInputStream bis = new BufferedInputStream(new FileInputStream(new File("E:\\a\\下载.jpg")));
//高效写的流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(new File("E:\\admin01\\d.txt")));
//读取
// int leng =-1;
// while ((leng= bis.read()) !=-1) {
// bos.write(leng);
// }
// bos.flush();
// bos.write("11111".getBytes());
//关闭资源
//一个类中第一次调用写入时会清空重输，第二次以及之后调用写入是添加内容
bos.write("11111".getBytes());
bos.flush();
bos.write("2222".getBytes());
bos.close();
//bos.flush();
//bos.close();
// bis.close();
// bos.write("11111".getBytes());
}
}
关闭流资源
1.使用流资源异常的处理: 抛出 捕获
可以确定其异常的时候 使用捕获 程序不会停止运行 可以继续下面的代码
不能确定其异常的时候 就抛出异常 发生异常 程序就会停止运行
2.流资源的关闭
1.流资源应该是从下往上进行关闭
2.不管是否发生异常都需要关闭流资源 放在finally中关闭
3.关闭流资源的时候一定要进行非空判断
3.代码
package day18;
import java.io.*;
public class Test01 {
public static void main(String[] args) {
InputStream is = null;
BufferedInputStream bis = null;
OutputStream os = null;
BufferedOutputStream bos = null;
try {
is= new FileInputStream("E:\\admin01\\d.txt");
bis= new BufferedInputStream(is);
os= new FileOutputStream("E:\\admin01\\b\\b.txt");
bos= new BufferedOutputStream(os);
int leng = -1;
while ((leng = bis.read()) != -1) {
bos.write(leng);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//从下往上关闭流资源
try {
if (bos !=null){
bos.close();
}
if(os !=null){
os.close();
}
if(bis !=null) {
bis.close();
}
if(is !=null) {
is.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
read(byte[] b) read()区别
1.read(byte[] b) 一次读取多个字节 效率高 read() 一次性读取一个字节 效率低
2.read() 返回的是读取的字节 read(byte[] b) 返回值是读取的有效的字节的个数
//用字节数组读取，才能正确解码中文，字符即char，字节即byte，char是字符类型，byte属于整数类型
//计算机用二进制（01）存储，一个0或1，表示一位，1bit; java中最小单位是字节byte,1B=8b,
//用read(b)字节数组读取，返回读取到字节的个数，读取到的字节存入字节数组 所以需要 byte [] b = new byte[1024];
//通过String构造方法使用utf-8编码格式 将字节数组解码转为字符串
//用read() 读取，返回的int类型，向上转型，int转为char使用Ascll码表 a 97 A 65 0 48
//byte转为char 使用的解码不是Ascll 只是0~127的字节默认对应ascll
// read()读取返回的int 因为byte范围是-128~127 有-1，java识别流的读取结束符号是-1，有冲突，
//将byte转为int类型，其读取范围变为0~255，结束返回-1；解决了冲突(byte类型的-1通过补0转为int类型的255)
重要代码理解
bos.write(“ablashdfkjhjadlfkasdfabb”.getBytes());
bos.flush();//刷入到内存和磁盘交互的缓冲区，bis 才能读取到，否则为空
BufferedOutputStream bos = null;//为了让finally 里的代码能够调用close()方法
int leng =-1;//读取用 while
while ((leng = bis.read()) !=-1){
list.add((char)leng);
}
while ((leng = bis.read(b))!=-1){
str = new String(b,0,leng);
}
//通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。
bytes - 要解码为字符数组
offset - 要解码的第一个 byte 的索引
length - 要解码的 byte 数
s = str.split(" ")[0]; 将字符串str以空格分割为数组，数组0索引的数据赋值给s
io代码标准格式 看代码
完成写入操作后flush 一下
io对象先复制为null
try catch finally 结构
try里 再用if 判断是否不存在 不存在就创建
finall 里 再用try catch 结构关闭流，判断非空，关闭流，从代码下往上依次关闭
package day18.work;
import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Work02 {
public static void main(String[] args) {
File file = new File("E:\\admin\\2.txt");
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
if(!file.exists()){
file.createNewFile();
}
bis = new BufferedInputStream(new FileInputStream(file));
bos = new BufferedOutputStream(new FileOutputStream(file));
bos.write("name=张三 age=12 psw=234".getBytes());
bos.flush();
byte [] b = new byte[1024];
String str = "";
int leng =-1;
while ((leng = bis.read(b))!=-1){
str = new String(b,0,leng);
}
/*List<Byte> list = new ArrayList<>();
int leng=-1;
while ((leng = bis.read())!=-1){
list.add((byte)leng);
}
byte [] bytes = new byte[list.size()];
for (int i = 0; i < list.size(); i++) {
bytes[i] = list.get(i);
}
String str = new String(bytes,0,bytes.length);
System.out.println(str);*/
//对字符进行分割
StringBuilder sb = new StringBuilder();
//以空格进行分割
String [] arrays = str.split(" ");
for (String s : arrays) {
// substring 两个参数包头不包尾 ，一个参数从参数索引开始截取后面所有
// insexOf 返回第一次出现时的索引
sb.append(s.substring(s.indexOf("=")+1)+" ");
}
System.out.println(sb);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(bis!=null){
bis.close();
}
if(bos!=null){
bos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
package day18.work;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Work03 {
public static void main(String[] args) {
File file = new File("E:\\admin\\d\\1.txt");
File file1 = new File("E:\\admin\\2.txt");
FileOutputStream os = null;
FileInputStream is = null;
FileOutputStream os1 =null;
try {
if(!file.exists()){
File f = new File(file.getParent());
f.mkdirs();
file.createNewFile();
}
if(!file1.exists()){
File f1 = new File(file.getParent());
f1.mkdirs();
file1.createNewFile();
}
os = new FileOutputStream(file);
is = new FileInputStream(file);
os1 = new FileOutputStream(file1);
os.write("admin 12345".getBytes());
os.flush();//完成写入操作后flush 一下，是个好习惯，但没有使用高效流 不写也可以
byte [] b = new byte[1024];
String str ="";
int leng =-1;
while ((leng=is.read(b))!=-1){
//str = new String(b,0,leng);
os1.write(b);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(os1!=null){
os1.close();
}
if(is!=null){
is.close();
}
if(os!=null){
os.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
扫一扫
486
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
