import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/*
File类：用于描述一个文件或者文件夹
通过File对象我们可以读取文件或者文件夹的属性数据，如果我们需要读取文件的内容数据，那么我们需要使用IO流技术。
IO流(Input Output)
IO流解决的问题：解决设备与设备之间的数据传输问题。 内存---->硬盘 硬盘----》内存
IO流技术
IO流分类：
如果是按照数据的流向划分： （判断使用输入流还是输出流的依据：以当前程序作为参照物，观察数据是流入还是流出，如果流出则使用输出流，如果数据是流入，则使用输入流）
输入流
输出流
如果按照处理的单位划分：
字节流：字节流读取得都是文件中二进制数据，读取到二进制数据不会经过任何处理。
字符流：字符流读取的数据是以字符为单位。字符流也是读取文件中的二进制数据，不过会把这些二进制数据转换成我们能识别的字符。
1111000100----->字符
字符流 = 字节流 + 解码
输入字节流：
-------|InputStream 所有输入字节流的基类 抽象类
----------|FileInputStream 读取文件数据的输入字节流
使用FileInputStream 读取文件数据的步骤：
1.找到目标文件
2.建立数据输入的通道
3.读取文件中的数据
4.关闭资源，实际上就是释放资源。
*/
public class Demo1 {
public static void main(String[] args) throws IOException {
readTest1();
readTest2();
readTest3();
readTest4();
}
//方式四：使用缓冲数组配合循环一起读取数据
public static void readTest4() throws IOException{
long startTime = System.currentTimeMillis();
//找到目标文件
File file = new File("F:\\a.txt");
//建立数据的输入通道
FileInputStream fileInputStream = new FileInputStream(file);
//建立缓冲数组配合循环读取文件数据
int length = 0;//保存 每次读取到的字节数。
byte[] buf = new byte[256];//存储读取到的数据 缓冲数组 的长度一般是1024的倍数，因为与计算机的处理单位。 理论上缓冲数组越大，效率越高
while((length = fileInputStream.read(buf))!=-1){//read方法如果读取到了文件的末尾，那么会返回-1表示。
System.out.println(new String(buf,0,length));
}
//关闭资源
fileInputStream.close();
long endTime = System.currentTimeMillis();
System.out.println("读取的时间4是："+ (endTime-startTime));
}
//方式三：使用缓冲数组读取.缺点：无法读取到完整一个文件的数据
public static void readTest3() throws IOException{
//找到目标文件
File file = new File("F:\\a.txt");
//建立数据的输入通道
FileInputStream fileInputStream = new FileInputStream(file);
//建立缓冲字节数组，读取文件的数据。
byte[] buf = new byte[1024];//相当于超市里面的购物车。
int length = fileInputStream.read(buf);//如果使用read读取数据传入字节数组，那么数据是存储到字节数组中的，而这时候read方法的返回值是表示的是本次读取了几个字节数据到字节数组中。
System.out.println("length："+length);
//使用字节数组构建字符串
String content = new String(buf,0,length);
System.out.println("内容是："+content);
//关闭资源
fileInputStream.close();
}
//方式二：使用循环读取文件的数据
public static void readTest2() throws IOException {
long startTime = System.currentTimeMillis();
//找到目标文件
File file = new File("F:\\a.txt");
//建立数据的输入通道
FileInputStream fileInputStream = new FileInputStream(file);
//读取文件中的数据
int content = 0;//声明该变量用于存储读取到的数据
while((content = fileInputStream.read())!=-1){
System.out.println((char)content);
}
//关闭资源
fileInputStream.close();
long endTime = System.currentTimeMillis();
System.out.println("读取的时间是："+ (endTime-startTime));
}
//读取方式一：无法读取完整一个文件的数据
public static void readTest1() throws IOException{
//1.找到目标文件
File file = new File("F:\\a.txt");
//建立数据输入的通道
FileInputStream fileInputStream = new FileInputStream(file);
//读取文件中的数据
int content = fileInputStream.read();//read() 读取一个字节的数据，把读取的数据返回。
System.out.println("读取到的内容："+(char)content);
//关闭资源，实际上就是释放资源。
fileInputStream.close();
}
}
package cn.itcast.input;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;
/*
问题1：读取玩一个文件数据的时候，我不关闭资源有什么影响？
答案：资源文件一旦使用完毕
*/
public class Demo2 {
public static void main(String[] args) throws IOException {
//找到目标文件
File file = new File("F:\\a.txt");
//建立数据的输入通道
FileInputStream fileInputStream = new FileInputStream(file);
//建立缓冲字节数组读取文件
byte[] buf = new byte[8];
int length = 0;
while ((length = fileInputStream.read(buf))!=-1){
System.out.println(new String(buf,0,length));//
//System.out.println(Arrays.toString(buf));
}
//释放文件资源
fileInputStream.close();
}
}
package cn.itcast.output;
/*
--------|OutputStream 是所有输出字节流的父类。抽象类
------------|FileOutputStream 向文件输出数据的输出字节流
FileOutputStream如何使用：
1.找到目标文件
2.建立数据的输出通道。
3.把数据转换成字节数组写出。
4.关闭资源
FileOutputStream要注意的细节：
1.使用FileOutputStream的时候，如果目标文件不存在，那么会自动创建目标文件对象。
2.使用FileOutputStream写数据的时候，如果目标文件已经存在，那么会先清空目标文件中的数据，然后再写入数据。
3.使用FileOutputStream写数据的时候，如果目标文件已经存在，需要在原数据基础上追加数据的时候应该使用new FileOutputStream(file,true)构造函数
4使用FileOutputStream的write方法写数据的时候，虽然接收的是一个int类型的数据，但是真正写出的只是一个字节的数据。只是把低八位的二进制数据写出，其他二十四位数据全部丢失。
00000000-00000000-00000000-00000001-11111111
*/
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo1 {
public static void main(String[] args) throws IOException {
writeTest1();
writeTest2();
writeTest3();
}
//使用字节数组把数据写出
public static void writeTest3() throws IOException{
//找到目标文件
File file = new File("F:\\b.txt");
//建立数据的输出通道
FileOutputStream fileOutputStream = new FileOutputStream(file,true);
//把数据写出
String data= "abc";
byte[] buf = data.getBytes();
fileOutputStream.write(buf,0,2);//0：从字节数组的指定索引值开始写， 2：写出两个字节
//关闭资源
fileOutputStream.close();
}
//使用字节数组把数据写出
public static void writeTest2() throws IOException{
//找到目标文件
File file = new File("F:\\b.txt");
//建立数据的输出通道
FileOutputStream fileOutputStream = new FileOutputStream(file,true);
//把数据写出
String data= "\r\n hello world";
fileOutputStream.write(data.getBytes());
//关闭资源
fileOutputStream.close();
}
//每次只能写一个字节的数据出去
public static void writeTest1() throws IOException{
//找到目标文件
File file = new File("F:\\b.txt");
//建立数据的输出通道
FileOutputStream fileOutputStream = new FileOutputStream(file);
//把数据写出
fileOutputStream.write('h');
fileOutputStream.write('e');
fileOutputStream.write('l');
fileOutputStream.write('l');
fileOutputStream.write('o');
//关闭资源
fileOutputStream.close();
}
}
/*4使用FileOutputStream的write方法写数据的时候，虽然接收的是一个int类型的数据，但是真正写出的只是一个字节的数据。只是把低八位的二进制数据写出，其他二十四位数据全部丢失。
00000000-00000000-00000000-00000001-11111111
*/
package cn.itcast.output;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
public class Demo2 {
public static void main(String[] args) throws IOException {
writeTest();
readTest();
}
public static void readTest() throws IOException {
//找到目标文件
File file = new File("F:\\c.txt");
//建立数据的输出通道
FileInputStream fileInputStream = new FileInputStream(file);
//建立缓冲输入读取文件数据
byte[] buf = new byte[4];
//读取文件数据
int length = fileInputStream.read(buf);
System.out.println("字节数组的内容："+Arrays.toString(buf));
//关闭资源
fileInputStream.close();
}
public static void writeTest() throws IOException {
//找到目标文件
File file = new File("F:\\c.txt");
//建立数据的输出通道
FileOutputStream fileOutputStream = new FileOutputStream(file);
//把数据写出
fileOutputStream.write(511);
//关闭资源
fileOutputStream.close();
}
}
package cn.itcast.output;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
需求：拷贝一张图片
*/
public class CopyImage {
public static void main(String[] args) throws IOException {
// 找到目标文件
File inFile = new File("F:\\1.jpg");
File destFile = new File("E:\\1.jpg");
//建立数据的输入输出通道
FileInputStream fileInputStream = new FileInputStream(inFile);
//每次创建一个FileOutputStream的时候，默认情况下FileOutputStream的指针是指向了文件的开始位置。每写出一次，指向都会出现相应移动
FileOutputStream fileOutputStream = new FileOutputStream(destFile);
//建立缓冲数据边读边写
byte[] buf = new byte[1024];
int length = 0;
while((length = fileInputStream.read(buf))!=-1){//最后一次只剩下了824个字节
fileOutputStream.write(buf, 0, length);
}
//关闭资源原则：先开后关，后开先关。
fileOutputStream.close();
fileInputStream.close();
}
}
package cn.itcast.buffered;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
我们清楚读取文件数据使用缓冲数组读取效率更高，sun也知道使用缓冲数组读取效率更高，那么
这时候sun给我们提供了一个-----缓冲输入字节流对象，让我们可以更高效率的读取文件。
输入字节流体系：
-----|InputStream 输入字节流的基类。抽象
---------|FileInputStream 读取文件数据的输入字节流
---------|BufferedInputStream缓冲输入字节流，缓冲字节流的出现
其实该类内部只不过是维护了一个8kb的字节数组而已。
注意： 凡是缓冲流都不具备读写文件的能力。
使用BufferedInputStream的步骤 :
1. 找到目标文件。
2. 建立数据 的输入通道
3. 建立缓冲 输入字节流流
4. 关闭资源
*/
public class Demo1 {
public static void main(String[] args) throws IOException {
readTest2();
}
public static void readTest2() throws IOException{
//找到目标文件
File file = new File("F:\\a.txt");
//建立数据的输入通道
FileInputStream fileInputStream= new FileInputStream(file);
//建立缓冲输入字节流
//疑问一：为甚么创建BufferedInputStream的时候都需要传递FileInputStream?BufferedInputStream本身不具备读文件的能力，所以需要借助FileInputStream来读写文件的数据
BufferedInputStream bufferedInputStream= new BufferedInputStream(fileInputStream);
//读取文件数据
bufferedInputStream.read();
FileOutputStream fileOutputStream= new FileOutputStream(file);
BufferedOutputStream bufferedOutputStream= new BufferedOutputStream(fileOutputStream);
fileOutputStream.write(null);
//读取文件数据
int content = 0 ;
//疑问二：BufferedInputStream出现 的目的是了提高读取文件的效率，但是BufferedInputStream的read方法每次读取一个字节的数据
//而FileInputStreram每次也是读取一个字节的数据，那么BufferedInputStream效率高从何而来？
while((content = fileInputStream.read())!=-1){
System.out.print((char)content);
}
//关闭资源
bufferedInputStream.close();//调用BufferedInputStream的close方法实际上关闭的是FileinputStream.
}
//读取文件的时候我们都是使用缓冲数组读取。效率会更加高
public static void readTest() throws IOException{
File file = new File("F:\\a.txt");
//建立数组通道
FileInputStream fileInputStream = new FileInputStream(file);
//建立缓冲数组读取数据
byte[] buf = new byte[1024*8];
int length = 0;
while((length = fileInputStream.read(buf))!=-1){
System.out.print(new String(buf,0,length));
}
//关闭资源
fileInputStream.close();
}
}
package cn.itcast.buffered;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
输入字节流体系：
-----|OutputStream 所有输出字节流的基类。抽象
---------|FileOutputStream 读取文件数据的输出字节流
---------|BufferedOutputStream 缓冲输出字节流，BufferedOutputStream出现的目的是为了提高内部也是维护一个8kb的字节数组而已
使用BufferedOutputStream的步骤：
1.找到目标文件
2.建立数据的输出通道
3。建立缓存输出字节流对象
4. 把数据写出
BufferedOutputStream 要注意的细节
1. 使用BufferedOutStream写数据的时候，它的write方法是是先把数据写到它内部维护的字节数组中。
2. 使用BufferedOutStream写数据的时候，它的write方法是是先把数据写到它内部维护的字节数组中，如果需要把数据真正的写到硬盘上面，需要
调用flush方法或者是close方法、 或者是内部维护的字节数组已经填满数据的时候。
练习：使用缓冲输入输出字节流拷贝一个图片
*/
public class Demo2 {
public static void main(String[] args) throws IOException {
// 找到目标文件
File file = new File("F:\\a.txt");
//建立数据的输出通道
FileOutputStream fileOutputStream = new FileOutputStream(file);
//建立缓存输出字节流对象
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
//把数据写出
bufferedOutputStream.write("hello".getBytes());
//把缓存数组中内部的数据写到硬盘上
//bufferedOutputStream.flush();
bufferedOutputStream.close();
}
}
package cn.itcast.buffered;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
练习：使用缓冲输入输出字节流拷贝一个图片
*/
public class copyImage {
public static void main(String[] args) throws IOException {
// 找到目标文件
File inFile = new File("F:\\1.jpg");
File outFile = new File("E:\\1.jpg");
//建立数据输入输出通道
FileInputStream fileInputStream = new FileInputStream(inFile);
FileOutputStream fileOutputStream = new FileOutputStream(outFile);
//建立缓冲输入输出流
BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
//边读变写
int content = 0;
//int length = bufferedInputStream.read(buf);/如果传入了缓冲数组，内容是存储到缓冲数组中，返回值是存储到缓冲数组中的字节个数。
while((content = bufferedInputStream.read())!=-1){//如果使用read方法没有传入缓冲数组，那么返回值是读取到的内容。
bufferedOutputStream.write(content);
bufferedOutputStream.flush();
}
//关闭资源
bufferedOutputStream.close();
bufferedOutputStream.close();
}
}