IO流
IO流概述
IO流简介:
概述:
I(Input,输入)/o(Output,输出)流,是Java中用来传输数据的方式.
划分:
按照流向分:
输入流:读数据.
输出流:写数据.
按照操作分:
字节流:以字节为单位来操作数据.
InputStream :字节输入流的顶层抽象类..
FileInputStream :普通的字节输入流.
BufferedInputStream :高效的字节输入流(也叫:字节缓冲输入流)
OutputStream:字节输出流的顶层抽象类.
FileOutputStream :普通的字节输出流.
BufferedOutputStream:高效的字节输出流(也叫:字节缓冲输出流).
字符流:以字符为单位来操作数据.
Reader:字符输入流的顶层抽象类.
FileReader :普通的字符输入流.
BufferedReader:高效的字符输入流(也叫:字符缓冲输入流)
Writer:字符输出流的顶层抽象类.
FileWriter :普通的字符输出流.
BufferedWriter:高效的字符输出流(也叫:字符缓冲输出流
File类
概念 文件,文件夹,一个File对象代表磁盘上的某个文件或文件夹 解释:就是用来操作文件夹路径的
构造方法∶ File(String pathname) File(String parent, String child) File(File parent, String child)
成员方法: 创建功能:如果不存在就创建,返回true,存在就不创建,返回false createNewFile():创建文件 mkdir()和mkdirs()∶创建目录 判断功能: isDirectory():判断File对象是否为目录 isFile():判断File对象是否为文件 exists():判断File对象是否存在
import java.io.File;
import java.io.IOException;
/* 概念
文件,文件夹,一个File对象代表磁盘上的某个文件或文件夹
解释:就是用来操作文件夹路径的
构造方法∶
File(String pathname)
File(String parent, String child)
File(File parent, String child)
成员方法:
创建功能:如果不存在就创建,返回true,存在就不创建,返回false
createNewFile():创建文件
mkdir()和mkdirs()∶创建目录
判断功能:
isDirectory():判断File对象是否为目录
isFile():判断File对象是否为文件
exists():判断File对象是否存在
*/
public class Test {
public static void main(String[] args) throws IOException {
//需求:将F:\abc\1.txt封装成File对象
//方式一根据字符串形式的路径获取File对象
//File file1 = new File("F:\\abc\\1.txt");
File file1 = new File("F:/abc/1.txt");
System.out.println("file1:"+file1);
//方式二根据字符串形式的父目录以及子目录创建File对象
File file2 = new File("F:/abc/","1.txt");
System.out.println("file2:"+file2);
//方式三根据父目录对象,以及字符串形式的子目录来获取File对象
File file3 = new File("F:/abc/");
File file4 = new File(file3,"1.txt");
System.out.println("file4:"+file4);
System.out.println("----------------------");
//在f盘下创建2.txt
File file5 = new File("F:/2.txt");
boolean flag1 = file5.createNewFile();
System.out.println("flag:"+flag1);
//在f盘下创建文件夹a
File file6 = new File("f:/a");
boolean m1 = file6.mkdir();//make directory创建单级目录
System.out.println("m1:"+m1);
//需求:在f盘下创建f:/a/b/c
File file7 = new File("f:/a/b/c");
boolean m2 = file7.mkdirs();//创建多级目录(也可以创建单级目录)
System.out.println("m2:"+m2);
System.out.println("-----------------");
//判断功能
File file8 = new File("f:/a/b");
System.out.println("测试file8是否是文件夹:"+file8.isDirectory());
System.out.println("测试file8是否是文件:"+file8.isFile());
System.out.println("测试file8是否是存在:"+file8.exists());
}
}
概念 文件,文件夹,一个File对象代表磁盘上的某个文件或文件夹
◆成员方法:
getAbsolutePath()∶获取绝对路径
绝对路径:以盘符开头的路径.例如:D:/1.txt
getPath()∶获取文件的相对路径
相对路径:一般是相对于当前项目路径来讲的.例如:1.txt
getName():获取文件名
list():获取指定目录下所有文件(夹)名称数组
listFiles()︰获取指定目录下所有文件(夹)File数组
import java.io.File;
/*概念
文件,文件夹,一个File对象代表磁盘上的某个文件或文件夹
成员方法:
getAbsolutePath()∶获取绝对路径
getPath()∶获取文件的相对路径
getName():获取文件名
list():获取指定目录下所有文件(夹)名称数组
listFiles()︰获取指定目录下所有文件(夹)File数组
java路径的划分:
绝对路径:以盘符开头的路径,固定的路径例如:D:/1.txt
相对路径:相对于某个路径而言,一般是相对于当前项目路径来讲的.例如:1.txt
*/
public class Test1 {
public static void main(String[] args) {
File file1 = new File("lib/1.txt");
//获取绝对路径
String path1 = file1.getAbsolutePath();
System.out.println("绝对路径:"+path1);
//获取相对路径
String path2 = file1.getPath();
System.out.println("相对路径:"+path2);
//获取文件名
String file1Name = file1.getName();
System.out.println("文件名:"+file1Name);
//获得lib文件下的所有文件夹:名称数组String[]
System.out.println("----------------");
File file2 = new File("F:/JavaSE/基础语法/lic");
String[] list1 = file2.list();
for (String s : list1) {
System.out.println(s);
}
//获得lib文件下的所有文件夹:File对象数组File[]
System.out.println("--------------");
File[] list2 = file2.listFiles();
for (File file : list2) {
System.out.println(file);
}
}
}
字符流读写文件
-
创建字符流读文件对象∶
Reader reader = new FileReader("readme.txt")
调用方法读取数据:
int data = reader. read() ;
读取一个字符,返回该字符代表的整数,若到达流的末尾,返回-1
异常处理;
throws IOException
关闭资源∶
reader.close();
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
/* 字符流读数据
Reader类中的方法:
int read() :
读一个字符,返回该字符对应的ASCII码值,读不到返回-1.
FileReader类的构造方法:
public FileReader(String pathname);根据传入的字符串形式的路径,获取字符输入流对象*/
public class Test01 {
public static void main(String[] args) throws IOException {
//需求:通过字符流读取文件
//1.创建字符流输入对象
Reader reader = new FileReader("F:/JavaSE/基础语法/lib/1.txt");
//2.读取数据
// int ch1 = reader.read();
// System.out.println(ch1);
// int ch2 = reader.read();
// System.out.println(ch2);
// int ch3 = reader.read();
// System.out.println(ch3);
// int ch4 = reader.read();
// System.out.println(ch4);
//优化上述代码实际开发中,不知道循环次数用while循环
/*(ch=reader.read())!=-1做了三件事
1.执行reader.read(),去文件中读取一个字符
2.执行ch=reader.read(),将读取到的字符赋值给变量ch
3.(ch=reader.read())!=-1,用读取到的字符和-1作比较
*/
int ch;//定义变量,用来接受读取到的数据
while ((ch=reader.read())!=-1){
//ch=reader.read();
System.out.println(ch);
}
//3.释放资源
reader.close();
}
}
2.
字符流读数据-按字符数组读取
创建字符流读文件对象:
Reader reader = new FileReader("readme.txt") ;
调用方法读取数据:
char[] chs = new char[2048];int len = r.read(chs) ;
读取字符到数组中,返回读取的字符数,若到达流的末尾,返回-1
异常处理:
throws IOException
关闭资源∶
reader.close();
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
/*
字符流读数据
Reader类中的方法:
int read(char[] chs) ;一次读一个字符数组,将读取到的内容存入到数组中,并返回读取到的有效字符数,读不到返回-1.
FileReader类的构造方法:
public FileReader(String pathname);根据传入的字符串形式的路径,获取字符输入流对象*/
public class Test02 {
public static void main(String[] args) throws IOException {
//需求:通过字符流读取数据,一次读取一个字符数组
//1.创建字符输入流对象
Reader reader = new FileReader("F:/JavaSE/基础语法/lib/2.txt");
//2.读取数据
/*char[] chs = new char[3];
int len1 = reader.read(chs);
System.out.println(chs);
System.out.println(len1);
int len2 = reader.read(chs);
System.out.println(chs);
System.out.println(len2);
int len3 = reader.read(chs);
System.out.println(chs);
System.out.println(len3);*/
//优化上述代码,用while循环
//定义字符数组
char[] chs = new char[3];
//定义一个变量,记录读取到有效字符
int len;
while ((len= reader.read(chs))!=-1){
//将读取到的数据转换成字符串,然后打印
/*chs:表示要操作的数组
0:表示起始索引
len:表示要操作字符的个数
*/
String s = new String(chs,0,len);
System.out.println(s);
}
//3.关闭资源
reader.close();
}
}
-
字符流写数据―按单个字符写入
创建字符流写文件对象∶Writer writer = new FileWriter("dest.txt");
调用方法写入数据∶
int x =’中’;
writer.write(x) ;
写一个字符
异常处理:
throws IOException
关闭资源:
writer.close();
-
字符流写数据–按字符数组写入
创建字符流写文件对象∶Writer writer = new FileWriter ("dest.txt);
调用方法写入数据:
char[] chs = {橙’,’心',’橙’,’意’手};
writer.write(chs);
写一个字符数组
异常处理∶
throws IOException
关闭资源︰
writer.close();
-
字符流写数据–按字符串写入
创建字符流写文件对象∶Writer writer = new FileWriter ("dest.txt);
调用方法写入数据:
writer.write("小马爱学习");
写一个字符串
异常处理∶
throws IOException
关闭资源︰
writer.close();
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
/*字符流写数据
Writer类中的方法:
void write(int ch); 一次写一个字符
void write(char[] chs,int index,int len);一次写一个指定的字符数组
void write(String str); 一次写一个字符串
FileWriter类的构造方法:
public FileWriter(String pathname); 根据传入的字符串形式的路径,获取字符输出流对象
*/
public class Test01 {
public static void main(String[] args) throws IOException {
//需求:通过字符流写数据
//创建字符输入流对象
Writer writer = new FileWriter("F:/JavaSE/基础语法/lib/1.txt");
//写数据
//一次写一个字符
//writer.write('好');
//一次写一个指定的字符数组
// char[] chs = {'你','是','一','个','大','帅','哥'};
// writer.write(chs,4,3);
//一次写一个字符串
writer.write("好好学习,天天向上");
//释放数据
writer.close();
}
}
字符流拷贝文件
-
字符流拷贝文件―按单个字符读写
创建字符流读文件对象∶
Reader reader = new FileReader("readme.txt);
创建字符流写文件对象∶
Writer writer = new FileWriter("dest.txt");
调用方法读取数据:
int data = reader.read() ;
调用方法写入数据:
writer.write(data) ;
异常处理:
throws IOException
关闭资源:
reader.close();
writer.close();
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Test01 {
public static void main(String[] args) throws IOException {
//需求:通过字符流拷贝文件,一次读写一个字符
//例如,把1.txt拷贝到2.txt中
/*
IO流拷贝文件核心6步:
1.创建字符输入流对象,关联数据源文件.
2.创建字狩输出流对象,关联目的地文件.
3.定义变量,记录读取到的内容.
4.循环读取,只要条件满足就一直读,并将读取到的内容赋值给变量.
5.将读取到的数据写入到目的地文件中.
6.释放资源.
*/
//1
FileReader fr = new FileReader("F:/JavaSE/基础语法/lib/1.txt");
//2
FileWriter fw = new FileWriter("F:/JavaSE/基础语法/lib/3.txt");
//如果目的地文件不存在,程序会自动创建
//3
int len;
//4
while ((len=fr.read())!=-1){
//5
fw.write(len);
}
//6
fr.close();
fw.close();
}
}
-
字符流拷贝文件―按字符数组读写
创建字符流读文件对象∶
Reader reader = new FileReader("readme.txt");
创建字符流写文件对象∶
Writer writer = new FileWriter("dest.txt");
调用方法读取数据:
char[] chs = new char[2048];int len = reader. read(chs) ;
调用方法写入数据∶
writer. write(chs,o, len);
异常处理:
throws IOException
reader.close();
writer.close();
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Test02 {
public static void main(String[] args) throws IOException {
//需求:通过字符流拷贝文件,一次读写一个字符数组
//例如,把1.txt拷贝到2.txt中
/*
IO流拷贝文件核心6步:
1.创建字符输入流对象,关联数据源文件.
2.创建字狩输出流对象,关联目的地文件.
3.定义变量,记录读取到的有效字符数.
4.循环读取,只要条件满足就一直读,并将读取到的内容赋值给变量.
5.将读取到的数据写入到目的地文件中.
6.释放资源.
*/
//1
FileReader fr = new FileReader("F:/JavaSE/基础语法/lib/1.txt");
//2
FileWriter fw = new FileWriter("F:/JavaSE/基础语法/lib/3.txt");
//如果目的地文件不存在,程序会自动创建
//3
//定义一个字符数组
char[] chs = new char[1024];
int len;
//4
while ((len=fr.read(chs))!=-1){
//5
fw.write(chs,0,len);
}
//6.
fr.close();
fw.close();
}
}
字符缓冲流拷贝文件
字节流的用法
FilefnputStream:普通的字节输入流,用来读取数据的.
构造方法:
public FileInputStream (String pathname) ;成员方法:
public int read();一次读取一个字节,并返回读取到的内容,读不到返回-1.
FileOutputStream:普通的字节输出流,用来写数据的.
构造方法:
public FileOutputStream (String pathname) ;成员方法:
public void write(int len);一次写入一个字节
字符缓冲流拷贝文件的标准代码
创建字符流读文件对象∶
BufferedReader br = new BufferedReader(
new FileReader("readme.txt")) ;
创建字符流写文件对象∶
BufferedWriter bw = new BufferedWriter(
new FileWriter("dest.txt")) ;
异常处理:
throws IOException
使用while循环读写数据∶
int len;
while((len = br.read()) != -1) {
bw.write(len) ; }
关闭资源∶
br.close() ;
bw.close) ;
字节流读写文件
字节流的用法
FilefnputStream:普通的字节输入流,用来读取数据的.
构造方法:
public FileInputStream (String pathname) ;成员方法:
public int read();一次读取一个字节,并返回读取到的内容,读不到返回-1.
FileOutputStream:普通的字节输出流,用来写数据的.
构造方法:
public FileOutputStream (String pathname) ;成员方法:
public void write(int len);一次写入一个字节
字节流拷贝文件
-
字节流拷贝文件-按单个字节读
创建字节流读文件对象:
InputStream is = new FileInputStream("")
创建字节流写文件对象∶
OutputStream os = new FileOutputStream("");
异常处理:
throws IOException
使用while循环读写数据:
int b;
while((b = is.read()) != -1) {
os.write(b);
}
关闭资源:
is.close() ;
os.close( ;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
字节流的用法
FilefnputStream:普通的字节输入流,用来读取数据的.
构造方法:
public FileInputStream (String pathname) ;成员方法:
public int read();一次读取一个字节,并返回读取到的内容,读不到返回-1.
FileOutputStream:普通的字节输出流,用来写数据的.
构造方法:
public FileOutputStream (String pathname) ;
成员方法:
public void write(int len);一次写入一个字节
*/
public class Test {
public static void main(String[] args) throws IOException {
// 1.创建字节输入流对象,关联数据源文件.
FileInputStream fii = new FileInputStream("F:/JavaSE/基础语法/lib/1.jpg");
// 2.创建字节输出流对象,关联目的地文件.
FileOutputStream fio = new FileOutputStream("F:/JavaSE/基础语法/lib/2.jpg");
// 3.定义变量,用来记录读取到的内容.
int len;
// 4.循环读取,只要条件满足就一直读,并将读取到的内容赋值给变量.
while ((len=fii.read())!=-1){
fio.write(len);
}
// 5.将读取到的数据写入到目的地文件中.
// 6.释放资源.
fii.close();
fio.close();
}
}
-
字节流拷贝文件-按字节数组读写
创建字节流读文件对象∶
InputStream is = new FileInputStream("");
创建字节流写文件对象∶
OutputStream os = new FileOutputStream("");
异常处理:
throws IOException
定义字节数组,每次读取2048个字节:
byte[] b = new byte[2048];
使用while循环读写数据:
int len;
while((len = is.read(b)) != -1) {
os.write(b,0, len) ;
关闭资源:
is.close() ;
os.close() ;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
字节流的用法
FileInputStream:普通的字节输入流,用来读取数据的.
成员方法:
public int read(byte[] bys);一次读取一个字芮数组,将读取到的内容存入到数组中,
并返回读取到的有效字节数,读不到返回-1.
FileOutputStream:普通的字节输出流,用来写数据的.
成员方法:
public void write(bytel] bys,int index,int len);一次写入一个指定的字节数组
*/
public class Test1 {
public static void main(String[] args) throws IOException {
//需求:通过普通字节流一次读写一个字节数组的方式,将4.jpg复制5.jpg
// 1.创建字节输入流对象,关联数据源文件.
FileInputStream fii = new FileInputStream("F:/JavaSE/基础语法/lib/4.jpg");
// 2.创建字节输出流对象,关联目的地文件.
FileOutputStream fio = new FileOutputStream("F:/JavaSE/基础语法/lib/5.jpg");
// 3.定义变量,用来记录读取到的内容.
byte[] b = new byte[2048];
//用来记录读取到有效字节数
int len;
// 4.循环读取,只要条件满足就一直读,并将读取到的内容赋值给变量.
while ((len=fii.read(b))!=-1){
// 5.将读取到的数据写入到目的地文件中.
fio.write(b,0,len);
}
// 6.释放资源.
fii.close();
fio.close();
}
}
字节缓冲流拷贝文件
字节缓冲流拷贝文件的标准代码
创建字节缓冲流读文件对象∶
BufferedInputStream bis = new BufferedInputStream(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() ;
import java.io.*;
/* 字节缓冲流的用法:
BufferTdInputStream:字节缓冲输入流(也叫:高效字节输入流),用来读取数据的.
构造方法:
public BufferedInputStream InputStream is);
成员方法:
public int read() ;一次读取一个字节,并返回读取到的内容,读不到返回-1
BufferedOutputStream:字节缓冲输出流(也叫:高效字节输出流),用来写数据的.
构造方法:
public BufferedOutputStream(OutputStream os) ;
成员方法:
public void write(int len);一次写入一个字节.
特点:
字节缓冲流有自己的缓冲区,大小为8192个字节,也就是8KB.
拷贝纯文本用字符流,拷贝其它(图片,音频,视频等)用字节流
*/
public class Test2 {
public static void main(String[] args) throws IOException {
//需求:通过字节缓冲流,将4.jpg复制到6.jpg
// 1.创建字节缓冲输入流对象,关联数据源文件.
BufferedInputStream bi = new BufferedInputStream(new FileInputStream("F:/JavaSE/基础语法/lib/4.jpg"));
// 2.创建字节缓冲输出流对象,关联目的地文件.
BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream("F:/JavaSE/基础语法/lib/6.jpg"));
// 3.定义变量,记录读取到的内容.
int len;
// 4.循环读取,只要条件满足就一直读,并将读取到的内容赋值给变量.
while ((len=bi.read())!=-1){
//5.将读取到的数据写入到目的地文件中.
bo.write(len);
}
// 6.释放资源.
bi.close();
bo.close();
}
}