1.1. 什么是IO流

IO流: Input/Output Stream

流: 指的是一串流动的数据, 在数据在流中按照指定的方向进行流动。 实现数据的读取、写入的功能。

1.2. IO流的使用场景

使用File类, 只能做关于文件的操作, 获取属性、 创建文件、 删除文件、 移动文件等操作, 但是不包含读取文件中的内容。 如果需要读取、修改文件中的内容, 此时就需要使用IO流来完成了。

使用场景: 对某一个文件进行读取或者写入操作。

注意事项:
IO流是对一个文件进行读写的, 不是一个文件夹! 在使用IO流的时候, 不要建立与一个文件夹的连接。

1.3. IO流的分类

按照不同的分类标准, 能够得到不同分类的IO流:

按照流中流动的数据单位:

字节流: 流中流动的数据, 是以字节为单位的。

字符流: 流中流动的数据, 是以字符为单位的。

按照流中数据流动的方向:

输入流: 数据从文件流动到程序中。

输出流: 数据从程序流动到文件中。

2.基础的IO流

2.1. 基础的IO流类的简介

其实在 http://java.io 包中, 有很多很多的类, 都是来描述IO流的。 但是基本上所有的IO流的类, 都是直接或间接的继承自四大父类流。

字节输入流: InputStream

字节输出流: OutputStream

字符输入流: Reader

字符输出流: Writer

2.2. IO流使用的注意事项

四大父类流, 都是抽象类, 都不能实例化对象。 因此, 需要借助他们的子类实现数据的读写。

流对象一旦实例化完成, 将建立一个程序与文件之间的连接。 这个连接会持有这个文件。 如果这个连接不断, 此时这个文件就是一个被使用中的状态, 此时将无法对这个文件进行其他的操作, 例如删除。

一个流在使用完成之后, 切记! 一定要进行流的关闭。

2.3. 建立程序与文件的连接

其实, 就是建立了程序与文件之间连接的管道, 实现数据在这个管道之内进行流动。 管道分为不同的类型: 字节输入流、 字节输出流、 字符输入流、 字符输出流。 下面以字节输入流 InputStream 为例。

2.3.1. 标准流程

try结构外面, 声明流对象, 为了在finally中使用。

在try结构里面, 实例化流对象, 并捕获异常。

在finally结构中, 对流进行关闭。 在关闭的时候, 需要考虑流对象是否是null, 以及要处理 IOException 异常。

importjava.io.*;/**
* @Description 测试文件与程序的连接建立
*/publicclassIO1{publicstaticvoidmain(String[]args){// 在外面声明变量
InputStreaminputStream=null;try{// 实例化一个FileInputStream对象,向上转型为InputStream类型类型。
// 这个实例化如果完成,将会建立程序与文件之间的连接。
// 建立好之后,数据就可以从文件中流动到程序中。
// 注意: 数据流动到程序中,并不意味着文件中没有数据了!
// 这个过程中,会出现 FileNotFoundException 的异常,原因: 路径写错了,这个路径上没有文件
inputStream=newFileInputStream("file\\day25\\source");// 数据的读取操作
// 在数据读取的过程中,也会出现 IOException 异常。一旦出现异常,后序的代码都不执行了,直接执行catch语句了
// 流的关闭,不能放到try里面。需要放到finally中。
}catch(FileNotFoundExceptione){e.printStackTrace();}finally{// 流在使用结束之后,一定要进行关闭。
if(inputStream!=null){try{inputStream.close();}catch(IOExceptione){e.printStackTrace();}}}}}

2.3.2. try结构的特使使用

在 JDK1.7 之后, 可以在try后面添加一对小括号。 将 AutoClosable 接口实现类的对象, 实例化放到小括号中完成。 此时, 在try结构执行结束的时候, 会自动的调用AutoClosable接口实现类中的close方法, 进行流的关闭。 这样写的流的建立比较简单, 也是后面我们最主要使用的方式。

importjava.io.*;/**
* @Description 常见的IO流的创建的方式
*/publicclassIO2{publicstaticvoidmain(String[]args){/**
* try结构的特殊语法: try ()
* 将 AutoClosable 接口的实现类对象的实例化放到小括号中。
* 此时,在离开了try结构的时候,会自动的对这个类进行close方法的调用
*/try(InputStreaminputStream=newFileInputStream("file\\day25\\source")){
// 数据的读取操作
}catch(FileNotFoundExceptione){e.printStackTrace();}catch(IOExceptione){e.printStackTrace();}System.out.println(newFile("file\\day25\\source").delete());}}

