【目标：操作设备上的数据，读写数据】
1，将内存中数据都写入到文件中。
需要使用系统资源，Java中用于操作系统资源的对象是哪个呢？
通过api的索引关键字 Output Input
找到OutputStream InputStream。
2，OutputStream InputStream
字节输出流和字节输入流的超类。
定义了write 和read方法。
3，它们的子类都具备名称定义规律：后缀名是父类名，前缀名是流对象的功能。★★★
4，依据这个规律，找到了可以用于操作文件的流对象。流可以理解系统资源。
5，写入数据到文件的特点。
5.1 必须明确目的地文件，会自动创建，如果文件存在则会覆盖。
5.2 续写只要在构造函数中传递true。换行只要使用系统的行分隔符。
5.2IO异常处理必须使用finally关闭资源，在关闭前做!=null的判断。★★★★
6，读取文件数据的特点：★★★★★
6.1 明确数据源，让读取流和数据源相关联。
6.2 读取有两种方式。
read():一次读取一个字节并返回，没有数据返回-1.
read(byte[])：读取一定数量的数据存储到byte[]中，返回读到字节的个数，没有数据返回-1.
第二种方式高效。字节数组的长度建议为 1024.
7，复制文件：需要中转。建议使用字节数组作为中转，效率高。
【学习结果】
1，查找IO流的方式，并使用共性方法。
2，必须会使用输出流完成文件的续写动作并写入三行数据。
3，两种读取方式的的区别。
4，动手完成对文件数据的读取，并打印，代码要熟悉。
5，必须明确复制文件的原理，并画图复制文件简图。
读取一个文件，通过read()方法
//需求：读取文件中的数据，显示在屏幕上。
File file = new File("tempfile\\file.txt");
//创建一个字节输入流对象,必须明确数据源，其实就是创建字节读取流和数据源相关联。
FileInputStream fis = new FileInputStream(file);
//读取数据。使用 read();一次读一个字节。
int ch = 0;
while((ch=fis.read())!=-1){
System.out.println("ch="+(char)ch);
}
/*
int ch1 = fis.read();
System.out.println("ch1="+(char)ch1);
int ch2 = fis.read();
System.out.println("ch2="+(char)ch2);
int ch3 = fis.read();
System.out.println("ch3="+(char)ch3);
*/
// 关闭资源。
fis.close();读取一个文件，通过read(byte[])方法
/*
* 演示第二个读取方法， read(byte[]);
*/
File file = new File("tempfile\\file.txt");
// 创建一个字节输入流对象,必须明确数据源，其实就是创建字节读取流和数据源相关联。
FileInputStream fis = new FileInputStream(file);
//创建一个字节数组。
byte[] buf = new byte[1024];//长度可以定义成1024的整数倍。
int len = 0;
while((len=fis.read(buf))!=-1){
System.out.println(new String(buf,0,len));
}
/*int len1 = fis.read(buf);
System.out.println(len1+":"+new String(buf,0,len1));
int len2 = fis.read(buf);
System.out.println(len2+":"+new String(buf,0,len2));
int len3 = fis.read(buf);
System.out.println(len3+":"+new String(buf,0,len3));
int len4 = fis.read(buf);
System.out.println(len4);
*/
fis.close();通过自定义缓冲区数组复制文件
File srcFile = new File("E:\\1.mp3");
File destFile = new File("E:\\copy_1.mp3");
// 2,明确字节流 输入流和源相关联，输出流和目的关联。
FileInputStream fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile);
// 3,定义一个缓冲区。
byte[] buf = new byte[1024];
int len = 0;
while ((len = fis.read(buf)) != -1) {
fos.write(buf, 0, len);// 将数组中的指定长度的数据写入到输出流中。
}
// 4,关闭资源。
fos.close();
fis.close();通过读写一个字节方式复制文件
/*
* 练习：复制文件。
* 原理；读取一个已有的数据，并将这些读到的数据写入到另一个文件中。
*/
//1,明确源和目的。
File srcFile = new File("E:\\1.mp3");
File destFile = new File("E:\\copy_2.mp3");
//2,明确字节流 输入流和源相关联，输出流和目的关联。
FileInputStream fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile);
//3, 使用输入流的读取方法读取字节，并将字节写入到目的中。
int ch = 0;
while((ch=fis.read())!=-1){
fos.write(ch);
}
//4,关闭资源。
fos.close();
fis.close();写入数据到一个文件
//需求：将数据写入到文件中。
//创建临时目录，
File dir = new File("tempfile");
if(!dir.exists()){
dir.mkdir();
}
//创建存储数据的文件。
File file = new File(dir,"file.txt");
//创建一个用于操作文件的字节输出流对象。一创建就必须明确数据存储目的地。
//输出流目的是文件，会自动创建。如果文件存在，则覆盖。
FileOutputStream fos = new FileOutputStream(file);
//调用父类中的write方法。
byte[] data = "abcde".getBytes();
fos.write(data);
//关闭流资源。
fos.close();续写和换行
//需求：将数据续写到已有文件中。
//FileOutputStream(File file, boolean append) 续写。
//在下一行写入新的数据。
File file = new File("tempfile\\file.txt");
FileOutputStream fos = new FileOutputStream(file, true);
String str = LINE_SEPARATOR+"itcast";
fos.write(str.getBytes());
fos.close()IO异常的处理
File file = new File("k:\\file.txt");
FileOutputStream fos = null;
try {
fos = new FileOutputStream(file);
fos.write("abcde".getBytes());
} catch (IOException e) {
System.out.println(e.toString() + "----");
} finally {
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
throw new RuntimeException("");
}
}
}了解available()方法
/*
* 字节输入流。
* available();
*/
FileInputStream fis = new FileInputStream("tempfile\\file.txt");
// System.out.println(fis.available());
byte[] buf = new byte[fis.available()];//定义了一个刚刚好的数组。 注意：如果文件过大，容易溢出。
//建议缓冲区的长度最好还是1024的整数倍。
fis.read(buf);
String str = new String(buf);
System.out.println(str);
fis.close();通过字节流缓冲区对象复制文件
//复制文件，通过字节流已有的缓冲区对象。
File srcFile = new File("tempfile\\file.txt");
File destFile = new File("tempfile\\bufcopy_file.txt");
//1,创建好流对象。
FileInputStream fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile);
//2,创建缓冲区对象并和指定的流相关联
BufferedInputStream bufis = new BufferedInputStream(fis);
BufferedOutputStream bufos = new BufferedOutputStream(fos);
byte[] buf = new byte[1024];
// int ch = 0;
int len = 0;
while((len=bufis.read(buf))!=-1){//缓冲区的read方法从缓冲区中读取一个字节。
bufos.write(buf,0,len);//将一个字节写入到缓冲区中。
bufos.flush();//刷新缓冲区，将数据刷到目的地。
}
bufos.close();//缓冲区的关闭方法内部其实调用的是流的关闭方法。
bufis.close();【目标：字节流的缓冲区对象】
1，读写过程通过自定义的数组可以完成高效的读写操作。
2，字节流中已经定义了封装数组的缓冲区对象，专门用于提高读写效率。
3，缓冲区对象的出现，必须先有具体可以操作系统资源的流对象，
因为缓冲区对象是给流对象的读写操作提高效率的。
4，缓冲区的流对象的读写方法其实操作的都是缓冲区数组中的数据，所以高效。
5，使用缓冲区读写时，建议大家要自定义一个数组用于两个缓冲区的数据交换作为中转。
别忘了记得进行flush()。
【学习结果】
1，掌握缓冲区对象的基本使用。
2，理解缓冲区的基本原理。参考图例。字节流缓冲区对象复制图解.JPG
3，通过缓冲区对象复制媒体文件。
输入输出操作：
1,File对象了解（操作文件的属性等信息，它可以操作文件中的数据吗？） –操作文件中的数据–>对数据进行输入输出操作(往文件中写入数据)。1，需求：往文件中写入数据。
通过api查找output。找到很多，其中java.io.OutputStream
OutputStream: 输出字节流的超类,1,操作的数据都是字节，2，定义了输出字节流的基本共性功能。3，输出流中定义都是写write方法。
操作字节数组write(byte[])，操作单个字节write(byte)。
子类有规律：所有的子类名称后缀是父类名，前缀名是这个流对象功能。
想要操作文件： FileOutputStream2,需求：读取文件中的数据，显示在屏幕上。
通过api查找input。java.io.InputStream
InputStream：字节输入流的超类。
常见功能：
1，int read():读取一个字节并返回，没有字节返回-1.
2，int read(byte[]): 读取一定量的字节数，并存储到字节数组中，返回读取到的字节数。3，已经完成了基本的读写操作，使用了数组后，提高了效率。
io中的字节流中也有提高效率的对象，无非就是把数组进行封装了。
通过父类的另请参见：BufferedInputStream BufferedOutputStream
字节流的缓冲区的出现提高了流的读写效率。
缓冲区对象中封装了数组。为了提高流的操作效率，所以缓冲区 的建立必须要明确具体的流对象。
缓冲区借助了流对象读方法获取数据，并存储到缓冲区对象的数组中。
缓冲区的read方法，是从缓冲区的数组中在读取数据。
将读取的数据通过中转（变量或数组）转到写入到缓冲区数组中，写入缓冲区在通过流将数据写入目的地。
2783
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
