新手小白看过来学JAVA必过IO流File字节流字符流
目录
- IO简介
- 1.流Stream
- 2.IO流的继承结构
- 3 File文件类
- 3.1概述
- 3.2创建对象
- 3.3常用方法
- 3.4 练习：测试常用方法
- 4.字节流读取
- 4.1 InputStream抽象类
- 4.2 FileInputStream子类
- 4.3 BufferedInputStream子类
- 4.4 练习：字节流读取案例
- 5.字符流读取
- 5.1 Reader抽象类
- 5.2 FileReader子类
- 5.3 BufferedReader子类
- 5.4 练习：字符流读取案例
- 6.字节流写出
- 6.1 OutputStream抽象类
- 6.2 FileOutputStream 子类
- 6.3 BufferedOutputstream 子类
- 6.4 练习: 字节输出流测试:
- 7.字符流写出
- 7.1 Writer 抽象类
- 7.2 FileWriter 子类
- 7.3 BufferedWriter子类
- 7.4 练习: 字符输出流测试:
- 8.拓展
- 9.总结:IO的继承结构
- 1.主流分类
- 2.学习方法:在抽象父类中学习通用的方法,在子类中学习如何创建对象
- 3.字节输入流:
- 4.字符输入流
- 5.字节输出流:
- 6.字符输出流
IO简介
1.流Stream
在学习IO流之前,我们首先需要学习的概念就是Stream流
为了方便理解,我们可以把数据的读写操作抽象成数据在"管道"中流动,但需注意:
1.流只能单方向流动
2.输入流用来读取 → in
3.输出流用来写出 → out
4.数据只能从头到尾顺序的读写一次
所以以程序的角度来思考,In/out 相对于程序而言的输入(读取)/输出(写出)的过程.
2.IO流的继承结构
在java中,根据处理的数据单位不同,可以把流分为字节流和字符流
字节流 : 针对二进制文件
字符流 : 针对文本文件,读写容易出现乱码的现象,在读写时,最好指定编码集为UTF-8
在结合对应类型的输入和输出方向,常用的流有:
File
字节流:针对二进制文件
InputStream
FileInputStream
BufferedInputStream
ObjectInputStream
OutputStream
FileOutputStream
BufferedOutputStream
ObjectOutputStream
字符流:针对文本文件
Reader
FileReader
BufferedReader
InputStreamReader
Writer
FileWriter
BufferedWriter
OutputStreamWriter
PrintWriter一行行写出
3 File文件类
3.1概述
封装一个磁盘路径字符串,对这个路径可以执行一次操作
可以封装文件路径、文件夹路径、不存在的路径
3.2创建对象
File(String pathname)通过将给定路径名字符串转换为抽象路径名来创建一个新的File实例
new File(“d:/abc/a.txt”);
new File(“d:/abc”,”a.txt”);
3.3常用方法
3.4 练习：测试常用方法
创建包: cn.tedu.file
创建类: TestFile.java
package cn.tedu.file;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
/*本类用来测试文件类 File*/
public class TestFile {
public static void main(String[] args) throws IOException {
//1.创建File文件对象
/*1.构造函数的参数是String类型的pathname(路径名)
* 这个路径可以是文件路径,也可以是文件夹路径*/
/*2.\在代码中有特殊的意义,所以想要真正表示这是一个\,需要用\进行转义*/
//注意:此处需要自己手动在D盘创建对应目录下的1.txt,并添加内容
//注意:创建1.txt时,需要设置系统显示文件后缀名,如果没设置,文件名应该是1
//注意:File需要导包:import java.io.File;
File file = new File("D:\\ready\\1.txt");
//2.测试常用方法
//2.1文件与文件夹属性测试
System.out.println(file.length());//12,获取指定文件的字节量大小
System.out.println(file.exists());//true,判断指定文件是否存在
System.out.println(file.isFile());//true,判断指定内容是否为文件
System.out.println(file.isDirectory());//false,判断指定内容是否为文件夹
System.out.println(file.getName());//1.txt,获取指定内容的名字
System.out.println(file.getParent());//D:\ready,获取指定内容的上级
System.out.println(file.getAbsolutePath());//D:\ready\1.txt,获取指定内容的绝对路径
//2.2创建与删除
file = new File("D:\\ready\\2.txt");
/*如果指定创建文件的文件夹不存在,会报错:java.io.IOException
* 系统找不到指定的路径,由于可能会发生异常,所以调用时需要抛出异常 */
//在windows中创建不存在的文件2.txt,成功返回true
System.out.println(file.createNewFile());//true
file = new File("D:\\ready\\m");
System.out.println(file.mkdir());//true,创建不存在的单层文件夹m
file = new File("D:\\ready\\a\\b\\c");
System.out.println(file.mkdirs());//true,创建不存在的多层文件夹a/b/c
System.out.println(file.delete());//c被删除,删除文件或者空文件夹
file = new File("D:\\ready\\a");
System.out.println(file.delete());//false,因为a目录里还有b目录
file = new File("D:\\ready\\2.txt");
System.out.println(file.delete());//true,删除2.txt文件成功
//2.3 文件列表测试
file = new File("D:\\ready");
String[] listName = file.list();
System.out.println(Arrays.toString(listName));
File[] fs = file.listFiles();
System.out.println(Arrays.toString(fs));
System.out.println(fs[0].length());
}
}
4.字节流读取
字节流是由字节组成的,字符流是由字符组成的.
Java里字符由两个字节组成.字节流是基本流，主要用在处理二进制数据。
所以字节流是比较常用的，可以可以处理多种不同种类的文件，比如文本文档/音频/视频等等
4.1 InputStream抽象类
此抽象类是表示字节输入流的所有类的超类/抽象类,不可创建对象哦
常用方法：
abstract int read() 从输入流中读取数据的下一个字节
int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中
int read(byte[] b, int off, int len) 将输入流中最多 len 个数据字节读入 byte 数组,off表示存时的偏移量
void close() 关闭此输入流并释放与该流关联的所有系统资源
4.2 FileInputStream子类
直接插在文件上，直接读取文件数据
创建对象
FileInputStream(File file)—直接传文件对象
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定FileInputStream(String pathname)—传路径
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定
4.3 BufferedInputStream子类
BufferedInputStream 为另一个输入流添加一些功能，在创建BufferedInputStream 时，会创建一个内部缓冲区数组(默认8k大小)。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。
创建对象
BufferedInputStream(InputStream in)
创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
4.4 练习：字节流读取案例
创建包: cn.tedu.file
创建类: TestIn.java
package cn.tedu.file;
import java.io.*;
/*本类用于练习字节输入流*/
public class TestIn {
public static void main(String[] args) {
//method();//字节流的读取
method2();//高效字节流的读取
}
//本方法用于测试高效字节流的读取
private static void method2() {
//定义一个在本方法中都生效的局部变量in,注意手动初始化，值为null
InputStream in = null;
try {
//1.创建高效字节输入流对象
// InputStream in = new BufferedInputStream(
// new FileInputStream(new File("E:\\ready\\1.txt")));
in = new BufferedInputStream
(new FileInputStream("E:\\ready\\1.txt"));
//2.使用流进行读取
int b;
while ((b= in.read())!= -1){
System.out.println(b);
}
} catch (Exception e) {
e.printStackTrace();
}finally {//关流操作写在finally{}中
//3.流用完以后一定要关闭！！！
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//本方法用于测试字节流的读取
private static void method() {
//创建一个在本方法都生效的局部变量注意手动初始化
InputStream in = null;
try {
//1.创建字节输入流对象用于读取
//InputStream in = new InputStream();//报错原因：抽象类不可实例化
//InputStream in = new FileInputStream(new File("E:\\ready\\1.txt"));
in = new FileInputStream("E:\\ready\\1.txt");
//2.开始读取
/*read()每次调用都会读取一个字节，如果读到了数据的末尾，返回-1*/
// System.out.println(in.read());
// System.out.println(in.read());
// System.out.println(in.read());
// System.out.println(in.read());
//需求：需要循环读取文件中的所有内容，直至读完
//定义变量，记录读到的数据
int b;
while((b=in.read())!= -1){
System.out.println(b);
}
} catch (Exception e) {
e.printStackTrace();//打印错误信息
/*try-catch结构中的第三个部分：finally{}
* 这部分不论是否捕获到异常，是一定会被执行到的代码，常用于关流*/
}finally {
try {
//3.释放资源，流资源用完必须释放！！！
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
5.字符流读取
常用于处理纯文本数据
5.1 Reader抽象类
用于读取字符流的抽象类。
常用方法：
int read() 读取单个字符
int read(char[] cbuf) 将字符读入数组
abstract int read(char[] cbuf, int off, int len) 将字符读入数组的某一部分
int read(CharBuffer target) 试图将字符读入指定的字符缓冲区
abstract void close() 关闭该流并释放与之关联的所有资源
5.2 FileReader子类
用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。
创建对象
FileReader(String fileName) 在给定从中读取数据的文件名的情况下创建一个新 FileReader
FileReader(File file) 在给定从中读取数据的 File 的情况下创建一个新 FileReader
5.3 BufferedReader子类
从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。
创建对象
BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流
5.4 练习：字符流读取案例
创建包: cn.tedu.file
创建类: TestIn2.java
package cn.tedu.file;
import java.io.*;
/*本类用于测试字符流的读取*/
public class TestIn2 {
public static void main(String[] args) {
//method();//测试普通字符输入流
method2();//测试高效字符输入流
}
//创建一个用于测试高效字符输入流的方法
private static void method2() {
//1.定义一个在本方法都生效的局部变量，手动初始化值null
Reader in=null;
try{
//1.创建高效字符读取流对象
//in = new BufferedReader(new FileReader(new File("E:\\ready\\1.txt")));
in = new BufferedReader(new FileReader("E:\\ready\\1.txt"));
//2.使用流对象
int b;
while((b=in.read())!=-1){
System.out.println(b);
}
}catch (Exception e){
e.printStackTrace();
}finally {
//3.关闭流对象
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//创建一个用于测试普通字符输入流的方法
private static void method() {
//1.1创建一个在本方法中都生效的局部变量，注意初始化值null
Reader in = null;
try {
//1.2创建字符输入流对象，注意需要捕获异常
//Reader in = new Reader();//报错原因：抽象父级不可实例化
//in = new FileReader(new File("E:\\ready\\1.txt"));
in = new FileReader("E:\\ready\\1.txt");
//2.使用流对象
//System.out.println(in.read());
//需求：循环读取文件中的所有内容，只要不是-1，就说明还有数据，继续读取
//3.1定义变量，记录读取到的数据
int b;
while((b = in.read())!= -1){
System.out.println(b);
}
} catch (Exception e) {
e.printStackTrace();
} finally {//3.关流
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
6.字节流写出
6.1 OutputStream抽象类
此抽象类是表示输出字节流的所有类的超类.输出流接受输出字节并将这些字节发送到某个接收器.
常用方法:
Void close() 关闭此输出流并释放与此流相关的所有系统资源
Void flush() 刷新此输出流并强制写出所有缓冲的输出字节
Void write(byte[ ] b) 将b.length个字节从指定的byte数组写入此输出流
Void write(byte[ ] b,int off ,int len) 将指定byte数组中从偏移量off开始的len个字节写入输出流
Abstract void write(int b) 将指定的字节写入此输出流
6.2 FileOutputStream 子类
直接插在文件上,直接写出文件数据
构造方法(创建对象):
FileOutputStream(String name)
创建一个向具有指定名称的文件中写入数据的文件输出流
FileOutStream(File file)
创建一个向指定File对象表示的文件中写入数据的文件输出流
FileOutStream(File file,boolean append)—如果第二个参数为true,表示追加,不覆盖
创建一个向指定File对象表示的文件中写入数据的文件输出流,后面的参数是指是否覆盖原文件内容
6.3 BufferedOutputstream 子类
该类实现缓冲的输出流,通过设置这种输出流,应用程序就可以将各个字节写入底层输出流中,而不必每次针对字节写出调用底层系统
构造方法(创建对象):
BufferedOutputStream(OutputStream out)
创建一个新的缓冲输出流,用以将数据写入指定的底层输出流
6.4 练习: 字节输出流测试:
创建包: cn.tedu.file
创建类: TestOut.java
package cn.tedu.file;
import java.io.*;
/*本类用于测试字节输出流*/
public class TestOut {
public static void main(String[] args) {
method();//用于测试普通字节输出流
//method2();//用于测试高效字节输出流
}
//创建一个用于测试高效字节输出流的方法
private static void method2() {
//1.创建一个在本方法都生效的局部变量，注意手动初始化
OutputStream out = null;
try{
//2.创建高效字节输出流对象
// out = new BufferedOutputStream(new FileOutputStream(new File("E:\\ready\\2.txt")));
out = new BufferedOutputStream(new FileOutputStream("E:\\ready\\2.txt"));
//3.使用流对象--进行写出操作
out.write(97);
out.write(97);
out.write(97);
}catch (Exception e){
e.printStackTrace();
}finally {//关流操作要放在finally{}中
try {
//4.关流
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//创建一个用于测试普通字节输出流的方法
private static void method() {
//1.创建一个在本方法中都生效的局部变量，注意手动初始化null
OutputStream out = null;
//2.创建try-catch-finally结构，因为IO操作可能会产生异常
try{
//3.创建普通字节输出流对象
//out = new FileOutputStream(new File("E:\\ready\\2.txt"));
//out = new FileOutputStream("E:\\ready\\2.txt");
out = new FileOutputStream("E:\\ready\\2.txt",true);
//4.使用流对象--进行写出操作
out.write(99);//对应ASCII码表中的a
out.write(99);//对应ASCII码表中的b
out.write(99);//对应ASCII码表中的c
}catch (Exception e){
e.printStackTrace();
}finally {//如果想要代码一定会执行，需要写在finally中
try {
//5.关流操作
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
7.字符流写出
7.1 Writer 抽象类
写入字符流的抽象类
常用方法:
Abstract void close() 关闭此流,但要先刷新它
Void write(char[ ] cbuf) 写入字符数组
Void write(int c) 写入单个字符
Void write(String str) 写入字符串
Void write(String str,int off,int len) 写入字符串的某一部分
Abstract void write(char[] cbuf,int off,int len)写入字符数组的某一部分
7.2 FileWriter 子类
用来写入字符文件的便捷类,此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的.如果需要自己自定义这些值,可以先在FileOutputStream上构造一个OutputStreamWriter.
构造方法(创建对象):
FileWriter(String filename)
根据给定的文件名构造一个FileWriter对象
FileWriter(String filename,boolean append)
根据给定的文件名以及指示是否附加写入数据的boolean值来构造FileWriter
7.3 BufferedWriter子类
将文本写入字符输出流,缓冲各个字符,从而提供单个字符,数组和字符串的高效写入.可以指定缓冲区的大小,或者接受默认的大小,在大多数情况下,默认值就足够大了
构造方法(创建对象):
BufferedWriter(Writer out)
创建一个使用默认大小输出缓冲区的缓冲字符输出流
7.4 练习: 字符输出流测试:
创建包: cn.tedu.file
创建类: TestOut2.java
package cn.tedu.file;
import java.io.*;
/*本类用于测试字符输出流*/
public class TestOut2 {
public static void main(String[] args) {
//method();//用于测试普通字符输出流
method2();//用于测试高效字符输出流
}
//创建一个用于测试高效字符输出流的方法
private static void method2() {
//1.创建一个在本方法都生效的局部变量，值为null,注意手动初始化！！！
Writer out = null;
//2.由于程序可能会抛出异常，所以需要写一个try-catch-finally结构
try{//存放可能会抛出异常的代码
//3.创建普通字符输出流对象
//out = new BufferedWriter(new FileWriter(new File("E:\\ready\\2.txt")));
//out = new BufferedWriter(new FileWriter("E:\\ready\\2.txt"));
out = new BufferedWriter(new FileWriter("E:\\ready\\2.txt",true));
//4.使用流对象
out.write(100);
out.write(100);
out.write(100);
out.write(100);
out.write(100);
}catch (Exception e){//匹配并捕获异常
e.printStackTrace();//如果捕获到异常就打印错误信息
}finally {//一定会被执行到的代码块，常用于关流
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//创建一个用于测试普通字符输出流的方法
private static void method() {
//1.创建一个在本方法都生效的局部变量，值为null,注意手动初始化！！！
Writer out = null;
//2.由于程序可能会抛出异常，所以需要写一个try-catch-finally结构
try{//存放可能会抛出异常的代码
//3.创建普通字符输出流对象
//out = new FileWriter(new File("E:\\ready\\2.txt"));
//out = new FileWriter("E:\\ready\\2.txt");
out = new FileWriter("E:\\ready\\2.txt",true);
//4.使用流对象
out.write(98);
out.write(98);
out.write(98);
out.write(98);
}catch (Exception e){//匹配并捕获异常
e.printStackTrace();//如果捕获到异常就打印错误信息
}finally {//一定会被执行到的代码块，常用于关流
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
8.拓展
通过学习以上的几种流,我们也可以拓展尝试做下文件的复制:
创建包: cn.tedu.file
创建类: TestCopyFile.java
package cn.tedu.file;
import java.io.*;
import java.util.Scanner;
/*本类用于练习文件复制综合案例*/
public class TestCopyFile {
public static void main(String[] args) {
//1.提示并接收用户输入的源文件路径和目标位置
System.out.println("请您输入源文件路径：");
String f = new Scanner(System.in).nextLine();
System.out.println("请您输入目标位置：");
String t = new Scanner(System.in).nextLine();
//2.调用方法完成文件的复制
//ZFCopy(f,t);//用字符流完成复制案例
ZJCopy(f,t);//用字节流完成复制案例
}
private static void ZJCopy(String f,String t) {
//1.定义在整个方法中都生效的局部变量，手动初始化值为null
InputStream in = null;
OutputStream out = null;
//2.由于代码可能会发生异常，所以需要try-catch-finally结构
try{
//3.1创建高效/缓冲字节输入流，参数是f
in = new BufferedInputStream(new FileInputStream(f));
//3.2创建高效/缓冲字节输出流，参数是t
out = new BufferedOutputStream(new FileOutputStream(t));
//4.创建好流对象以后就可以通过流对象完成业务了
//4.1定义变量保存读到的数据
int b;
//4.2使用循环完成复制操作
while((b=in.read())!=-1){
out.write(b);
}
System.out.println("恭喜您~文件复制成功~");
}catch(Exception e){
System.out.println("很抱歉~文件复制失败~");
e.printStackTrace();
}finally {
//5.关流
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private static void ZFCopy(String f,String t) {
//1.定义在整个方法中都生效的局部变量，手动初始化值为null
Reader in = null;
Writer out = null;
//2.由于代码可能会发生异常，所以需要try-catch-finally结构
try{
//3.1创建高效/缓冲字符输入流,传入的参数是源文件的路径
in = new BufferedReader(new FileReader(f));
//3.2创建高效/缓冲字符输出流，传入的参数是目标文件的路径
out = new BufferedWriter(new FileWriter(t));
//4.拿到流对象以后，就可以使用流对象来完成业务了
//4.1定义变量用来记录读到的数据
int b;
//4.2循环读取目标文件，直到返回值为-1，没有数据时结束循环
while((b=in.read())!=-1){
out.write(b);/*将本次循环从源文件读到的内容写出到目标文件中*/
}
System.out.println("恭喜您！文件复制成功！");
}catch (Exception e){
System.out.println("很抱歉！文件复制失败！");
e.printStackTrace();
}finally {
/*关流是有顺序的：如果有多个流，最后创建的流最先关闭
* 多条关流语句需要各自try-catch*/
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
9.总结:IO的继承结构
1.主流分类
1.按照方向进行分类:输入流 输出流(相对于程序而言,从程序写数据到文件中是输出)
2.按照传输类型进行分类:字节流 字符流
3.组合: 字节输入流 字节输出流 字符输入流 字符输出流
2.学习方法:在抽象父类中学习通用的方法,在子类中学习如何创建对象
3.字节输入流:
InputStream 抽象类,不能new,可以作为超类,学习其所提供的共性方法
--FileInputStream 子类,操作文件的字节输入流,普通类 --BufferedInputStream 子类,缓冲字节输入流,普通类
4.字符输入流
Reader 抽象类,不能new,可以作为超类,学习其所提供的共性方法
--FileReader,子类,操作文件的字符输入流,普通类 --BufferedReader,子类,缓冲字符输入流,普通类
5.字节输出流:
OutputStream 抽象类,不能new,可以作为超类,学习其所提供的共性方法
--FileOutputStream 子类,操作文件的字节输出流,普通类 --BufferedOutputStream 子类,缓冲字节输出流,普通类
6.字符输出流
Writer 抽象类,不能new,可以作为超类,学习其所提供的共性方法
--FileWriter,子类,操作文件的字符输出流,普通类 --BufferedWriter,子类,缓冲字符输出流,普通类
到此这篇关于新手小白看过来学JAVA必过IO流File字节流字符流的文章就介绍到这了,更多相关Java的IO流File字节流字符流内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！
相关推荐
-
Java IO流学习总结之文件传输基础
一.Java IO流总览 二.File类 2.1 常用API package pkg1; import java.io.File; import java.io.IOException; /** * @author Administrator * @date 2021/4/2 */ public class FileDemo { public static void main(String[] args) { // 了解构造函数,可查看API File file = new File("d:\\
-
java使用IO流对数组排序实例讲解
在学会了java中io流的使用后,我们对于数组的排序,又多了一种使用方法.大家知道流处理数据的效率是比较理想的,那么在具体操作数组排序上,很多人对于排序的方法还没有明确.下面我们先java使用流对数组排序的思路为大家进行梳理,然后带来对应的实例代码方法. 1.排序思路 (1)从字符输入流中读取文本,缓冲各个字符,从而实现字符.数组和行的高效读取 (2)询问用户需要多少位数的数组 (3)转换为数字类型 (4)将用户输入数字存入数组 (5)把数组按排序需求并打印出来 2.实例 public stat
-
java中的IO流
目录 java中的IO流 1.普通字节流 2.字节缓冲流 3.转换流 4.常用的IO类FileReader和BufferedReader 5.总结 java中的IO流 前言: 在java中IO类很庞大,初学的时候觉得傻傻分不清楚.其实java流归根结底的原理是普通字节流,字节缓冲流,转换流.最基础的是普通字节流,即从硬盘读取字节写入到内存中,但在实际使用中又发现一些特殊的需求,所以java语言的设计者这引入了字节缓冲流和转换流.所有的java IO类对IO的处理都是基于这三种流中的一种或多种:在
-
Java字节流和字符流总结IO流!
目录 从接收输入值说起 字节流读取 字符流读取 Scanner 读取 什么是 IO 流 字节流和字符流 字节流 字节输入流 字节输出流 缓冲流的原理 字符流 字符输入流 字符输出流 RandomAccessFile 总结 从接收输入值说起 在日常的开发应用中,有时候需要直接接收外部设备如键盘等的输入值,而对于这种数据的接收方式,我们一般有三种方法:字节流读取,字符流读取,Scanner 工具类读取. 字节流读取 直接看一个例子: public class Demo01SystemIn { pub
-
java基础入门之IO流
目录 io学习框架: 文件: Io流的原理: 节点流和处理流: BufferWriter: 处理字节的处理流: 标准输入和输出: 转换流: 打印流: Properties类: 总结 io学习框架: 文件: 保存数据的地方. 1)常见文件对象的相关构造器和方法: 当进行File file = new File(filePath);只是在内存上有一个文件对象: 只有file.createNewFile();才会在磁盘创建文件 获取文件的相关信息: utf8中,一个汉字是三个字节,所以当用字节流的re
-
Java-IO流实验
目录 前言 一.资源管理器 [1]. 题目 [2]. 实例 [3]. 代码 二.文件复制与剪切 [1]. 题目 [2]. 复制 [3]. 剪切 [4]. 代码 三.文件数据读写 [1]. 题目 [2]. 实例 [3]. 代码 总结 前言 项目结构如下,在使用代码的时候注意修改成你自己的包名和类名 一.资源管理器 [1]. 题目 设计一个用于显示指定目录下所有文件与文件夹的资源管理器类,要求包括: 从命令行输入一个路径,如果不是目录,则输出提示信息 如果是目录且存在,则显示该目录下,所有的文件与文
-
Java之IO流面试题案例讲解
一.Java中IO流分为几种? 按照流的流向分,可以分为输入流和输出流: 按照操作单元分,可以分为字节流和字符流(字节流可以读写任何单位的数据,字符流只可以读写txt数据): 按照流的角色分,可以分为节点流和处理流: 二.IO中flush()和close()的区别 close()方法具备刷新功能,在关闭流之前就会先刷新缓冲区,将缓冲区的字节全部刷新到文件上,在关闭流.(close()方法包含一次flush()方法) flush()方法可以刷新,并且刷新之后可以继续写,而close()方法刷新之后
-
Java IO流深入理解
目录 阻塞(Block)和非阻塞(Non-Block) 同步(Synchronization)和异步(Asynchronous) BIO与NIO对比 面向流与面向缓冲 阻塞与非阻塞 选择器的问世 Java NIO三件套 缓冲区Buffer Buffer的基本的原理 缓冲区分配 选择器Selector 通道Channel 使用NIO读取数据 使用NIO写入数据 IO多路复用 总结 阻塞(Block)和非阻塞(Non-Block) 阻塞和非阻塞是进程在访问数据的时候,数据是否准备就绪的一种处理方式,
-
Java IO流和文件操作实现过程解析
Java.io 包几乎包含了所有操作输入.输出需要的类.所有这些流类代表了输入源和输出目标. Java.io 包中的流支持很多种格式,比如:基本类型.对象.本地化字符集等等. 一个流可以理解为一个数据的序列.输入流表示从一个源读取数据,输出流表示向一个目标写数据. Java 为 I/O 提供了强大的而灵活的支持,使其更广泛地应用到文件传输和网络编程中. 控制台输入 BufferedReader br = new BufferedReader(new InputStreamReader(Syste
-
Java IO流之节点流与字符流的相关知识总结
一.File file是文件和目录路径名的抽象表示 1.1 File的用法 用法: File file = new File("路径名"); //如 File file = new File("L:\\FileTestDemo\\AAA\\aaa.txt"); 注意:在windows中,路径名不能使用单个的\,单个的\为转义字符,可以使用\\,//或/ 1.2 File的常用方法 1.boolean createNewFile() 当且仅当具有此名称的文件尚不存在时
-
Java IO流常用字节字符流原理解析
Java的流体系十分庞大,我们来看看体系图: 这么庞大的体系里面,常用的就那么几个,我们把它们抽取出来,如下图: 一:字节流 1:字节输入流 字节输入流的抽象基类是InputStream,常用的子类是 FileInputStream和BufferedInputStream. 1)FileInputStream 文件字节输入流:一切文件在系统中都是以字节的形式保存的,无论你是文档文件.视频文件.音频文件...,需要读取这些文件都可以用FileInputStream去读取其保存在存储介质(磁盘等)上
-
Java如何基于IO流实现同一文件读写操作
1.注意事项 众所周知,对一个文件进行读写操作时,我们需要创建对应的输入流和输出流 但需要注意的是,读写操作不能同时进行(边读边写),即不能同时打开输入流和输出流,直白一点说就是不能同时对同一个文件的输入流和输出流进行赋值,否则影响文件进行正常的读写操作.如果是不同的文件,则可以边读边写. 2.那么我们怎么对同一个文件进行读写操作呢? 不能边读边写,但是可以先读后写,先写后读. a.先读后写 打开输入流,对文件进行读操作,操作完成之后把输入流关掉(注意一定要关掉).然后再打开输出流,对文件进行写
-
Java全面解析IO流相关知识
目录 前言 一.File 1.File类的概述和构造方法 2.File类创建功能 3.File类判断和获取功能 4.File类删除功能 二.字节流 1.IO流的概述和分类 2.字节流写数据 3.字节流写数据的两个小问题 字节流写数据如何换行 字节流写数据如何实现追加写入 4.字节流写入数据假异常处理 5.字节流读数据(重点) 6.字节缓冲流 7.如何选择怎样得数据读取呢? 三.字符流 1.为什么会出现字符流? 2.字符串中的编码解码问题 3.如何实现解决编译解码的问题 4.字符流写数据的方法 5
-
Java中IO流解析及代码实例详解
目录 1.IO流 1.流和流的分类 什么是IO流? IO流的分类? java.io包下需要掌握的流有16个: 2.如何使用流 1.输入流(读文件):FileInputStream 2.输出流(写文件):FileOutputStream 3.文件的拷贝 总结 1.IO流 1.流和流的分类 什么是IO流? I:Input (输入) O: Ouput(输出) IO流的分类? 有多种分类方式: 一种方式是按照流的方向进行分类: 以内存作为参照物 往内存中去,叫做输入(Input).或者叫做读(Read)