day19_io流01(File-字节流-字节缓冲流)

最新推荐文章于 2024-09-27 00:45:01 发布
最新推荐文章于 2024-09-27 00:45:01 发布
阅读量55 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42929213/article/details/128397320
版权

文章目录

1、File类

1.1、File类概述和构造方法

  • File类介绍
    • 它是文件和目录路径名的抽象表示
    • 文件和目录是可以通过File封装成对象的
    • 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已，他可以是存在的，也可以是不存在的，将来是要通过具体的操作把这个路径的内容转换为具体存在的
  • File类的构造方法
方法名说明
File(String pathname)通过将给定的路径名字字符串转换为抽象路径名来创建新的File实例
File(String parent,String chile)从父路径名字字符串创建新的File实例
File(File parent,String chile)从父抽象路径名字符串创建新的File实例
  • 示例代码
public class FileDemo01 {
    public static void main(String[] args) {
        //File(String pathname):通过将给定的路径名字字符串转换为抽象路径名来创建新的File实例
        File f1 = new File("D:\\itcast\\java.txt");
        System.out.println(f1);

        //File(String parent,String child):从父路径名字符串和子路径名字符串创建新的File实例
        File f2 = new File("D:\\itcast","java.txt");
        System.out.println(f2);

        //File(File parent,String):从父抽象路径名和子路径名字符串创建新的File实例
        File f3 = new File("D:\\itcast");
        File f4 = new File(f3,"java.txt");
        System.out.println(f4);
    }
}

1.2、绝对路径和相对路径

  • 绝对路径
    • 是一个完整的路径，从盘符开始
  • 相对路径
    • 是一个简化的路径，相对当前项目下的路径
  • 示例代码
public class FileDemo02{
	public static void main(String[] args){
		//是一个完整的路径，从盘符开始
		File file1 = new File("D:\\itheima\\a.txt");
		//是一个简化的路径，从当前项目根目录开始
		File file2 = new File("a.txt");
		File file3 = new File("模块名\\a.txt");
	}
}

1.3、File类创建功能

  • 方法分类
方法名说明
public boolean createNewFile()当具有该名称的文件不存在时，创建一个由该抽象路径名命名的新空文件
public boolean mkdir()创建由该抽象路径名命名的目录
public boolean mkdirs创建由此抽象路径名命名的目录，包括任何必须但不存在的父目录
  • 示例代码
public class FileDemo01 {
    public static void main(String[] args) throws IOException {
        //需求1：我要在D:\\itcast目录下创建一个文件java.txt
        File f1 = new File("D:\\itcast\\java.txt");
        System.out.println(f1.createNewFile());
        System.out.println("-----------------");
        //需求2：在D:\\itcast目录下创建一个目录JavaSE
        File f2 = new File("D:\\itcast\\JavaSE");
        System.out.println(f2.mkdir());
        System.out.println("--------------");
        //需求3：在D:\\itcast目录下创建一个多级目录JavaWEB\\HTML
        File f3 = new File("D:\\itcast\\JavaWEB\\HTML");
        System.out.println(f3.mkdirs());
        //需求4：在D:\\itcast目录下创建一个文件javase.txt
        File f4 = new File("D:\\itcast\\javase.txt");
        System.out.println(f4.createNewFile());
    }
}

1.4、File类删除功能

  • 方法分类
方法名说明
public boolean delete()删除由此抽象路径名表示的文件或目录
  • 代码演示
public class FileDemo03 {
    public static void main(String[] args) throws IOException {
        //File f1 = new File("D:\\itcast\\java.txt");
        //需求1：在当前模块目录下创建java.txt文件
        File f1 = new File("myFile\\java.txt");
        //System.out.println(f1.createNewFile());
        //需求2：删除当前模块目录下的java.txt文件
        System.out.println(f1.delete());
        System.out.println("---------------");
        //需求3：在当前模块目录下创建itcast目录
        File f2 = new File("myFile\\itcast");
        System.out.println(f2.mkdir());
        //需求4：删除当前模块目录下的itcast目录
        System.out.println(f2.delete());
        System.out.println("------------------");
        //需求5：在当前模块下创建一个目录itcast,然后在该目录下创建一个文件java.txt
        File f3 = new File("myFile\\itcast");
        System.out.println(f3.mkdir());
        File f4 = new File("myFile\\itcast\\java.txt");
        System.out.println(f4.createNewFile());
        //需求6：删除当前模块下的的目录itcast
        System.out.println(f4.delete());
        System.out.println(f3.delete());
    }
}