2.4. InputStream

2.4.1. InputStream简介

这是一个字节输入流。 从方向来说, 是一个输入流, 数据是从文件中流动到程序中, 是为了读取文件中的数据的。 从数据单位来说, 这个流中流动的数据是以字节为单位的。

2.4.2. 文件的读取

importjava.io.FileInputStream;importjava.io.FileNotFoundException;importjava.io.IOException;importjava.io.InputStream;/**
* @Description 使用字节流进行数据的读取
*/publicclassInputStreamTest{publicstaticvoidmain(String[]args){// 1. 建立程序与文件之间的连接,用来读取这个文件
try(InputStreaminputStream=newFileInputStream("file\\day25\\source")){// 2. 读取字节流中的数据,需要有一个字节数组,用来读取数据
// 这个数组长度,不用和文件一样大小,找一个大小合适的数组读取即可
byte[]array=newbyte[32];// 3. 声明一个整型变量,用来记录每次读取了多少个字节的数据
intlength=0;// 3. 循环读取数据
while((length=inputStream.read(array))!=-1){// 将读取到的字节数组中的数据,转成字符串输出
// 为了去除最后一次进行读取数据的时候,上次读取残留的问题
// 最后一次读取的数据,只有指定部分是我们需要的数据
Stringstr=newString(array,0,length);System.out.print(str);}}catch(IOExceptione){e.printStackTrace();}}}

2.5. OutputStream

2.5.1. OutputStream简介

字节输出流。 从方向上来分, 是一个输出流, 数据从程序中流动到文件中, 实现文件的写操作。 从流中流动的数据单位来分, 是一个字节流, 流中流动的数据是以字节为单位的。

2.5.2. 文件的写

importjava.io.FileNotFoundException;importjava.io.FileOutputStream;importjava.io.IOException;importjava.io.OutputStream;/**
* @Description 字节输出流,写文件
*/publicclassOutputStreamTest{publicstaticvoidmain(String[]args){// 1. 实例化一个管道,连接文件和程序。
// 对于FileOutputStream来说,如果目标文件不存在,则会自动的创建。
// 当无法创建这个文件的时候(父级目录不存在),创建会失败,会触发 FileNotFoundException 。
try(OutputStreamoutputStream=newFileOutputStream("file\\day25\\dst",true)){// 2. 准备需要写入到这个文件中的数据
Stringmessage="你好,师姐";// 3. 将数据写入到输出流中,由输出流写入到文件中
outputStream.write(message.getBytes());// 冲刷缓冲区,将缓冲区中的数据强制流动到文件中。
// 在流关闭的时候,会自动的调用。
outputStream.flush();}catch(IOExceptione){e.printStackTrace();}}}​

2.6. 案例: 文件拷贝

2.6.1. 需求分析

实现, 将一个文件拷贝到另外一个地方。 注意, 这个不是剪切, 拷贝完成之后, 原文件还在。

实现方式: 借助两个流来完成。

使用字节流输入, 循环读取原文件中的数据。

使用字节输出流, 将每次读取到的数据, 写入到目标文件中。

2.6.2. 示例代码

importjava.io.*;/**
* @Description 使用字节流实现文件的拷贝
*/publicclassFileCopy{publicstaticvoidmain(String[]args){booleanret=copy("C:\\Users\\luds\\Desktop\\src.mp4","C:\\Users\\luds\\Desktop\\dst.mp4");System.out.println(ret);}/**
* 实现功能: 将源文件中的数据拷贝到目标文件
* @param srcPath 原文件路径
* @param dstPath 目标文件路径
* @return 拷贝的结果
*/privatestaticbooleancopy(StringsrcPath,StringdstPath){// 1. 判断目标路径上,是否有文件存在
Filedst=newFile(dstPath);if(dst.exists()){returnfalse;}// 2. 实现文件的拷贝
try(InputStreaminputStream=newFileInputStream(srcPath);OutputStreamoutputStream=newFileOutputStream(dst)){// 拷贝的过程
// 2.1. 实例化一个字节数组
byte[]array=newbyte[1024];// 2.2. 声明一个整型变量,用来记录每次读取到了多少个字节的数据
intlength=0;// 2.3. 循环读取数据
while((length=inputStream.read(array))!=-1){// 2.4. 将读取到的数据,写入到输出流中
outputStream.write(array,0,length);}// 2.5. 冲刷缓冲区
outputStream.flush();returntrue;}catch(IOExceptione){e.printStackTrace();returnfalse;}}}

