------------恢复内容开始------------
IO流概述
java中用于传输数据的工具。
IO流能干什么：在本地磁盘和网络上操作数据。
IO流的分类：
（1）按数据流向分： ①输入流②输出流
（2）按操作方式分： ①字节流 以字节的形式操作数据
InputStream:字节输入流，以字节的形式读取数据。字节输入流的顶层抽象类
OutputStream：字节输出流，以字节的形式写出数据
②字符流 以字符的形式操作数据
Reader ：字符输入流
Writer：字符输出流
这四个类都是抽象类，在使用时要使用它们的子类
IO流体系：字符流：按字符读写数据的IO流：Reader：FileReader 普通字符输入流
BufferedReader 高效字符输入流
Writer：FileWriter 普通字符输出流
BufferedReader 高效字符输出流
字节流：InputStream：FileInputStream
BufferedInputStream
OutputStream：FileOutputStream
BufferedOutputStream
File类
一个File对象代表磁盘上的某个文件或文件夹
构造方法 ：
File(String pathname):根据字符串形式的路径来创建其对应的File对象
File(String parent,String child):根据传入的父目录和子目录创建一个File对象
File(File parent,String child):先将父目录封装成File对象，结合字符串形式的子目录来获取新的File对象
成员方法：
createNewFile():创建文件
mkdir()和mkdirs():创建目录
isDirectory():判断File对象是否为目录，是否为文件夹
isFile():判断File对象是否为文件
exists():判断File对象是否存在
package com.wang.file;
import com.sun.xml.internal.messaging.saaj.soap.impl.FaultElementImpl;
import java.beans.FeatureDescriptor;
import java.io.File;
import java.io.IOException;
public class Demo01 {
public static void main(String[] args) throws IOException {
//将d盘下的文件夹abc中的1.txt封装成file对象
File file=new File("D:/abc/1.txt");
System.out.println("file:"+file);
File file1=new File("D:/abc","1.txt");
System.out.println("file1:"+file1);
File file2=new File("D:/abc");
File file3=new File(file2,"1.txt");
System.out.println("file3:"+file3);
System.out.println("=========================================");
System.out.println("创建功能");
//在D盘下创建2.txt文件
File file4=new File("D:/2.txt");
boolean bl=file4.createNewFile();//抛出异常
System.out.println(bl);
//在D盘下创建a文件夹
File file5=new File("D:/a");
boolean bl1=file5.mkdir();//make directory
System.out.println(bl1);
//在D盘下创建a/b/c文件夹
File file6=new File("D:/a/b/c");
boolean bl2=file6.mkdirs();
System.out.println(bl2);
System.out.println("==================================");
System.out.println("测试判断功能");
File file7=new File("D:/a/b");
System.out.println("测试file7是否是文件夹");
System.out.println(file7.isDirectory());
System.out.println("测试file1是否是文件");
System.out.println(file1.isFile());
System.out.println("测试file7是否存在");
System.out.println(file7.exists());
}
}
成员方法：
getAbsolutePath():获取绝对路径 绝对路径就是以盘符开头的路径 eg：D：/1.txt
getPath():获取文件的相对路径 相对路径一般是相对于当前项目路径来讲的 eg：1.txt
getName():获取文件名
list():获取指定目录下所有文件（夹）名称数组
listFiles():获取指定 目录下所有文件（夹）File数组
package com.wang.file;
import java.io.File;
public class Demo02 {
public static void main(String[] args) {
//1.txt 只写一个文件名是相对于当前项目来讲的，在当前项目中创建文件夹
File file=new File("lib/1.txt");
//获取file的绝对路径
System.out.println(file.getAbsolutePath());
//获取file的相对路径
System.out.println(file.getPath());
//获取文件名
System.out.println(file.getName());
System.out.println("===========================");
//获取lib文件夹下所有的文件的名称数组String[]
File file1=new File("lib");
String[] names=file1.list();
for (String name:names) {
System.out.println(name);
}
System.out.println("==========================");
//获取lib文件夹下所有File对象数组 File[]
File[] files=file1.listFiles();
for (File file2:files) {
System.out.println(file2);
System.out.println(file2.exists());
}
}
}
（1）字符流读数据-按单个字符读取
创建字符流读文件对象：Reader reader=new FileReader("readme.txt");
调用方法读取数据：int data=reader.read();
读取一个字符，返回该字符代表的整数，若到达流的末尾，没有数据可读时，返回-1
异常处理：throws IOException
关闭资源：reader.close();
package com.wang.charliu;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class Demo01 {
public static void main(String[] args) throws IOException {
//通过字符流读取数据
//1、创建字符流输入对象
Reader reader=new FileReader("lib/1.txt");
//2、读取数据
//不知道循环次数，所以用while循环
int ch;
while ((ch=reader.read())!=-1){
System.out.println(ch);
}
reader.close();
}
}
（2）字符流读数据-按字符数组读取
创建字符流读文件对象：Reader reader=new FileReader("readme.txt(数据源文件的路径)");
调用方法读取数据：char[] chs=new char[2048];
int len=r.read(chs); 读取字符到数组中，返回读取的字符数，若到达流的末尾，返回-1
异常处理：throws IOException
关闭资源：reader.close();
package com.wang.charliu;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class Demo02{
public static void main(String[] args) throws IOException {
//通过字符流读取数据，一次读取一个字符数组
Reader reader=new FileReader("lib/1.txt");
/* char[] chars=new char[3];//一次性从文件中读取3个字符
int len=reader.read(chars);//返回读取到的有效字符数
System.out.println(chars);//字符串的底层是字符数组，打印时自动拼接成字符串
System.out.println(len);
int len1=reader.read(chars);
System.out.println(chars);
System.out.println(len1);
int len2=reader.read(chars);
System.out.println(chars);
System.out.println(len2);
*/
//优化上述代码
char[] chars=new char[3];
int len;
while ((len=reader.read(chars))!=-1){
//将读取到的内容，转换成字符串，然后打印
String s=new String(chars,0,len);//chars表示要操作的数组，0表示起始索引，
//len表示要操作的字符的个数
System.out.println(s);
}
reader.close();
}
}
（3）字符流写数据-按单个字符写入
调用方法写入数据：写入单个字符要先创建一个字符，字符的底层是整数 int x='中';
writer.writer(x);
异常处理：throws IOException
关闭资源：writer.close();
（4）字符流写数据-按字符数组写入
创建字符流写文件对象：Writer writer=new FileWriter("dest.txt");
调用方法写入数据：char[] char=new char[];
writer.writer(char);
异常处理：throws IOException
关闭资源：writer.close();
（5）字符流写数据-按字符串写入
创建字符流写文件对象：Writer writer=new FileWriter("dest.txt");
调用方法写入数据: writer.writer("XXX");
异常处理：throws IOException
关闭资源：writer.close();
package com.wang.charliu;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class Demo03 {
public static void main(String[] args) throws IOException {
Writer writer=new FileWriter("lib/2.txt");
writer.write('中');
char[] chars={'黑','马','程','序','员'};
writer.write(chars,2,3);
writer.write("ddeiecowjosoias");
writer.close();
}
}
（6）字符流拷贝文件-按单个字符读写
创建字符流读文件对象：Reader reader=new FileReader("XXX");
创建字符流写文件对象：Writer writer=new FileWriter("XXX");
调用方法读取数据：int data=reader.reader();
调用方法写入数据：writer.writer(data);
异常处理：throws IOException
关闭资源：reader.close(); writer.close();
package com.wang.charliu;
import java.io.*;
/*
IO流拷贝文件核心6步
1.创建字符输入流对象，关联数据源文件（要读谁）
2.创建字符输出流对象，关联目的地文件（要把数据写到哪里）,如果目的地文件不存在，程序会自动创建
3.定义变量，记录读取到的内容
4.循环读取，只要条件满足就一直读取，并将读取到的内容赋值给变量
5.将读取到的数据写入到目的地文件中
6.释放资源
*/
public class Demo04 {
public static void main(String[] args) throws IOException {
//将1.txt文件中的内容复制到2.txt文件中
Reader reader=new FileReader("lib/1.txt");
Writer writer=new FileWriter("lib/4.txt");
int ch;
while ((ch=reader.read())!=-1){
writer.write(ch);
}
reader.close();
writer.close();
}
}
（7）字符流拷贝文件-按字符数组读写
创建字符流写文件对象：Writer writer=new FileWriter("XXX");
调用方法读取数据：char[] chars=new char[x]; int len=reader.reader(chars);
调用方法写入数据：writer.writer(chars,0,len);
异常处理：throws IOException
关闭资源：reader.close(); writer.close();`
package com.wang.charliu;
import java.io.*;
public class Demo05 {
public static void main(String[] args) throws IOException {
Reader reader=new FileReader("lib/1.txt");
Writer writer=new FileWriter("lib/a/3.txt");
char[] chars=new char[2];
int len;
while ((len=reader.read(chars))!=-1){
writer.write(chars,0,len);
}
reader.close();
writer.close();
}
}
（8）字符缓冲流拷贝文件的标准代码
创建字符流读文件对象：BufferedReader br=new BufferedReader(new FileReader("readme.txt"));
BufferedReader类的构造方法，这样就可以创建一个字符缓冲输入流对象
创建字符流写文件对象：BufferedWriter bw=new BufferedWriter(new FileWriter("dest.txt"));
异常处理：throws IOException
使用while循环读写数据：int len
while((len=br.reader())!=-1){ bw.writer(len); }
关闭资源：br.close(); bw.close();
字符缓冲流自带缓冲区，大小为8192个字符，也就是16KB
package com.wang.charliu;
import java.io.*;
public class Demo06 {
public static void main(String[] args) throws IOException {
BufferedReader br=new BufferedReader(new FileReader("lib/1.txt"));
BufferedWriter bw=new BufferedWriter(new FileWriter("lib/2.txt"));
int len;
while((len=br.read())!=-1){//底层按字符数组进行读取
bw.write(len);
}
br.close();
bw.close();
}
}
（9）字符缓冲流用法
成员方法：public String readLine();一次读取一行数据并返回读取到的内容，读不到返回null
BufferedWriter：字符缓冲输出流
成员方法：public void newLine(); 根据当前操作系统给出对应的换行符
package com.wang.charliu;
import java.io.*;
public class Demo07 {
public static void main(String[] args) throws IOException {
BufferedReader br=new BufferedReader(new FileReader("lib/1.txt"));
BufferedWriter bw=new BufferedWriter(new FileWriter("lib/2.txt"));
String s;
while ((s=br.readLine())!=null){
bw.write(s);
bw.newLine();
}
br.close();
bw.close();
}
}
字符流只能拷贝纯文本文件
字节流读写文件
（1）字节流拷贝文件-按单个字节读写
创建字节流读文件对象：InputStream is=new FileInputStream("Desktop.jpg");
创建字节流写文件对象：OutputStream os=new FileOutputStream("D:xxx.jpg");
异常处理：throws IOException
使用while循环读写数据：int b;
while((b=is.read())!=-1){ os.write(b); }
关闭资源：is.close(); os.close();
package com.wang.byteliu;
import java.io.*;
public class Demo01 {
public static void main(String[] args) throws IOException{
//通过普通的字节流，一次读写一个字节的方式，将a.jpg复制到b.jpg
FileInputStream fis=new FileInputStream("lib/a.jpg");
FileOutputStream fos=new FileOutputStream("lib/b.jpg");
int i;
while ((i=fis.read())!=-1){
fos.write(i);
}
fis.close();
fos.close();
}
}
字节流的用法： FileInputStream:普通的字节输入流，用来读取数据的
构造方法：public FileInputStream(String pathname);
成员方法：public int read();一次读取一个字节，并返回读取到的内容，读不到返回-1
FileOutputStream:普通的字节输出流，用来写数据
构造方法：public FileOutputStream(String pathname);
成员方法 ：public void writer(int len);一次写入一个字符
（2）字节流拷贝文件-按字节数组读写
创建字节流读文件对象：InputStream is=new FileInputStream("Desktop.jpg");
创建字节流写文件对象：OutputStream os=new FileOutputStream("D:xxx.jpg");
异常处理：throws IOException
定义字节数组，每次读取2048个字节：byte[] b=new byte[2048];
使用while循环读写数据：int len;
while((b=is.read())!=-1){ os.write(b,0,len); }
关闭资源：is.close(); os.close();
package com.wang.byteliu;
import java.io.*;
public class Demo02 {
public static void main(String[] args) throws IOException {
InputStream is=new FileInputStream("lib/a.jpg");
OutputStream os=new FileOutputStream("lib/c.jpg");
byte[] b=new byte[1024];//最好写1024的整数倍
int len;
while((len=is.read(b))!=-1){
os.write(b,0,len);
}
is.close();
os.close();
}
}
（3）字节缓冲流拷贝文件的标准代码
创建字节缓冲流读文件对象：BufferedInputStream bis=new BuffferedInputStream(new FileInputStream("a.jpg"));
创建字节缓冲流写文件对象：BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("b.jpg"));
异常处理：throws IOException
使用while循环读写数据：int len;
while((len=bis.read())!=-1){ bos.write(len); }
关闭资源：bis.close();
bos.close();
package com.wang.byteliu;
import java.io.*;
public class Demo03 {
public static void main(String[] args) throws IOException {
BufferedInputStream bis=new BufferedInputStream(new FileInputStream("lib/a.jpg"));
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("lib/d.jpg"));
int len;
while((len=bis.read())!=-1){
bos.write(len);
}
bis.close();
bos.close();
}
}
拷贝文本文件用字符流，拷贝其他（图片、音频、视频）使用字节流
------------恢复内容结束------------