1.5、File类判断和获取功能

  • 判断功能
方法名说明
public boolean isDirectory()测试此抽象路径名表示的File是否为目录
public boolean isFile()测试此抽象路径名是否表示的File是否为文件
public boolean exists()测试此抽象路径名表示的File是否存在
  • 获取功能
方法名说明
public String getAbsolutePath()返回抽象路径名的绝对路径名字符串
public String getPath()将此抽象路径名转换为路径名字符串
public String getName()返回由此抽象路径名表示的文件或者目录的名称
public File[] listFile()返回由此抽象路径名表示的目录和文件的File对象数组
  • 示例代码
public class FileDemo04 {
    public static void main(String[] args) {
        //创建一个File对象
        File f = new File("myFile\\java.txt");
        //public boolean isDirectory():测试此抽象路径名表示的File是否为目录
        //public boolean isFile():测试此抽象路径名表示的File是否为文件
        //public boolean exists():测试此抽象路径名表示的File是否存在
        System.out.println(f.isDirectory());
        System.out.println(f.isFile());
        System.out.println(f.exists());

        //public String getAbsolutePath():返回此抽象路径名的绝对路径名字符串
        //public String getPath():将此抽象路径名转换为路径名字符串
        //public String getName():返回由此抽象路径名表示的文件或目录的名称
        System.out.println(f.getAbsoluteFile());
        System.out.println(f.getPath());
        System.out.println(f.getName());
        System.out.println("------------");
        //public File[] listFiles():返回此抽象路径名表示的目录中的文件和目录的File对象数组
        File f2 = new File("D:\\itcast");
        File[] fileArray = f.listFiles();
        for (File file : fileArray) {
//            System.out.println(file);
//            System.out.println(file.getName());
            if(file.isFile()){
                System.out.println(file.getName());
            }
        }
    }
}

1.6、File类练习1

  • 案例需求
    • 在当前模块下的aaa文件夹中创建一个a.txt文件
  • 实现步骤
    • 创建File对象，指向aaa文件夹
    • 判断aaa文件夹是否存在，如果不存在则创建
    • 创建File对象，指向aaa文件夹下的a.txt文件
    • 创建这个文件
  • 代码实现
public class Test1 {
    public static void main(String[] args) throws IOException {
        //练习1：在当前模块下的aaa文件夹中创建一个a.txt文件
        /*File file = new File("filemodule\\aaa\\a.txt");
        file.createNewFile();
        //注意点：文件所在的文件夹必须要存在*/

        //1、创建File对象，指向aaa文件夹
        File file = new File("filemodule\\aaa");
        //2、判断aaa文件夹是否存在如果不存在则创建
        if(!file.exists()){
            //如果文件夹不存在，就创建出来
            file.mkdirs();
        }
        //3、创建File对象，指向aaa文件夹下的a.txt文件
        File newFile = new File(file,"a.txt");
        //4、创建这个文件
        newFile.createNewFile();
    }
}

1.7、File类练习2

  • 案例需求；
    • 删除一个多级文件夹
  • 实现步骤
    • 定义一个方法，接收一个File对象
    • 遍历这个File对象，获取它下边的每个文件和文件夹对象
    • 判断当前遍历到的File对象是文件还是文件夹
    • 如果是文件，直接删除
    • 如果是文件夹，递归调用自己，将当前遍历到的File对象当做参数传递
    • 参数传递过来的文件夹File对象已经处理完成，最后直接删除这个空文件夹
  • 代码实现
