IO

最新推荐文章于 2024-10-31 20:58:11 发布

大胖驾到

最新推荐文章于 2024-10-31 20:58:11 发布

阅读量248

点赞数

文章标签： intellij-idea java intellij idea

本文链接：https://blog.csdn.net/weixin_51239196/article/details/121194451

版权

java.io.File

package file;

import java.io.File;
import java.io.IOException;

public class Demo {

    public static void main(String[] args) throws IOException {
        //创建文件
        File haha = new File("F://1.txt");
        boolean flag =haha.createNewFile();
        //判断该盘中是否已有文件
        System.out.println(flag?"创建成功":"创建失败");
        //创建文件夹
        File dir = new File("F://haha");
        dir.mkdir();
        //创建子文件
        File a = new File(dir,"a.txt");
        a.createNewFile();
        //创建子文件夹,但文件和文件夹不可重名
        a.mkdir();
        //创建子文件2
        File b = new File("F://haha","b.txt");
        b.createNewFile();
        //创建子文件夹,但文件和文件夹不可重名
        b.mkdir();
        //删除文件
        a.delete();
        b.delete();
        haha.delete();
        dir.delete();
        //移动文件并重命名
        File file = new File("D:\\开课吧\\新建文件夹\\idea使用步骤.zip");
        File newfile = new File("F:\\a.zip");
        file.renameTo(newfile);
        newfile.delete();
        //路径分隔符
        System.out.println(File.pathSeparator);
        //名称分隔符
        System.out.println(File.separator);


    }
}

文件遍历

package file;

import java.io.File;

public class Demo1 {
    //java.10.*
    public static void main(String[] args) {
        File file = new File("F:\\");
        File[] files=file.listFiles();
        listFiles(files);
    }

    public static void listFiles(File[] files){
        if (files!=null && files.length>0){
            for (File file:files) {
                if (file.isFile()){
                    //文件
                    if (file.getName().endsWith(".avi")){
                        //找到了一个文件
                        //如果大于200M输出
                        if (file.length()>200*1024*1024){
                            System.out.println("找到了一个avi文件:"+file.getAbsolutePath());
                        }

                    }
                }else {
                    //文件夹
                    File[] files2 = file.listFiles();
                    listFiles(files2);
                }
            }
        }
    }
}

文件过滤器

package file;

import java.io.File;
import java.io.FileFilter;

public class Demo2 {
    public static void main(String[] args) {
        File e = new File("e:\\");
        listFiles(e);
    }

    public  static void listFiles(File file){
        //1.创建一个过滤器 并 描述规则
        FileFilter filter = new AVIFileFileter();
        //2. 通过文件获取子文件夹
        File[] files = file.listFiles(filter);
        if (files!=null && files.length>0)
        for (File f:files) {
            if (f.isDirectory()){
                listFiles(f);
            }else {
                System.out.println("发现一个avi:"+f.getAbsolutePath());
            }
        }
    }

    static class AVIFileFileter implements FileFilter{

        @Override
        public boolean accept(File pathname) {
            if (pathname.getName().endsWith(".avi") || pathname.isDirectory())
                return false;
            return false;
        }
    }
}

相对路径与绝对路径

package file;

import java.io.File;

public class Demo3 {
    //相对路径和绝对路径
    //绝对路径:从盘符开始,是一个完整的路径,例如:c://a.txt
    //相对路径:在java代码中是相对于项目目录路径,这是一个不完整的便捷路径,在java开发中很常用,例如:a.txt
    public static void main(String[] args) {
        File file1 = new File("c://a.txt");
        File file2 = new File("a.txt");
        System.out.println("file1的路径:"+file1.getAbsolutePath());
        System.out.println("file2的路径:"+file2.getAbsolutePath());
    }
}

IO流概述

流概述
可以将这种数据传输操作,看做一种数据的流动,按照流动的方向分为输入Input 和 输出Output
Java中的IO操作主要指的是 java.io 包下的一些常用类的使用,通过这些常用类数据进行读取(输入Input) 和  写出(输出Output) 
IO流的分类
按照流的方向来分,可以分为:输入流和输出流.
按照流动的数据类型来分,可以分为:字节流和字符流
    
    字节流:
         -  输入流:InputStream
         -  输出流:OutputStream
    字符流:
         -   输入流:Reader
         -   输出流:Writer

一切皆字节:
         计算机中的任何数据(文本,图片等)都是以二进制的形式存储的
         在数据传输时,也都是以二进制形式存储的
         后续学习的任何流,在传输时底层都是二进制

FileOutputStream

 //FileOutputStream
        FileOutputStream fos = new FileOutputStream("F://a.txt",true);//有true表示在原有基础上追加,没有或false表示清空文件重新写入
        //以Ascall码值写入ABCDEF
        byte[] bytes ={65,66,67,68,69};
        fos.write(bytes);
        byte[] bytes1 = {65,66,67,68,69};
        fos.write(bytes1);
        //以文字形式写入ABCDEF
        byte[] bytes2 = "ABCDEF".getBytes();
        //写入下标为1到2的值(BC)
        fos.write(bytes2,1,2);
        fos.close();
        System.out.println("已经写出");

java.io.FileInputStream

