收藏闪存小组博问

freedomAndWind

园龄：4年4个月粉丝：13关注：9

📂java
🔖java
2021-12-14 17:09阅读: 618评论: 0推荐: 0

IO

流

什么是流:内存与存储设备之间的传输.(所有的都是先进行Output在进行Input,我只是习惯先写Input在写Output)

流的分类

  • 按方向[重点]:
    • 输入流:将<存储设备>中的内容读入到<内存>中.
    • 输出流:将<内存>中得到内容写入到<存储设备>中.
  • 按单位:
    • 字节流:以字节为单位,可以读写所有数据.
    • 字符流:以字符为单位,只能读写文本数据.
  • 按功能:
    • 节点流:具有实际传输数据的读写功能.
    • 过滤流:在节点流的基础之上增强功能.

文件字节流

FileInputStream:

  • public int read(byte[] b)//从流中读取多个字节,将读到的内容存入b数组,返回实际读到的字节数;如果达到文件的尾部,则返回-1.
package IO.byteStream;

import java.io.FileInputStream;

/*
演示FileInputStream的使用
文件字节输入流
 */
public class fileInputStream {
    public static void main(String[] args) throws Exception {
//        //1创建FileInputStream,并指定文件路径
          FileInputStream fis = new FileInputStream("d:\\aaa.txt");
//        //2读取文件
//        //fis.read();
          //2.1单个字节读取
//        int data = 0;
//        while ((data=fis.read())!=-1){
//            System.out.print((char) data);
//        }
        //2.2一次读取多个字节
        byte[] buf = new byte[3];
        int count =0;
        while((count=fis.read(buf))!=-1){
            System.out.print(new String(buf,0,count));
        }
        //3关闭
        fis.close();
        System.out.println();
        System.out.println("执行完毕");
    }
}


FileOutputStream:

  • public void write(byte[] b)//一次写多个字节,将b数组中所有字节,写入输出流.
package IO.byteStream;

import java.io.FileOutputStream;

/*
演示文件字节输出流的使用
FIleOutputStream
 */
public class fileOutStream {
    public static void main(String[] args) throws Exception {
        //1创建文件字节输出流对象
        FileOutputStream fos = new FileOutputStream("d:\\bbb.txt",true);//这里的true就是append的意思,如果是在true就把字节写在末尾而不是开头
        //2写入文件
//        fos.write(97);
//        fos.write('b');
//        fos.write('c');
        String string = "helloworld";
        fos.write(string.getBytes());
        //3关闭
        fos.close();
        System.out.println("执行完毕");
    }
}



字节流文件复制

package IO.byteStream;

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class fileCopy {
    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;
        while ((count=fis.read(buf))!=-1){
            fos.write(buf,0,count);
        }
        //3关闭
        fis.close();
        fos.close();
        System.out.println("执行完毕");
    }
}


字节缓冲流

  • BufferedInputStream/BufferedOutputStream
    • 提高IO效率,减少访问磁盘的次数
    • 数据存储在缓冲区中,flush是将缓存区的内容写入文件中,也可以直接close.

BufferedInputStream

package IO.byteStream;

import java.io.BufferedInputStream;
import java.io.FileInputStream;

/*
使用字节缓冲流读取
BufferedInputStream
 */
public class bufferedInputStream {
    public static void main(String[] args) throws Exception{
        //1创建BufferedInputStream
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        //2读取
//        int data = 0;
//        while ((data=bis.read())!=-1){
//            System.out.print((char)data);
//        }
        byte[] buf = new byte[1024];
        int count = 0;
        while ((count=bis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //3关闭
        bis.close();
    }
}


BufferedOutputStream

package IO.byteStream;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

/*
使用缓冲流写入文件
BufferedOutputStream
 */
public class bufferedOutputStream {
    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".getBytes());//写入8K缓冲区
            bos.flush();//刷新到硬盘
        }
        //3关闭
        bos.close();
    }
}