public class Test2 {
    public static void main(String[] args) {
        //练习2：删除一个多级文件夹
        //delete方法
        //只能删除文件和空文件夹
        //如果现在要删除一个有内容的文件夹
        //先删掉这个文件夹里面所有的内容
        //最后再删除这个文件夹
        File src = new File("C:\\Users\\haochen-lyl\\Desktop\\src");
        deleteDir(src);
    }
    //1、定义一个方法，接收一个File对象
    private static void deleteDir(File src) {
        //先删掉这个文件夹里面所有的内容
        //递归 方法在方法体中自己调用自己
        //注意：可以解决所有文件夹和递归相结合的题目
        //2、遍历这个File对象，获取它下面的每个文件和文件夹对象
        File[] files = src.listFiles();
        //3、判断当前遍历到的File对象是文件还是文件夹
        for (File file : files) {
            //4、如果是文件，直接删除
            if(file.isFile()){
                file.delete();
            }else{
                //5、如果是文件夹，递归调用自己，将当前遍历到的File对象当做参数传递
                deleteDir(file);//参数一定要是src文件夹里面的文件夹File对象
            }
        }
        //最后直接删除这个空文件夹
        src.delete();
    }
}

1.8、File类练习3

  • 案例需求
    • 统计一个文件夹中每种文件的个数并打印
    • 打印格式如下：
    • txt:3个
    • doc:4个
    • jpg:6个
    • …
  • 实现步骤
    • 定义一个方法，参数是HashMap集合用来统计次数和File对象要统计的文件夹
    • 遍历File对象，获取它下边的每一个文件和文件夹对象
    • 判断当前File对象是文件还是文件夹
    • 如果是文件，判断这种类型文件后缀名在HashMap集合中是否出现过
      • 没出现过，将这种类型文件的后缀名存入集合中，次数存1
      • 出现过，获取这种类型文件的后缀名出现的次数，对其+1，再存回集合中
    • 如果是文件夹，递归调用自己，HashMap集合就是参数集合，File对象是当前文件夹对象
  • 代码实现
import java.io.File;
import java.util.HashMap;

public class Test3 {
    public static void main(String[] args) {
        //统计一个文件夹中，每种文件出现的次数
        //统计---定义一个变量用来统计，---弊端：同时只能统计一种文件
        //利用Map集合进行数据统计，键---文件后缀名，值---次数
        File file = new File("filemodule");
        HashMap<String, Integer> hm = new HashMap<>();
        getCount(hm,file);
        System.out.println(hm);
    }
    //1、定义一个方法，参数是HashMap集合用来统计次数和File对象要统计的文件夹
    private static void getCount(HashMap<String, Integer> hm, File file) {
        //2、遍历File对象，获取他下边的每一个文件和文件夹对象
        File[] files = file.listFiles();
        for (File f : files) {
            //3、判断当前File对象时文件还是文件夹
            if(f.isFile()){
                //如果是文件，判断这种文件类型后缀名在HashMap集合中是否出现过
                String fileName = f.getName();
                String[] fileNameArr = fileName.split("\\.");
                if(fileNameArr.length==2){
                    String fileEndName = fileNameArr[1];
                    if(hm.containsKey(fileEndName)){
                        //出现过，获取这种类型文件的后缀名出现的次数，对其+1，再存回集合中
                        Integer count = hm.get(fileEndName);
                        //这种文件又出现了一次
                        count++;
                        //把已经出现的次数给覆盖掉
                        hm.put(fileEndName,count);
                    }else{
                        //没出现过，将这种类型文件的后缀名存入集合中，次数存1
                        hm.put(fileEndName,1);
                    }
                }
            }else{
                //如果是文件夹，递归调用自己，HashMap集合就是参数集合，File对象是当前文件夹对象代码实现
                getCount(hm,f);
            }
        }
    }
}

2、字节流