2.7. Reader

2.7.1. Reader的简介

这是一个字符输入流。 从方向来说, 是一个输入流, 数据是从文件中流动到程序中, 是为了读取文件中的数据的。 从数据单位来说, 这个流中流动的数据是以字符为单位的。

2.7.2. 读取文件

importjava.io.FileReader;importjava.io.IOException;importjava.io.Reader;/**
* @Description 字符输入流读取数据
*/publicclassReaderTest{publicstaticvoidmain(String[]args){// 读取过程与字节输入流完全相同,只需要将使用到的类换一下即可。
try(Readerreader=newFileReader("file\\day25\\src")){// 1. 实例化一个字符数组
char[]array=newchar[100];// 2. 声明一个变量,用来记录每次读取到了多少个数据
intlength=0;// 3. 循环读取数据
while((length=reader.read(array))!=-1){Stringstr=newString(array,0,length);System.out.print(str);}}catch(IOExceptione){e.printStackTrace();}}}

2.8. Writer

2.8.1. Writer的简介

字符输出流。 从方向上来分, 是一个输出流, 数据从程序中流动到文件中, 实现文件的写操作。 从流中流动的数据单位来分, 是一个字符流, 流中流动的数据是以字符为单位的。

2.8.2. 文件的写操作

importjava.io.FileWriter;importjava.io.IOException;importjava.io.Writer;/**
* @Description 使用字符流写数据
*/publicclassWriterTest{publicstaticvoidmain(String[]args){// 1. 实例化相关的类
try(Writerwriter=newFileWriter("file\\day25\\target",true)){// 2. 将数据写入到输出流中
writer.write("hello, world");// 3. 冲刷缓冲区
writer.flush();}catch(IOExceptione){e.printStackTrace();}}}

2.9. 案例: 文件拷贝

2.9.1. 需求分析

实现, 将一个文件拷贝到另外一个地方。 注意, 这个不是剪切, 拷贝完成之后, 原文件还在。

实现方式: 借助两个流来完成。

使用字符输入流, 循环读取原文件中的数据。

使用字符输出流, 将每次读取到的数据, 写入到目标文件中。

2.9.2. 示例代码

/**
* 使用字符流实现文件的拷贝
* @param srcPath 原文件路径
* @param dstPath 目标文件路径
*/privatestaticvoidfileCopy2(StringsrcPath,StringdstPath){// 2. 循环读取目标文件中的数据
try(Readerreader=newFileReader(srcPath);Writerwriter=newFileWriter(dstPath)){// 3. 循环读取源文件中的数据
char[]array=newchar[100];intlength=0;while((length=reader.read(array))!=-1){// 4. 将读取到的数据写入到输出流
writer.write(array,0,length);}writer.flush();returntrue;}catch(IOExceptione){e.printStackTrace();returnfalse;}}

3. 常见的其他流

3.1. 缓冲流

3.1.1. 缓冲流的简介

给普通的IO流, 套上一个缓冲区。 所有的使用缓冲流进行的读写操作, 都是和缓冲区进行交互的, 避免了频繁的IO操作。 这样一来, 带来的好处就是可以提高读写的效率。 这个缓冲区, 其实是一个数组。

常见的缓冲流:

BufferedInputStream : 缓冲字节输入流

BufferedOutputStream : 缓冲字节输出流

BufferedReader : 缓冲字符输入流

BufferedWriter : 缓冲字符输出

3.1.2. 缓冲字节流

