笔记17-File&递归&字节流

最新推荐文章于 2021-12-18 18:37:55 发布
最新推荐文章于 2021-12-18 18:37:55 发布
阅读量123 收藏 1
点赞数
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36463278/article/details/107683406
版权

File类

File类概述和构造方法

File: 它是文件和目录路径名的抽象表示

  • 文件和目录是可以通过File封装成的对象的
  • 对于File而言,其封装的并不是一个真正存在的文件, 仅仅是一个路径名而已. 它可以是存在的,也可以是不存在的,将来是要通过具体的操作把这个路径的内容转换为具体存在的

在这里插入图片描述

package com.itdemo_25;

import java.io.File;

public class FileDemo01 {
    public static void main(String[] args) {
//        File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
        File f1 = new File("E:\\itcast\\java.txt");//抽象路径的表示形式,不一定需要路径存在
        System.out.println(f1);

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

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

File类创建功能

在这里插入图片描述

package com.itdemo_25;

import java.io.File;
import java.io.IOException;
/*
        public boolean createNewFile()当具有该名称的文件不存在时，创建一个由该抽象路径名命名的新空 文件
            如果文件不存在,就创建文件,并返回true
            如果文件存在,就不创建文件,返回false
        public boolean mkdir() 创建由此抽象路径名命名的目录
            如果目录不存在,就创建目录,并返回true
            如果目录存在,就不创建目录.并返回false
        public boolean mkdirs() 创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录
            如果目录不存在,就创建目录,并返回true
            如果目录存在,就不创建目录.并返回false
*/
public class FileDemo02 {
    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());

        //需求2：我要在D:\\itcast目录下创建一个目录JavaSE
        File f2 = new File("D:\\itcast\\JavaSE");
        System.out.println(f2.mkdir());

        //需求3：我要在D:\\itcast目录下创建一个多级目录JavaWEB\\HTML
        File f3 = new File("D:\\itcast\\JavaWEB\\HTML");
//        System.out.println(f3.mkdir());//false
        System.out.println(f3.mkdirs());//true
        //需求4：我要在D:\\itcast目录下创建一个文件javase.txt
        File f4 = new File("D:\\itcast\\javase.txt");
//        System.out.println(f4.mkdir());
        //不能根据路径名来判断是目录还是文件,要根据使用的方法来判断
        System.out.println(f4.createNewFile());//不能出现命名一样的,不论是目录还是文件
    }
}

File类的判断和获取功能

在这里插入图片描述

package com.itdemo_25;


import java.io.File;

/*
判断功能
public boolean isDirectory() 测试此抽象路径名表示的File是否为目录
public boolean isFile() 测试此抽象路径名表示的File是否为文件
public boolean exists() 测试此抽象路径名表示的File是否存在

获取功能
public String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串
public String getPath() 将此抽象路径名转换为路径名字符串
public String getName() 返回由此抽象路径名表示的文件或目录的名称
public String[] list() 返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
public File[] listFiles() 返回此抽象路径名表示的目录中的文件和目录的File对象数组


 */