对象流

  • ObjectOutputStream/ObjectInputStream
  • 增强了缓冲区功能
  • 增强了读写8种基本数据类型和字符串功能
  • 增强了读写对象的功能:
    • readObject();从流中读取一个对象
    • writeObject(Object obj);向流中写入一个对象

使用流传输对象的过程称为序列化、反序列化。

使用ObjectOutputStream实现对象的序列化
要求:
(1)序列化类必须要实现Serializable接口;
(2)序列化类中对象属性要求实现Serializable接口;
(3)序列化版本号ID,保证序列化的类和反序列化的类是同一个类;
(4)使用transient(瞬间的)修饰属性,这个属性就不能序列化;
(5)静态属性不能被序列化;
(6)序列化多个对象,可以借助集合来实现

ObjectInputStream

package IO.Objectflow;
/*
使用ObjectInputStream实现反序列化(读取重构成对象)
 */

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.ArrayList;

public class objectInputStream {
    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();
        ArrayList list = (ArrayList) ois.readObject();
        //3关闭
        ois.close();
        System.out.println("执行完毕");
//        System.out.println(s.toString());
//        System.out.println(s2.toString());
        System.out.println(list.toString());
    }
}

ObjectOutputStream

package IO.Objectflow;
/*
使用ObjectOutputStream实现对象的序列化
要求:
(1)序列化类必须要实现Serializable接口;
(2)序列化类中对象属性要求实现Serializable接口;
(3)序列化版本号ID,保证序列化的类和反序列化的类是同一个类;
(4)使用transient(瞬间的)修饰属性,这个属性就不能序列化;
(5)静态属性不能被序列化;
(6)序列化多个对象,可以借助集合来实现
 */
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.io.Serializable;

public class objectOutputStream {
    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("李四", 22);
        ArrayList<Student> list = new ArrayList<>();
        list.add(zhangsan);
        list.add(lisi);
        oos.writeObject(list);
        //3关闭
        oos.close();
        System.out.println("执行完毕");
    }
}
class Student implements Serializable {
    //serialVersionUID序列化ID
    private static final long serialVersionUID = 100L;
    private String name;
    private transient 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;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}


字符编码

  • ISO-8859-1收录除ASCII外,还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号。
  • UTF-8：针对Unicode码表的可变长度字符编码。
  • GB2321：简体中文
  • GBK：简体中文、扩充
  • BIG 台湾：繁体中文

字符流

  • 字符流的父类（抽象类）
    • Reader：字符输入流
      • public int read（）{}
      • public int read （char[] c）{}
      • public int read (char[] b,int off,int len){}
    • Write:字符输出流
      • public void write (int n){}
      • public void write(String str){}
      • public void write(char[] c){}

文件字符流

FileReader

  • public int read(char[] c)//从流中读取多个字符，将读到内容存入c数组，返回实际读到的字符数；如果达到文件尾部，则返回-1.
package IO.charStream;

import java.io.FileReader;

/*
使用FileReader读取文件
 */
