递归、IO流

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量78 收藏
点赞数
文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Silly_waiter/article/details/129809459
版权

递归

概念：递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂的问题,同时可以让代码变得简洁。

public int sum(int n) {
    if (n <= 1) {
        return 1;
    } 
    return sum(n - 1) + n; 
}

递归的特点

实际上，递归有两个显著的特征,终止条件和自身调用:

终止条件：递归必须有一个终止的条件，即不能无限循环地调用本身。

自身调用：原问题可以分解为子问题，子问题和原问题的求解方法是一致的，即都是调用自身的同一个函数。

递归解题思路

解决递归问题一般就三步曲，分别是：

第一步，定义函数功能
第二步，寻找递归终止条件
第二步，递推函数的等价关系式
这个递归解题三板斧理解起来有点抽象，我们就用阶乘(factorial)来举个例子吧

递归需要遵守的重要规则

1)执行一个方法时，就创建一个新的受保护的独立空间(栈空间)2)方法的局部变量是独立的，不会相互影响,如n变量
3)如果方法中使用的是引用类型变量(比如数组)，就会共享该引用类型的数据.

4)递归必须向退出递归的条件逼近，否则就是无限递归,出现StackOverflowError

5)当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。

UUID

UUID 是指（Universally Unique Identifier）通用唯一识别码，128位。

UUID 的目的是让分布式系统中的所有元素都能有唯一的识别信息。如此一来，每个人都可以创建不与其它人冲突的 UUID，就不需考虑数据库创建时的名称重复问题。其作用视场景而定。

IO流

InputStream ： 输入流 ： 从磁盘里面读取内容到代码里面去
OutputStream： 输出流 ： 从代码里面读取数据到磁盘里面去

字节输出流【OutputStream】

java.io.OutputStream 抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。

  • public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
  • public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
  • public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
  • public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
  • public abstract void write(int b) ：将指定的字节输出流。

注意：

close方法，当完成流的操作时，必须调用此方法，释放系统资源。

FileOutputStream类

java.io.FileOutputStream 类是文件输出流，用于将数据写出到文件。

构造方法
  • public FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件。
  • public FileOutputStream(String name)： 创建文件输出流以指定的名称写入文件。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。

  • 构造举例，代码如下：
public class FileOutputStreamConstructor throws IOException {
    public static void main(String[] args) {
   	 	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileOutputStream fos = new FileOutputStream(file);
      
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("b.txt");
    }
}
写出字节数据
  1. 写出字节：write(int b) 方法，每次可以写出一个字节数据，代码使用演示：
public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
      	// 写出数据
      	fos.write(97); // 写出第1个字节
      	fos.write(98); // 写出第2个字节
      	fos.write(99); // 写出第3个字节
      	// 关闭资源
        fos.close();
    }
}
输出结果：
abc

注意：

  1. 虽然参数为int类型四个字节，但是只会保留一个字节的信息写出。
  2. 流操作完毕后，必须释放系统资源，调用close方法，千万记得。
  1. 写出字节数组：write(byte[] b)，每次可以写出数组中的数据，代码使用演示：
public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
      	// 字符串转换为字节数组
      	byte[] b = "程序".getBytes();
      	// 写出字节数组数据
      	fos.write(b);
      	// 关闭资源
        fos.close();
    }
}
输出结果：
程序
  1. 写出指定长度字节数组：write(byte[] b, int off, int len) ,每次写出从off索引开始，len个字节，代码使用演示：
public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
      	// 字符串转换为字节数组
      	byte[] b = "abcde".getBytes();
		// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
        fos.write(b,2,2);
      	// 关闭资源
        fos.close();
    }
}
输出结果：
cd
数据追加续写

经过以上的演示，每次程序运行，创建输出流对象，都会清空目标文件中的数据。如何保留目标文件中数据，还能继续添加新数据呢？

  • public FileOutputStream(File file, boolean append)： 创建文件输出流以写入由指定的 File对象表示的文件。
  • public FileOutputStream(String name, boolean append)： 创建文件输出流以指定的名称写入文件。