2.1、io流概述和分类

  • io流介绍
    • IO：输入/输出（input/output）
    • 流：是一种抽象概念，是对数据传输的总称，也就是说数据在设备间的传输称为流，流的本质是数据传输
    • IO流就是用来处理设备间数据传输问题的，常见的应用：文件复制，文件上传，文件 下载
  • io流的分类
    • 按照数据的流向
      • 输入流：读数据
      • 输出流：写数据
    • 按照数据类型分类
      • 字节流
        • 字节输入流
        • 字节输出流
      • 字符流
        • 字符输入流
        • 自如输出流
  • io流的使用场景
    • 如果操作的是纯文本文件，优先使用字符流
    • 如果操作的是图片、视频、音频等二进制文件，优先使用字节流
    • 如果不确定文件类型，优先使用字节流，字节流是万能的流

2.2、字节流写数据

  • 字节流抽象基类
    • InputStream:这个抽象类是表示字节输入流的所有类的超类
    • OutputStream:这个抽象类是表示字节输出流的左右类的超类
    • 子类名特点：子类名称都是以其父类名作为子类名的后缀
  • 字节输出流
    • FileOutputStream(Stream name):创建文件输出流以指定的名称写入文件
  • 使用字节输出流写数据步骤
    • 创建字节输出流对象（调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件）
    • 调用字节输出流对象的写数据方法
    • 释放资源（关闭此文件输出流并释放与此流相关联的任何系统资源）
  • 示例代码
public class FileOutputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        /*
            注意点：
                1、如果文件不存在，会帮我们创建
                2、如果文件存在，会把文件清空
         */
        //FileOutputStream(String name):创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("fos.txt");
        //void write(int b):将指定的字节写入此文件输出流
        fos.write(97);
        fos.write(57);
        fos.write(55);
        //最后都要释放资源
        //void close():关闭此文件输出流并释放与此流相关联的任何系统资源
        fos.close();
    }
}

2.3、字节流写数据的三种方式

  • 写数据的方法分类
方法名说明
void write(int b)将指定的字节写入此文件输出流，一次写一个字节数据
void write(byte[] b)将b.length字节从指定的字节数组写入此文件输出流，一次写一个字节数组数据
void write(byte[] b,int off,int len)将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流一次写一个字节数组的部分数据
  • 示例代码
public class FileOutputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //FileOutputStream(String name):创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("fos.txt");
        //FileOutputStream(File file):创建文件输出流以写入由指定的File对象表示的文件
        //FileOutputStream fos = new FileOutputStream(new File("fos.txt"));
        //void write(int b):将指定的字节写入此文件输出流
//        fos.write(97);
//        fos.write(98);
//        fos.write(99);
//        fos.write(100);
//        fos.write(101);
        //void write(byte[] b):将b.length字节从指定的字节数组写入此文件输出流
//        byte[] bys = {97,98,99,100,101};
        //byte[] getBytes():返回字符串对应的字节数组
        byte[] bys = "abcdefedjgj".getBytes();
        fos.write(bys);
        //void write(byte[] b,int off,int len):将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流
//        fos.write(bys,0,bys.length);
        fos.write(bys,1,bys.length);
        //释放资源
        fos.close();
    }
}

2.4、字节流写数据的两个小问题

  • 字节流写数据如何实现换行
    • windows:\r\n
    • linux:\n
    • mac:\r
  • 字节流写数据如何实现追加写入
    • public FileOutputStream(String name,boolean append)
    • 创建文件输出流以指定的名称写入文件。如果第二个参数为true,则字节将写入文件的末尾而不是开头
  • 实例代码
public class FileOutputStreamDemo03 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("fos1.txt",true);
        //写数据
        for (int i = 0; i < 10; i++) {
            fos.write("hello".getBytes());
            fos.write("\r\n".getBytes());
        }
        //释放资源
        fos.close();
    }
}

2.5、字节流写数据加异常处理

  • 异常处理格式
    • try-cathch-finally
	try{
		可能出现异常的代码;
	}catch(异常类名 变量名){
		异常的处理代码;
	}finally{
		执行所有清除操作;
	}
  • finally特点
    • 被finally控制的语句一定会执行，除非jvm退出
  • 示例代码
