什么是流
- 概念:内存与存储设备之间传输数据的通道
- 水借助管道传输,数据借助流传输
流的分类
-
按方向【重点】:
- 输入流:将存<储设备>中的内容读入到<内存>中。
- 输出流:将<内存>中的内容写入到<存储设备中>。
-
按单位:
- 字节流:以字节为单位,可以读写所有数据。
- 字符流:以字符为单位,只能读写文本数据。
-
按功能
- 节点流:具有实际传输数据的读写功能。
- 过滤流:在节点流的基础之上增强功能。
字节流
- 字节流的父类(抽象类);
- Input Stream:字节输入流
- Output Stream:字节输出流
文件字节流
- File Input Stream:
- public int read(byte[] b) //从流中读取多个子节,将读到内容存入b数组,返回实际读到的字节数:如果达到文件的尾部,则返回-1。
- File Output Stream:
- public void write(byte[] b) //一次写多个字节,将b数组中所有字节,写入输出流
package com.xu_1;
import java.io.FileInputStream;
/**
* 演示File Input Stream的使用
* 文件字节输入流
* @author 【徐先生】
*
*/
public class Demo01 {
public static void main(String[] args) throws Exception{
// 1创建FileInputStream,并指定文件路径
FileInputStream fis = new FileInputStream("C:\\Desktop\\MarkDown\\basic\\javaSE一\\初识JAVA.md");
// 2读取文件
// fis.read()
// int data=0;
// while((data=fis.read())!=-1) {
// System.out.println((char)data);
// }
// 关闭
// fis.close();
// System.out.println("执行完毕");
// 2.2一次读取多个字节
byte[] buf = new byte[1024];
int count = 0;
while((count=fis.read(buf))!=-1) {
System.out.println(new String(buf,0,count));
}
// 3关闭
fis.close();
System.out.println("执行完毕");
}
}
package com.xu_1;
import java.io.FileOutputStream;
/**
* 演示文件字节输出流的使用
* File Output Stream
* @author 【徐先生】
*
*/
public class Demo02 {
public static void main(String[] args) throws Exception{
// 1创建文件字节输出流对象
FileOutputStream fos = new FileOutputStream("D:\\bbb.txt",true);
// 2写入文件
// fos.write(97);
// fos.write('b');
// fos.write('c');
String s1 = "helloWorld";
fos.write(s1.getBytes());
// 3关闭
fos.close();
System.out.println("执行完毕");
}
}
package com.xu_1;
import java.io.FileInputStream;
import java.io.FileOutputStream;
/**
* 使用文件字节流实现文件的复制
* @author 【徐先生】
*
*/
public class Demo03 {
public static void main(String[] args) throws Exception{
// 1创建流
// 1.1文件字节输入流
FileInputStream fis = new FileInputStream("D:\\Sketchpad.png");
// 1.2文件字节输出流
FileOutputStream fos = new FileOutputStream("D:\\001.jpg");
// 2一边读一边写
byte[] buf = new byte[1024];
int count = 0;
while ((count=fis.read(buf))!=-1) {
fos.write(buf,0,count);
}
// 3关闭
fis.close();
fos.close();
System.out.println("执行完毕");
}
}
字节缓冲流
- 缓冲流:BufferedInput Stream/BufferedOutput Stream
- 提高IO效率,减少访问磁盘的次数;
- 数据存储在缓冲区中,flush是将缓存区的内容写入文件中,也可以直接close。
package com.xu_1;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
/**
* 使用字节缓冲流读取
* BufferedInputStream
* @author 【徐先生】
*
*/
public class Demo04 {
public static void main(String[] args) throws Exception{
// 1创建BufferedInputStream
FileInputStream fis = new FileInputStream("D:\\aaa.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
// 2读取
byte[] bytes = new byte[1024];
int count = 0;
while((count=bis.read(bytes))!=-1) {
System.out.println(new String(bytes,0,count));
}
// 3关闭
bis.close();
System.out.println("执行完毕");
}
}
package com.xu_1;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
/**
* 使用字节缓冲流写入
* @author 【徐先生】
*
*/
public class Dmeo05 {
public static void main(String[] args) throws Exception{
// 创建字节输出流
FileOutputStream fot = new FileOutputStream("D:\\aaa.txt");
BufferedOutputStream bos = new BufferedOutputStream(fot);
// String string ="12344556566677";
// bos.write(string.getBytes());
// 写入文件
for(int i=0;i<10;i++) {
bos.write("helloworld\r\n".getBytes());//写入8k缓冲区
bos.flush();//刷新到硬盘
}
// 关闭
bos.close();
}
}
package com.xu_1;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class Demo06 {
public static void main(String[] args) throws Exception{
FileInputStream fis = new FileInputStream("D:\\001.jpg");
BufferedInputStream bis = new BufferedInputStream(fis);
FileOutputStream fos = new FileOutputStream("D:\\002.jpg");
int count= 0;
while((count=bis.read())!=-1) {
fos.write(count);
}
// 关闭
bis.close();
fos.close();
}
}
对象流
- 对象流:ObjectOutputStream/ObjectInputStream
- 增强了缓冲区功能
- 增强了读写8种基本数据类型和字符串功能
- 增强了读写对象的功能readObject()从流中读取一个对象
- writeObject(Object obj)向流中写入一个对象
使用流传输对象的过程称为序列化、反序列化。
package com.xu_1;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
/**
* 使用ObjectOutputStream实现对象的序列化
* 要求,序列化必须要实现Serializable接口
* @author 【徐先生】
*
*/
public class Demo07 {
public static void main(String[] args) throws Exception{
// 1.创建对象流
FileOutputStream fos =new FileOutputStream("D:\\stu.bin");
ObjectOutputStream oos =new ObjectOutputStream(fos);
// 2.序列化(写入操作)
Student zhangsan= new Student("张三","20");
oos.writeObject(zhangsan);
// 3.关闭
oos.close();
System.out.println("序列化完毕");
}
}
package com.xu_1;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
/**
* 使用Object InputStream实现反序列化(读取重构成对象)
* @author 【徐先生】
*
*/
public class Demo08 {
public static void main(String[] args) throws Exception {
// 1.创建对象流
FileInputStream fis = new FileInputStream("D:\\stu.bin");
ObjectInputStream ois = new ObjectInputStream(fis);
// 2.读取(反序列化)
Student s = (Student)ois.readObject();
System.out.println(s);
// 3.关闭
ois.close();
System.out.println("执行完毕");
}
}
package com.xu_1;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
/**
* 使用ObjectOutputStream实现对象的序列化
* 1.要求,序列化必须要实现Serializable接口
* 2.序列化类中对象属性要求实现Serializable接口
* 3.序列化版本号ID,保证序列化的类和你反序列化的类是同一个类
* 4.使用transient(瞬间的)修饰属性,这个属性不能序列化
* 5.静态属性不能序列化
* 6.序列化多个对象,可以借助集合实现
* @author 【徐先生】
*
*/
public class Demo07 {
public static void main(String[] args) throws Exception{
// 1.创建对象流
FileOutputStream fos =new FileOutputStream("D:\\stu.bin");
ObjectOutputStream oos =new ObjectOutputStream(fos);
// 2.序列化(写入操作)
Student zhangsan= new Student("张三","20");
Student lisi = new Student("李四","19");
ArrayList<Student> list = new ArrayList<>();
list.add(zhangsan);
list.add(lisi);
oos.writeObject(list);
oos.writeObject(list);
// 3.关闭
oos.close();
System.out.println("序列化完毕");
}
}
package com.xu_1;
import java.io.Serializable;
/**
* 学术类
* @author 【徐先生】
*
*/
public class Student implements Serializable{
/**
*
*/
private static final long serialVersionUID = 100L;
/**
* 序列化版本号ID,保证序列化的类和你反序列化的类是同一个类
*/
private String name;
private transient String age;
package com.xu_1;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.ArrayList;
/**
* 使用Object InputStream实现反序列化(读取重构成对象)
* @author 【徐先生】
*
*/
public class Demo08 {
public static void main(String[] args) throws Exception {
// 1.创建对象流
FileInputStream fis = new FileInputStream("D:\\stu.bin");
ObjectInputStream ois = new ObjectInputStream(fis);
// 2.读取(反序列化)
// Student s = (Student)ois.readObject();
// Student s2 = (Student)ois.readObject();
@SuppressWarnings("unchecked")
ArrayList<Student> list = (ArrayList<Student>) ois.readObject();
System.out.println(list);
// System.out.println(s);
// System.out.println(s2);
// 3.关闭
ois.close();
System.out.println("执行完毕");
}
}
字符编码
- ISO-8859-1收录除ASCII外,还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号。
- UTF-8 针对Unicode码表的可变长度字符编码
- GB2312 简体中文
- GBK 简体中文、扩充
- BIG5 ,台湾,繁体中文
- 当编码方式和解码方式不同的时候会出现乱码
字符流
- reader()
- wreter()
文件字符流
- File Reader:
- public int read(char[] c) //从流中读取多个字符,将读到内容存入c 数组,返回实际读到的字符数;如果到达文件尾部,则返回-1.
- File Writer:
- public void write(String str)//一次写多个字符,将b数组中所有字符,写入输出流。
package com.xu_2;
import java.io.FileReader;
/**
* 使用File Reader读取文件
* @author 【徐先生】
*
*/
public class Demo02 {
public static void main(String[] args) throws Exception{
// 创建File Reader 文件字符流输入
FileReader fr = new FileReader("D:\\hello.txt");
int count=0;
while((count=fr.read())!=-1) {
System.out.println((char)count);
}
// 关闭
fr.close();
}
}
package com.xu_2;
import java.io.FileWriter;
/**
* 使用FileWriter写入文件
*
* @author 【徐先生】
*
*/
public class Demo03 {
public static void main(String[] args) throws Exception {
// 创建File Writer对象
FileWriter fw = new FileWriter("D:\\write.txt");
// 写入
for(int i=0; i<10;i++) {
fw.write("java是世界上最好的语言\r\n");
fw.flush();
}
String data = "java是世界上最好的语言";
fw.write(data);
// 关闭
fw.close();
System.out.println("执行完毕");
}
}
package com.xu_2;
import java.io.FileReader;
import java.io.FileWriter;
/**
* 使用File Reader和File Writer复制文本文件,不能复制图片或二进制文件
* @author 【徐先生】
*
*/
public class Demo04 {
public static void main(String[] args) throws Exception{
// 创建File Reader File Writer
FileReader fr =new FileReader("D:\\write.txt");
FileWriter fw = new FileWriter("D:\\hello.txt");
int data=0;
while((data=fr.read())!=-1) {
fw.write(data);
fw.flush();
}
// 关闭
fr.close();
fw.close();
System.out.println("执行完毕");
}
}
字符缓冲流
- 缓冲流:BufferedReader/BufferedWriter
- 高效读写
- 支持输入换行符
- 可一次写一行、读一行。
package com.xu_2;
import java.io.BufferedReader;
import java.io.FileReader;
/**
* 使用字符缓冲流来读取文件 BufferedWriter
*
* @author 【徐先生】
*
*/
public class Democrats {
public static void main(String[] args) throws Exception{
// 创建缓冲流
FileReader fr = new FileReader("D:\\write.txt");
BufferedReader br = new BufferedReader(fr);
// 读取文件
// char[] bs = new char[1024];
// int count=0;
// while((count=br.read(bs))!=-1) {
// System.out.print(new String(bs,0,count));
// }
// 第二种读取方法,一行一行的读取
String line = null;
while((line=br.readLine())!=null) {
System.out.println(line);
}
// 关闭
br.close();
}
}
package com.xu_2;
import java.io.BufferedWriter;
import java.io.FileWriter;
/**
* 演示BufferedWriter的使用
* @author 【徐先生】
*
*/
public class Demo07 {
public static void main(String[] args) throws Exception{
// 1创建BufferedWriter对象
FileWriter fw = new FileWriter("D:\\buffer.txt");
BufferedWriter bw = new BufferedWriter(fw);
// 写入
for(int i=0;i<10;i++) {
bw.write("索尼大法好");
bw.newLine();
bw.flush();
}
// 关闭
bw.close();
}
}
打印流
- PrintWriter:
- 封装了print()/println()方法,支持写入后换行。
- 支持数据原样打印
package com.xu_2;
import java.io.PrintWriter;
/**
* 演示PrintWriter的使用
* @author 【徐先生】
*
*/
public class Demo08 {
public static void main(String[] args) throws Exception{
// 1创建打印流
PrintWriter pw = new PrintWriter("D:\\print.txt");
// 打印
pw.println(97);
pw.println(true);
pw.println(3.14);
// 关闭
pw.close();
}
}
转换流
-
桥转换流:Input Stream Reader/Output Stream Writer
- 可以将字节流转换为字符流。
- 可设置字符编码的编码方式。
package com.xu_2;
import java.io.FileInputStream;
import java.io.InputStreamReader;
/**
* 使用Input Stream Reader读取文件,指定使用的编码
* @author 【徐先生】
*
*/
public class Demo09 {
public static void main(String[] args) throws Exception{
// 1.创建Input Stream Reader对象
FileInputStream fis = new FileInputStream("D:\\write.txt");
InputStreamReader isr = new InputStreamReader(fis,"gbk");
// 读取文件
int data=0;
while((data=isr.read())!=-1) {
System.out.print((char)data);
}
// 关闭
isr.close();
}
}
package com.xu_2;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
/**
* 使用OutputStreamWriter写入文件,使用指定编码
* @author 【徐先生】
*
*/
public class Demo10 {
public static void main(String[] args) throws Exception{
// 1创建OutputStreamWriter
FileOutputStream fos = new FileOutputStream("D:\\info.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");
// 2写入
for(int i=0;i<10;i++) {
osw.write("我爱北京,我爱故乡\r\n");
}
// 关闭
osw.close();
}
}
File类
- 概念:代表物理盘符中的一个文件或者文件夹。
- 方法:
- createNewFile()//创建一个新文件
- mkdir()//创建一个新目录
- delete()//删除文件或空目录
- exists()//判断File对象所代表的对象是否存在
- getAbsolutePath()//获取文件的绝对路径
- getName()//取得名字
- getParent()//获取文件/目录所在的目录
- isDirectory()//是否是目录
- isFile()//是否是文件
- length()//获得文件的长度
- listFiles()//列出目录中的所有内容
- renameTo()//修改文件名为
package com.xu_3;
import java.io.File;
import java.util.Date;
/**
* File类的使用 (1)分隔符 (2)文件操作 (3)文件夹操作
*
* @author 【徐先生】
*
*/
public class Demo01 {
public static void main(String[] args) throws Exception {
fileOpe();
}
public static void separator() {
System.out.println("路径分隔符" + File.pathSeparator);
System.out.println("名称分隔符" + File.pathSeparator);
}
// 2文件操作
public static void fileOpe() throws Exception {
// 创建文件
File file = new File("D:\\file.txt");
// System.out.println(file);
if (!file.exists()) {
boolean b = file.createNewFile();
System.out.println("创建结果" + b);
}
// 删除文件
// System.out.println(file.delete());
// 使用JVM来删除
// file.deleteOnExit();
// Thread.sleep(5000);
// 获取文件的绝对路径
System.out.println("获取文件的绝对路径:" + file.getAbsolutePath());
System.out.println("获取路径"+file.getName());
System.out.println("获取路径"+file.getPath());
System.out.println("获取父目录"+file.getParent());
System.out.println("获取文件长度:"+file.length());
System.out.println("文件创建时间"+new Date(file.lastModified()));
// 判断
System.out.println("是否可写:"+file.canWrite());
System.out.println("是否是文件:"+file.isFile());
System.out.println("是否隐藏"+file.isHidden());
}
}
package com.xu_3;
import java.io.File;
import java.util.Date;
// 3文件夹操作
public static void directoryOpe() throws Exception {
// 1创建文件夹
File dir = new File("D:\\aa\\bb\\cc");
System.out.println(dir.toString());
if (!dir.exists()) {
// dir.mkdir();只能创建单级目录
System.out.println("创建结果:"+dir.mkdirs());//创建多级目录
}
// 2删除文件夹
// System.out.println("删除文件夹"+dir.delete());
// 使用JVM删除
// dir.deleteOnExit();
// Thread.sleep(5000);
// 3获取文件夹信息
System.out.println("获取绝对路径"+dir.getAbsolutePath());
System.out.println("获取路径"+dir.getPath());
System.out.println("获取文件夹名称"+dir.getName());
System.out.println("获取父目录"+dir.getParent());
System.out.println("获取文件创建时间"+ new Date(dir.lastModified()));
// 4判断
System.out.println("是否是文件夹:"+dir.isDirectory());
System.out.println("是否隐藏"+dir.isHidden());
// 5遍历文件夹
File dir2 = new File("D:\\图片");
String[] files = dir2.list();
System.out.println("-----------------------");
for (String string : files) {
System.out.println(string);
}
}
}
FileFilter接口
-
public interface FileFilter
- boolean accept(File pathname)
-
当调用File类中的listFiles()方法时,支持传入FileFilter接口接口实现类,对获取文件进行过滤,只有满足条件的文件才可出现在listFiles()的返回值中。
package com.xu_3;
import java.io.FileFilter;
// 5遍历文件夹
File dir2 = new File("D:\\图片");
String[] files = dir2.list();
System.out.println("-----------------------");
for (String string : files) {
System.out.println(string);
}
System.out.println("---------FileFilter接口的使用-------------");
File[] files2 = dir2.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
if(pathname.getName().endsWith(".jpg")) {
return true;
}
return false;
}
});
for (File file : files2) {
System.out.println(file .getName());
}
}
}
递归遍历和递归删除
package com.xu_3;
import java.io.File;
/**
* 案例1遍历文件夹
* @author 【徐先生】
*
*/
public class ListDemo {
public static void main(String[] args) {
listDir(new File("D:\\图片"));
deleteDir(new File("D:\\图片"));
}
public static void listDir(File dir) {
File[] files = dir.listFiles();
if (files !=null&&files.length>0) {
for (File file : files) {
if (file.isDirectory()) {
listDir(file);
}else {
System.out.println(file.getAbsolutePath());
}
}
}
}
// 案例2:递归删除文件夹
public static void deleteDir(File dir) {
File[] files = dir.listFiles();
if (files!=null&&files.length>0) {
for (File file : files) {
if (file .isDirectory()) {
deleteDir(file);
}else {
// 删除文件
System.out.println(file.getAbsolutePath()+"删除"+file.delete());
}
}
}
System.out.println(dir.getAbsolutePath()+"删除"+dir.delete());
}
}
Properties集合
-
Properties:属性集合
-
特点:
-
- 存储属性名和属性值
- 属性名和属性值都是字符串类型
- 没有泛型
- 和流有关
-
package com.xu_3;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.Properties;
import java.util.Set;
/**
* 演示Properties集合的使用
* @author 【徐先生】
*
*/
public class Demo02 {
public static void main(String[] args) throws Exception {
// 1创建集合
Properties properties = new Properties();
// 2添加数据
properties .setProperty("username", "zhangsan");
properties .setProperty("age", "20");
System.out.println(properties .toString());
// 3遍历
// 3.1keyset
for (Object string : properties .keySet()) {
System.out.println(string+"-------"+properties .get(string));
}
// 3.2entryset
for (Object string : properties .entrySet()) {
System.out.println(string);
}
// 3.3stringPropertyNames
Set<String> pronames = properties .stringPropertyNames();
for (String pro : pronames) {
System.out.println(pro+"--------"+properties .getProperty(pro));
}
// 4和流有关的方法
1.list方法
// PrintWriter pW = new PrintWriter("D:\\print.txt");
// properties .list(pW);
// pW.close();
// 2. store方法
FileOutputStream fos = new FileOutputStream("D:\\store.properties");
properties .store(fos, "注释");
fos.close();
// 3.load方法 加载
Properties properties2 = new Properties();
FileInputStream fis = new FileInputStream("D:\\store.properties");
properties2.load(fis);
fis.close();
System.out.println(properties2.toString());
}
}
总结
- 流的概念:
- 内存与存储设备之间传输数据的通道。
- 流的分类:
- 输入流、输出流、字节流、字符流、节点流、过滤流
- 序列化、反序列化:
- 将对象通过流写入到文件,或将对象通过流读取到内存,必须实现Serializable接口
- File对象:
- 代表物理盘符中的一个文件或者文件夹。