这两个构造方法，参数中都需要传入一个boolean类型的值，true 表示追加数据，false 表示清空原有数据。这样创建的输出流对象，就可以指定是否追加续写了，代码使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt"，true);     
      	// 字符串转换为字节数组
      	byte[] b = "abcde".getBytes();
		// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
        fos.write(b);
      	// 关闭资源
        fos.close();
    }
}
文件操作前：cd
文件操作后：cdabcde
写出换行

Windows系统里，换行符号是\r\n 。把

以指定是否追加续写了，代码使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");  
      	// 定义字节数组
      	byte[] words = {97,98,99,100,101};
      	// 遍历数组
        for (int i = 0; i < words.length; i++) {
          	// 写出一个字节
            fos.write(words[i]);
          	// 写出一个换行, 换行符号转成数组写出
            fos.write("\r\n".getBytes());
        }
      	// 关闭资源
        fos.close();
    }
}

输出结果：
a
b
c
d
e
  • 回车符\r和换行符\n ：
    • 回车符：回到一行的开头（return）。
    • 换行符：下一行（newline）。
  • 系统中的换行：
    • Windows系统里，每行结尾是 回车+换行 ，即\r\n；
    • Unix系统里，每行结尾只有 换行 ，即\n；
    • Mac系统里，每行结尾是 回车 ，即\r。从 Mac OS X开始与Linux统一。

字节输入流【InputStream】

java.io.InputStream 抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。

  • public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。
  • public abstract int read()： 从输入流读取数据的下一个字节。
  • public int read(byte[] b)： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。

小贴士：

close方法，当完成流的操作时，必须调用此方法，释放系统资源。

FileInputStream类

java.io.FileInputStream 类是文件输入流，从文件中读取字节。

构造方法
  • FileInputStream(File file)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
  • FileInputStream(String name)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件,会抛出FileNotFoundException 。

  • 构造举例，代码如下：
public class FileInputStreamConstructor throws IOException{
    public static void main(String[] args) {
   	 	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileInputStream fos = new FileInputStream(file);
      
        // 使用文件名称创建流对象
        FileInputStream fos = new FileInputStream("b.txt");
    }
}
读取字节数据
  1. 读取字节：read方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回-1，代码使用演示：
public class FISRead {
    public static void main(String[] args) throws IOException{
      	// 使用文件名称创建流对象
       	FileInputStream fis = new FileInputStream("read.txt");
      	// 读取数据，返回一个字节
        int read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
      	// 读取到末尾,返回-1
       	read = fis.read();
        System.out.println( read);
		// 关闭资源
        fis.close();
    }
}
输出结果：
a
b
c
d
e
-1

循环改进读取方式，代码使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException{
      	// 使用文件名称创建流对象
       	FileInputStream fis = new FileInputStream("read.txt");
      	// 定义变量，保存数据
        int b ；
        // 循环读取
        while ((b = fis.read())!=-1) {
            System.out.println((char)b);
        }
		// 关闭资源
        fis.close();
    }
}
输出结果：
a
b
c
d
e

注意：

  1. 虽然读取了一个字节，但是会自动提升为int类型。
  2. 流操作完毕后，必须释放系统资源，调用close方法，千万记得。
  1. 使用字节数组读取：read(byte[] b)，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1 ，代码使用演示：
public class FISRead {
    public static void main(String[] args) throws IOException{
      	// 使用文件名称创建流对象.
       	FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
      	// 定义变量，作为有效个数
        int len ；
        // 定义字节数组，作为装字节数据的容器   
        byte[] b = new byte[2];
        // 循环读取
        while (( len= fis.read(b))!=-1) {
           	// 每次读取后,把数组变成字符串打印
            System.out.println(new String(b));
        }
		// 关闭资源
        fis.close();
    }
}

输出结果：
ab
cd
ed