importjava.io.BufferedInputStream;importjava.io.FileInputStream;importjava.io.IOException;/**
* @Description BufferedInputStream使用
*/publicclassBufferedInputStreamTest{publicstaticvoidmain(String[]args){// 过程和InputStream一模一样的
// 缓冲字节输入流流是需要基于一个字节输入流来进行实例化的
// 在这里,BufferedInputStream构造方法中的InputStream对象,只是用来做当前的对象的实例化,在使用结束的时候,理论上来讲,是需要关闭的
// 实际在使用中,使用结束后,只需要关闭BufferedInputStream即可。
try(BufferedInputStreambufferedInputStream=newBufferedInputStream(newFileInputStream("file\\day26\\source"))){// 1. 实例化一个字节数组
byte[]array=newbyte[1024];// 2. 声明一个整型变量,用来记录每次读取了多少个字节数据
intlength=0;// 3. 循环读取
while((length=bufferedInputStream.read(array))!=-1){// 4. 将读取到的数据转成字符串输出到控制台
Stringmsg=newString(array,0,length);System.out.println(msg);}}catch(IOExceptione){e.printStackTrace();}}}
importjava.io.BufferedOutputStream;importjava.io.FileOutputStream;importjava.io.IOException;/*
* @Description BufferedOutputStream
*/publicclassBufferedOutputStreamTest{publicstaticvoidmain(String[]args){// 1. 实例化一个缓冲字节输出流对象
try(BufferedOutputStreambufferedOutputStream=newBufferedOutputStream(newFileOutputStream("file\\day26\\target"))){// 2. 将数据写入到输出流中
bufferedOutputStream.write("hello world".getBytes());bufferedOutputStream.flush();}catch(IOExceptione){e.printStackTrace();}}}

3.1.3. 缓冲字符流

importjava.io.BufferedReader;importjava.io.FileReader;importjava.io.IOException;/**
* @Description
*/publicclassBufferedReaderTest{publicstaticvoidmain(String[]args){// 借助一个字符流,实例化一个缓冲字符输入流
try(BufferedReaderbufferedReader=newBufferedReader(newFileReader("file\\day26\\src"))){// 从流中读取数据
char[]array=newchar[100];intlength=0;while((length=bufferedReader.read(array))!=-1){System.out.print(newString(array,0,length));}}catch(IOExceptione){e.printStackTrace();}}}
importjava.io.BufferedWriter;importjava.io.FileWriter;importjava.io.IOException;/**
* @Description
*/publicclassBufferedWriterTest{publicstaticvoidmain(String[]args){// 借助一个字符输出流,实例化一个缓冲字符输出流对象
try(BufferedWriterbufferedWriter=newBufferedWriter(newFileWriter("file\\day26\\dst"))){bufferedWriter.write("hello world");bufferedWriter.flush();}catch(IOExceptione){e.printStackTrace();}}}

3.1.4. 缓冲流中的特殊方法

BufferedReader 类中多了一个方法 readLine()

意义: 读取缓冲流中的一行数据, 可以逐行读取。 一直到读取到的数据是null, 表示数据读取完了, 没有下一行数据了。

注意事项: readLine() 是逐行读取, 但是, 只能读取到一行中的内容, 并不能读取走换行符。

