IO流(一)字节流 – 尽情飞奔

1:io流体系:对数据进行读写操作。所以IO不是读就是写咯。

2:io流的相关的类:java.io包。

有关IO的操作都会产生IOException异常

3:io:参照物是程序,

         i:input.进来,读取数据到程序中。

         o:output:出去,将数据从程序中写出去。

4:io流的分类,相关的类都会有相应的单词。

         4.1:从数据的流向分。个人理解为就是内存和硬盘之间的数据交换,内存上的数据是暂时性的,而硬盘上的数据是永久性的。

                   Input(输入):读取数据,数据往程序中流。或者说:将硬盘上的数据放到内存上

                   Output(输出):写出数据,将数据从程序中写出去。或者说:将内存上的数据放到硬盘上

         4.2:字节流和字符流

                   Stream:字节流,所有的数据都可以用字节流操作。计算机真正能识别的就是010101这些东西,8个0或者1组合成位,8位就是一个字节了。

                   Reader或者Writer:字符流。字符流是在字节流的基础上加了编码机制。只能对文字进行操作,虽说是文字,更贴切的说是文本文件,并不包括.doc等富文本文件,因为这些文件里面可以放图片或者其他的非文字内容。不能够对图片或者音频文件进行操作。

         InputSteam:读取字节流。OutputStream:输出字节流。

         Reader:读取字符流,   Writer:写出字符流。

5:文件字节流

         OutputStream,:抽象类  

                            文件输出字节流:FileOutputStream:节点流,跟目标设备相关联。

    实例一:

1 import java.io.FileOutputStream;
2 import java.io.IOException;
3
4 public class FileOutputStreamDemo1 {
5
6 public static void main(String[] args) throws IOException {
7 //1.创建文件输出流对象,参数为全路径名
8 FileOutputStream fos = new FileOutputStream(“e:\aa.txt”);
9 //2.写出数据
10 //2.1准备数据
11 String str = “要写出的数据”;
12 //2.2将数据转为字节数组的形式
13 byte[] b = str.getBytes();
14 //3.0将数据按照一个个字节地写出目标文件中
15 /*for(int i=0; i<b.length; i++){
16 fos.write(b[i]);
17 }*/
18 //3.1以下是将整个数组输出去,和3.0可到达相同的效果
19 fos.write(b);
20 //4.释放资源
21 fos.close();
22 }
23
24 }

 

                            BufferedInputStream:处理流,必须先有节点流。为了增加效率。处理的方式是将节点流包装起来

 

1 public static void testBufferedOutputStream() throws IOException{
2 //在使用带缓冲区的字节流的时候先要有一个节点流作为参数,或者说先指定一个目标文件
3 FileOutputStream fos = new FileOutputStream(“d:\test.txt”);
4 BufferedOutputStream bos = new BufferedOutputStream(fos);
5
6 //将以下文字写到目标文件中去
7 String str = “这几个文字即将通过带缓冲区的字节流写到一个文本文件中”;
8 bos.write(str.getBytes());
9 //写完之后记得要刷新才能真正写入到文件中,不然还会保存在缓冲区里,直到释放资源
10 bos.flush();
11 //释放资源(关闭流)
12 bos.close();
13
14 }

 

         InputStream:抽象类。

                            文件输入字节流:FileInputStream:节点流,和要读取那个文件关联起来

1 import java.io.FileInputStream;
2 import java.io.IOException;
3
4 public class FileInputStreamDemo1 {
5 public static void main(String[] args) throws IOException {
6 //1.创建字节输入流对象
7 FileInputStream fis = new FileInputStream(“e:\bb.txt”);
8 //2.开始读取数据
9 // System.out.println((char)fis.read());
10 int b;
11 while((b=fis.read())!=-1){
12 System.out.print((char)b);
13 }
14 fis.close();
15 }
16 }

 

                            BufferedOutputStream:带缓冲区的。也是为了增加效率,处理的方式是将节点流包装起来

 

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/*
* 将一个文件的文字输出到控制台
*/
public class BufferedInputStreamDemo1 {

public static void main(String[] args) {

FileInputStream fis = null;
BufferedInputStream bis
= null;
try {
fis
= new FileInputStream(“d:\aa.txt”);
bis
= new BufferedInputStream(fis);
//byte数组用来装读取到的数据
byte[] b = new byte[1024];
int len = -1;
while((len = bis.read(b))!=-1){
System.out.println(
new String(b, 0, len));
}
}
catch (FileNotFoundException e) {
e.printStackTrace();
}
catch (IOException e) {
e.printStackTrace();
}
finally{
try {
bis.close();
}
catch (IOException e) {
e.printStackTrace();
}
}

}

}

 

6:字节流:在文件系统中,任何文件都是以二进制形式存储的,二进制用位体现(8位为一个二进制单元),8位=1字节,所以字节流可以处理任何文件。

         6.1字节流常用的一些类:

                   6.1.1输入流read(), 读到末尾返回-1

常用read(byte[] b, int off, int len) 从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。

                            FileInputStream:文件输入流

                            BufferedInputStream:带缓冲区的输入流,先要传入一个节点流(输入流)作为参数

                   6.1.2输出流write()

常用write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。

                            FileOutputStream:文件输入流

                            BufferedOutputStream:带缓冲区的输入流,先要传入一个节点流(输入流)作为参数

 结合输入输出流写一个文件复制的工具:

public static boolean copyFile( String filePath,String target){

boolean flag = false;
//输出流,将数据写入到目标文件中
FileOutputStream fos = null;
//输入流,将要用的文本拿到程序中
FileInputStream fis = null;
//读取文本
byte[] b = new byte[1024];
//每次读取字符数据的有效长度
int length = -1;

try {
fis
= new FileInputStream(filePath);
fos
= new FileOutputStream(target);
/*
* fis.read(b):从fis关联的文件中每次读取 1024 个字节,
* 并把读取到的字节数据保存这个数组里面,
* 但是这个文件并不是只有1024 这个么大,有可能要读多次,所以要用循环
* 寻到的条件是读到文件没有得读了,就是读到最后了就不读了,
* 读到末尾的返回值是-1,如果返回值是-1则停止循环
*
*/
while((length=fis.read(b)) != -1){//读到文件末尾就返回-1,不在往下读取
//将读到的数据写入目标文件中
fos.write(b, 0, length);
fos.flush();
//将数据刷到目标文件
}
System.out.println(
“文件复制成功!”);
}
catch (FileNotFoundException e1) {
e1.printStackTrace();
}
catch (IOException e) {
e.printStackTrace();
}
finally{
//关闭释放资源
try {
fos.close();
fis.close();
}
catch (IOException e) {
e.printStackTrace();
}
}
flag
= true;
return flag;
}

 

本文链接:IO流(一)字节流,转载请注明。



You must enable javascript to see captcha here!

Copyright © All Rights Reserved · Green Hope Theme by Sivan & schiy · Proudly powered by WordPress

无觅相关文章插件,快速提升流量