错误数据d，是由于最后一次读取时，只读取一个字节e，数组中，上次读取的数据没有被完全替换，所以要通过len ，获取有效的字节，代码使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException{
      	// 使用文件名称创建流对象.
       	FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
      	// 定义变量，作为有效个数
        int len ；
        // 定义字节数组，作为装字节数据的容器   
        byte[] b = new byte[2];
        // 循环读取
        while (( len= fis.read(b))!=-1) {
           	// 每次读取后,把数组的有效字节部分，变成字符串打印
            System.out.println(new String(b，0，len));//  len 每次读取的有效字节个数
        }
		// 关闭资源
        fis.close();
    }
}

输出结果：
ab
cd
e

注意：

使用数组读取，每次读取多个字节，减少了系统间的IO操作次数，从而提高了读写的效率，建议开发中使用。

Silly_waiter
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
递归例题（斐波那契不死神兔案例&遍历指定目录下所有的指定后缀名文件名称&递归删除带内容的目录）
qnmdlzg的博客
02-17 187
不死神兔案例。 假设有一对兔子，从出生的第三个月开始，每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子。 假设所有的兔子都不会死。问题：二十个月后，兔子的对数是多少？ 找规律： 月份 兔子的对数 第一个月 1 第二个月 1 第三个月 2 第四个月 3 第五个月 5 ...
简单的整数划分问题（递归）
cxoi9010的博客
05-03 1070
描述 将正整数n 表示成一系列正整数之和，n=n1+n2+…+nk, 其中n1>=n2>=…>=nk>=1 ，k>=1 。 正整数n 的这种表示称为正整数n 的划分。正整数n 的不同的划分个数称为正整数n 的划分数。 输入 标准的输入包含若干组测试数据。每组测试数据是一个整数N(0 < N <= 50)。 输出 对于每组测试数据，输出N的划分数。 样例输入 5 样例输出 7 提示 5, 4+1, 3+2, 3+1+1, 2+2+1, 2+1+1+1, 1+1+1+1
OI基本算法题目（1.回溯2.递归与递推3.贪心4.分治5.图6.树7.搜索8.动态规划）
08-15
1.回溯 2.递归与递推 3.贪心 4.分治 5.图 6.树 7.搜索 8.动态规划 题目比较基础，适合初学者
关于递归的笔记
yogkin的专栏
05-13 420
1:递归(理解) (1)方法定义中调用方法本身的现象 举例：老和尚给小和尚讲故事，我们学编程 (2)递归的注意事项； A:要有出口，否则就是死递归 B:次数不能过多，否则内存溢出 C:构造方法不能递归使用 (3)递归的案例： A:递归求阶乘 B:兔子问题 C:递归输出指定目录下所有指定后缀名的文件绝对路径 D:递归删除带内容的目录(小心使用) 2:IO流(掌握)
IO流_递归输出指定目录下所有的java文件的绝对路径案例
辐_射的博客
02-07 2572
package cn.itcast_03; import java.io.File; /* * 需求:把D:\JavaSE_WorkdSpace2目录下所有的java结尾的文件的绝对路径给输出在控制台。 * * 分析: * A:封装目录 * B:获取该目录下的文件或者文件夹的File数组 * C:遍历该File数组,得到每一个File对象 * D:判断该File
递归，IO
JustChenxx的博客
10-21 102
递归： 方法定义本身调用方法本身的现象叫递归 注意： 递归一定要有一个出口，结束条件，否则就是死循环； 递归的次数不能太多，否则就会发生内存溢出； 构造方法不能递归使用。 IO流的分类：（java程序为中心的） 流向： 输入流 读取数据 输出流 写出数据 数据类型： 字节流 字节输入流 读取数据 InputStream 字节输出流 写出数据 OutputStream 字符流 字...
IO流-递归
迷失的星星的博客
08-08 141
递归概述和注意事项 package fun_01; /* * 递归概述和注意事项 * * 递归:方法定义中调用方法本身的现象 * public void show(int n){ * if(n&lt;=0){ * System.exit(0); * } * System.out.println(n); * show(n--); * } * *...
IO流递归复制多级目录
04-20
在Java编程中，IO流（Input/Output Stream）是用来处理数据输入和输出的重要工具，而“IO流递归复制多级目录”是一个常见的文件系统操作，尤其在文件管理、备份或者程序部署等场景中十分常见。这个过程涉及到对文件...
Java IO流 File类的常用API实例
08-30
Java IO流 File类的常用API实例 Java IO流 File类是Java语言中用于操作文件和目录的基本类之一，提供了丰富的API实例来操作文件和目录。在本节中，我们将详细介绍Java IO流 File类的常用API实例。 一、File类的...
方法引用, Stream流，File类 , 递归 ，字节流.md
08-25
关于一些java的流处理
高级开发员面试宝典之JavaIO流的操作.docx
10-29
1. **流的分类**：Java IO流分为字节流（Byte Stream）和字符流（Character Stream），又各自分为输入流（InputStream/Reader）和输出流（OutputStream/Writer）。它们之间的关系和应用场景是什么？ 2. **缓冲流...
commons-io.jar.rar
07-24
IO流分为四类：字节流（Byte Stream）、字符流（Character Stream）、对象流（Object Stream）和套接字流（Socket Stream）。字节流处理原始字节数据，而字符流处理Unicode字符集中的字符。对象流允许序列化和反序列...
IO流之递归
weixin_34378767的博客
08-22 111
递归： 递归，指在当前方法内调用自己的这种现象 public void method(){ System.out.println(“递归的演示”); //在当前方法内调用自己 method(); } 递归分为两种，直接递归和间接递归。 直接递归称为方法自身调用自己。间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。 l 递归的代码演示，计算1-...
递归和IO流总结
kaszxc的博客
09-14 188
1.递归 (1)方法定义调用方法本身的现象 (2)递归的注意事项 A:要有出口，否则就是死递归 B:次数不能过多，否则就是死递归 C:构造方法不能递归使用 (3)递归的案例 A: 递归求阶乘 B: 兔子问题（裴波纳契数列问题） C: 递归或输出指定目录下所有指定或追名的文件的绝对路径 D:递归删除带内容的目录（小心使用） 2.IO流 (1)用于在设备间进行数据传输
IO流（二） 递归
qq_41781316的博客
07-22 118
递归的概述 递归，指在当前方法内调用自己的这种现象递归分为两种，直接递归和间接递归。 public void method(){ System.out.println(“递归的演示”); //在当前方法内调用自己 method(); } 直接递归称为方法自身调用自己。间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。 注意事项： - 递归...
javaAPI_IO流_递归
u013185175的博客
08-21 215
IO流_递归 1.递归概述 递归指的是方法定义中调用自身方法的情况。 2.递归的注意事项 (1).要有出口，否则就是死递归 (2).次数不能太多，否则就内存溢出 (3).构造方法不能递归使用[不然在创建对象的时候就会内存溢出] 3.递归解决问题的思想 (1).分解法: 把问题细分为一个基本皆可以解决的单元，如:7+8 = ? --> 3+4 =? 4+4 =? --->1+2 =...
IO流的递归概述
Ting1king的博客
03-19 162
递归：方法定义中调用方法本身的现象。 注意事项： A：递归一定要有出口，否则就是死递归 B：递归的次数不能太多，否则就内存溢出 C：构造方法不能递归使用 需求：5的阶乘 5！=5*4*3*2*1； 5！=5*4！； public class test { public static int resault(int n){ int sum=1; if(n==1) return...
javaday49_IO流_深度遍历文件夹,递归手法的使用
叶巨岩的博客
05-10 660
  一. 创建给定路径下的文件 package com.jorian.text.httpClient; import java.io.File; import java.io.IOException; /**  * 创建一个给定路径下的文件  *  */ public class creatFolder{ //定义 地址,文件名 private String path=nul...
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1208
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java IO 流操作详解与实例
Java的IO库提供了一套丰富的API，使得开发者可以方便地处理输入输出流。本文档重点介绍了File类和RandomAccessFile类的相关功能。 1. File类： - 构造方法：File类的构造方法通常接收一个字符串参数，表示文件或...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值