importjava.io.BufferedReader;importjava.io.FileReader;importjava.io.IOException;/*
* @Date 2020/4/26
* @Description
*/publicclassBufferedReaderSpecial{publicstaticvoidmain(String[]args){try(BufferedReaderreader=newBufferedReader(newFileReader("file\\day26\\src"))){// 1. 定义一个字符串,用来接收每一行读取到的数据
Stringline="";// 2. 循环读取数据
while((line=reader.readLine())!=null){// 3. 将读取到的数据输出
System.out.println(line);}}catch(IOExceptione){e.printStackTrace();}}

BufferedWriter 类中多了一个方法 newLine()

意义: 无参的方法, 写一个换行符。

importjava.io.BufferedWriter;importjava.io.FileWriter;importjava.io.IOException;/**
* @Description
*/publicclassBufferedWriterSpecial{publicstaticvoidmain(String[]args){try(BufferedWriterbufferedWriter=newBufferedWriter(newFileWriter("file\\day26\\dst"))){bufferedWriter.write("hello world");bufferedWriter.newLine();bufferedWriter.write("你好,世界");bufferedWriter.newLine();bufferedWriter.write("end");}catch(IOExceptione){e.printStackTrace();}}}

使用缓冲字符流进行文件的拷贝

importjava.io.*;/**
* @Description 使用缓冲字符流实现文本文件的拷贝
*/publicclassBufferedCopy{publicstaticvoidmain(String[]args){try(BufferedReaderreader=newBufferedReader(newFileReader("file\\day26\\src"));BufferedWriterwriter=newBufferedWriter(newFileWriter("file\\day26\\destination"))){Stringline="";while((line=reader.readLine())!=null){writer.write(line);writer.newLine();}writer.flush();}catch(IOExceptione){e.printStackTrace();}}

3.2. Scanner类

3.2.1. 简介

这个类, 并不是一个IO流。 是一个扫描器, 这个类最主要的作用, 是从一个文件中或者从一个流中浏览数据。 在这个类中封装了若干个方法, 方便了数据的读取。

3.2.2. API

注意事项

这里nextLine和BufferedReader中的readLine都可以读取一行数据。 但是区别在于: 结束条件不同。

BufferedReader: 如果读取到的数据是null, 说明没有下一行数据了。

Scanner: 如果没有下一行了,再去读取,会出现异常。 所以, 此时的结束条件是 hasNextLine() 为false。

importjava.io.File;importjava.io.FileNotFoundException;importjava.util.Scanner;importjava.util.regex.Pattern;/**
* @Description Scanner类的方法
*/publicclassScannerTest{publicstaticvoidmain(String[]args){// 其实,Scanner在使用结束之后,也是需要进行关闭的。 调用close方法。
try(Scannerscanner=newScanner(newFile("file\\day26\\src"))){// 读取文件中的内容
while(scanner.hasNextLine()){System.out.println(scanner.hasNextLine());}}catch(FileNotFoundExceptione){e.printStackTrace();}}

3.3. 标准输入输出流

3.3.1. 简介

标准输入流: http://System.in : 连接了程序和控制台。 读取控制台中的内容。

标准输出流: System.out : 连接了程序和控制台。 将程序中的内容输出到控制台。

3.3.2. 标准输入流

importjava.io.BufferedInputStream;importjava.io.IOException;importjava.util.Scanner;/**
* @Description 标准输入流
*/publicclassSystemInTest{publicstaticvoidmain(String[]args){try(BufferedInputStreambis=newBufferedInputStream(System.in)){byte[]array=newbyte[128];intlength=0;while((length=bis.read(array))!=-1){Stringstr=newString(array,0,length);System.out.println(str);}}catch(IOExceptione){e.printStackTrace();}}}

3.3.3. 标准输出流

importjava.io.File;importjava.io.FileOutputStream;importjava.io.IOException;importjava.io.PrintStream;/**
* @Description 标准输出流
*/publicclassSystemOutTest{publicstaticvoidmain(String[]args){PrintStreamoriginal=System.out;// PrintStream: 是一个打印流,可以将数据输出到指定位置。
try(PrintStreamps=newPrintStream(newFileOutputStream("file\\day26\\logs",true))){// ps.println("hello world!");
// 重定向标准输出流
System.setOut(ps);System.out.println("123");}catch(IOExceptione){e.printStackTrace();}finally{System.setOut(original);}System.out.println("你好");// System.out; 标准输出流地址
// System.out -> ps
}}

3.4. 转换流

3.4.1. 为什么要用转换流

在进行文件读取的时候, 如果项目采用的字符集和文件的字符集不同,会出现乱码的情况。

3.4.2. 输入流

importjava.io.*;/**
* @Description 转换流
* 转换输入流:可以以指定的字符集读取某一个文件中的数据
* 转换输出流:可以以指定的字符集把数据写入到某一个文件
*/publicclassTransforeTest{publicstaticvoidmain(String[]args){read();}privatestaticvoidread(){// 当前的项目是 utf-8, 读取的文件是 GBK
// 如果需要以指定的字符集进行文件的读取,需要使用 InputStreamReader(InputStream inputStream, String charsetName)
try(InputStreamReaderreader=newInputStreamReader(newFileInputStream("file\\day26\\src"),"GBK")){char[]array=newchar[128];intlength=0;while((length=reader.read(array))!=-1){System.out.println(newString(array,0,length));}}catch(IOExceptione){e.printStackTrace();}}}

3.4.3. 输出流

importjava.io.*;/**
* @Description 转换流
* 转换输入流:可以以指定的字符集读取某一个文件中的数据
* 转换输出流:可以以指定的字符集把数据写入到某一个文件
*/publicclassTransforeTest{publicstaticvoidmain(String[]args){write();}privatestaticvoidwrite(){// 以指定的字符集写数据
try(OutputStreamWriterwriter=newOutputStreamWriter(newFileOutputStream("file\\day26\\dst",true),"GBK")){writer.write("hello world");writer.write("你好,世界");}catch(IOExceptione){e.printStackTrace();}}}

3.5. 对象流

3.5.1. 简介

ObjectInputStream、 ObjectOutputStream, 主要是用来做对象的序列化和反序列化的。

序列化: 将内存中的某个对象, 以文件的形式保存到本地。

反序列化: 将本地保存的某一个文件, 信息读取出来, 存到某一个对象中。

序列化、 反序列化, 是对象的持久化存储的一种常用手段。

3.5.2. 注意事项

所有的要序列化到本地的类的对象, 类必须实现 java.io.Serilizable 接口。

如果需要序列化多个文件到本地, 尽量不要序列化到一个文件中。 如果需要序列化多个文件到本地, 通常采用的方式, 是村集合。 将多个对象存入一个集合中, 将这个集合序列化到本地。

3.5.3. 示例代码

importjava.io.*;/**
* @Description
*/publicclassTest{publicstaticvoidmain(String[]args){load();}/**
* 反序列化
*/privatestaticvoidload(){try(ObjectInputStreaminputStream=newObjectInputStream(newFileInputStream("file\\day26\\person"))){// 读取文件中的数据
Objectobj=inputStream.readObject();if(objinstanceofPerson){Personxiaoming=(Person)obj;System.out.println(xiaoming);}}catch(IOException|ClassNotFoundExceptione){e.printStackTrace();}}/**
* 序列化
*/privatestaticvoidsave(){// 实例化一个Person对象
Personxiaoming=newPerson("xiaoming",12,100);// 序列化对象
try(ObjectOutputStreamoutputStream=newObjectOutputStream(newFileOutputStream("file\\day26\\person"))){// 序列化
outputStream.writeObject(xiaoming);outputStream.flush();}catch(IOExceptione){e.printStackTrace();}}}

3.6. Properties

3.6.1. 简介

Properties也不是一个IO流, 是一个集合。 是Hashtable的子类。

使用Properties主要是为了描述程序中的属性列表文件。 有时候, 我们会将一些比较简单的项目的配置信息, 以 .properties 格式的文件进行存储。 可以使用Properties对象读写 .properties 文件。

3.6.2. 示例代码

importjava.io.FileReader;importjava.io.FileWriter;importjava.io.IOException;importjava.util.Properties;/**
* @Description
*/publicclassProgram{publicstaticvoidmain(String[]args){// 1. 实例化一个Properties对象
Propertiesproperties=newProperties();// 2. 加载一个 .properties 文件中的数据
try{properties.load(newFileReader("file\\day27\\my.properties"));}catch(IOExceptione){e.printStackTrace();}// 3. 遍历
System.out.println(properties);// 4. 键值对的增删改查
// 由于这个类是Map的实现类,因此在Map集合中定义的所有的方法,它都有。
// 但是,对于Properties类的来说,增删改查基本上不用从Map中继承到的方法。
// 因为,从Map集合中继承下来的方法,键和值都是Object类型的。
// 4.1. 可以在集合中新增一个键值对,也可以修改集合中的存在的键值对。
properties.setProperty("userlevel","12");properties.setProperty("password","ABCDEFG");// 4.2. 通过键,获取值
Stringlevel=properties.getProperty("userlevel");Stringid=properties.getProperty("userid","123");System.out.println(properties);// 5. 将内存中的数据,同步到文件中
try{properties.store(newFileWriter("file\\day27\\my.properties"),"hello");}catch(IOExceptione){e.printStackTrace();}}}

IO流详解及常用方法的更多相关文章

  1. 基于JavaSE阶段的IO流详解

    1.IO流基本概述 在Java语言中定义了许多针对不同的传输方式,最基本的就是输入输出流(俗称IO流),IO流是属于java.io包下的内容,在JavaSE阶段主要学下图所示的: 其中从图中可知,所有 ...

  2. IO流详解

    目录 IO流 IO流概述及其分类 IO概念 流按流向分为两种: 流按操作类型分为两种: 常用的IO流类 字节流的抽象父类: 字符流的抽象父类: InputStream & FileInputS ...

  3. Java IO流详解(二)——File类

    在上一章博客中简单的介绍了Java IO流的一些特征.也就是对文件的输入输出,既然至始至终都离不开文件,所以Java IO流的使用得从File这个类讲起. File类的描述:File类是文件和目录路径 ...

  4. JAVA中IO流详解

    IO流:数据传输是需要通道的,而IO流就是数据传输的通道. IO流可以形象的比喻为运送货物的传输带. IO流的分类: ①根据操作的数据类型的不同可以分为 :字节流与字符流. ②根据数据的流向分为:输入 ...

  5. java IO流详解

    流的概念和作用 学习Java IO,不得不提到的就是JavaIO流. 流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象.即数据在两设备间的传输称为流,流的本质是数据传输,根据数据传输 ...

  6. IO流详解(半教材类型)

    这两天学习了IO流,整理了一些理论知识点,仅供参考. java流概述 一 流 从操作系统层面和文件系统,数据保存相关的是所有语言都具备的一个基本功能,java专门开发了一个包:java.io.*;ja ...

  7. Java之IO流详解

    IO流 Input/Output 完成输入/输出 应用程序运行时——数据在内存中  ←→ 把数据写入硬盘(磁带)  内存中的数据不可持久保存的  输入:从外部存储器(硬盘.磁带.U盘)把数据读入内存. ...

  8. java之IO流详解(一)

    IO流的分类: A:流向 输入流 读取数据 输出流 写出数据 B:数据类型 字节流 字节输入流  InputStream 字节输出流  OutputStream 字符流 字符输入流  Reader 字 ...

  9. Java io流详解二

    原文地址https://www.cnblogs.com/xll1025/p/6418766.html 一.IO流概述 概述: IO流简单来说就是Input和Output流,IO流主要是用来处理设备之间 ...

  10. 《Java基础知识》Java IO流详解

    Java IO概念 1. 用于设备之间的数据传输. 2. Java 将操作数据流的功能封装到了IO包中. 3. 数据流流向分:输入流和输出流,操作对象为文件. 4. 流按照操作数据分:字节流(通用)和 ...

随机推荐

  1. CSS边框(实线、虚线、破折号)

    1.CSS边框 border:1px solid red; /*实线*/ border:1px dotted red; /*虚线*/ border:1px dashed red; /*破折号*/

  2. Mysql--查询"01"课程比"02"课程成绩高的学生的信息及课程分数

    今天在写Mysql代码作业时,写到这个题,感觉值得分享!!!!!!! 查询"01"课程比"02"课程成绩高的学生的信息及课程分数 分析如下: 首先先查询&quo ...

  3. CSS中z-index的属性与使用

    z-index 属性指定一个元素的堆叠顺序. 拥有更高堆叠顺序的元素总是会处于堆叠顺序较低的元素的前面. Z-index 仅能在定位元素上奏效,z-index 进行定位元素(position:abso ...

  4. win常用的dos命令

    常用的dos命令 开启dos终端的两种方式: win+r后输入cmd指令 在资源管理器上方的路径窗口直接输入cmd,即可开启指定路径下的cmd终端,省去了cd/d这一步 注:在dos终端里ctrl+v ...

  5. 排查占用cpu最高线程

  6. 正则爬取'豆瓣之乘风破浪的姐姐'的并存入excel文档

    import requests import re import pandas as pd def parse_page(url): headers = { 'User-Agent':'Mozilla ...

  7. 2月26日Android开发学习

    1.App运行日志 Android采用Log工具打印日志,他讲各类日志划分为五个等级 (1)Log.e:表示错误信息,比如可能导致程序崩溃的异常. (2)Log.w:表示警告信息. (3)Log.i: ...

  8. OSS 解锁

    一.解开LSKEYF00的编辑锁定  进入SE30,点击Tips & Tricks按钮,输入以下代码     UPDATE PROGDIR SET EDTX = ''       WHERE ...

  9. install package within python

    import os os.system("pip install numpy") import subprocess subprocess.call(['pip3', 'insta ...

  10. Spring AOP的动态代理原理和XML与注解配置

    AOP 实现底层就是对上面的动态代理的代码进行了封装,封装后我们只需要对需要关注的部分进行代码编写,并通过配置的方式完成指定目标的方法增强. 相关术语: Target(目标对象):代理的目标对象 Pr ...