public class FileOutputStreamDemo04 {
    public static void main(String[] args) {
        //加入finally来实现释放资源
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("fos2.txt");
            fos.write("hello".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2.6、字节流读数据（一次读一个字节数据）

  • 字节输入流
    • FileInputStream(String name):通过打开与实际文件的连接来创建一个FileInputStream,该文件由文件系统中的路径名name命名
  • 字节输入流读取数据的步骤
    • 创建字节输入流对象
    • 调用字节输入流对象的读取数据方法
    • 释放资源
  • 示例代码
public class FileInputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        //FileInputStream(String name)
        FileInputStream fis = new FileInputStream("fos.txt");
        int by;
        /*
            fis.read():读数据
            by = fis.read():把读取到的数据赋值给by
            by != -1:判断读取到的数据是否是-1
         */
        while ((by=fis.read()) != -1){
            System.out.println((char)by);
        }
        //释放资源
        fis.close();
    }
}

2.7、字节流复制文件

  • 案例需求
    • 把"E:\itcast\窗里窗外.txt"复制到模块目录下的"窗里窗外.txt"（文件可以是任意文件）
  • 实现步骤
    • 复制文本文件，其实就把文本文件的内容从一个文件中读取出来（数据源），然后写入到另一个文件中（目的地）
    • 数据源
      • E:\itcast\窗里窗外.txt–读数据–InputStream–FileInputStream
    • 目的地
      • myByteStream\窗里窗外.txt–写数据–OutputStream–FileOutputStream
  • 代码实现
public class CopyTxDemo {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("D:/a.txt");
        //根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("test.txt");
        //读写数据，复制文本文件（一次读取一个字节，一次写入一个字节）
        int by;
        while((by = fis.read())!=-1){
            fos.write(by);
        }
        //释放资源
        fos.close();
        fis.close();
    }
}

2.8、字节流读数据（一次读一个字节数组数据）

  • 一次读一个字节数组的方法
    • public int read(byte[] b):从输入流读取最多b.length个字节的数据
    • 返回的是读入缓冲区的总字节数，也就是实际的读取字节个数
  • 示例代码
public class FileInputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        // 创建字节输入流对象
        FileInputStream fis = new FileInputStream("fos.txt");
        byte[] bys = new byte[1024];//1024及其整数倍
        int len;
        //循环读取
        while((len = fis.read(bys))!=-1){
            System.out.println(new String(bys,0,len));
        }
        //释放资源
        fis.close();
    }
}

2.9、字节流复制文件

  • 案例需求：
    • 把"E:\itheima\mn.jpg"复制到模块目录下的"mn.jpg"(文件可以是任意文件去)
    • 实现步骤
      • 根据数据源创建字节输入流对象
      • 根据目的地创建字节输出流对象
      • 读写数据，复制图片（一次读取一个字节数组，一次写入一个字节数组）
      • 释放资源
  • 代码实现
public class CopyJpgDemo {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("D:\\黑马程序员Java学习资料\\03 2021-2022海量Java增值课(赠送)\\01.java基础就业班(新)\\01.JavaEE基础就业班课件讲义源码\\1.阶段一-Java基础\\9.IO流\\9.IO流\\day19_IO流01\\笔记\\img\\2022-12-26_235616.png");
        //根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("mn.png");
        //读写数据，复制图片（一次读取一个字节数组，一次写入一个字节数组）
        byte[] bys = new byte[1024];
        int len;
        while((len = fis.read(bys))!=-1){
            fos.write(bys,0,len);
        }
        //释放资源
        fos.close();
        fis.close();
    }
}

3、字节缓冲流

3.1、字节缓冲流构造方法

  • 字节缓冲流介绍
    • BufferOutputStream:该类实现缓冲输出流，通过设置这样的输出流，应用程序可以想底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用
    • BufferedInputStream:创建BufferedInputStream将创建一个内部缓冲数组，当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充一次很多字节
  • 构造方法
方法名说明
BufferedOutputStream(OutputStream out)创建字节缓冲输出流对象
BufferedInputStream(InputStream in)创建字节缓冲输入流对象
  • 示例代码
