JavaIO流

File类

File类的理解

File类的一个对象，代表一个文件或一个文件目录(俗称:文件夹)
FiLe类声明在java.io包下。
File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用Io流来完成。
后续File类的对象常会作为参数传递到流的构造器中，指明读取或写入的"终点"。

File的构造器

File(String filePath)
File(string parentPath,string childPath)
File(File parentFile,string childPath)

路径的分类

相对路径:相较于某个路径下，指明的路径。
绝对路径:包含盘符在内的文件或文件目录的路径。

说明:IDEA中:
如果大家开发使用JUnit中的单元测试方法测试，相对路径即为当前Module下.如果大家使用main()测试，相对路径即为当前的Project下。
Eclipse中:
不管使用单元测试方法还是使用main()测试，相对路径都是当前的Project下。

路径分隔符

windows和DOS系统默认使用"\"来表示
UNIX和URL使用"/"来表示

File类的常用方法

File类的获取功能

**public String getAbsolutePath()：**获取绝对路径。
public String getPath():获取路径。
public String getName():获取名称。
**public String getParent()：**获取上层文件目录路径。若无，返回null。
public long length():获取文件长度（即:字节数）。不能获取目录的长度。
public long lastModified():获取最后一次的修改时间，毫秒值。
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()：**创建文件。若文件存在，则不创建，返回false。
public boolean mkdir():创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
**public boolean mkdirs()：**创建文件目录。如果上层文件目录不存在，一并创建注意事项:如果你创建文件或者文件目录没有写盘符路径，那么，默认在项目路径下。

File类的删除功能

**public boolean delete()：**删除文件或者文件夹删除
注意事项:
Java中的删除不走回收站。
要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录。

IO流

Java IO 原理

I/O是Input/Output的缩写，I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。
Java程序中，对于数据的输入/输出操作以“流(stream)”的方式进行。
java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。
**输入input:**读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。
**输出output:**将程序（内存)数据输出到磁盘、光盘等存储设备中。

流的分类

按操作数据单位不同分为：字节流（8bit）,字符流（16bit）.
按数据流的流向不同分为：输入流，输出流。
按流的角色的不同分为：字节流，处理流。

（抽象基类）	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

Java的Io流共涉及40多个类，实际上非常规则，都是从如下4个
抽象基类派生的。
由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。

IO流体系

字节流

FileReader

package com.zy.TestIO;import org.junit.Test;import java.io.File;
import java.io.FileReader;
import java.io.IOException;public class TestFileReader {//    说明点:
//            1. read()的理解:返回读入的一个字符。如果达到文件末尾，返回-1
//            2．异常的处理:为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理
//            3．读入的文件一定要存在，否则就会报FiLeNotFoundException。@Testpublic void Test01(){//创建流FileReader fr = null;try {//1.实例化File对象，指明要操作的文件File file = new File("src/com/zy/TestIO/hello.txt");//2.具体的操作流fr = new FileReader(file);//3.创建接收int data ;//4.数据读入//read()每次读入一个字符，如果到文件末尾，返回-1while ((data=fr.read())!=-1){//read()返回的是字符对应的ascii码System.out.print((char) data);}} catch (IOException e) {e.printStackTrace();} finally {//判断流存在，再关闭if(fr!=null) {try {//关闭流fr.close();} catch (IOException e) {e.printStackTrace();}}}}@Testpublic void Test02(){//创建流FileReader fr = null;try {//1.实例化File对象，指明要操作的文件File file = new File("src/com/zy/TestIO/hello.txt");//2.具体的操作流fr = new FileReader(file);//3.创建接收字符数组，长度为5char[] cbuffer = new char[5];int len;//4.数据读入//read()每次读入字符数组长度，如果到文件末尾，返回-1while ((len=fr.read(cbuffer))!=-1){//方法1
//                for(int i=0;i<len;i++)
//                {//                    System.out.print(cbuffer[i]);
//                }//方法2String str =new String(cbuffer,0,len);System.out.print(str);}} catch (IOException e) {e.printStackTrace();} finally {//判断流存在，再关闭if(fr!=null) {try {//关闭流fr.close();} catch (IOException e) {e.printStackTrace();}}}}
}

