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.*Error
*/
private static void b(int i) {
System.out.println(i);
if(i==20000){
return;//结束方法
}
b(++i);
}
/*
1.递归必须有结束的条件,保证方法自己调用自己能停止下来,否则会抛出栈内存溢出的错误
Exception in thread "main" java.lang.*Error
*/
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();
}
}