java笔记整理:IO流
IO流
什么是流
概念:内存与存储设备之间传输数据的通道
流的分类
- 按方向【重点】:
- 输入流:将<存储设备>中的内容读入到<内存>中
- 输出流:将<内存>中的内容写入到<存储设备>中
- 按单位:
- 字节流:以字节为单位,可以读写所有数据
- 字符流:以字符为单位,只能读写文本数据
- 按功能:
- 节点流:具有实际传输数据的读写功能
- 过滤流:在字节流的基础之上增强功能
字节流
- 字节流的父类(抽象类):
- InputStream:字节输入流
- public int read(){}
- public int read(byte[] b){}
- public int read(byte[] b,int off,int len){}
- OutputStream:字节输出流
- public void write(int n){}
- public void write(byte[] b){}
- public void write(byte[] b,int off,int len){}
- InputStream:字节输入流
文件字节流
- FileInputStream:
- public int read(byte[] b) //从流中读取多个字节,将读取到的内容存入b数组,返回实际读到的字节数,如果达到文件的尾部,则返回-1
- FileOutputStream:
- public void write(byte[] b) //一次写多个字节,将b数组中的所有字节,写入输入流
- 输入流的使用
package IO;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* FileInputStream的使用
* 文件字节输入流
*/
public class Demo01 {
public static void main(String[] args) throws IOException {
//创建文件字节输入流
FileInputStream fis = new FileInputStream("E:\\aaa.txt");
//读取文件
//单个字节读取
// int data = 0;
// while((data=fis.read())!=-1){
// System.out.print((char) data);
// }
//多个字节读取
byte[] buf = new byte[10];
int count = 0 ;
while ((count=fis.read(buf))!=-1){
System.out.println(new String(buf,0,count));
}
fis.close();
System.out.println("读取完毕");
//
}
}
- 输出流的使用
package IO;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 输出流的使用
* FileOutStream
*/
public class Demo02 {
public static void main(String[] args) throws IOException {
//创建文件字节输出流对象(true表示添加时不覆盖)
FileOutputStream fos = new FileOutputStream("E:\\bbb.txt",true);
//写入文件
// fos.write(99);
// fos.write(98);
// fos.write(97);
String str = "HelloWorld";
fos.write(str.getBytes());
fos.close();
System.out.println("执行完毕");
}
}
- 使用文件流复制
package IO;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 文件流的复制
*/
public class Demo03 {
public static void main(String[] args) throws IOException {
//创建输入流
FileInputStream fis = new FileInputStream("E:\\a.txt");
//创建输出流
FileOutputStream fos = new FileOutputStream("E:\\b.txt");
//一边读,一边写
byte[] buf = new byte[1024];
int count = 0;
while((count=fis.read(buf))!=-1){
fos.write(buf,0,count);
}
fis.close();
fos.close();
System.out.println("复制完毕");
}
}
字节缓冲流
- 缓冲流:BufferedInputStream/BufferedOutputStream
- 提高IO效率,减少访问磁盘的次数
- 数据存储在缓冲区中,flush是将缓冲区的内容写入文件中,也可以直接close
- 使用字节缓冲流读取
package IO;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* 使用字节缓冲流读取
* BufferedInputStream
*/
public class Demo04 {
public static void main(String[] args) throws IOException {
//创建缓冲流BufferedInputStream
FileInputStream fis = new FileInputStream("E:\\a.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
//读取
int data = 0;
while ((data=bis.read())!=-1){
System.out.print((char) data);
}
//关闭
bis.close();
}
}
- 使用字节缓冲流写入
package IO;
import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 使用字节缓冲流写入文件
* BufferedOutputStream
*
*/
public class Demo05 {
public static void main(String[] args) throws IOException {
//创建字节输出缓冲流
FileOutputStream fos = new FileOutputStream("E:\\b.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
//写入文件
for (int i=0;i<10;i++){
bos.write("HelloWorld\r\n".getBytes());//写入缓冲区
bos.flush();//刷新到硬盘
}
bos.close();//会调用flush()方法
}
}
对象流
- 对象流:ObjectOutputStream/ObjectInputStream
- 增强了缓冲区功能
- 增强了读写8种基本数据类型和字符串功能
- 增强了读写对象的功能
- readObject()从流中读取一个对象
- writeObject(Object obj)向流中写入一个对象
- 使用流传输对象的过程称为序列化、反序列化
- 序列化的实现
package IO;
import java.io.*;
/**
* 使用ObjectOutputStream实现对象的序列化
* 要求:
* 1.序列化的类必须要实现Serializable
* 2.序列化类中对象属性要求实现Serializable接口
*/
public class Demo06 {
public static void main(String[] args) throws IOException {
//创建对象流
FileOutputStream fis = new FileOutputStream("E:\\a.bin");
ObjectOutputStream oos = new ObjectOutputStream(fis);
//序列化(写入操作)
Student s1 = new Student("张三",18);
oos.writeObject(s1);
//关闭
oos.close();
System.out.println("序列化完毕");
}
}
- 反序列化实现
package IO;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
/**
* 使用ObjectInputStream实现反序列化(读取重构成一个对象)
*/
public class Demo07 {
public static void main(String[] args) throws Exception {
//创建一个对象流
FileInputStream fis = new FileInputStream("E:\\a.bin");
ObjectInputStream ois = new ObjectInputStream(fis);
//读取文件(反序列化)
Student s = (Student) ois.readObject();
//关闭
ois.close();
System.out.println("执行完毕");
System.out.println(s.toString());
}
}
package IO;
import java.io.Serializable;
/**
* 学生类
*/
public class Student implements Serializable {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
字符编码
- ISO-8859-1收录除ASCLL外,还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号
- UTF-8:针对Unicode码表的可变长度字符编码
- GB2312:简体中文
- GBK:简体中文、扩充
- BIG5:台湾、繁体中文
- 注:当编码方式和解码方式不一致时,会出现乱码
字符流
- 字符流的父类(抽象类)
- Reader:字符输入流
- public int read(){}
- public int read(char[] c){}
- public int read(char[] b,int off,int len()){}
- Writer:字符输出流
- public void write(int n){}
- public void write(String str){}
- public void write(char[] c){}
- Reader:字符输入流
文件字符流
- FileReader:
- pubilc int read(char[] c) //从流中读取多个字符,将读到内容存入c数组就,返回实际读到的字符数;如果达到文件的尾部,则返回-1
- FileWrite:
- public void write(String str) //一次写多个字符,将b数组中所有字符,写入输出流
字符缓冲流
- 缓冲流:BufferedReader/BufferedWriter
- 高效读写
- 支持输入换行符
- 可一次写一行、读一行
打印流
- PrintWriter:
- 封装了print()/println()方法,支持写入后换行
- 支持数据原样打印
转换流
- 桥接转换:InputStreamReader/OutputStreamWrinter
- 可将字节流转换为字符流
- 可设置字符的编码方式
File类
- 概念:代表物理磁盘符中的一个文件或文件夹
- 方法:
- createNewFile() //创建一个新文件
- mkdir() //创建一个新目录
- delete() //删除文件或空目录
- exists() //判断File对象所代表的对象是否存在
- getAbsolutePath() //获取文件的绝对路径
- getName() //取得名字
- getParent() //获取文件/目录所在的目录
- isDirectory() //是否是目录
- isFile() //是否是文件
- length() //获取文件的长度
- listFiles() //列出目录中的所有内容
- renameTo() //修改文件名为
- 文件操作
package IO;
import java.io.File;
import java.io.IOException;
import java.util.Date;
/**
* File类的使用
* (1)分隔符
* (2)文件操作
* (3)文件夹操作
*/
public class Demo08 {
public static void main(String[] args) throws IOException {
separator();
fileOpe();
}
//(1)分隔符
public static void separator(){
System.out.println("路径分隔符:"+File.pathSeparatorChar);
System.out.println("名称分隔符:"+File.separator);
}
//(2)文件操作
public static void fileOpe() throws IOException {
//1创建文件
File file = new File("E:\\file.txt");
// System.out.println(file.toString());
if(file.exists()) {
System.out.println("文件已存在");
}else {
boolean b = file.createNewFile();
System.out.println("创建结果为:" + b);
}
// //2删除文件
// //2.1直接删除
// System.out.println(file.delete());
//
// //2.2使用JVM退出时删除
// file.deleteOnExit();
//3获取文件信息
//3.1获取文件路径
System.out.println(file.getAbsoluteFile());
System.out.println(file.getPath());
//3.2获取文件名称
System.out.println(file.getName());
//3.3获取父目录
System.out.println(file.getParent());
//3.4获取文件长度
System.out.println(file.length());
//获取文件创建时间
System.out.println(new Date(file.lastModified()).toLocaleString());
//判断
//是否可写
System.out.println(file.canWrite());
//是否可读
System.out.println(file.canRead());
//是否是文件
System.out.println(file.isFile());
//是否隐藏
System.out.println(file.isHidden());
}
}
- 文件夹操作
package IO;
import java.io.File;
import java.io.IOException;
import java.util.Date;
/**
* File类的使用
* (1)分隔符
* (2)文件操作
* (3)文件夹操作
*/
public class Demo08 {
public static void main(String[] args) throws IOException {
directoryOpe();
}
public static void directoryOpe() throws IOException {
//创建文件夹
File dir = new File("E:\\ddd\\aaa\\bbb\\ccc");
System.out.println(dir.toString());
if(dir.exists()){
System.out.println("文件已存在");
}else{
// dir.mkdir()创建单级目录
// dir.mkdirs()创建多级目录
boolean b = dir.mkdirs();
System.out.println(b);
}
//删除文件夹
//1.直接删除
System.out.println(dir.delete());
//2.调用JVM删除
dir.deleteOnExit();
//获取文件夹信息
//3.1获取文件夹路径
System.out.println(dir.getAbsoluteFile());
System.out.println(dir.getPath());
//3.2获取文件夹名称
System.out.println(dir.getName());
//3.3获取父目录
System.out.println(dir.getParent());
//获取文件夹创建时间
System.out.println(new Date(dir.lastModified()).toLocaleString());
//判断
//是否是文件夹
System.out.println(dir.isDirectory());
//是否隐藏
System.out.println(dir.isHidden());
//遍历
File dir2 = new File("C:\\Users\\crush\\Desktop\\一些图片");
String[] str = dir2.list();
System.out.println("-------------------");
for (String string:str
) {
System.out.println(string);
}
}
}
FileFilter接口
-
public interface FileFilter
- boolean accept(File pathname)
-
当调用File类中的ListFiles()方法时,支持传入FileFilter接口接口实现类,对获取文件进行过滤,只有满足条件的文件才可以出现在listFiles()的返回值中
-
递归调用和递归删除文件夹
package IO;
import java.io.File;
/**
* 递归遍历文件夹
* 递归删除文件夹
*/
public class listDemo {
public static void main(String[] args) {
listDir(new File("E:\\aaa\\bbb\\ccc"));
deleteDir(new File("E:\\aaa") );
}
//1.递归调用文件夹
public static void listDir(File dir){
File[] files = dir.listFiles();
System.out.println(dir.getAbsolutePath());
if(files!=null&&files.length>0){
for (File file:files
) {
if(file.isDirectory()){
listDir((file));//递归
}else{
System.out.println(file.getAbsolutePath());
}
}
}
}
//递归删除文件夹
public static void deleteDir(File dir){
File[] files = dir.listFiles();
if(files!=null&&files.length>0){
for (File file:files
) {
if(file.isAbsolute()){
deleteDir(file);//递归
}else{
//删除文件
System.out.println("已删除:"+file.getAbsolutePath()+file.delete());
}
}
}
System.out.println("已删除:"+dir.getAbsolutePath()+dir.delete());
}
}
补充:Properties
- Properties:属性集合
- 特点:
- 存储属性名和属性值
- 属性名和属性值都是字符串类型
- 没有泛型
- 和流有关
- Properties的使用
package IO;
import java.io.*;
import java.util.Properties;
import java.util.Set;
/**
* Properties集合的使用
*/
public class Demo09 {
public static void main(String[] args) throws IOException {
//创建一个集合
Properties properties = new Properties();
//添加元素
properties.setProperty("username","zhangsan");
properties.setProperty("age","20");
System.out.println(properties.toString());
//遍历
//keySet
//entrySet
//stringPropertiesNames()
Set<String> pronames = properties.stringPropertyNames();
for (String pro:pronames
) {
System.out.println(pro+":"+properties.getProperty(pro));
}
//和流有关的方法
//4.1 list方法
// PrintWriter printWriter = new PrintWriter("E:\\ddd\\aaa\\bbb\\print.txt");
// properties.list(printWriter);
// printWriter.close();
//store方法:保存
// FileOutputStream fos = new FileOutputStream("E:\\\\ddd\\\\aaa\\\\bbb\\\\prin.txt");
// properties.store(fos, "注释");
// fos.close();
//load方法:加载
Properties properties1 = new Properties();
FileInputStream fis = new FileInputStream("E:\\\\ddd\\\\aaa\\\\bbb\\\\print.txt");
properties1.load(fis);
fis.close();
System.out.println(properties1.toString());
}
}