目录
1.流的概念
- 流:内存与存储设备之间传输数据的通道
2.流的分类
2.1 按流向分类
- 输入流:将<存储设备>中的内容读到<内存>中
- 输出流:将<内存>中的内容写到<存储设备>中
2.2 按单位分类
- 字节流:以字节为单位,可以读写所有数据
- 字符流:以字符为单位,只能读写文本数据
2.3 按功能分类
- 节点流:具有实际传输数据的读写功能
- 过滤流:在节点流的基础之上增强功能
3.字节流
字节流的父类(抽象类)
//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){}
3.1文件字节流
FileInputStream entends InputStream:
public int read(byte[] b)//从流中读取多个字节,将读到内容存入b数组,返回实际读到的字节数;如果达到文件的尾部,则返回-1。
FileOutputStream entends OutputStream:
public void write(byte[] b)//一次写多个字节,将b数组中所有字节,写入输出流。
/**
* 演示FileInputStream的使用
*/
public class Demo01 {
public static void main(String[] args) throws Exception{
// 1 创建FileInputStream 并指定文件路径
FileInputStream fis = new FileInputStream("d:\\aaa.txt");//abcdefg
// 2 读取文件
// fis.read();
// 2.1单字节读取
// System.out.println("==========单字节读取=========");
// int data = 0;
// while((data = fis.read()) != -1){
// System.out.print(((char) data));//read():返回读到的的字节(ASCII编码形式),读到结尾返回-1
// }//执行完以上代码,read()方法中指针已到达文件结尾
// System.out.println();
// 2.2 一次读取多个字节
System.out.println("==========一次读取多个字节=========");
byte[] buf = new byte[3]; // 建立大小为3的字节数组
// int count = fis.read(buf); // read(Byte[] byte):一次读3个字节,并将读到的字节存储到byte[]中,并返回读取的个数
// String str=new String(buf);//new String(Bytr[] byte):把byte中的字节转为字符串
// System.out.println(str);//输出abc
// System.out.println(count);//输出3
// int count1 = fis.read(buf); // 再读3个
// System.out.println(new String(buf));//输出def
// System.out.println(count1);
// int count2 = fis.read(buf);//返回读取的个数
// System.out.println(new String(buf));//输出gef
// System.out.println(count2);//输出1,此时读取了1个字节
// int count3 = fis.read(buf);//返回读取的个数
// System.out.println(count3);//输出-1,此时指针到达末尾
// 上述代码有些冗长,进行优化
int count = 0;
while((count = fis.read(buf)) != -1){
System.out.println((new String(buf, 0, count)));//把buf中下标从0到(count-1)的字节转换为字符串
}
// 3 关闭
fis.close();
System.out.println("执行完毕");
}
}
/**
* 演示文件字节输出流的使用
* FileOutPutStream
*/
public class Demo02 {
public static void main(String[] args) throws Exception{
//1.创建一个FileOutPutStream对象
FileOutputStream fos = new FileOutputStream("d:\\bbb.txt");
// FileOutputStream fos = new FileOutputStream("d:\\bbb.txt",true);
// 这种方法可以不覆盖源文件,在源文件后面追加
//2.写入文件
fos.write(97);//写入的是ASCII码
fos.write('b');
fos.write('c');
String str="Hello World";
fos.write(str.getBytes());//getBytes():获取字符串对应的字节数组
//3.关闭
fos.close();
System.out.println("执行完毕");
}
}
/**
* 使用文件字节流实现文件的复制
*/
public class Demo03 {
public static void main(String[] args) throws Exception{
//1.创建流
//1.1文件字节输入流
FileInputStream fis=new FileInputStream("d:\\001.jpg");
//1.2文件字节输出流
FileOutputStream fos = new FileOutputStream("d:\\002.jpg");
//2.边读边写
byte[] buf=new byte[1024];
int count=0;
count=fis.read(buf);
int i=0;
while ((count=fis.read(buf))!=-1){
fos.write(buf,0,count);
i++;
}
System.out.println(i);
fis.close();
fos.close();
System.out.println("执行完毕");
}
}
3.2字节缓冲流
- 缓冲流:BufferedInputStream/BufferedOutputStream。
- 提高IO效率,减少访问磁盘的次数;
- 数据存储在缓冲区中,flush是将缓存区的内容写入文件中,也可以直接close。
/**
* 使用字节缓冲流读取
* BufferedInputStream
* @author NG
*/
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.读取
// int date=0;
// while ((date=bis.read())!=-1){//bis实际上创建了一个大小为8k的缓冲区,先把数据读到了缓冲区
// System.out.print((char) date);
// }
byte[] bytes=new byte[1024];
int count=0;
while ((count=fis.read(bytes))!=-1);{
System.out.println(new String(bytes,0,count));
}
//3.关闭
bis.close();
}
}
/**
* 使用字节缓冲流输出
* BufferedOutputStream
* @author NG
*/
public class Demo05 {
public static void main(String[] args) throws Exception{
//1.创建字节输出缓冲流
FileOutputStream fos=new FileOutputStream("d:\\buffer.txt");
BufferedOutputStream bos=new BufferedOutputStream(fos);
//2.写入文件
for (int i = 0; i <10 ; i++) {
bos.write("HelloWorld\r\n".getBytes());//写入了8k的缓冲区,没有写入硬盘
bos.flush();//刷新到硬盘
}
//3.关闭
bos.close();//内部会调用fos.close()
}
}
3.3对象流
-
对象流:ObjectOutputStream/ObjectInputStream
-
增强了缓冲区功能
-
增强了读写8种基本数据类型和字符串功能
-
增强了读写对象的功能:
readObject()//从流中读取一个对象 writeObject(0bject obj)//向流中写入一个对象
-
-
使用流传输对象的过程称为序列化、反序列化。
/**
*使用ObjectOutputStream实现对象的序列化
* 要实现序列化的类必须实现Serializable接口
*/
public class Demo06 {
public static void main(String[] args) throws Exception{
//1.创建对象流
FileOutputStream fos=new FileOutputStream("d:\\JavaStream\\stu.bin");
ObjectOutputStream oos=new ObjectOutputStream(fos);
//2.实现序列化(写入操作)
Student student = new Student("张三",20);
oos.writeObject(student);
//3.关闭
oos.close();
System.out.println("序列化完毕");
}
}
/**
* 使用ObjectInputStream实现对象的反序列化(读取重构成对象)
* 要实现序列化的类必须实现Serializable接口
*/
public class Demo07 {
public static void main(String[] args) throws Exception{
//1.创建对象流
FileInputStream fis=new FileInputStream("d:\\JavaStream\\stu.bin");
ObjectInputStream ois=new ObjectInputStream(fis);
//2.反序列化(读取文件)
Student s=(Student)ois.readObject();
//3关闭
ois.close();//内部会关闭fis
System.out.println(s.toString());
}
- 对象流注意事项
/**
*使用ObjectOutputStream实现对象的序列化
* 注意事项:
* (1)要实现序列化的类必须实现Serializable接口
* (2)要实现序列化的类中对象属性必须实现Serializable接口
* (比如学生类中有一个由类创建的属性,那么这个类也要实现Serializable接口)
* (3)序列化版本ID,保证序列化和反序列化的类是同一个类
* (4)使用transient修饰符修饰属性,那么这个属性就不能序列化了
* (5)静态属性不能序列化
* (6)序列化多个对象,可以借助集合来实现
*/
public class Demo06 {
public static void main(String[] args) throws Exception{
//1.创建对象流
FileOutputStream fos=new FileOutputStream("d:\\JavaStream\\stu.bin");
ObjectOutputStream oos=new ObjectOutputStream(fos);
//2.实现序列化(写入操作)
Student student = new Student("张三",20);
Student student1 = new Student("李四",22);
ArrayList<Student> arrayList=new ArrayList<>();
arrayList.add(student);
arrayList.add(student1);
oos.writeObject(arrayList);
//3.关闭
oos.close();
System.out.println("序列化完毕");
}
/**
* 使用ObjectInputStream实现对象的反序列化(读取重构成对象)
* 要实现序列化的类必须实现Serializable接口
*/
public class Demo07 {
public static void main(String[] args) throws Exception{
//1.创建对象流
FileInputStream fis=new FileInputStream("d:\\JavaStream\\stu.bin");
ObjectInputStream ois=new ObjectInputStream(fis);
//2.反序列化(读取文件)
ArrayList<Student> list= (ArrayList<Student>) ois.readObject();
//3关闭
ois.close();//内部会关闭fis
System.out.println(list.toString());
}
}
/**
* 学生类
*/
public class Student implements Serializable {
//把鼠标放到需要添加序列号的类名上,Alt + Enter快速生成SerializableUID
private static final long serialVersionUID = -441706825686703656L;
private String name;
private transient int age;//transient修饰符修饰的属性不能序列化
public static String country="中国";//静态属性不能序列化
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;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
4.字符流
-
常见字符编码:
-
ISO-8859-1:收录除ASCII外,还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号。
-
UTF-8:针对Unicode码表的可变长度字符编码(1个字节,或者两个字节,对于中文是三个字节)
-
GB2312:简体中文(1个字节,或者两个字节)
-
GBK:简体中文、扩充(1个字节,或者两个字节)
-
BIG5:台湾,繁体中文
-
-
当编码方式和解码方式不一致时,会出现乱码。
-
字符流的父类(抽象类):Reader和Writer
//Reader:字符输入流
//Reader中的方法:
public int read() {}
public int read(char[]c){}
public int read (char[] b, int off,int len){}
//Writer:字符输入流
//Writer中的方法:
public void write(int n){}
public void write(String str){}
public void write(ehar[] c){}
4.1文件字符流
//FileReader:
public int read(char[] c)//从流中读取多个字符,将读到内容存入c数组,返回实际读到的字符数;如果达到文件的尾部,则返回-1
//FileWriter:
public void write(String str)//一次写多个字符,将b数组中所有字符,写入输出流。
/**
* 使用FileReader来读取文件
*/
public class Demo02 {
public static void main(String[] args) throws Exception{
//1.创建文件字符输入流
FileReader fr=new FileReader("d:\\JavaStream\\hello.txt");
//2.读取文件
//2.1单个字符读取
// int count;
// while ((count=fr.read())!=-1){//每次读取一个字符,如果是汉字就读取三个字节
// System.out.print((char) count);
// }
//2.2多个字符读取
char[] chars=new char[1024];
int count;
while ((count=fr.read(chars))!=-1){
System.out.println(new String(chars,0,count));
}
//3.关闭
fr.close();
}
}
/**
* 使用FileWriter来输出文件
*/
public class Demo03 {
public static void main(String[] args) throws Exception{
//1.创建文件字符输出流
FileWriter fw=new FileWriter("d:\\JavaStream\\write.txt");
//2.输出文件
for (int i=0;i<10;i++) {
fw.write("Java是世界上最好的语言\n");
}
//3.关闭
fw.close();
}
}
/**
* 使用文件字符流来实现文件的复制,只能复制文本文件,不能复制图片,音频等二进制文件
*/
public class Demo04 {
public static void main(String[] args) throws Exception{
FileReader fr=new FileReader("d:\\JavaStream\\write.txt");
FileWriter fw=new FileWriter("d:\\JavaStream\\write111.txt");
int count;
char[] chars=new char[1024];
while ((count=fr.read(chars))!=-1){
fw.write(chars,0,count);
}
fr.close();
fw.close();
System.out.println("复制完毕");
}
}
4.2字符缓冲流
-
缓冲流: BufferedReader/BufferedWriter
- 高效读写
- 支持输入换行符。
- 可一次写一行、读一行。
/** * 使用字符缓冲流读取文件 * BufferedReader */ public class Demo05 { public static void main(String[] args) throws Exception{ //1.创建缓冲流 FileReader fr=new FileReader("d:\\JavaStream\\write.txt"); BufferedReader br=new BufferedReader(fr); //2.读取 //2.1 创建缓冲区读取 // char[] buf=new char[1024]; // int count; // while ((count=br.read(buf))!=-1){ // System.out.println(new String(buf,0,count)); // } // for (int i = 0; i < 13; i++) { // System.out.println(buf[i]); // } //2.2 一行一行的读取 String str=null; while((str=br.readLine())!=null) { //reafLine():读取一行,以String形式返回这一行的内容,读到结束返回null System.out.println(str); } //3.关闭 br.close(); } }
/** * 演示BufferedWriter的使用 * */ public class Demo06 { public static void main(String[] args) throws Exception{ //1.创建BufferedWriter对象 FileWriter fw=new FileWriter("d:\\JavaStream\\buffer.txt"); BufferedWriter bw=new BufferedWriter(fw); //2.写入 for (int i = 0; i < 10; i++) { bw.write("好好学习,天天向上"); bw.newLine();//写入一个换行符\r\n bw.flush(); } //3.关闭 bw.close(); System.out.println("执行完毕"); } }
4.3打印流
- PrintWriter:
- 封装了print() / println()方法,支持写入后换行
- 支持数据原样打印
/**
* 演示PrintWriter的使用
*/
public class Demo07 {
public static void main(String[] args) throws Exception{
//1.创建打印流
PrintWriter pw=new PrintWriter("d:\\JavaStream\\print.txt");
//2.打印
pw.println(97);
pw.println(true);
pw.println(3.14);
pw.print('a');
//3.关闭
pw.close();//关闭时自动执行flush()
System.out.println("执行完毕");
}
}
5.转换流
- 桥转换流:InputStreamReader/OutputStreamWriter。
- 可将字节流转换为字符流。
- 可设置字符的编码方式。
/**
* 演示InputStreamReader的使用
*/
public class Demo08 {
public static void main(String[] args) throws Exception{
//1.创建InputStreamReader对象
FileInputStream fis=new FileInputStream("d:\\JavaStream\\write.txt");
InputStreamReader isr=new InputStreamReader(fis,"utf-8");
//2.读取文件
int data=0;
while ((data=isr.read())!=-1){
System.out.print((char)data);
}
//3.关闭
isr.close();
}
}
/**
* 使用OutputStreamWriter写入文件,使用指定的编码
*/
public class Demo09 {
public static void main(String[] args) throws Exception{
//1.创建OutputStreamWriter对象
FileOutputStream fos=new FileOutputStream("d:\\JavaStream\\info.txt");
OutputStreamWriter osw=new OutputStreamWriter(fos,"gbk");
//2.写入
for (int i = 0; i < 10; i++) {
osw.write("我爱北京,我爱故乡\r\n");
osw.flush();
}
//3.关闭
osw.close();
}
}
6.File类
- 概念:代表物理盘符中的一个文件或者文件夹。
- 方法:
createNewFile()//创建一个新文件.
mkdir()//创建一个新目录
delete( //删除文件或空日录
exists()//判断File对象所代表的对象是否存在
getAbsolutePath)//获取文件的绝对路径
getName 0)//取得名字
getParent 0 //获取文件/目录所在的目录
isDirectory () //是否是日录
isFile()//是否是文件
length()//获得文件的长度
listFiles()//列出目录中的所有内容
renameTo()//修改文件名为
/**
* 演示File类的使用
* (1)分隔符
* (2)文件操作
* (3)文件夹操作
*/
public class Demo01 {
public static void main(String[] args) throws Exception{
seperator();
fileOpe();
directoryOpe();
}
//(1)分隔符
public static void seperator(){
System.out.println("路径分隔符"+ File.pathSeparator);
System.out.println("名称分隔符"+ File.separator);
}
//(2)文件操作
public static void fileOpe() throws Exception{
System.out.println("==========文件操作=============");
//1.创建文件
File file=new File("d:\\JavaStream\\file.txt");//此时文件还不存在,只是创建了一个文件对象
//System.out.println(file.toString());
if (!file.exists()) {//file.exists():判断文件是否存在,存在返回true,否则false
boolean bool = file.createNewFile();//创建文件,创建成功返回true;创建成功以后再次创建返回false
System.out.println("创建结果:" + bool);
}
//2.删除文件
//2.1 直接删除
// System.out.println("删除结果:"+file.delete());//file.delete():删除文件,删除成功返回true,否则false
//2.2 使用JVM退出时删除
// file.deleteOnExit();//JVM退出时删除文件
// Thread.sleep(5000);//休眠5s
//3.获取文件信息
System.out.println("获取文件的绝对路径:"+file.getAbsolutePath());
System.out.println("获取路径:"+file.getPath());
System.out.println("获取名称:"+file.getName());
System.out.println("获取父目录:"+file.getParent());
System.out.println("获取文件长度:"+file.length());
System.out.println("获取文件创建时间:"+new Date(file.lastModified()).toLocaleString());
//4.判断
System.out.println("是否可写:"+file.canWrite());
System.out.println("是否是文件:"+file.isFile());
System.out.println("是否隐藏:"+file.isHidden());
}
//(3)文件夹操作
public static void directoryOpe() throws Exception{
System.out.println("==========文件夹操作=============");
//1.创建文件夹
File dir=new File("d:\\JavaStream\\aaa\\bbb");
// System.out.println(dir.toString());//此时并没有创建文件夹
while (!dir.exists()){
//dir.mkdir();//只能创建单级目录,本案例是多级目录
System.out.println("创建结果:"+dir.mkdirs());//创建成功返回true,否则false
}
//2.删除文件夹
// //2.1直接删除
// System.out.println("删除结果"+dir.delete());
// //删除文件夹:只能删除最底层目录,并且只有文件夹为空文件夹时才能删除成功
// //2.2使用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()).toLocaleString());
//4.判断
System.out.println("判断是否是文件夹:"+dir.isDirectory());
System.out.println("判断是否隐藏:"+dir.isHidden());
//5.遍历文件夹
File dir2=new File("d:\\JavaCode");
String[] files=dir2.list();//遍历使用list()或者listFile(),list()返回字符串数组,listFile()返回File数组
System.out.println("==================");
for (String s:files){
System.out.println(s);
}
}
}
7.FileFilter接口
public interface FileFilter{
boolean accept(File pathname)}
- 当调用File类中的listFiles()方法时,支持传入FileFilter接口接口实现类,对获取文件进行过滤,只有满足条件的文件的才可出现在listFiles()的返回值中。
/**
* 演示FileFilter接口的使用
*/
public class Demo02 {
public static void main(String[] args) throws Exception{
directoryOpe();
}
public static void directoryOpe() throws Exception{
File dir=new File("C:\\Users\\15924\\Desktop\\党建德育助理\\2021.3");
File[] files=dir.listFiles(new FileFilter() {//使用匿名内部类可以简化代码
@Override
public boolean accept(File pathname) {
if(pathname.getName().endsWith(".xls")){
return true;
}
return false;
}
});
for(File file:files){
System.out.println(file.getName());
}
}
}
public class Demo02 implements FileFilter{
public static void main(String[] args) throws Exception{
directoryOpe();
}
public static void directoryOpe() throws Exception{
File dir=new File("C:\\Users\\15924\\Desktop\\党建德育助理\\2021.3");
FileFilter ff=new Demo02();
File[] files = dir.listFiles(ff);
for(File file:files){
System.out.println(file.getName());
}
}
@Override
public boolean accept(File pathname) {
if(pathname.getName().endsWith(".xls")){
return true;
}
return false;
}
}
/**
* 递归遍历文件夹和递归删除文件夹
*/
public class Demo03 {
public static void main(String[] args) {
listDir(new File("C:\\Users\\15924\\Desktop\\myfiles"));
deleteDir(new File("C:\\Users\\15924\\Desktop\\myfiles"));
}
//案例1:递归遍历文件夹
public static void listDir(File dir){
File[] files=dir.listFiles();
if(files!=null&&files.length>0){
for(File file:files){
if(file.isDirectory()){
System.out.println(file.getAbsolutePath());
listDir(file);
}
if(file.isFile()){
System.out.println(file.getAbsolutePath());
}
}
}
}
//案例1:递归删除文件夹
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());
}
}
8.Properties集合
- Properties:属性集合
- 特点:
- 1存储属性名和属性值
- 2属性名和属性值都是字符串类型
- 3 没有泛型
- 4和流有关
/**
* 演示Properties的使用
*/
public class Demo01 {
public static void main(String[] args) throws Exception{
//1.创建一个Properties集合
Properties properties=new Properties();
//2.添加数据
properties.setProperty("username", "zhangsan");
properties.setProperty("age", "20");
System.out.println(properties.toString());
//3.遍历
//3.1 ------keySet()------
System.out.println("=========keySet()=========");
Set<Object> set=properties.keySet();
for (Object o : set) {
System.out.println( o+"="+properties.get(o));
}
//3.2 ------entrySet()------
System.out.println("=========entrySet()=========");
Set entryset=properties.entrySet();
for (Object o : entryset) {
System.out.println(o);
}
//3.3 ------stringPropertyNames()------
System.out.println("=========stringPropertyNames()=========");
Set<String> pronames=properties.stringPropertyNames();
for (String proname : pronames) {
System.out.println(proname+"="+properties.getProperty(proname));
}
//4.和流有关的方法
//------list()方法------
PrintWriter pw=new PrintWriter("d:\\print.txt");
properties.list(pw);
pw.close();
//------store()方法------
FileOutputStream fos=new FileOutputStream("d:\\store.properties");
properties.store(fos,"注释");//store()方法不允许出现中文,存储过程中会进行转码
fos.close();
//------load()方法------
Properties properties1=new Properties();
FileInputStream fis=new FileInputStream("d:\\store.properties");
properties1.load(fis);
fis.close();
System.out.println(properties1.toString());
}
}