Java17：IO流
一：File类：
1.File类的理解：
1.File类的一个对象，代表一个文件或一个文件目录（俗称：文件夹）
2.File类声明在java.io包下
3.File类中涉及到关于文件或文件目录的创建,删除，重命名，修改时间，大小等方法
并涉及到写入或读取文件 内容的操作。如果需要读取或写入文件内容，必须使用IO流来完成
4.后续File类的对象常会作为参数传递到流的构造器中，指明读取或写入的“终点”。
2.File类的实例化
2.1 常用构造器
File(String filePath)
File(String parentPath,String childPath)
File（File parentFile, String chilPath）
2.2 路径的分类
相对路径：相较于某个路径下的，指明的路径
绝对路径： 包含盘符在内的文件或文件目录的路径
说明：如果大家开发中使用JUnit中的单元测试方法测试，相对路径即为当前Module下。
如果大家使用main（）测试，相对路径为当前project 下
2.3 路径分隔符
windows：\\
unix:/
public void test1(){
//构造器1：相对路径
File file = new File("hello.txt");
System.out.println(file);
//构造器1：绝对路径
File file1 =new File("D:\\java\\TestDemo1\\h1.txt");
System.out.println(file1);
//构造器2
File file2 =new File("D:\\java\\TestDemo1","filetest");
System.out.println(file2);
//构造器3
File file3 =new File(file2,"h3.txt");
System.out.println(file3);
}
3.File类的常用方法
file类的获取功能
public String getAbsolutePath():获取绝对路径
public String getPath()：获取路径
public String getName()：获取名称
public String getParent():获取上层文件目录的路径。若无返回null
public long length()：获取文件长度（即：字节数）。不能获取目录的长度
public long lastModifiled（）：获取最后一次的修改时间，毫秒值
public String [] list(): 获取指定目录下所有文件或者文件目录的名称数组
public File() listFiles():获取指定目录下的所有文件或文件目录的File数组
file类的重命名功能
public boolean renameTo(File dest): 把文件重命名为指定的文件路径
file类的判断功能
public boolean isDirectory(): 判断是否是文件目录
public boolean isFile(): 判断是否是文件
public boolean exists():判断是否存在
public boolean canRead(): 判断是否可读
public boolean canWrite(): 判断是否可写
public boolean isHidden(): 判断是否可读
file类的创建功能
public boolean createNewFile(): 创建文件。若文件存在，则不创建，返回flase
public boolean mkdir()：创建文件目录。如果此文件目录存在，就不创建了。如果
此文件目录的上次目录不存在，也不创建
public boolean mkdirs()：创建文件目录。如果此文件目录的上次目录不存在，一并创建
注意事项： 如果你创建文件或文件目录没有写盘符路径，那么默认在项目路径下
file类的删除功能
public boolean delete():删除文件或者文件夹：
注意事项：
java 中删除不走回收站。 要删除一个文件目录，请注意该文件目录内不能包含文件或文件目录
代码示例：
@Test
public void test5(){
File file2 =new File("D:\\java\\TestDemo1\\IOtest","filetest");
if(!file2.exists()){
file2.mkdirs();
System.out.println("创建成功！");
}else{
file2.delete();
System.out.println("删除成功！");
}
}
@Test
public void test6() {
//判断指定目录是否由以.jpg 结尾的文件，如果有输出文件名称
File file = new File("D:\\java");
String[] list= file.list();
for(String str: list){
if(str.endsWith(".jpg")){
System.out.println("以jpg结尾的文件是:"+str);
}
}
}
二：IO流概述：
1.流的概述
》操作数据单位：字节流，字符流
》数据的流向：输入流，输出流
》流的角色;j节点流，处理流
2.流的体系结构
3. 重点说明的几个流结构
抽象基类 节点流（或文件流） 缓冲流（处理流的一种）
InputStream FileInputStream (read(byte[] buffer)） BufferedInputStream (read(byte[]buffer)）
OutputStream FileOutputStream(write(byte[] buffer,0,len)) BufferedOutputStream(write(byte[] buffer,0,len))
Reader FileReader(read(char[] cbuf)) BufferedReader(read(char[] cbuf) /readline（）
Writer FileWriter(write(char[] cbuf,0,len)) BufferedWriter(write(char[] cbuf,0,len))
4.输入，输出的标准过程
4.1输入过程
①创建FIle的对象，指明读取的数据来源。（要求文件一定存在）
②创建相应的输入流，将File类的对象作为参数，传入流的构造器中
③具体的读入过程
创建相应的byte[]或char[]
④关闭流资源
说明：程序中出现的异常需要使用try-catch-finally处理
4.2输出过程
①创建FIle的对象，指明写出的数据来源。（不要求文件一定存在）
②创建相应的输出流，将File类的对象作为参数，传入流的构造器中
③具体的写出过程
write(char[]/byte[],0,len)
④关闭流资源
说明：程序中出现的异常需要使用try-catch-finally处理
三：节点流：
1.FileReader/FileWriter的使用
1.1 FileReader的使用
说明点：
1.read()的理解：返回读入的一个字符。如果达到文件末尾，返回-1；
2.异常的处理：为了保证流资源一定可以执行关闭操作，需要使用try-catch-finally处理
3.读入的文件一定要存在，否则就会报FileNotFoundException
@Test
public void test1() {
//创建文件
File file = null;
FileReader fr = null;
try {
file = new File("hello.txt");
/* 创建字符输入流 */
fr = new FileReader(file);
int data;
//每次读取一个字符并返回，当读到末尾，返回-1
while ((data = fr.read()) != -1) {
System.out.print((char) data);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
//关闭字符流
catch (IOException e) {
e.printStackTrace();
} finally {
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
@Test
public void test2() throws IOException {
//创建文件
File file = new File("hello.txt");
//创建输入流
FileReader fr = new FileReader(file);
char[] cbuff = new char[5];
int len;
//读入文件,返回读取个数，读取完成返回-1
while ((len = fr.read(cbuff)) != -1) {
String str = new String(cbuff, 0, len);
System.out.print(str);
}
fr.close();
}
1.2 FileWriter的使用
说明点：
1.输出操作，对应的File可以不存在的。并不会报异常
2.
File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件
File对应的硬盘中的文件如果存在，
如果流使用的构造器是：FileWriter（file，false）：对原文件的覆盖
如果流使用的构造器是：FileWriter（file，true）: 不会对原文件覆盖，而是在 原文件基础上，追加内容
@Test
public void test3() {
FileWriter fw = null;
try {
//创建文件
File file = new File("hello1.txt");
//创建输出流
fw = new FileWriter(file);
//写出内容
fw.write("hello");
fw.write("world");
fw.write("123");
} catch (IOException e) {
e.printStackTrace();
} finally {
//关闭流
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
1.3 文本文件的复制：
@Test
public void test4() {
//创建文件
FileReader fr = null;
FileWriter fw = null;
try {
File file = new File("hello.txt");
File file2 = new File("hello2.txt");
//创建输入，输出流
fr = new FileReader(file);
fw = new FileWriter(file2);
//拷贝文件
char[] cbuff = new char[5];
int len;
while ((len = fr.read(cbuff)) != -1) {
fw.write(new String(cbuff, 0, len));
}
} catch (IOException e) {
e.printStackTrace();
} finally {
}
//关闭流
try {
if( fw!=null)
{ fw.close();}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if( fr!=null)
{ fr.close();}
} catch (IOException e) {
e.printStackTrace();
}
}
}InputStream
2.FileInputStream/FileOutputStream的使用
1.对文本文件（.txt,.java , .c, .cpp）使用字符流处理
2.对于非文本文件（.jpg, .mp3,.mp4,.avi, .doc,.ppt....）使用字节流处理
@Test
public void test5() {
/*
字节流实现图片复制
*/
FileInputStream fis = null;
FileOutputStream fos = null;
try {
//创建文件
File file = new File("cat.jpg");
File file2 = new File("cat2.jpg");
//创建字节流
fis = new FileInputStream(file);
fos = new FileOutputStream(file2);
//读写文件
int len;
byte[] bytes = new byte[10];
while ((len = fis.read(bytes)) != -1) {
fos.write(bytes, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
}
//关闭流
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fos != null)
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
//封装复制方法
public void InputOutputCopyFile(String srcpath, String destpath) throws IOException {
//创建文件
File file = new File(srcpath);
File file2 = new File(destpath);
//创建字节流
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(file2);
//读写文件
int len;
byte[] bytes = new byte[1024];
while ((len = fis.read(bytes)) != -1) {
fos.write(bytes, 0, len);
}
}
相对路径在idea和eclipse的区别：
idea：
如果使用单元测试方法，相对路径基于当前的Module
如果使用main()测试，相对路径基于当前project
eclispe：
单元测试方法还是main()测试，相对路径基于当前project
四：处理流：
4.1 缓冲流
4.1.1 缓冲流涉及到的类：
BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter
4.1.2作用：
4.1.3典型代码：
》使用BufferedInputStream 和BufferedOutputStream
@Test
public void test7() {
/*
缓冲流实现图片复制
*/
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
//创建文件
File file = new File("cat.jpg");
File file2 = new File("cat2.jpg");
//创建字节流
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(file2);
//创建处理流
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(fos);
//读写文件
int len;
byte[] bytes = new byte[10];
while ((len = bis.read(bytes)) != -1) {
bos.write(bytes, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
}
//关闭流
if (bis != null) {
try {
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (bos != null)
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
》使用BufferedReader 和BufferedWriter
@Test
public void test8() throws IOException {
/*
缓冲字符流实现文本复制
*/
//创建文件对象
File file = new File("hello.txt");
File file2 = new File("hellocp.txt");
//创建字符流对象
FileReader fr = new FileReader(file);
FileWriter fw = new FileWriter(file2);
//创建处理流
BufferedReader bur = new BufferedReader(fr);
BufferedWriter buw =new BufferedWriter(fw);
//读写文件 方式一：
//
// char[] buff =new char[1024];
// int len;
// while((len=bur.read(buff))!=-1 ){
// buw.write(buff,0,len);
//
//
// }
//读写文件 方式二：
char[] buff =new char[1024];
String str;
while((str=bur.readLine())!=null){
//buw.write(str+"\n");
buw.write(str);
buw.newLine();
}
//关闭流
bur.close();
buw.close();
}
4.2转换流
4.2.1 转换流涉及到的类
InputSteamReader:将一个字节的输入流转换为字符的输入流
解码：字节，字节数组----》字符数组，字符串
OutputStreamWriter：将一个字符的输出流转换为字节的输出流
编码：字符数组，字符串----》字节，字节数组
4.2.2 作用
提供字节流与字符流之间的转换
4.2.3 图示
4.2.4 典型实现
@Test
public void test(){
//创建文件
InputStreamReader isr = null;
OutputStreamWriter osw = null;
try {
File file = new File("hello.txt");
File file2 = new File("hellogbk.txt");
//创建字节流
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(file2);
//创建转换流
isr = new InputStreamReader(fis,"utf-8");
osw = new OutputStreamWriter(fos,"gbk");
char[] ch= new char[10];
int len;
while((len=isr.read(ch))!=-1){
osw.write(ch,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//关闭流
try {
if(isr!=null)
isr.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if(osw!=null)
osw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
五：其他流：
1.标准的输入输出流
System.in:标准的输入流，默认从键盘输入
System.out:标准的输出流，默认从控制台输出
修改默认的输入和输出行为：
System类的SetIn(InputStrem is)/setOut(PrintStream ps）方式重新指定输入和输出流
2.打印流
PrintStream 和PrintWriter
说明：
》提供了一系列重载的print（）和println（）方法，用于多种数据类型的输出
》System.out返回的是PrintStream的实例
3.代码
1.实现键盘标准输入字符串，并转换成大写输出! 方法一：Scanner
public class ScannerTest {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
while(true){
System.out.println("请输入内容，输入e或者exit 结束输入！");
String next = scan.next();
if("e".equalsIgnoreCase(next)||"exit".equalsIgnoreCase(next)){
System.out.println("系统输入结束！");
break;
}
System.out.println(next.toUpperCase());
}
}
}
方法二：缓冲流BufferedReader
public class StandardTest {
public static void main(String[] args) {
BufferedReader bur = null;
try {
InputStreamReader fir =new InputStreamReader(System.in);
bur = new BufferedReader(fir);
while(true){
System.out.println("请输入内容，输入e或者exi退出:");
String str = bur.readLine();
if("e".equalsIgnoreCase(str)||"exit".equalsIgnoreCase(str)){
System.out.println("退出程序！");
break;
}
String toUpperCase = str.toUpperCase();
System.out.println(toUpperCase);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if(bur!=null){
try {
bur.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
2.读取文档，并统计字符出现的次数
public class WordCount {
@Test
public void test() throws IOException {
//创建流和map集合
FileReader fr = new FileReader(new File("hello.txt"));
BufferedWriter buw = new BufferedWriter(new FileWriter(new File("wordcount.txt")));
Map map =new HashMap();
//按字符读取文件，每一个字符出现的次数放到map中
int c;
while(( c=fr.read())!=-1){
char ch = (char)c;
if(map.get(ch)==null)
{ map.put(ch,1);}
else{
map.put(ch,map.get(ch)+1);
}
}
//把集合数据写到文件中
Set> entries = map.entrySet();
for(Map.Entry entry: entries){
switch(entry.getKey()){
case ' ':
buw.write("空格="+entry.getValue());
break;
case '\t':
buw.write("制表符="+entry.getValue());
break;
case '\r':
buw.write("回车="+entry.getValue());
break;
case '\n':
buw.write("换行="+entry.getValue());
break;
default:
buw.write(entry.getKey()+"="+entry.getValue());
break;
}
buw.newLine();
}
//关闭流：
fr.close();
buw.close();
}
}