public class FileDemo03 {
    public static void main(String[] args) {
        //创建一个File对象
        File f = new File("D:\\IDEADemo\\Demo\\src\\java.txt");
//        public boolean isDirectory() 测试此抽象路径名表示的File是否为目录
        System.out.println(f.isDirectory());

//        public boolean isFile() 测试此抽象路径名表示的File是否为文件
        System.out.println(f.isFile());

//        public boolean exists() 测试此抽象路径名表示的File是否存在
        System.out.println(f.exists());

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

File类的删除功能

在这里插入图片描述
绝对路径和相对路径的区别

  • 绝对路径: 完整的路径名,不需要任何其他信息就可以定位它所表示的文件.例如: D:\itcast\java.txt
  • 相对路径: 必须使用取自其他路径名的信息进行解释. 例如myFile\java.txt

删除目录时的注意事项

  • 如果一个目录中有内容(目录,文件),不能直接删除,应该先删除目录中的内容,最后才能删除目录.
package com.itdemo_25;

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

public class FileDemo04 {
    public static void main(String[] args) throws IOException {
//        File f1 = new File("D:\\itcast\\java.txt");
        //需求1: 在当前模块目录下创建java.txt文件
        File f1 = new File("java.txt" );
        System.out.println(f1.createNewFile());
//        需求2: 删除当前模块目录下的java.txt
//        System.out.println(f1.delete());
        System.out.println("--------");

//        需求3 :在当前文件目录下创建itcast目录
        File f2 = new File("src\\com\\itdemo_25\\itcast");
//        System.out.println(f2.mkdir());

        //需求4: 删除当前模块目录下的itcast
        System.out.println(f2.delete());
        System.out.println("---------");

        //需求5: 在当前模块下创建一个目录itcast,然后在目录下创建一个文件java.txt
        File f3 = new File("src\\itcast");
        System.out.println(f3.mkdir());
        File f4 = new File("src\\itcast\\java.txt");
        System.out.println(f4.createNewFile());

//        需求6: 删除当前模块下的目录itcast
        System.out.println(f4.delete());
        System.out.println(f3.delete());
    }
}

递归

递归概述: 以编程的角度来看,递归指的是方法定义中调用方法本身的现象

递归解决问题的思路:
把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解
递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算

递归解决问题要找到两个内容:

  • 递归出口: 否则会出现内存溢出
  • 递归规则: 与原问题相似的规模较小的问题
package com.itdemo_25;

public class DiGuDemo {
    public static void main(String[] args) {
        //回顾不死神兔:  求第20个月兔子的对数
        //每个月兔子对数: 1,1,2,3,5,8.....
        int[] arr= new int[20];

        arr[0] =1;
        arr[1] =1;

        for(int i=2; i<arr.length;i++){
            arr[i] =arr[i-1]+arr[i-2];
        }
        System.out.println(arr[19]);
        System.out.println(f(20));
    }

    /*
    递归解决问题: 首先就是定义一个方法,
         定义一个方法f(n)：表示第n个月的兔子对数
         那么，第n-1个月的兔子对数该如何表示呢？f(n-1)
      同理，第n-2个月的兔子对数该如何表示呢？f(n-2)

   StackOverflowError:当堆栈溢出发生时抛出一个应用程序递归太深
     */
    public static int f(int n) {
        if (n == 1 || n == 2) {
            return 1;
        } else {
            return f(n - 1) + f(n - 2);
        }
    }
}

案例:递归求阶乘

需求:用递归求5的阶乘,并把结果在控制台输出

分析:
1.阶乘: 一个正整数的阶乘是所有小于及等于该数的正整数的积,自然数n的阶乘写作n!
5! = 54321
2.递归出口: 1! = 1
3.递归规则:n!= n*(n-1)!
5! = 5*4!

思路:
1.定义一个方法,用于递归求阶乘,参数为一个int类型的变量
2.在方法内部判断该变量的值是否是1
是返回1
不是: 返回n*(n-1)!
3.调用方法
4.输出结果

package com.itdemo_25;

public class DiGuDemo01 {
    public static void main(String[] args) {
        //调用方法
        int result = jc(5);
        System.out.println(result);
    }
    //定义一个方法,用于递归求阶乘,参数为一个int类型的变量
    public static int jc(int n){
        //在方法内部判断该变量的值是否是1
        if(n==1){
//            是返回1
            return 1;
        }else{
            //不是返回n*(n-1)!
            return n*jc(n-1);
        }
    }
}

案例: 遍历目录

需求:给定一个路径(D:\itcast)，通过递归完成遍历该目录下所有内容，并把所有文件的绝对路径输出在控制台
思路:

  1. 根据给定的路径创建一个File对象
  2. 定义一个方法, 用于获取给定目录下的所有内容,参数为第一步创建的File对象
  3. 获取给定的File目录下所有的文件或者目录的File数组
  4. 遍历该File数组,得到每一个File对象
  5. 判断该File对象是否是目录
    是:递归调用
    不是: 获取绝对路径输出在控制台
  6. 调用方法
package com.itdemo_25;

import java.io.File;

public class DiGuDemo02 {
    public static void main(String[] args) {
        //根据给定的路径创建一个File对象
        File srcFile = new File("D:\\itcast");
        //调用方法
        getAllFilePath(srcFile);
    }
    //定义一个方法,用于获取给定目录下的所有内容,参数为第一步创建爱你的File对象
    public static void getAllFilePath(File srcFile){
        //获取给定的File目录下所有文件或者目录的File数组
        File[] fileArray = srcFile.listFiles();
        //遍历该file数组,得到一个file对象
        if(fileArray != null){
            for(File file:fileArray){
                //判断该file对象是否是目录
                if(file.isDirectory()){
                    //是,递归调用
                    getAllFilePath(file);
                }else{
                    //不是,获取绝对路径
                    System.out.println(file.getAbsoluteFile());
                }
            }
        }
    }
}

IO流概述和分类

IO流概述:

  • IO: 输入/输出(Input/Output)
  • 流: 是一种抽象概念,是对数据传输的总称,也就是说数据在设备间的传输称为流,流的本质是数据传输
  • IO流就是用来处理设备间数据传输问题的
    常见的应用: 文件复制, 文件上传,文件下载

IO流的分类

  • 按照数据的流向
    • 输入流: 读数据
    • 输出流; 写数据
  • 按照数据类型来分
    • 字节流:
      • 字节输入流
      • 字节输出流
    • 字符流
      • 字符输入流
      • 字符输出流

IO流的使用场景

  • 如果操作是纯文本文件, 优先使用字符流
  • 如果操作的是图片/ 视频/音频/等二进制文件,优先使用字节流
  • 如果不确定文件类型,优先使用字节流,字节流是万能的流

字节流写数据

  • 字节流抽象基类
    • InputStream: 这个抽象类是表示字节输入流的所有类的超类
    • OutputStream: 这个抽象类是表示字节输出流的说有类的超类
    • 子类名特点:子类名称都是以其父类名作为子类名的后缀
  • 字节输出流:
    • FileOutputStream(String name): 创建文件输出流以指导的名称写入文件
  • 使用字节输出流写数据的步骤
    • 创建字节输出流对象(调用系统功能创建了文件,创建字节输出流对象,让字节输出流对象指向文件)
    • 调用字节输出流对象的写数据方法
    • 释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源)
package com.itdemo_25;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo01 {
    public static void main(String[] args) throws IOException{
        //创建字节流输出对象
        //FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("src\\fos.txt");
        /*            
        做了三件事情：              
        A:调用系统功能创建了文件                
        B:创建了字节输出流对象                
        C:让字节输出流对象指向创建好的文件        
        */
        //void write(int b)：将指定的字节写入此文件输出流
        fos.write(97);//a
        fos.write(57);//9
        fos.write(55);//7

        //最后都要释放资源        
        // void close()：关闭此文件输出流并释放与此流相关联的任何系统资源。
        fos.close();
    }
}

字节流写数据的3种方式

在这里插入图片描述

package com.itdemo_25;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
构造方法
    FileOutputStream(String name) 创建文件输出流以指定的名称写入文件
    FileOutputStream(File file) 创建文件输出流以写入由指定的file对象表示问津
 */
public class FileOutputStreamDemo03 {
    public static void main(String[] args) throws IOException {

        //创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("fos.txt");
//        new File(name);
//        FileOutputStream fos = new FileOutputStream(new File("fos.txt"));//与第一种方法相同

        //  FileOutputStream(File file) 创建文件输出流以写入由指定的file对象表示问津
        File file = new File("src\\fos.txt");
        FileOutputStream fos1 = new FileOutputStream(file);
        //可以等于
        FileOutputStream fos2 = new FileOutputStream(new File("src\\fos.txt"));

//      void write(int b) 将指定的字节写入此文件输出流 一次写一个字节数据
//        fos1.write(97);
//        fos1.write(98);
//        fos1.write(99);
//        void write(byte[] b)
//将 b.length字节从指定的字节数组写入此文件输出流 一次写一个字节数组 数据
        byte[] bys = {97,98,99,100};
//        fos1.write(bys);

//        void write(byte[] b, int off, int len)
// 将 len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流 一 次写一个字节数组的部分数据
        fos1.write(bys,1,3);
        //释放资源
        fos1.close();
    }
}

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

