Java:输入输出流笔记



概述

  • 关闭流时,先打开后关闭,后打开先关闭
输出

:指一连串流动的字符,以先进先出的方式发送信息的通道

输入流

File类的应用

  • 什么是文件?
  • 文件可认为是相关记录或放在一起的数据的集合

File类的常用方法

  1. isDirectory():表示的是否为目录。
  2. isFile():表示是否为文件。
  3. exists():表示的文件或目录是否存在。
  4. mkdir():表示创建目录。
  5. mkdirs():表示创建多个目录。
  6. createNewFile():表示创建文件。
  7. getName:表示的文件或目录的名称。
  8. getParent:表示返回路径。
public class FileDemo {
    public static void main(String[] args) {
        //创建File类对象
//        File file=new File("D:\\JavaSE\\file\\src\\file\\FileDemo.java");
//        File file=new File("D:\\JavaSE","file\\src\\file\\FileDemo.java");
        File file=new File("D:\\JavaSE");
        File file1=new File(file,"file\\set\\HashSet\\文件");
        //判断是文件还是目录
        System.out.println("是不是文件?"+file1.isFile());//判断是不是文件?
        System.out.println("是不是目录?"+file1.isDirectory());//判断是不是目录?
        //创建文件目录
        File file2=new File("D:\\JavaSE\\file","HashSet");
        File file3=new File("D:\\JavaSE\\file\\set\\HashSet");
        if (!file2.exists()){//判断是否存在,不存在就创建
             file2.mkdir();//创建一个目录
             file3.mkdirs();//创建多个目录
        }
        //创建文件
        if (!file1.exists()){
            try {
                file1.createNewFile();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

绝对路径与相对路径

绝对路径:从盘符开始的路径

/**
 * 绝对路径
 */
public class FileDemo {
    public static void main(String[] args) {
        File file=new File("E:\\Hua\\thread.txt");
        try {
            file.createNewFile();
            //是不是绝对路径
            System.out.println(file.isAbsolute());
            //获取相对路径
            System.out.println(file.getPath());
            //获取绝对路径
            System.out.println(file.getAbsolutePath());
            //获取文件名
            System.out.println(file.getName());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

绝对路径:是从当前路径开始的路径

/**
 * 相对路径
 */
public class FileDemo {
    public static void main(String[] args) {
        File file=new File("..\\thread.txt");
        try {
            file.createNewFile();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

字节流

字节输入流InputStream

字节输入流

字节输出流OutputStream

字节输出流

FileInputStream 输入流

  1. 输入流:只能读取数据,不能写入数据
  • 从文件系统中的某一个文件中获取输入字节
字节输入流1
  • 用于读取诸如图像数据之类的原始字节流
QQ截图20220426180243

如果返回值为-1,表示已经达到文件末尾!

public class FileInputDemo1 {
    public static void main(String[] args) {
        //创建一个FileInputStream对象
        try {
            FileInputStream fis = new FileInputStream("e:\\Hua\\Hua.txt");
//            int n = fis.read();
//            while (n != -1) {
//                System.out.print((char) n);
//                n=fis.read();
//            }
            int n=0;
            while ((n=fis.read())!=-1){
                System.out.print((char) n);
            }
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
public class FileInputDemo2 {
    public static void main(String[] args) {
        //创建一个FileInputStream对象
        try {
            FileInputStream fis = new FileInputStream("e:\\Hua\\Hua.txt");
            byte[] b=new byte[15];
            fis.read(b,0,10);//从小标0开始,存放10个
            System.out.println(new String(b));
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

FileOutputStream 输出流

输出流:只能写数据,不能读取数据

FileOutputStream
public class FileOutputDemo {

    public static void main(String[] args) {
        FileOutputStream fos;
        FileInputStream fis;
        try {
            fos=new FileOutputStream("e:\\Hua\\hua.txt",true);
            fis=new FileInputStream("e:\\Hua\\hua.txt");
            fos.write(50);
            fos.write('a');
            System.out.println("读取后的文件"+fis.read());
            System.out.println("读取后的文件"+((char)fis.read()));
            fos.close();
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
public class FileOutputDemo2 {
    public static void main(String[] args) {
        //拷贝文件
        try {
            FileInputStream fis = new FileInputStream("e:\\2.png");
            FileOutputStream fos = new FileOutputStream("e:\\22.png");
            int n = 0;
            byte[] b = new byte[1024];
            while ((n = fis.read(b)) != -1) {
                fos.write(b,0,n);//off:偏移量,从0开始,len:如果n不等于-1表示的是实际读取到字节数组b当中的字节数
            }
            fis.close();
            fos.close();
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

缓存流

  1. 缓冲输入流BufferedInputStream
  2. 缓冲输出流BufferedOutputStream

字符流

  • 字符输入流Reader
字符输入流
  • 字符输出流Writer
字符输出流

字节字符转环流

  1. InputStreamReader
  2. OutputStreamWriter
  3. 读写数据的时候要保持编码一致
public class ReaderDemo {
    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("e:\\one.txt");
            InputStreamReader isr = new InputStreamReader(fis);//字符输入流
            FileOutputStream fos=new FileOutputStream("e:\\1one.txt");
            OutputStreamWriter osw=new OutputStreamWriter(fos);//字符输出流
            int n = 0;
            char[] cbuf = new char[10];
            //方案一
//            while ((n = isr.read()) != -1){
//                System.out.print((char) n);
//            }
            //方案二
//            while ((n = isr.read(cbuf)) != -1) {
//                String s=new String(cbuf,0,n);
//                System.out.print(s);
//            }
            //方案三
            while ((n = isr.read(cbuf)) != -1) {
                osw.write(cbuf,0,n);
                osw.flush();
            }
            fis.close();
            isr.close();
            fos.close();
            osw.close();
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

其它字符流

BufferedReader 缓冲输入流

BufferedWriter 缓冲输出流

/**
* 和上边基本一致
*/
FileInputStream fis = new FileInputStream("e:\\one.txt");
InputStreamReader isr = new InputStreamReader(fis);//字符输入流
BufferedReader br=new BufferedReader(isr);//缓存输入流
FileOutputStream fos=new FileOutputStream("e:\\1one.txt");
OutputStreamWriter osw=new OutputStreamWriter(fos);//字符输出流
BufferedWriter bw=new BufferedWriter(osw);//缓冲输出流
int n=0;
char[] cbuf=new char[10];
while((n = br.read(cbuf)) != -1){
    bw.write(cbuf,0,n);
    bw.flush;
}

对象序列化与反序列化

Java对象的序列化(Serialization)和反序列化详解

Java的对象序列化就是把对象写入到输出流中,用来存储或传输;反序列化就是从输入流中读取对象。

对象序列化

  • 步骤:
    1. 创建一个类,继承Serializable接口
    2. 创建对象
    3. 将对象写入文件
    4. 从文件读取对象信息
  • 对象输入流ObjectInputStream
  • 对象输出流ObjectOutputStream
© 版权声明
THE END
喜欢就支持一下吧
点赞0 分享
评论 抢沙发
头像
欢迎您留下宝贵的见解!
提交
头像

昵称

取消
昵称表情代码图片