public class fileReader {
    public static void main(String[] args) throws Exception{
        //1创建FileReader 文件字符输入流
        FileReader fr = new FileReader("d:\\write.txt");
        //2读取
        //2.1单个字符读取
//        int data = 0;
//        while ((data=fr.read())!=-1){//读取一个字符
//            System.out.print((char) data);
//        }
        //
        char[] buf = new char[1024];
        int count = 0;
        while ((count=fr.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //3关闭
        fr.close();
    }
}

FileWrite

  • public void write(String str)//一次写多个字符,将b数组中所有字符,写入输出流.
package IO.charStream;

import java.io.FileWriter;

/*
使用FileWrite写入文件
 */
public class fileWrite {
    public static void main(String[] args) throws Exception{
        //1创建File Write对象
        FileWriter fw = new FileWriter("d:\\write.txt");
        //2写入
        for (int i = 0; i < 10; i++) {
            fw.write("java是世界上最好的语言\r\n");
            fw.flush();
        }
        //3关闭
        fw.close();
    }
}

字符缓冲流

  • 缓冲流:BufferedReader/BufferedWrite
    • 高效读写
    • 支持输入换行符
    • 可一次写一行、读一行

BufferedReader

package IO.charStream;

import java.io.BufferedReader;
import java.io.FileReader;

/*
BufferedReader
 */
public class bufferedReader {
    public static void main(String[] args) throws Exception{
        //1创建缓冲流
        FileReader fr = new FileReader("d:\\buffer.txt");
        BufferedReader br = new BufferedReader(fr);
        //2读取
        //2.1第一行种方式
//        char[] buf = new char[1024];
//        int count = 0;
//        while ((count= br.read(buf))!=-1){
//            System.out.println(new String(buf,0,count));
//        }
        //2.2第二种方式,一行一行的读取
        String line = null;
        while ((line= br.readLine())!=null){
            System.out.println(line);
        }
        //3关闭
        br.close();
    }

}

BufferedWrite

package IO.charStream;

import java.io.BufferedWriter;
import java.io.FileWriter;

/*
演示BufferedWrite的使用
 */
public class bufferedWrite {
    public static void main(String[] args) throws Exception{
        //1创建BufferedWrite对象
        FileWriter fw = new FileWriter("d:\\buffer.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        //2写入
        for (int i = 0; i < 10; i++) {
            bw.write("好好学习,天天向上");
            bw.newLine();//写入一个换行符
            bw.flush();
        }
        //3关闭
        bw.close();
        System.out.println("执行完毕");
    }
}


字符流复制文件

package IO.charStream;

import java.io.FileReader;
import java.io.FileWriter;

/*
使用File Reader和FileWrite复制文本,不能复制图片或二进制文件
 */
public class fileCopy {
    public static void main(String[] args) throws Exception{
        //1创建FileReader FileWrite
        FileReader fr = new FileReader("d:\\001.jpg");
        FileWriter fw = new FileWriter("d:\\003.jpg");
        //2读写
        int data = 0;
        while ((data=fr.read())!=-1){
            fw.write(data);
            fw.flush();
        }
        //3关闭
        fr.close();
        fw.close();
        System.out.println("复制完毕");
    }
}




打印流

  • PrintWriter
    • 封装了print()/println()方法,支持写入后换行
    • 支持数据原样打印
package IO.charStream;

import java.io.PipedWriter;
import java.io.PrintWriter;

/*
演示PrintWrite的使用
 */
public class printWrite {
    public static void main(String[] args) throws Exception{
        //1创建打印流
        PrintWriter pw = new PrintWriter("d:\\print.txt");
        //2打印
        pw.println(97);
        pw.println(true);
        pw.println(3.14);
        pw.println('a');
        //3关闭
        pw.checkError();
        System.out.println("执行完毕");
    }
}



转换流

  • 桥接换流:InputStreamReader/OutputStreamWrite
    • 可将字节流转换为字符流
    • 可设置字符的编码方式

InputStreamReader

package IO.charStream;

import java.io.FileInputStream;
import java.io.InputStreamReader;

/*
演示InputStreamReader读取文件,指定使用的编码
 */
public class inputStreamReader {
    public static void main(String[] args) throws Exception{
        //1创建InputStreamReader对象
        FileInputStream fis = new FileInputStream("d:\\info.txt");
        InputStreamReader isr = new InputStreamReader(fis,"gbk");
        //2读取文件
        int data = 0;
        while ((data=isr.read())!=-1){
            System.out.print((char)data);
        }
        //3关闭
        isr.close();
    }
}

OutputStreamWrite

package IO.charStream;

import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

/*
使用OutputStreamWrite写入文件,使用指定编码
 */
public class outputStreamWrite {
    public static void main(String[] args) throws Exception{
        //1创建OutputStreamWrite
        FileOutputStream fos = new FileOutputStream("d:\\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();
        System.out.println("执行完毕");
    }
}



File类

  • 概念:代表物理盘符中的一个文件或者文件夹.
  • 方法:
    • createNewFile()//创建一个新文件
    • mkdir()//创建一个新目录
    • delete()//删除文件或空目录
    • exists()//判断File对象所对象所代表的对象是否存在
    • getAbsolutePath()//获取文件的绝对路径
    • getName()//取的名字
    • getParent()/获取文件/目录所在的目录
    • isDirectory()//是否是目录
    • isFile()//是否是文件
    • length()//获得文件长度
    • listFiles()//列出目录中的所有目录
    • renameTo()//修改文件名为

File Filter接口

  • public interface File Filter
    • boolean accept(File name)
  • 当调用File类中的listFiles()方法时,支持传入FileFilter接口,接口实现类,对获取文件进行过滤,只有满足条件的文件的才可出现在listFiles()的返回值中
package IO.file;

import java.io.File;
import java.io.FileFilter;
import java.util.Date;

/*
File类的使用
(1)分隔符
(2)文件操作
(3)文件夹操作
 */
public class Demo01 {
    public  static void main(String[] args) throws Exception {
        //separator();
        //fileOpe();
        directoryOpe();
    }
    //(1)分隔符
    public static void separator(){
        System.out.println("路径分隔符"+ File.pathSeparator);
        System.out.println("名称分隔符"+File.separator);
    }
    //(2)文件操作
    public static void fileOpe() throws Exception{
        //1创建文件
        File file = new File("d:\\file.txt");
        //System.out.println(file.toString());
        if (!file.exists()){
            boolean b = file.createNewFile();
            System.out.println("创建结果:"+b);
        }
        //2删除文件
        //2.1直接删除
        //System.out.println("删除结果:"+file.delete());

        //2.2使用jvm退出时删除
//        file.deleteOnExit();
//        Thread.sleep(5000);

        //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()).toString());

        //4判断
        System.out.println("是否可写:"+file.canWrite());
        System.out.println("是否是文件:"+ file.isFile());
        System.out.println("是否隐藏:"+file.isHidden());

    }
    //(3)文件夹操作
    public static void directoryOpe() throws Exception {
        //1创建文件夹
        File dir = new File("d:\\aaa\\bbb\\ccc");
        System.out.println(dir.toString());
        if (!dir.exists()){
            //dir.mkdir();//只能创建单极目录
            System.out.println("创建结果:"+dir.mkdirs());//创建多级目录
        }
        //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:\\aaa");
        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;//满足要求返回true,不满足返回false
                }
                return false;
            }
        });
        for (File file : files2) {
            System.out.println(file.getName());
        }
    }
}