  • 字节流写数据如何实现换行
    • windows : \r\n
    • linux : \n
    • mac: \r
  • 字节流写数据如何实现追加写入
    • public FileOutputStream(String name; boolean append)
    • 创建文件输出流以指定的名称写入文件, 如果第二个参数为true, 则字节将写入文件的末尾而不是开头
package com.itdemo_25;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo04 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        //只能在第一次创建时写入
//        FileOutputStream fos = new FileOutputStream("fox,txt");
//        再次运行重新写入,追加数据
        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();
    }
}

字节流写数据加异常处理

finally: 在异常处理时提供finally块来执行所有消除操作,比如说IO流中的释放资源
特点: 被finally控制语句一定会执行,除非JVM退出
异常处理格式:
try -catch-finally

try{
	可能出现异常的代码;
}catch(异常类名   变量名){
	异常的处理代码;
}fianlly{
	执行所有清除操作
}

package com.itdemo_25;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo05 {
    public static void main(String[] args) {
//        try {
//            FileOutputStream fos = new FileOutputStream("src\\fos1.txt");
//            fos.write("hello".getBytes());
//            fos.close();//释放资源就会被跳过,调用的资源就一直被占用
//        } catch (IOException e) {
//            e.printStackTrace();
//        }

        //加入finally来实现释放资源
        FileOutputStream fos =null;
        //创建目录不存在这出现FileNotFoundException异常
        try {
            fos = new FileOutputStream("src\\fos2.txt");
            fos.write("java".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            //若创建的目录为空,,则保错所以
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

字节流读数据(一次读一个字节数据)

  • 字节输入流
    • FileInputStream(String name):通过打开与实际文件的连接来创建一个FileInputStream,该文件由文件系统中的路径名name命名
  • 字节输入流读取数据的步骤
    • 创建字节输入流对象
    • 调用字节输入流对象的读取数据方法
    • 释放资源
package com.itdemo_25;

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

public class FileInputStreamDemo01{
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("src\\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();
    }
}

字节流读数据(一次读一个字节数组数据)

  • 一次读一个字节数组的方法
    • public int read(byte[] b):从输入流读取量最多b.length个字节的数据
    • 返回的是读入缓冲区的总字节数, 也就是实际的读取字节个数
package com.itdemo_25;

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

public class FileInputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //创建字节输入对象
        FileInputStream fis = new FileInputStream("src\\fos.txt");
/*
        //调用字节输入流对象的读取方法
        byte[] bys = new byte[1024];
        //第一次读取
        int len = fis.read(bys);
        //读取的是实际读取的长度
        System.out.println(len);//5
//        String (byte[] bytes)通过使用平台的默认字符集解码指定的字节数组来构造新的 String 。
//        System.out.println(new String(bys));//javas
        System.out.println(new String(bys,0,len));

        //第二次读取
        len = fis.read(bys);
        System.out.println(len);//5
//        String (byte[] bytes)通过使用平台的默认字符集解码指定的字节数组来构造新的 String 。
//        System.out.println(new String(bys));//\r\nhel
        System.out.println(new String(bys,0,len));

        //第二次读取
        len = fis.read(bys);
        System.out.println(len);//5
//        String (byte[] bytes)通过使用平台的默认字符集解码指定的字节数组来构造新的 String 。
//        System.out.println(new String(bys));//lo\r\nw\r\n
        //String​(byte[] bytes, int offset, int length)
        System.out.println(new String(bys,0,len));//当实际长度到达-1时已经到达末尾了
        //与上一个的到结果相同,但上一种方法存在局限性,若byte数组长度为1000,将会在第一次读取的时候全部读取完
        */

//改进
        byte[] bys = new  byte[1024];//一般给予1024及其整数倍
        int len;
        while ((len =fis.read(bys))!=-1){
            System.out.println(new String(bys,0,len));
        }
        fis.close();
    }
}

案例: 复制文本文件

需求: 把“E:\itcast\窗里窗外.txt”复制到模块目录下的“窗里窗外.txt”
实现步骤

  • 复制文本文件，其实就把文本文件的内容从一个文件中读取出来(数据源)，然后写入到另一个文件中(目 的地)
  • 数据源： E:\itcast\窗里窗外.txt — 读数据 — InputStream — FileInputStream
  • 目的地： myByteStream\窗里窗外.txt — 写数据 — OutputStream — FileOutputStream

思路:

  1. 根据数据源创建字节输入流对象
  2. 根据目的地创建字节输出流对象
  3. 读写数据,复制文本文件(一次读取一个字节,一次写入一个字节)
  4. 释放资源
package com.itdemo_25;

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

public class CopyTxtDemo {
    public static void main(String[] args) throws IOException {
        //1. 根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("D:\\BaiduNetdiskDownload\\窗里窗外.txt");
        //2. 根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("src\\窗里窗外.txt");
        //3. 读写数据,复制文本文件(一次读取一个字节,一次写入一个字节)
        int by;
        while ((by=fis.read())!=-1){
            fos.write(by);
        }
        //4. 释放资源
        fis.close();
        fos.close();
    }
}

案例: 复制图片

案例需求
把“E:\itcast\mn.jpg”复制到模块目录下的“mn.jpg”
实现步骤

  1. 根据数据源创建字节输入流对象
  2. 根据目的地创建字节输出流对象
  3. 读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
  4. 释放资源
package com.itdemo_25;

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

public class CopyJpgDemo {
    public static void main(String[] args) throws IOException {
        //1.根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("D:\\BaiduNetdiskDownload\\mn.jpg");
        //2. 根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("src\\mn.jpg");
        //3. 读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
        byte[] bys = new byte[1024];
        int len;
        while ((len=fis.read(bys) )!=- 1){
            fos.write(bys,0,len);
        }
        //4. 释放资源
        fis.close();
        fos.close();
    }
}
Saito__Asuka
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java-基础语法17:IO流&Properties集合
DrewWong的博客
10-31 258
1.IO流案例 1.1集合到文件数据排序改进版【应用】 1.1.1案例需求 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩)。要求按照成绩总分从高到低写入文本文件 格式：姓名,语文成绩,数学成绩,英语成绩 举例：林青霞,98,99,100 1.1.2分析步骤 定义学生类 创建TreeSet集合，通过比较器排序进行排序 键盘录入学生数据 创建学生对象，把键盘录入的数据对应赋值给学生对象的成员变量 把学生对象添加到TreeSet集合 创建字符缓冲输出流对象 遍历集合，得到每一个学生对象 把学生
Java使用字节型文件流完成文件夹的复制（递归）
发光吖的博客
04-23 481
Java使用字节型文件流完成文件夹的复制（递归） 对于程序而言，文件夹的深度是不可预知的，因此想要对其进行删除、复制粘贴、加密解密等等操作，都需要使用递归。 这里仅仅演示文件夹的复制粘贴。（复制单个文件肯定也是没问题的） 演示：将E:\test\dirc复制到F:\test路径下。 程序代码： package com.rjxy; import java.io.*; public class...
Java中流的概念和递归算法
weixin_30641999的博客
05-31 63
文件类: 　　java.io.File 　　　　基本方法; 　　　　　　geName: 获取文件名称 　　　　　　getPath: 获取文件路径 　　　　　　length: 获取文件大小 　　　　　　isDirectory: 判断这个东西是不是一个目录 　　　　　　isFile: 判断这个东西是不是一个文件 　　　　　　listFiles: 获取当前这个路径下面所有的文件和文件夹 ...
字节流复制文本文件【应用】
Leon_Jinhai_Sun的博客
09-13 268
案例需求 ​ 把“E:\leon\窗里窗外.txt”复制到模块目录下的“窗里窗外.txt” 实现步骤 复制文本文件，其实就把文本文件的内容从一个文件中读取出来(数据源)，然后写入到另一个文件中(目的地) 数据源： ​ E:\leon\窗里窗外.txt --- 读数据 --- InputStream --- FileInputStream 目的地： ​ myByteStream\窗里窗外.txt --- 写数据 --- OutputStr..
java 递归复制文件夹和文件
ouYang的博客
09-25 1091
微信公众号：程序yuan 关注可了解更多的资源。问题或建议，请公众号留言; 公司的电脑是有安全检查的，每次复制一个文件到U盘中都要扫描半天，特别的慢，为了避开电脑的扫描， 想到了java中的io流，写的一个使用递归的方式复制文件夹的demo。保存到博客中，跟大家分享一下， 同时也可以方便后面自己查看。 1.先看看复制文件 ①使用基本字节流 publicvoidcopyF...
day08-File&递归&字节流
06-10
day08-File&递归&字节流
read-file-tree:递归读取目录中所有文件的内容
05-12
递归读取目录中所有文件的内容 安装 npm install read-file-tree 用法 var readFileTree = require ( 'read-file-tree' ) readFileTree ( '/path/to/directory' , function ( err , tree ) { console . log ( tree ...
vue_ant-design-vue菜单递归
12-28
3. **递归渲染**：在Vue组件中，我们可以利用`v-for`指令和递归组件来渲染无限层级的菜单。首先创建一个递归组件`MenuNode`，它接收一个`MenuItem`作为props，并在自身内部渲染菜单项及其子项： ```javascript ...
01-E-5 分而治之 & 01-E-6 数组求和-二分递归1
08-03
01-E-5 分治之 & 01-E-6 数组求和-分递归#数据结构邓神为了求解个规模的问题，可以将其划分为若（通常两个）字问题，规模体相当分别求解字问题，从从问
node-file-walker:递归遍历文件目录的 Node.js 模块
07-07
npm install file-walker 回调参数 files - 当前目录中的文件/目录数组，例如['dummy', 'test.js'] dir - 目录名，例如'./test' level - 当前目录级别从0开始 示例用法 假设我们有以下目录结构 ./test/ +- a.js...
字节缓冲流构造方法
Leon_Jinhai_Sun的博客
09-13 385
字节缓冲流介绍 lBufferOutputStream：该类实现缓冲输出流。 通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用 lBufferedInputStream：创建BufferedInputStream将创建一个内部缓冲区数组。 当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节 构造方法： 方法名 说明 BufferedOutputStream(Ou..
File&递归 & I/O
TiAmonal的博客
08-14 94
1.File类 1.1File类概述和构造方法【应用】 File类介绍 它是文件和目录路径名的抽象表示 文件和目录是可以通过File封装成对象的 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的 File类的构造方法 方法名 说明 File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例 File(Strin
Java基础——File类
weixin_44550963的博客
04-08 119
文章目录File类概述和构造方法创建文件和目录判断和获取功能案例 File类 概述和构造方法 1.概述： 它是文件和目录路径名的抽象表示 文件和目录是可以通过 File封装成对象的 对于 File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的 2.构造方法 创建文件和目录 判断和获取功能...
Java（File类，Arrays工具类）
taka_is_beauty的博客
07-22 678
目录 一.File类 二.工具类 一.File类 构造: * public File(String path); * public File(String parent,String child); ps：两个字符串路径的拼接。 * public File(File parent,String child); ps：本质也是两个字符串路径的...
黑马程序员全套Java教程_Java基础教程_IO流之字节流（三十一）
qq_44009317的博客
12-18 889
2.1 IO流概述和分类 IO流概述： （1）IO：输出（Input）/输出（Output）； （2）流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输。 （3）IO流就是用来处理设备间数据传输问题的，常见的应用有：文件复制、文件上传、文件下载。 硬件层次的IO流： IO流分类： （1）按照数据的流向：输入流（读数据）、输出流（写数据）； （2）按照数据类型：字节流（又分字节输入流和字节输出流）、字符流（又分字符输出流和字符输入流）。 （3）一般来说，我们说I
Java递归复制文件及目录（包含子目录及子文件）
weixin_46831361的博客
12-12 587
一个课程作业： 复制文件夹,实现如下方法，把源文件夹下所有的文件 复制到目标文件夹下(包括子文件夹) public static void copyFolder(String srcFolder, String destFolder){ } package FileExercise; import java.io.*; public class FileExercise_18 { public static void main(String[] args) { new FileExercise_
IO流-----字节流基类和多级文件递归复制代码实现
weixin_42291052的博客
08-13 136
IO流 Java的IO流是实现输入输出的基础，将不同的输入\输出源（键盘、文件、网络连接）均抽象的称之为流。按照流的流向分，站在内存的角度，分为输入流和输出流。按照数据类型又可分为可以读写任何文件的字节流，和只能读取文本文件的字符流。两者的区别在于字节流操作的字节单元是8个字节，字符流是16个。 IO流基类 字节流基类–InputStream 和 OutputStream 构造方法 FileOutputStream(File file) FileOutputStream(String name) Fi
$_FILES数组详解
weixin_30650859的博客
09-27 958
$_FILES数组详解 ​ form表单数据编码类型由enctype决定，进行文件上传时其属性值需设置为multipart/form-data。如存在以下文件域，myFile为文件域的name属性： ​ 文件上传后，文件信息自动保存在预定义变量$_FILES数组中。 1. 文件原始名称 $_FILES['myFile']['nam...
IO流，字节流读写数据
allenguitar的博客
08-17 250
1.File类 File类介绍 它是文件和目录路径名的抽象表示 文件和目录是可以通过File封装成对象的 对于File而言,其封装的并不是一个真正存在的文件,仅仅是一个路径名而已.它可以是存在的,也可以是不存在的.将来是要通过具体的操作把这个路径的内容转换为具体存在的 File类的构造方法 方法名 说明 File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例 File(String parent, Stri
递归算法-----递归算法优化------非递归算法（递推，迭代）----运行时间
最新发布
09-19
递归算法是一种通过调用自身来解决问题的方法。它将问题分解为更小的子问题，直到达到基本情况，然后再逐步合并解决子问题以获得最终结果。递归算法的一个常见例子是计算阶乘。 尽管递归算法在某些情况下非常简洁和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值