public class BufferStreamDemo {
    public static void main(String[] args) throws IOException {
        //字节缓冲输出流：BufferedOutputStream(OutputStream out)
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));
        //写数据
        bos.write("hello\r\n".getBytes());
        bos.write("world\r\n".getBytes());
        //释放资源
        bos.close();

        //字节缓冲输入流：BufferedInputStream(InputStream in)
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bos.txt"));
        //一次读取一个字节数据
//        int by;
//        while ((by = bis.read()) != -1) {
//            System.out.print((char) by);
//        }
        System.out.println("----------");
        //一次读取一个字节数组数据
        byte[] bys = new byte[1024];
        int len;
        while ((len = bis.read(bys)) != -1) {
            System.out.println(new String(bys,0,len));
        }
        //释放资源
        bis.close();
    }
}

3.2、字节缓冲流复制视频

  • 案例需求：把"E:\itcast\字节流复制图片.avi"复制到模块目录下的"字节流复制图片.avi"
  • 实现步骤
    • 根据数据源创建字节输入流对象
    • 根据目的地创建字节输出流对象
    • 读写数据，复制视频
    • 释放资源
  • 代码实现
public class CopyAviDemo {
    public static void main(String[] args) throws IOException {
        //复制视频
        method();
    }
    //字节缓冲流一次读写一个字节数组
    private static void method() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\黑马程序员Java学习资料\\03 2021-2022海量Java增值课(赠送)\\01.java基础就业班(新)\\01.JavaEE基础就业班\\01.阶段一 Java基础\\09.第九章 IO流\\9-3 缓冲流\\25-缓冲流-一次读写一个字节代码实现_【海量资源尽在 】.mp4"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.mp4"));
        byte[] bys = new byte[1024];
        int len;
        while((len = bis.read())!=-1){
            bos.write(bys,0,len);
        }
        bos.close();
        bis.close();
    }
    //字节缓冲流一次读写一个字节
    public static void method1() throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\黑马程序员Java学习资料\\03 2021-2022海量Java增值课(赠送)\\01.java基础就业班(新)\\01.JavaEE基础就业班\\01.阶段一 Java基础\\09.第九章 IO流\\9-3 缓冲流\\25-缓冲流-一次读写一个字节代码实现_【海量资源尽在 】.mp4"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.mp4"));
        int by;
        while((by = bis.read())!=-1){
            bos.write(by);
        }
        bos.close();
        bis.close();
    }