package liu;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class DemoFileInputStream {
    public static void main(String[] args) throws IOException {
        //InputStream
        FileInputStream fis = new FileInputStream("F://a.txt");
        /*读取字节,每次读取一个
        while (true){
            byte b = (byte) fis.read();
            System.out.println((char) b);
            if (b == -1){
                break;
            }
            System.out.println((char)b);
        }
        fis.close();*/
        /*打印字节,每次打印一个
        byte b = (byte) fis.read();
        System.out.println((char) b);
        b = (byte) fis.read();
        System.out.println((char) b);
        b = (byte) fis.read();
        System.out.println((char) b);
        fis.close();*/
        //读取一组字节
        byte[] bytes = new byte[10];
        int len = fis.read(bytes);
        System.out.println(new String(bytes,0,len));
        len = fis.read(bytes);
        System.out.println(new String(bytes,0,len));
        len = fis.read(bytes);
        System.out.println(new String(bytes,0,len));
        len = fis.read(bytes);
        System.out.println(len);
        fis.close();


    }
}

FlieWriter字符输出

package liu;

import java.io.FileWriter;
import java.io.IOException;

public class DemoFileWriter {
    public static void main(String[] args) throws IOException {
        //writer
        FileWriter fw = new FileWriter("F://a.txt",true);
        //写入
        fw.write("床前明月光");
        //追加
        FileWriter fw2  = (FileWriter) fw.append("锄禾日当午,");
        fw.append("汗滴禾下土,谁知盘中餐,粒粒皆辛苦").append("12");
        //true 在原有的fw上追加,还是返回给fw,所以fw2==fw
        System.out.println(fw==fw2);
        fw.close();
    }
}

字符读取 FileRead

package liu;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class DenoFileRead {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("f://a.txt");
                /*一次读一个字符
                while (true){
                    int c = fr.read();
                    if (c==-1)
                        break;
                    System.out.println((char)c);

                }*/
        //一次读取一组字符
        char[] chars = new char[100];
        int len = fr.read(chars);
        String text = new String(chars,0,len);
        System.out.println(text);
        System.out.println(text.length());
        fr.close();
    }
}

flush 刷新管道

字节转换字符流

package liu;

import java.io.*;

public class DemoZhuanHuan {
    public static void main(String[] args) throws IOException {
        //转换流
        //字节流 '装饰'为 字符流   :    使用了装饰者设计模式.
        FileInputStream fis = new FileInputStream("F://a.txt");
        //将字节输入流,转换为字符输入流
        //参数1.要转换的字节流
        //参数2.指定编码名称
        InputStreamReader isr = new InputStreamReader(fis);
        while (true){
            int c = isr.read();
            if (c==-1){
                break;
            }
            System.out.println((char)c);
        }
        //将字节输出流,转换为字符输出流
        FileOutputStream fos = new FileOutputStream("f://a.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos);
        osw.write("床前明月光");
        osw.flush();
        osw.close();
    }
}

Print与BufferedReader(打印流与输出流)

按行和按列打印

package liu;

import java.io.*;

public class DemoPront {
    public static void main(String[] args) throws IOException {
        //字符输出去(打印流)

        PrintStream ps = new PrintStream("F://c.txt");
        ps.println("锄禾日当午,汗滴禾下土1");
        ps.println("锄禾日当午,汗滴禾下土2");
        ps.println("锄禾日当午,汗滴禾下土3");
       
        //缓存读取流
        PrintWriter pw = new PrintWriter("F://c.txt");
        pw.println("锄禾日当午,汗滴禾下土1");
        pw.println("锄禾日当午,汗滴禾下土2");
        pw.println("锄禾日当午,汗滴禾下土3");
        pw.close();
        FileOutputStream fos = new FileOutputStream("f://c.txt");
        PrintWriter aw = new PrintWriter(fos);
        aw.println("锄禾日当午,汗滴禾下土1");
        aw.println("锄禾日当午,汗滴禾下土2");
        aw.println("锄禾日当午,汗滴禾下土3");
        aw.flush();
        aw.close();
        //缓存读取流,将字符输入流 转换为带有缓存 可以一次读取一行的缓存字符读取流
        FileReader fw = new FileReader("f:c.txt");
        BufferedReader br = new BufferedReader(fw);
        String text = br.readLine();
        System.out.println(text);
        text = br.readLine();
        System.out.println(text);
        text = br.readLine();
        System.out.println(text);
        br.close();


    }
}

手机异常日志

package liu;

import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DemoTry {
    public static void main(String[] args) throws FileNotFoundException {
        try {
            String s =null;
            s.toString();
        }catch (Exception e){
            PrintWriter pw = new PrintWriter("f://bug.txt");
            SimpleDateFormat sdf =  new SimpleDateFormat("yyy-MM-dd HH:mm");
            pw.println(sdf.format(new Date()));
            e.printStackTrace(pw);
            pw.close();
        }
    }
}

properties文件与 properties类

package liu;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.util.Properties;

public class DemoProprties {
    public static void main(String[] args) throws IOException {
        //.properties文件 与 Properties类
        /*Properties ppt = new Properties();
        ppt.put("name","金苹果");
        ppt.put("info","讲述了苹果种植的过程");
        FileWriter fw = new FileWriter("F://book.properties");
        ppt.store(fw,"存储的图书");
        fw.close();*/

        Properties ppt = new Properties();
        Reader r = new FileReader("F://book.properties");
        ppt.load(r);

        System.out.println(ppt.getProperty("name"));
        System.out.println(ppt.getProperty("info"));
    }
}

序列化与反序列化

package liu;

import java.io.*;

public class DemoXuLie {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //序列化  与 反序列化
        //序列化
        /*Book b = new Book("金苹果","描述了啥也不是");
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("f://book.txt"));
        oos.writeObject(b);
        oos.close();*/
        //反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("f://book.txt"));
        Object o =  ois.readObject();
        System.out.println(o);

    }

    static class Book implements Serializable {
        private String name;
        private String info;

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

        public Book() {
        }

        public Book(String name, String info) {
            this.name = name;
            this.info = info;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getInfo() {
            return info;
        }

        public void setInfo(String info) {
            this.info = info;
        }
    }

}