FileWriter

package com.zy.TestIO;import org.junit.Test;import java.io.File;
import java.io.FileWriter;
import java.io.IOException;public class TestFileWriter {public static void main(String[] args) {}
//    说明:
//            1．输出操作，对应的File可以不存在的。并不会报异常
//            2.File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
//            File对应的硬盘中的文件如果存在:如果流使用的构造器是:Filewriter(file,false) / Filewriter(file)（默认为false）:，对文件的进行覆盖
//            对原如果流使用的构造器是:Filewriter(file,true):不会对原有文件覆盖，而是在后面继续添加@Testpublic void Test01(){FileWriter fw = null;try {//创建File的对象，指定操作File file = new File("src/com/zy/TestIO/Hellot.txt");//创建操作流fw = new FileWriter(file);//开始写入fw.write("hello world\n");fw.write("你好!");} catch (IOException e) {e.printStackTrace();} finally {//关闭流try {if(fw!=null)fw.close();} catch (IOException e) {e.printStackTrace();}}}
}

前两者结合

@Testpublic void TestFileReaderFileWriter(){FileReader fr = null;FileWriter fw = null;try {//1.创建读写的文件File rfile = new File("src/com/zy/TestIO/hello.txt");File wfile = new File("src/com/zy/TestIO/Hellot.txt");//2.创建对应操作流fr = new FileReader(rfile);fw = new FileWriter(wfile);//3.创建字符数组，开始读写char[] cbuffer = new char[5];int len;while ((len = fr.read(cbuffer))!=-1){fw.write(cbuffer,0,len);}} catch (IOException e) {e.printStackTrace();} finally {//关闭流//方法1
//            try {//                if(fw!=null)
//                fw.close();
//            } catch (IOException e) {//                e.printStackTrace();
//            }finally {//                try {//                    if(fr!=null)
//                    fr.close();
//                } catch (IOException e) {//                    e.printStackTrace();
//                }
//            }//方法2，两者没有区别try {if(fw!=null)fw.close();} catch (IOException e) {e.printStackTrace();}try {if(fr!=null)fr.close();} catch (IOException e) {e.printStackTrace();}}}

不能用字符流实现图片视频的复制，要用字节流

FileInputStream FileOutputStream

package com.zy.TestIO;import org.junit.Test;import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class TestFileInputStreamFileOutputStream {//方法使用和字符流类似
// 测试FiLeInputstream和FileoutpuStream的使用*
//    结论:
//        1．对于文本文件(.txt,.java,.c,.cpp)，使用字符流处理
//        2．对于非文本文件(.jpg,.mp3 ,.mp4, .avi,.doc,.ppt,. ..)，使用字节流处理@Testpublic void Test01(){FileInputStream fis = null;FileOutputStream fos = null;try {//使用字节流操作文本文件可能会出现乱码//1.复制图片，开创建文件File ipsFile = new File("src/com/zy/TestIO/bj.jpg");File opsFile = new File("src/com/zy/TestIO/bj2.jpg");//2.创建对应操作字节流fis = new FileInputStream(ipsFile);fos = new FileOutputStream(opsFile);//3.创建字节数组byte[] buffer = new byte[1024];int len;//4.开始复制while ((len = fis.read(buffer))!=-1){fos.write(buffer,0,len);}} catch (IOException e) {e.printStackTrace();} finally {//5.关闭流try {if(fos!=null)fos.close();} catch (IOException e) {e.printStackTrace();}try {if(fis!=null)fis.close();} catch (IOException e) {e.printStackTrace();}}}
}

缓冲流

BufferedInputStream,BufferedOutputStream

package com.zy.TestIO;import org.junit.Test;import java.io.*;public class TestBuffered {//    作用:提高流的读取、写入的速度
//    提高读写速度的原因:内部提供了一个缓冲区，大小为8192，bos.flush();刷新缓冲区，没存满就先输出，满了会自动调用public static void CopyBuffered(String srcFile,String destFile){BufferedInputStream bis = null;BufferedOutputStream bos = null;try {//创建文件File srcfile = new File(srcFile);File destfile = new File(destFile);//创建节点流FileInputStream fis = new FileInputStream(srcfile);FileOutputStream fos = new FileOutputStream(destfile);//创建缓冲流bis = new BufferedInputStream(fis);bos = new BufferedOutputStream(fos);//创建字节数组，开始复制byte[] bytes = new byte[1024];int len;while ((len = bis.read(bytes))!=-1){bos.write(bytes,0,len);}} catch (IOException e) {e.printStackTrace();} finally {//关闭流//先关外面的，再关里面的//不过缓冲流的关闭会自动关闭内部的流if(bos!=null) {try {bos.close();} catch (IOException e) {e.printStackTrace();}}if(bis!= null) {try {bis.close();} catch (IOException e) {e.printStackTrace();}}}}@Testpublic void Test01(){long start =  System.currentTimeMillis();String srcFile = "E:\\QLDownload\\新世界\\新世界 第69集 蓝光(1080P).qlv";String destFile = "E:\\视频\\xsj.qlv";TestBuffered.CopyBuffered(srcFile,destFile);long end = System.currentTimeMillis();System.out.println("时间："+(end-start));//时间：4119,没有用缓冲流的时间为6451}
}

BufferedReader,BufferedWriter

使用方法和上面的相同，只是是字符流

读写的特殊方法

@Testpublic void Test02(){BufferedReader br = null;BufferedWriter bw = null;try {//创建流br = new BufferedReader(new FileReader(new File("src/com/zy/TestIO/hello.txt")));bw = new BufferedWriter(new FileWriter(new File("src/com/zy/TestIO/hellot.txt")));//方法一：
//            char[] cb = new char[1024];
//            int len;
//            while((len=br.read(cb))!=-1){//                bw.write(cb,0,len);
//            }//方法二：String data;while ((data=br.readLine())!=null)//每次返回一行，结束返回null{//                bw.write(data);//没有换行符，复制的内容会在一排//1.
//                bw.write(data+"\n");//2.bw.write(data);bw.newLine();//相当于一个换行行符}} catch (IOException e) {e.printStackTrace();} finally {//关闭流if(bw!=null) {try {bw.close();} catch (IOException e) {e.printStackTrace();}}if(br!=null) {try {br.close();} catch (IOException e) {e.printStackTrace();}}}}

转换流

转换提供了在字符流和字节流之间的转换
Java API 提供了两个转换流：
- InputStreamReader：将InputStream转换为Reader
- OutputStreamWriter：将Writer转换为OutputStream
- 这两个流属于字符流
字节流中的数据都是字符时，转换字符流操作更高效。
很多时候我们使用转换流来处理文件乱码问题。实现编码和解码的功能。
- 解码:字节、字节数组—>字符数组、字符串
- 编码:字符数组、字符串—>字节、字节数组

package com.zy.TestIO;import org.junit.Test;import java.io.*;public class TestInputStreamReader {/*** 结合使用，可以定义字符集，定义复制的文件的字符集*/@Testpublic void Test01(){InputStreamReader isr = null;OutputStreamWriter osw = null;try {//1.创建流和操作的文件isr = new InputStreamReader(new FileInputStream(new File("src/com/zy/TestIO/hello.txt")),"UTF-8");osw = new OutputStreamWriter(new FileOutputStream(new File("src/com/zy/TestIO/hello_gdk.txt")),"gbk");//2.读写操作char[] cbuffer =new char[1024];int len;while ((len=isr.read(cbuffer))!=-1){String str = new String(cbuffer,0,len);System.out.println(str);osw.write(cbuffer,0,len);}} catch (IOException e) {e.printStackTrace();} finally {//3.关闭流，外面关闭，内部一起try {if(osw!=null)osw.close();} catch (IOException e) {e.printStackTrace();}try {if(isr!=null)isr.close();} catch (IOException e) {e.printStackTrace();}}}
}

字符编码

编码表的由来
计算机只能识别二进制数据，早期由来是电信号。为了方便应用计算机，让它可以识别各个国家的文字。就将各个国家的文字用数字来表示，并一一对应，形成一张表。这就是编码表。
常见的编码表
- **ASCII：**美国标准信息交换码。
  - 用一个字节的7位可以表示。
- **ISO8859-1：**拉丁码表。
  - 欧洲码表用一个字节的8位表示。
- **GB2312：**中国的中文编码表。最多两个字节编码所有字符
- **GBK：**中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码
- **Unicode：**国际标准码，融合了目前人类使用的所有字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示
- **UTF-8：**变长的编码方式，可用1-4个字节来表示一个字符。
Unicode不完美，这里就有三个问题，一个是，我们已经知道，英文字母只用一个字节表示就够了，第二个问题是如何才能区别Unicode和IASClI?计算机怎么知道两个字节表示一个符号，而不是分别表示两个符号呢?第三个，如果和GBK等双字节编码方式一样，用最高位是1或O表示两个字节和一个字节，就少了很多值无法用于表示字符，不够表示所有字符。unicode在很长一段时间内无法推广，直到互联网的出现。
面向传输的众多UTF (UCS Transfer Format）标准出现了，顾名思义，UTF-8就是每次8个位传输数据，而UTF-16就是每次16个位。这是为传输而设计的编码，并使编码无国界，这样就可以显示全世界上所有文化的字符了。
Unicode只是定义了一个庞大的、全球通用的字符集，并为每个字符规定了唯一确定的编号，具体存储成什么样的字节流，取决于字符编码方案。推荐的Unicode编码是UTF-8和UTF-16。

其他类型流

标准的输入输出流

System.in和System.out分别代表了系统标准的输入和输出设备
默认输入设备是：键盘，输出设备是：显示器
System.in的类型是lnputStream
System.out的类型是PrintStream，其是OutputStream的子类FilterOutputStream的子类
重定向：通过System类的setIn，setOut方法对默认设备进行改变。
- public static void setln(InputStream in)
- public static void setOut(PrintStream out)

package com.zy.TestIO;import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Locale;public class TestOtherIO {public static void main(String[] args) {BufferedReader br = null;try {//创建，要使用到缓冲流和转换流，测试System.inbr = new BufferedReader(new InputStreamReader(System.in));//获取键盘输入的内容，exit结束while (true){System.out.println("输入：");String str = br.readLine();if(str.equalsIgnoreCase("exit")){System.out.println("程序结束");break;}String data = str.toUpperCase(Locale.ROOT);System.out.println(data);}} catch (IOException e) {e.printStackTrace();} finally {//关闭流try {if(br!=null)br.close();} catch (IOException e) {e.printStackTrace();}}}
}

打印流

实现将基本数据类型的数据格式转化为字符串输出
打印流：PrintStream和PrintWriter
- 提供了一系列重载的print()和println()方法，用于多种数据类型的输出
- PrintStream和PrintWriter的输出不会抛出IOException异常
- PrintStream和PrintWriter有自动flush功能
- PrintStream打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用PrintWriter 类。
- System.out返回的是PrintStream的实例

打印流就是可以将输出到页面的内容，自己定义一个文件，打印到那个文件中去

@Testpublic void TestPrint(){PrintStream ps = null;try {//创建文件输出流FileOutputStream fos = new FileOutputStream(new File("src/com/zy/TestIO/print.txt"));//创建打印流ps = new PrintStream(fos,true);//将标准输出改为文件if(ps!=null){System.setOut(ps);}//执行for(int i =0;i<255;i++){System.out.print((char) i);//输出AscII码字符if(i%50==0)//每五十个换行{System.out.println();}}} catch (FileNotFoundException e) {e.printStackTrace();} finally {//关闭流if(ps!=null)ps.close();}}

数据流

为了方便地操作Java语言的基本数据类型和Strirjg的数据，可以使用数据流。
数据流有两个类:(用于读取和写出基本数据类型、String类的数据)
- DatalnputStream和 DataOutputStream
- 分别“套接”在 lnputStream和 OutputStream子类的流上
DatalnputStream中的方法
boolean readBoolean()
byte readByte()
char readChar()
float readFloat()
double readDouble()
short readShort()
long readLong()
int readInt()
String readUTF()
void readFully(byte[] b)
DataOutputStream中的方法
将上述的方法的read改为相应的write即可。

 @Testpublic void TestDataOutputStream(){DataOutputStream dos = null;try {//创建数据流，将内存中的数据写入文件dos = new DataOutputStream(new FileOutputStream(new File("src/com/zy/TestIO/data.txt")));//写入数据dos.writeUTF("字符串");dos.flush();//刷新缓冲，将上面内容保存到文件中dos.writeInt(22);//intdos.flush();dos.writeBoolean(true);//booleandos.flush();} catch (IOException e) {e.printStackTrace();} finally {//关闭流if(dos!=null) {try {dos.close();} catch (IOException e) {e.printStackTrace();}}}}@Testpublic void TestDateInputStream(){DataInputStream dis = null;try {//将基本类型从文件中输入出来dis = new DataInputStream(new FileInputStream(new File("src/com/zy/TestIO/data.txt")));//要按写入的顺序将它们输入String str = dis.readUTF();int i = dis.readInt();boolean b = dis.readBoolean();System.out.println("String："+str+" int："+i+" boolean："+b);} catch (IOException e) {e.printStackTrace();} finally {//关闭流if(dis!=null) {try {dis.close();} catch (IOException e) {e.printStackTrace();}}}}

用数据流存入文件的内容，只能用数据流再输出，不能直接查看

数据流只能操作基本数据类型和Strirjg的数据，要操作对象要使用对象流

Java IO流基础相关推荐

java IO流基础万字详解（从拷贝文件到模拟上传头像）
目录一.前言: 二.IO流简介: 1.什么是IO流? 2.IO流能干什么? 3.IO流的分类: 4.IO流体系: 三.字符流读写文件: 1.普通字符流读取文件: 前言: ①以单个字符读取: 代码演示 ...
java IO流进阶模拟上传头像系统详解
目录一.前言: 二.思路: PS:直接看代码中的注释也可以. ①分析: ②总结: 三.代码: ①准备工作: ②代码演示: ③运行效果: 四.撒❀: 一.前言: 这篇文章是对之前java IO流基础 ...
java io流教程_Java基础教程：IO流与文件基础
Java:IO流与文件基础说明: 本章内容将会持续更新,大家可以关注一下并给我提供建议,谢谢啦. 走进流什么是流流:指的是从源到目的地的字节的有序序列. 在Java中,可以从其中读取一个字节序列 ...
java io flush_《文件传输基础——Java IO流》，对其中flush方法的思考
在学习了<文件传输基础--Java IO流> 课程后,发现自己对flush()方法的调用有很多疑惑.在查询资料和自己看源码以及动手试验之后发现有以下几个特点.如有误也请大家指正出来,一切为 ...
[重学Java基础][Java IO流][Exter.2]IO流中几种不同的读写方法的区别
[重学Java基础][Java IO流][Exter.2]IO流中几种不同的读写方法的区别 Read 读入方法 read(): 一般是这种形式 public int read() 1.从流数据中读取的 ...
Java基础知识（三十一）IO流（二） File类、递归、IO流基础
目录一. File类 1.File: 2.构造方法: 3.创建功能 4.删除功能 5. 重命名功能 6.判断功能 7.基本获取功能 8.高级获取功能 9.需求: 二.递归 1.概述: 2. 递 ...
JAVA IO流read方法基础使用
java io流read方法基础用法一.FileInputStream 二.字节数组读取三.循环读取一.FileInputStream 首先使用FileInputStream创建一个读入流,读取 ...
笔记整理2----Java语言基础（二）06 断点调试与数据加密+07 面向对象-类与对象+08 java常用API-基础+09 java集合+10 IO流-基础
06 断点调试与数据加密+07 面向对象-类与对象+08 java常用API-基础+09 java集合+10 IO流-基础第06天 java基础语法今日内容介绍  Eclipse断点调试  基 ...
Java基础17：Java IO流总结
版权声明:本文为博主原创文章,未经博主允许不得转载. https://blog.csdn.net/a724888/article/details/80201802 这位大侠,这是我的公众号:程序员江湖 ...
java io流的学习总结~~
java io流的学习总结~~ 流的概念和作用流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象.即数据在两设备间的传输称为流,流的本质是数据传输,根据数据传输特性将流抽象为各种类, ...

Java IO流基础