一人一只猫
关注
Java基础复习_day16_IO流--字节流
weixin_42931689的博客
02-12 217
字节流 一. 字节输入流(InputStream) InputStream 这个抽象类是表示字节输入流的所有类的超类 1. FileInputStream(字节输入流) ① 概述 从文件系统中的某个文件中获得输入字节。 用于读取诸如图像数据之类的原始字节流。 ② 构造方法 FileInputStream(File file) 通过打开一个到实际文件的连接来创建一个 FileInputSt...
java file io流_JAVA基础---File、IO流
weixin_39945789的博客
02-16 134
1.FileFile类代表文件或者文件的类创建文件类的对象，在创建对象的过程中没有检测路径的信息是否存在,会把路径信息放在对象的身上。即若路径信息不存在，创建对象的语句编译和运行都不会报错。File file=new File(路径);新建文件,新建文件为空文件，若路径信息的指定文件已经存在的话，返回值将会为falseboolean b=file.createNewFile();创建文件夹(多级)...
Java--IO流,字节流,字符流,缓冲流
weixin_53263488的博客
07-15 717
I指Input，称为输入流：负责把数据读到内存中去O指Output，称为输出流：负责写数据出去。
JAVA中file是不是字节流_Java IO-file(读写查)字节流、字符流
weixin_42469083的博客
02-26 160
使用字节流操作汉字或特殊的符号语言的时候,容易乱码,建议使用字符流.先有字节流,后有字符流,字符流是对字节流的补充.使用记事本打开某个文件,可以看到内容的就是文本文件,否则可以理解二进制.一般的,操作二进制文件(图片,音频,视频等)必须使用字节流.一般的,操作文本文件使用字符流.如果不清楚是哪一类型文件,使用字节流.-----------------------------------------...
Day19-1.IO流概述 、字节流
Aaphasia的博客
08-30 178
Day191 IO概述2 字节流2.1 InputStream2.2 FileInputStream代码2.3 OutPutStream2.4 FileOutputStream代码2.5 文件的拷贝代码2.6 文件拷贝效率的提升代码2.7 高效缓冲字节流代码2.8 close和flush的区别 1 IO概述 概述：IO是Input和Output的缩写。 输入、输出。数据的输入和数据的输出。 输入输出的概念： 数据的输入和输出相对于运行内存来说，数据从其他设备进入到运行内存就是输入，数 据从运行内存到其他设
Java基础复习_day17_IO流--字符流&Properties
weixin_42931689的博客
02-13 250
字符流 一. 输入流(Reader) 用于读取字符流的抽象类。 1. InputStreamReader(字符输入流) ① 概述 是从字节流到字符流的桥梁 它读取字节，并使用指定的编码将其解码为字符 它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集 ② 构造方法 InputStreamReader(InputStream in) 创建一个使用默认字符集的 In...
IO流---字节流
XiaoBoYes的博客
09-14 562
IO流---字节流
Day15：File类、IO字节流
亲爱的瑶的博客
05-15 355
一、File类 File类 -- 表示文件或文件夹，不能对文件里的数据进行操作。 File类是IO包中唯一代表磁盘文件本身的对象。File类定义了一些与平台无关的方法来操纵文件，通过调用File类提供的各种方法，能够完成创建、删除文件，重命名文件，判断文件的读写权限及文件是否存在，设置和查询文件的最近修改时间等操作。 //创建文件对象 File file = new File("E:\\J...
《JAVA300集》IO流_入门-day14
Amigo_1997的博客
12-22 321
目录 IO入门 文件编码与解码 四个抽象类 文件字节输入流 正式规范代码 文件字节输出流 IO入门 文件编码与解码 字符集：Java字符使用16位的双字节存储，实际文件存储的数据有各种字符集。 编码（encode）：字符 —》字节。 解码（decode）：字节 —》字符。 不同的编码方式对应不同的字符集 import java.io.UnsupportedEncodingException; import java.nio.charset.StandardCharsets
VIP09_JavaSE_JavaIO_File_day0307-1.rar
10-08
1. **Java IO体系结构**：Java IO框架主要包括字节流和字符流，分为输入流和输出流。字节流处理单个字节的数据，如InputStream和OutputStream家族；字符流处理Unicode字符，如Reader和Writer家族。此外，还有缓冲流...
day12_IO流01.zip
09-12
Java IO流分为四大类：字节流（Byte Stream）和字符流（Character Stream），以及输入流（Input Stream）和输出流（Output Stream）。字节流处理的是8位的字节数据，适用于处理任何类型的二进制数据，如图片、音频...
day13_IO流02.zip
09-12
Java中的IO流分为字节流和字符流两大类，字节流处理单个字节的数据，而字符流处理Unicode字符集的字符。 - 字节流又分为输入流（InputStream）和输出流（OutputStream），字符流则有Reader和Writer。这些基类分别有...
工厂模式的介绍及实现
户伟伟的博客
09-25 117
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Spring Boot 学习和使用
cesske的博客
09-24 1097
Spring Boot是一款开源的Java Web应用框架，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot通过整合Spring技术栈中的诸多关键组件，为开发者提供了一种快速、简便的Spring应用开发方式。它遵循“约定优于配置”的原则，通过自动配置、起步依赖和内置的Servlet容器，极大地简化了传统Spring应用的配置和部署过程。Spring Boot通过其自动化配置、起步依赖、内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 443
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
智能BI平台项目
2302_79400545的博客
09-22 238
BI商业智能：数据可视化、报表可视化系统。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 913
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 746
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
Java IO理解：字节流与字符流解析
"这篇文档详细介绍了Java中的字节流、字符流以及属性集的概念和使用。文档内容主要包括IO流的基本概念、分类、流向以及相关的抽象类。" 在Java编程中，IO流（Input/Output Stream）是处理数据传输的核心部分，主要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值