遍历删除文件/文件夹

package IO.file;

import java.io.File;


public class ListDemo {
    public static void main(String[] args) {
        //listDir(new File("d:\\myfiles"));
        deleteDir(new File("d:\\myfiles"));
    }
    //案例1:递归遍历文件夹
    public static void listDir(File dir){
        File[] files = dir.listFiles();
        System.out.println(dir.getAbsoluteFile());
        if (files!=null&&files.length>0){
            for (File file : files) {
                if (file.isDirectory()){
                    listDir(file);
                }else {
                    System.out.println(file.getAbsoluteFile());
                }
            }
        }
    }
    //案例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.getAbsoluteFile()+"删除"+file.delete());
            }
        }
        System.out.println(dir.getAbsoluteFile()+"删除"+dir.delete());
    }
}

补充

  • Properties:属性集合
  • 特点
    1. 存储属性名和属性值
    2. 属性名和属性值都是字符串类型
    3. 没有泛型
    4. 和流有关
package IO.Properties;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.Properties;
import java.util.Set;

/*
演示Properties集合的使用
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{
        //1创建集合
        Properties properties = new Properties();
        //2添加数据
        properties.setProperty("username","zhangasan");
        properties.setProperty("age","29");
        System.out.println(properties.toString());
        //3遍历
        //3.1---keyset---
        //3.2--entryset--
        //3.3--stringPropertyName---
        Set<String> pronames=properties.stringPropertyNames();
        for (String pro:pronames) {
            System.out.println(pro+"=="+properties.getProperty(pro));
        }
        //4和流有关的方法
        //---list方法---
//        PrintWriter pw = new PrintWriter("d:\\print.txt");
//        properties.list(pw);
//        pw.close();

        //-----2store方法:保存----
//        FileOutputStream fos = new FileOutputStream("d:\\print.properties");
//        properties.store(fos,"注释");
//        fos.close();

        //----3load方法:加载---
        Properties properties2 = new Properties();
        FileInputStream fis = new FileInputStream("d:\\print.properties");
        properties2.load(fis);
        System.out.println(properties2.toString());
    }
}

本文作者：freedomAndWind

本文链接：https://www.cnblogs.com/linjiangplus/p/15684550.html

版权声明：本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。

posted @   freedomAndWind  阅读(618)  评论(0)  编辑  收藏  举报
点击右上角即可分享
微信分享提示
AI IDE Trae
评论
收藏
关注
推荐
深色
回顶
收起
  1. 1 Meet Fi9江澈,果妹
Meet - Fi9江澈,果妹
00:00 / 00:00
An audio error has occurred.

作词 : Fi9江澈

作曲 : Fi9江澈

她不是很瘦 她的个子也够不高

她不是很瘦 她的个子也够不高

她有时很逗 有时候 她也够SAO

每次她化完妆盯着问我 我会说她很丑

但每次离开的时候 我们互相 谁都不肯走

她爱吃粉丝的醋 也爱跟我 生气

她做傻事的时候 也都是和我会有争议

她不化妆的时候 我会刻意的说她很漂亮

总爱素颜的时候 去和别的女生去较量

她喜欢我性格的好 和行为上的屌丝

喜欢我的城市还有运河街道边的小吃

她有时很任性 莫名的跟我吵架

每次她耍小性子 也都会被我都一顿的好骂

她叫我玩游戏 我总故意不跟她玩

每次吵架的时候 总骂我是个渣男

她会讨好我爸妈 也会买礼物给悄悄

每次 卖萌 我也心领神会的笑笑

HOOK：街边的落雨下 我在这个小小世界

你走进我生命 又出现在我面前

谁又能代替呢 我所有的留恋

每次的遇见都是我们的永恒的瞬间

她一直都很敏感 总是常常怕我失去

她不知道 在我心里 她是我写下的诗句

她会在心情不好的时候 跟朋友去酗酒

大醉之后会说以后的路 她会陪着我去走

总爱问我分手了 会不会像以前 那样去对她

提些奇怪的问题 手机屏保为什不是她

说我对你这么好 你竟然想要跟我分手

哎 这个贱男人 我就知道 你可真狗

这个不可理喻的女人让我又爱又恨

生病的时候让人心疼 看起来又乖又笨

就算吵架的时候 不爱跟你讲道理

在人群中我依然 一眼就能找到你

我可以为 她遮风为她挡雨

也可以陪她一整天 依偎在我房里

还记得第一次见她 是我 第一次的演出

还记得她也曾在 夜里 为我闭着眼哭

HOOK：街边的落雨下 我在这个小小世界

你走进我生命 又出现在我面前

谁又能代替呢 我所有的留恋

每次的遇见都是我们的永恒的瞬间

街边的落雨下 我在这个小小世界

你走进我生命 又出现在我面前

谁又能代替呢 我所有的留恋

每次的遇见都是我们的永恒的瞬间

混音：Fi9江澈

混音：Fi9江澈

统筹：杨冰

OP:汇音文化