file&递归&IO
2022/2/24 23:53:51
本文主要是介绍file&递归&IO,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!
file&递归&IO
- 能够说出File对象的创建方式(必须会) 使用构造方法 public File(String pathname) :通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。 public File(String parent, String child) :从父路径名字符串和子路径名字符串创建新的 File实例。 public File(File parent, String child) :从父抽象路径名和子路径名字符串创建新的 File实例。 - 能够使用File类常用方法(必须会) public String getName() :获取构造方法中路径的名称(末尾部分) public String getAbsolutePath() : 获取构造方法中路径的绝对路径 public long length() :获取文件的大小,单位是字节 public boolean isDirectory() :是否为目录(文件夹)。 public boolean exists() :判断构造方法中传递的路径是否存在 public boolean createNewFile() :当且仅当具有该名称的文件尚不存在时,创建一个新的空文件。 public boolean mkdir() :创建单级文件夹 public boolean mkdirs() :即可以创建单级文件夹,又可以创建多级文件夹 public boolean delete() :删除文件和文件夹,不走回收站 - 能够辨别相对路径和绝对路径(必须会) 绝对:以盘符开始 相对:相对当前项目的根目录而言;使用项目的跟目录可以省略书写(不是盘符开始) 绝对:D:\\Work_idea\\EE173\\day15\\a.txt 相对:day15\\a.txt 项目的根目录 D:\\Work_idea\\EE173 - 能够遍历文件夹(必须会) public String[] list() : 遍历构造方法传递的文件夹,获取文件夹中每一个文件|子文件夹的名称,把多个名称存储到一个String类型的数组中返回 public File[] listFiles() :返回一个File数组,表示该File目录中的所有的子文件或目录。 遍历构造方法传递的文件夹,获取文件夹中每一个文件|子文件夹,把文件|子文件夹封装为File对象,多个File对象存储到一个File类型的数组中返回 - 能够解释递归的含义 方法自己调用自己 - 能够使用递归的方式计算5的阶乘(必须会) public static int jc(int n) {//方法的主体不变,每次调用自己参数在发生变化5,4,3,2,1 //递归结束的条件:获取到1的时候结束 if(n==1){ return 1; } //递归的目的:获取下一个被乘的数字n-1 return n * jc(n-1); } - 能够说出使用递归会内存溢出隐患的原因 方法自己调用自己,没有结束条件,栈内存中会有无数多个方法,如果方法过多超出了栈内存是范围就会发生内存溢出 - 能够说出IO流的分类和功能 输入流:把硬盘上的数据读取到内存中 字符输入流:读取字符 字节输入流:读取字节 输出流:把内存中的数据写入到硬盘中 字符输出流:写入字符 字节输出流:写入字节 - 能够使用字节输出流写出数据到文件(必须会) 1.创建FileOutputStream对象,构造方法中传递写入数据的目的地 2.调用FileOutputStream对象中的方法write,把数据写入到文件中 3.释放资源
第一章 File类
1.File类的介绍
java.io.File类 文件和目录路径名的抽象表示形式。 把计算机中的文件和文件夹(目录)封装为了File对象,就可以使用File对象来操作这些文件和文件夹 我们可以使用File对象创建文件和文件夹 我们可以使用File对象删除文件和文件夹 我们可以使用File对象获取文件和文件夹的路径 我们可以使用File对象获取文件的大小(单位是字节) 我们可以使用File对象遍历文件夹 记住3个相关的单词: 1.file:文件 2.directory:文件夹(目录) 3.path:路径
2.路径
路径:表示存储文件和文件夹的路径(位置) 分类: 1.绝对路径:以盘符开始的路径(c:,d:,e:) c:\\1.jpg d:\\aaa\\a.txt D:\\Work_idea\\EE173\\day15 2.相对路径:相对于当前项目的根目录而言,我们使用路径,可以省略项目的根目录 项目的根目录:D:\\Work_idea\\EE173 注意:大家的项目根目录都不同 a.绝对路径[必须包含项目的根目录]才可以省略为相对路径 D:\\Work_idea\\EE173\\day15 可以省略为 day15 D:\\Work_idea\\EE173\\day15\\a.txt 可以省略为 day15\\a.txt c:\\1.jpg 不能省略 1.jpg==> D:\Work_idea\EE173\\1.jpg abc\\bbc\\ccc\\abc.java==>D:\\Work_idea\\EE173\\abc\\bbc\\ccc\\abc.java b.当我们省略书写项目的根目录,java会在相对路径前默认给添加上项目的根目录 注意: 1.路径是不区分大小写的 c:\\1.jpg 等价 C:\\1.jpg 2.路径中目录的分割的符号\必须的写两个\\,\本身是一个转义字符,必须的写两个代表一个\ 3.路径中目录的分割的符号也可以使用一个正斜杠/ c:\\a.txt 等价 c:/a.txt
3.File的构造方法(重点)
package com.itheima.demo01File; import java.io.File; /* File的构造方法(重点) 作用:创建File对象,通过对象调用File类的成员方法 */ public class Demo01FileConstructor { public static void main(String[] args) { //show02("c:\\","1.jpg");//c:\1.jpg //show02("d:\\","1.jpg");//d:\1.jpg //show02("d:\\","demo\\a.txt");//d:\demo\a.txt //show02("d:\\aaa\\bbb\\ccc\\ddd\\","demo\\a.txt");//d:\aaa\bbb\ccc\ddd\demo\a.txt show03(); } /* File(File parent, String child) 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。 参数:把路径分成了两部分 File parent:父路径 String child:子路径 好处: 创建File对象的时候,父路径和子路径可以分别传递不同的路径,从而组成不同的路径 */ private static void show03() { File f = new File("c:\\"); File file = new File(f,"1.jpg"); System.out.println(file);//c:\1.jpg } /* File(String parent, String child) 根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。 参数:把路径分成了两部分 String parent:父路径 String child:子路径 好处: 创建File对象的时候,父路径和子路径可以分别传递不同的路径,从而组成不同的路径 */ private static void show02(String parent, String child) { File file = new File(parent,child); System.out.println(file); } /* File(String pathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。 参数: String pathname:传递一个路径名称 注意: 1.参数传递的路径,可以是绝对路径,也可以是相对路径 2.参数传递的路径,可以是以文件结尾的,也可以是以文件夹结尾 3.参数传递的路径,可以是真实存在的,也可以是不存在(假的) 构造方法仅仅是把字符串路径转换为File对象,不考虑路径的真实情况 */ private static void show01() { File f1 = new File("c:\\1.jpg"); System.out.println(f1);//c:\1.jpg File类重写了Object类的toString方法 File f2 = new File("c:/aaa/bbb/ccc/ddd"); System.out.println(f2);//c:\aaa\bbb\ccc\ddd //相当路径day15==>绝对路径D:\Work_idea\EE173\day15 File f3 = new File("day15"); System.out.println(f3); File f4 = new File("day15\\a.txt"); System.out.println(f4); } }
4.File类的成员方法_获取功能的方法(重点)
public String getAbsolutePath() :返回此File的绝对路径名字符串。 public String getPath() :将此File转换为路径名字符串。 public String getName() :返回由此File表示的文件或目录的名称。 public long length() :返回由此File表示的文件的长度。 不能获取目录的长度
package com.itheima.demo01File; import java.io.File; /* File类的成员方法_获取功能的方法(重点) public String getAbsolutePath() :返回此File的绝对路径名字符串。 public String getPath() :将此File转换为路径名字符串。 public String getName() :返回由此File表示的文件或目录的名称。 public long length() :返回由此File表示的文件的长度。 不能获取目录的长度 */ public class Demo02FileMethod { public static void main(String[] args) { show04(); } /* public long length() 获取构造方法中传递的文件的大小,单位是字节 注意: 1.如果此路径名表示一个目录,则返回值是不确定的。不能获取文件夹的大小,文件夹没有大小概念的 2.如果文件不存在,则返回 0L */ private static void show04() { File f1 = new File("c:\\1.jpg"); System.out.println(f1.length());//161,548 字节 File f2 = new File("day15\\全球通史.txt"); System.out.println(f2.length());//5,155,785 字节 File f3 = new File("day15\\afdsafa.txt"); System.out.println(f3.length());//0 文件不存在 File f4 = new File("day15"); System.out.println(f4.length());//0 文件夹是没有大小概念的 File f5 = new File("D:\\base\\20211115EE173\\day15"); System.out.println(f5.length());//4096 文件夹是没有大小概念的 } /* public String getName() 获取构造方法中传递路径末尾的文件|文件夹名称 */ private static void show03() { File f1 = new File("c:\\1.jpg"); System.out.println(f1.getName());//1.jpg File f2 = new File("day15\\a.txt"); System.out.println(f2.getName());//a.txt File f3 = new File("aa\\bb\\cc\\dd"); System.out.println(f3.getName());//dd } /* public String getPath(): 获取构造方法中传递的路径 返回值: 构造方法中传递的是绝对路径,就返回绝对路径 构造方法中传递的是相对路径,就返回相对路径 File类重写了Object的toString方法 public String toString() { return getPath(); } */ private static void show02() { File f1 = new File("c:\\1.jpg"); System.out.println(f1.getPath());//c:\1.jpg File f2 = new File("D:\\Work_idea\\EE173\\day15\\a.txt"); System.out.println(f2.getPath()); File f3 = new File("day15\\a.txt"); System.out.println(f3.getPath());//day15\a.txt System.out.println(f3.toString());//day15\a.txt System.out.println(f3);//day15\a.txt } /* get:获取 Absolute:绝对的 path:路径 public String getAbsolutePath() :获取File构造方法中传递路径的绝对路径 返回值: 构造方法中传递的是绝对路径,直接返回绝对路径 构造方法中传递的是相对路径,会自动在相对路径前增加上项目的根目录,组成绝对路径返回 */ private static void show01() { File f1 = new File("c:\\1.jpg"); System.out.println(f1.getAbsolutePath());//c:\1.jpg File f2 = new File("D:\\Work_idea\\EE173\\day15\\a.txt"); System.out.println(f2.getAbsolutePath());//D:\Work_idea\EE173\day15\a.txt File f3 = new File("day15\\a.txt"); System.out.println(f3.getAbsolutePath());//D:\Work_idea\EE173\day15\a.txt } }
5.File类的成员方法_判断功能的方法(重点)
public boolean exists() :此File表示的文件或目录是否实际存在。 public boolean isDirectory() :此File表示的是否为目录。 public boolean isFile() :此File表示的是否为文件。
package com.itheima.demo01File; import java.io.File; /* File类的成员方法_判断功能的方法(重点) public boolean exists() :此File表示的文件或目录是否实际存在。 public boolean isDirectory() :此File表示的是否为目录。 public boolean isFile() :此File表示的是否为文件。 */ public class Demo03FileMethod { public static void main(String[] args) { show02(); } /* public boolean isDirectory() :判断构造方法中的路径是否以文件夹结尾 返回值: boolean 路径是以文件夹结尾,返回true 路径不是以文件夹结尾,返回false public boolean isFile() :判断构造方法中的路径是否以文件结尾 返回值: boolean 路径是以文件结尾,返回true 路径不是以文件结尾,返回false 注意: 1.以上两个方法的使用前提,是构造方法中的路径必须是存在的;否则都返回false 2.计算机中除了文件,就是文件夹,所以以上两个方法互斥 */ private static void show02() { File f1 = new File("d:\\adfdsafdsa"); System.out.println(f1.isDirectory());//false System.out.println(f1.isFile());//false System.out.println("-------------------------------"); File f2 = new File("c:\\1.jpg"); if(f2.exists()){ System.out.println(f2.isDirectory());//false System.out.println(f2.isFile());//true } System.out.println("-------------------------------"); File f3 = new File("day15"); if (f3.exists()){ System.out.println(f3.isDirectory());//true System.out.println(f3.isFile());//false } } /* exists:存在 public boolean exists() 判断构造方法中传递的路径是否存在 返回值:boolean 路径真实存在,返回true 路径不存在,返回false */ private static void show01() { File f1 = new File("c:\\1.jpg"); boolean b1 = f1.exists(); System.out.println("b1:"+b1);//b1:true File f2 = new File("d:\\adfdsafdsa"); boolean b2 = f2.exists(); System.out.println("b2:"+b2);//b2:false File f3 = new File("day15\\a.txt"); boolean b3 = f3.exists(); System.out.println("b3:"+b3);//b3:true } }
6.File类的成员方法_创建删除功能的方法(重点)
public boolean createNewFile() :当且仅当具有该名称的文件尚不存在时,创建一个新的空文件。 public boolean mkdir() :创建由此File表示的目录。 public boolean mkdirs() :创建由此File表示的目录,包括任何必需但不存在的父目录。 public boolean delete() :删除由此File表示的文件或目录。
package com.itheima.demo01File; import java.io.File; import java.io.IOException; /* File类的成员方法_创建删除功能的方法(重点) public boolean createNewFile() :当且仅当具有该名称的文件尚不存在时,创建一个新的空文件。 public boolean mkdir() :创建由此File表示的目录。 public boolean mkdirs() :创建由此File表示的目录,包括任何必需但不存在的父目录。 public boolean delete() :删除由此File表示的文件或目录。 */ public class Demo04FileMethod { public static void main(String[] args) throws IOException { show03(); } /* delete:删除 public boolean delete() 删除构造方法中传递的文件|文件夹 返回值:boolean 文件|文件夹存在,删除成功,返回true 文件|文件夹不存在,删除失败,返回false 文件夹中有内容,删除失败,返回false 注意: 此删除方法不走回收站,直接在硬盘删除,需要谨慎 */ private static void show03() { File f1 = new File("d:\\1.txt"); boolean b1 = f1.delete(); System.out.println("b1:"+b1); File f2 = new File("day15\\aaa"); boolean b2 = f2.delete(); System.out.println("b2:"+b2); File f3 = new File("day15\\111"); boolean b3 = f3.delete(); System.out.println("b3:"+b3);//b3:false 文件夹中有内容 } /* mk:make 创建 dir:directory 文件夹 public boolean mkdir() 用于创建单级文件夹 public boolean mkdirs() 既能创建单级文件夹,又能创建多级文件夹 返回值:boolean 文件夹不存在,创建成功,返回true 文件夹存在,创建失败,返回false;创建文件夹的路径不存在,返回false 注意: 1.此方法只能创建文件夹,不能创建文件 2.创建文件夹的名称和路径在构造方法中给出 */ private static void show02() { File f1 = new File("day15\\aaa"); boolean b1 = f1.mkdir(); System.out.println("b1:"+b1); File f2 = new File("day15\\111\\222\\333\\444\\555\\hehe"); boolean b2 = f2.mkdirs(); System.out.println("b2:"+b2); File f3 = new File("e:\\bbb"); boolean b3 = f3.mkdir(); System.out.println("b3:"+b3);//b3:false 路径不存在 } /* create:新建,创建 new:新的 public boolean createNewFile() :当且仅当具有该名称的文件尚不存在时,创建一个新的空文件。 返回值:boolean 文件不存在,创建成功,返回true 文件存在,不在创建(不覆盖),返回false 注意: 1.此方法只能创建文件,不能创建文件夹 2.创建文件的名称和路径在构造方法中给出 3.创建文件的路径不存在,会抛出异常 4.有些操作系统的c盘,没有创建文件的权限的,会抛出拒绝访问异常 */ private static void show01() throws IOException { File f1 = new File("d:\\1.txt"); boolean b1 = f1.createNewFile(); System.out.println("b1:"+b1); File f2 = new File("day15\\hello.txt"); boolean b2 = f2.createNewFile(); System.out.println("b2:"+b2); File f3 = new File("e:\\a.txt"); //boolean b3 = f3.createNewFile();//IOException: 系统找不到指定的路径。 File f4 = new File("d:\\adfdsafdsf\\a.txt"); boolean b4 = f4.createNewFile();//IOException: 系统找不到指定的路径。 adfdsafdsf文件夹不存在 } }
7.File类的成员方法_目录遍历的方法(重点)
package com.itheima.demo01File; import java.io.File; /* File类的成员方法_目录遍历的方法(重点) 目录:就是文件夹 String[] list() 用于遍历目录,可以获取目录中所有文件和子文件夹的名称, 把多个名称存储到一个String类型的数组中返回 File[] listFiles() 用于遍历目录,可以获取目录中所有文件和子文件夹, 把获取到的文件和文件封装为File对象, 把多个File对象存储到一个File类型的数组中返回 注意: 1.要遍历的目录,需要在构造方法中给出 2.以上两个方法只能遍历目录(文件夹),不能遍历文件,要遍历文件,以上两个方法,都返回null 3.要遍历的目录,不存在,以上两个方法,都返回null 4.以上两个方法,只能遍历单级文件夹,不会遍历子文件夹 */ public class Demo05FileMethod { public static void main(String[] args) { //File file = new File("d:\\aaa\\aaa.txt");//null //File file = new File("d:\\aaaasdfadsf");//null File file = new File("d:\\aaa"); String[] arr = file.list(); System.out.println(arr); //在工作中:在遍历数组|集合之前,增加一个非空判断,防止空指针异常 if(arr!=null && arr.length>0){ for (String fileName : arr) { System.out.println(fileName); } } System.out.println("-------------------"); File[] files = file.listFiles(); System.out.println(files); if(files!=null && files.length>0){ for (File f : files) { System.out.println(f); } } } }
第二章 递归
1.递归的概述
递归:方法自己调用自己 分类: 1.直接递归 public void a(){ a(); } 2.间接递归 public void a(){ b(); } public void b(){ a(); } 注意事项: 1.递归必须有结束的条件,保证方法自己调用自己能停止下来,否则会抛出栈内存溢出的错误 2.递归有结束的条件,但是递归的次数也不能太多了,否则会抛出栈内存溢出的错误 3.构造方法禁止递归 什么时候使用递归: 当我们频繁的调用一个方法,方法的主体不变,方法的参数每次发生变化,就可以使用递归
package com.itheima.demo02Recursion; /* 递归:方法自己调用自己 */ public class Demo01DiGui { public static void main(String[] args) { //a(); //b(1); } //3.构造方法禁止递归 public Demo01DiGui() { //Demo01DiGui(); } /* 2.递归有结束的条件,但是递归的次数也不能太多了,否则会抛出栈内存溢出的错误 11414 11404 内存的使用率随时在变化 Exception in thread "main" java.lang.StackOverflowError */ private static void b(int i) { System.out.println(i); if(i==20000){ return;//结束方法 } b(++i); } /* 1.递归必须有结束的条件,保证方法自己调用自己能停止下来,否则会抛出栈内存溢出的错误 Exception in thread "main" java.lang.StackOverflowError */ private static void a() { System.out.println("a方法"); a(); } }
2.练习:使用递归计算1-n的和
package com.itheima.demo02Recursion; /* 练习:使用递归计算1-n的和 分析: 1-n的和,就是n-1的和 公式: n+(n-1)+(n-2)+(n-3)+...+1 10+9+8+7+...+1 已知: n: 10,100,1000 未知: n-1 递归的目的:获取下一个被加的数字n-1 递归的结束的条件:获取到1的时候结束 */ public class Demo02Test { public static void main(String[] args) { int sum = getSum(100); System.out.println("sum:"+sum); } /* 定义一个递归求和的方法 当我们频繁的调用一个方法,方法的主体不变,方法的参数每次发生变化,就可以使用递归 */ public static int getSum(int n){//3,2,1 //递归的结束的条件:获取到1的时候结束 if(n==1){ return 1; } //递归的目的:获取下一个被加的数字n-1 return n+getSum(n-1); } }
3.练习:递归求阶乘(重点)
package com.itheima.demo02Recursion; /* 递归求阶乘 n的阶乘:n! = n * (n-1) *...* 3 * 2 * 1 已知: n: 10,100,1000 未知: n-1 递归的目的:获取下一个被乘的数字n-1 递归的结束的条件:获取到1的时候结束 */ public class Demo03Test { public static void main(String[] args) { int jc = jieCheng(5); System.out.println(jc); } /* 定义一个使用递归计算阶乘的方法 5!=5*4*3*2*1=120 */ public static int jieCheng(int n){ //递归的结束的条件:获取到1的时候结束 if(n==1){ return 1; } //递归的目的:获取下一个被乘的数字n-1 return n * jieCheng(n-1); } }
5.练习:文件搜索
需求:模拟window系统中的文件搜索功能,搜索d:\aaa目录下所有的以.java|.JAVA结尾的文件
package com.itheima.demo02Recursion; import java.io.File; /* 练习:文件搜索 需求:模拟window系统中的文件搜索功能,搜索d:\aaa目录下所有的以.java|.JAVA结尾的文件 分析: 1.定义一个遍历文件夹的方法getAllFile,方法的参数传递要遍历的File对象 2.在方法中使用File中的listFiles方法,获取文件夹中所有的内容,封装到一个File数组中返回 3.对数组进行一个非空判断,防止空指针异常 4.数组不是null,遍历数组,获取数组中的每一个File对象 5.判断File对象是一个文件,还是一个文件夹 是一个文件:判断文件是否是一个以.java|.JAVA结尾的文件,是则打印文件的绝对路径 是一个文件夹:继续遍历文件夹 我们发现getAllFile方法,就是一个传递文件夹遍历文件夹的方法,调用getAllFile方法即可(递归:自己调用自己) */ public class Demo04Test { public static void main(String[] args) { File file = new File("d:\\aaa"); getAllFile(file); } //1.定义一个遍历文件夹的方法getAllFile,方法的参数传递要遍历的File对象 public static void getAllFile(File dir){ //2.在方法中使用File中的listFiles方法,获取文件夹中所有的内容,封装到一个File数组中返回 File[] files = dir.listFiles(); //4.数组不是null,遍历数组,获取数组中的每一个File对象 if(files!=null && files.length>0){ //4.数组不是null,遍历数组,获取数组中的每一个File对象 for (File f : files) { //5.判断File对象是一个文件,还是一个文件夹 if(f.isFile()){ /* 是一个文件:判断文件是否是一个以.java|.JAVA结尾的文件,是则打印文件的绝对路径 String类 endsWith方法:判断字符串是以什么字符串结尾 toLowerCase方法:把字符串中的英文字符转换为小写 "B.JAVA"==>toLowerCase方法==>"b.java" 把File对象(f),转换为字符串对象 toString方法 "d:\\aaa\\aaa.java" getPath方法 "d:\\aaa\\aaa.java" getName方法 "aaa.java" */ if(f.getName().toLowerCase().endsWith(".java")){ System.out.println(f.getAbsolutePath()); } }else{ /* 是一个文件夹:继续遍历文件夹 我们发现getAllFile方法,就是一个传递文件夹遍历文件夹的方法,调用getAllFile方法即可(递归:自己调用自己) */ getAllFile(f); } } } } }
第三章 IO概述
1.IO流的概述和分类
IO流的作用:读写数据
I:input 输入,读取
O:output 输出,写入
流:流动的是数据,输入和输出的都是数据(字节 byte,字符 char)
2.一切皆为字节
硬盘中的一切文件数据(文本、图片、视频等)在存储时,都是以二进制数字的形式保存(计算机只能识别0和1),都一个一个的字节(1个字节=8比特位),那么传输时一样如此。所以,字节流可以传输任意文件数据。在操作流的时候,我们要时刻明确,无论使用什么样的流对象,底层传输的始终为二进制数据(1,0)。
0,1比特位:计算机的最小单位
为了方便把8个0,1组成一个字节:计算机的基本单位
1个字节=8个比特位(0,1)
1kb=1024字节(b)
1MB = 1024kb
1GB=1024MB
1TB = 1024GB
1PB = 1024TB
第四章 字节流
1.字节输出流的介绍(了解)
java.io.OutputStream类:字节输出流 此抽象类是表示输出字节流的所有类的超类。 OutputStream类是所有字节输出流的父类,里边定义了所有字节输出流共性成员方法,任意的子类都可以使用 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) :将指定的字节输出流 ------------------------------------------------------------------------------------- java.io.FileOutputStream:文件字节输出流 extends OutputStream:字节输出流 作用:把内存中数据以字节的方式写入到文件中 构造方法: FileOutputStream(File file) 创建FileOutputStream对象 FileOutputStream(String name) 创建FileOutputStream对象 参数:传递写入数据的目的地 d:\\1.txt File file:目的地就是一个文件 String name:目的地就是一个文件的路径 构造方法的作用: 1.创建FileOutputStream对象 2.会根据传递写入数据的目的地,创建一个相关的文件 3.会把FileOutputStream对象指向创建好的文件 ------------------------------------------------------------------------------------- java程序把数据由内存中写入到硬盘中底层步骤: java程序==>JVM==>操作系统==>调用操作系统中写数据的方法==>把数据写入到文件中
2.字节输出流的基本使用(重点)
package com.itheima.demo03OutputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; /* 字节输出流的基本使用(重点) 1.创建文件字节输出流FileOutputStream对象,构造方法中传递要写入的目的地(文件,文件路径) 2.使用FileOutputStream对象中的方法write,把数据以字节的方式写入到文件中 3.释放资源(关闭此输出流并释放与此流相关联的任何系统资源) */ public class Demo01FileOutputStream { public static void main(String[] args) throws IOException { //1.创建文件字节输出流FileOutputStream对象,构造方法中传递要写入的目的地(文件,文件路径) //FileNotFoundException: day15\aaa\1.txt (系统找不到指定的路径。) day15下没有aaa文件夹 FileOutputStream fos = new FileOutputStream("day15\\1.txt"); //2.使用FileOutputStream对象中的方法write,把数据以字节的方式写入到文件中 //void write(int b) 一次写一个字节 fos.write(97); //3.释放资源 fos.close(); } }
2.使用记事本打开文件会查询编码表(扩展-面试)
3.字节输出流中写多个字节的方法(重点)
package com.itheima.demo03OutputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.util.Arrays; /* 字节输出流中写多个字节的方法(重点) void write(int b) 一次写一个字节 void write(byte[] b) 一次写入字节数组中的所有字节 void write(byte[] b, int off, int len) 一些写入字节数组中的一部分字节 int off:从数组的哪个索引开始写 int len:写的字节个数 */ public class Demo02FileOutputStream { public static void main(String[] args) throws IOException { //需求:在文件中显示100,应该怎么写==>写了3个字节 FileOutputStream fos = new FileOutputStream("day15\\2.txt"); //void write(int b) 一次写一个字节 //fos.write(49);//'1' //fos.write(48);//'0' //fos.write(48);//'0' //void write(byte[] b) 一次写入字节数组中的所有字节 byte[] bytes = {49,48,48}; fos.write(bytes);//100 byte[] bytes2 = {65,66,67,68,69,70}; fos.write(bytes2);//ABCDEF /* void write(byte[] b, int off, int len) 一些写入字节数组中的一部分字节 int off:从数组的哪个索引开始写 int len:写的字节个数 */ fos.write(bytes2,2,2);//CD //了解:如果想写入一个字符串到文件中 // String类 byte[] getBytes() 查询编码表,把字符串转换为字节数组 byte[] bytes3 = "你好".getBytes(); System.out.println(Arrays.toString(bytes3));//[-28, -67, -96, -27, -91, -67] fos.write("你好".getBytes()); fos.close(); } }
4.字节输出流的续写和换行(重点)
package com.itheima.demo03OutputStream; import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; /* 续写,追加写:使用两个参数的构造方法 FileOutputStream(File file, boolean append) FileOutputStream(String name, boolean append) 参数: File file,String name:传递要写入的目的地,文件,文件路径 boolean append:续写开关 true:使用构造方法创建对象,文件已经存在的,不会创建一个新的文件覆盖之前的文件,使用之前的文件 false:使用构造法方法创建对象,文件已经存在的,会创建一个新的空白文件覆盖之前的文件 */ public class Demo03FileOutputStream { public static void main(String[] args) throws IOException { //创建FileOutputStream对象,构造方法中传递要写入的目的地和续写开关 File file = new File("day15\\3.txt"); FileOutputStream fos = new FileOutputStream(file,true); //使用write方法往文件中写数据 fos.write("你好".getBytes()); //释放资源 fos.close(); } }
package com.itheima.demo03OutputStream; import java.io.FileOutputStream; import java.io.IOException; /* 写换行 Windows系统里,换行符号是 \r\n \r:回车 回到一行的开头 \n:换行 换到下一行 ------------------------------------- 系统中的换行: Windows系统里,每行结尾是 回车+换行 ,即 \r\n ; Unix,Linux系统里,每行结尾只有 换行 ,即 \n ; Mac系统里,每行结尾是 回车 ,即 \r 。从 Mac OS X开始与Linux统一。 */ public class Demo04FileOutputStream { public static void main(String[] args) throws IOException { FileOutputStream fos = new FileOutputStream("day15\\4.txt",true); for (int i = 1; i <= 10; i++) { fos.write(("hello"+i).getBytes()); fos.write("\r\n".getBytes()); } fos.close(); } }
这篇关于file&递归&IO的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!
- 2024-07-04TiDB 资源管控的对撞测试以及最佳实践架构
- 2024-07-03万字长文聊聊Web3的组成架构
- 2024-07-02springboot项目无法注册到nacos-icode9专业技术文章分享
- 2024-06-26结对编程到底难不难?答案在这里
- 2024-06-19《2023版Java工程师》课程升级公告
- 2024-06-15matplotlib作图不显示3D图,怎么办?
- 2024-06-1503-Loki 日志监控
- 2024-06-1504-让LLM理解知识 -Prompt
- 2024-06-05做软件测试需要懂代码吗?
- 2024-06-0514-ShardingSphere的分布式主键实现