IO流输出写入方法
java.io.OutputStream;字节输出流
此抽象类是表示输出字节流的所有类的超类
定义了一些子类共性的成员方法：
public void close():关闭此输出流并且释放与此流相关联的任何系统资源
public void flush():刷新此输出流并且强制任何缓冲的输出字节被写出
public void write(byte[] b):将b.length字节从指定的字节数组写入此输出流
public abstract void write(int b):将指定的字节输出流
java.io.FileOutputStream extends OutputStream
FileOutputStream:文件字节输出流
作用：把内存中的数据写入到硬盘的文件中。
构造方法；FileOutputStream(String name)创建一个向具有指定名称文件中写入数据的输出文件流
FileOutputStream(File file)创建一个向指定File对象表示的文件中写入数据的文件输出流
参数：写入数据的目的地。String name：目的地是一个文件的路径。File file：目的地是一个文件
构造方法的作用：1、创建一个FileOutputStream的对象
2、会根据构造方法中传递的文件/文件路径，创建一个空的文件
3、会把FileOutputStream对象指向创建好的文件
写入数据的原理（内存–>硬盘）
java程序–>JVM（java虚拟机）–>OS（操作系统）–>OS调用写数据的方法–>把数据写入到文件中
字节输出流的使用步骤（重点）：
1、创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
2、调用FileOutputStream对象中的方法write，把数据写入到文件中
3、释放资源（流使用会占用一定的空间，使用完毕要把内存清空，提高程序的效率）
public class demo01 {
public static void main(String[] args) throws IOException {
//创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
FileOutputStream fos=new FileOutputStream("C:\\Users\\ASUS\\Desktop\\其他文件");
//调用FileOutputStream对象中的方法write，把数据写入到文件中
fos.write(97);
fos.close();
}
}
一次写入多个字节的方法:
public void write(byte[] b):将b.length字节从指定的字节数组写入此输出流
public void write(byte[] b,int off,int len):从指定的字节数组写入len字节，从偏移量off开始到此输出流
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class demo02 {
public static void main(String[] args) throws IOException {
//创建一个FileOutputStream的对象,构造方法中绑定要写入数据的目的地
FileOutputStream fos=new FileOutputStream(new File("C:\\Users\\ASUS\\Desktop"));
//调用FileInputStream对象中的方法write，把数据写入到文件中
//在文件中显示100
byte[] bytes={65,66,67,68,69};
/*public void write(byte[] b,int off,int len):从指定的字节数组写入len字节，从偏移量off开始到此输出流
int off:数组开始索引。int 冷：写几个字节*/
fos.write(bytes,1,2);
/*写入字符的方法：可以使用String类中的方法，转换字节为字节数组*/
fos.close();
}
}
追加写/续写
追加写/续写：使用两个参数的构造方法
FileOutputStream(String name,boolean append)创建一个具有指定name的文件中写入数据的输出流
FileOutputStream(File file,boolean append)创建一个指定Fil对象表示的文件中写入数据的文件输出流
参数：String name，File file：写入数据的目的地
boolean append：追加开关
true：创建对象不会覆盖原文件，继续在文件的末尾追加数据
false：创建一个新文件，覆盖原文件
写换行：需要用换行符号
windows系统：\r\n
linux系统：/n
mac系统：/r
import java.io.FileOutputStream;
import java.io.IOException;
public class demo04 {
public static void main(String[] args) throws IOException {
FileOutputStream fos=new FileOutputStream("E:\\编程");
fos.write("你好".getBytes());
for(int i=0;i<5;i++) {
fos.write("123".getBytes());
fos.write("\r\n".getBytes());
}
fos.close();
}
}
文件字节输入流
java.io.InputStream:字节输入流
此抽象类是表达字节输入的所有类的超体
定义了所有子类的共性的方法：
int read()从输入流读取数据的下一个字节。
int read(byte[] b)从输入流中读取一定数量的字节，并且将其存储在缓冲区数组b中
void close（）关闭此输入流并且释放该流的所有资源
java.io.FileInputStream extents InputStream
FileInputStream：文件字节输入流
作用：把硬盘文件中的数据读取到内存中使用
构造方法：FileInputStream(String name)
FileInputStream(File file)
参数：读取文件的数据源
String name：文件的路径
File file:文件
构造方法的作用：1、会创建一个FileInputStream的对象
2、会把FileInputStream对象指定构造方法中要读取的文件
字节输入流的使用步骤（重点）：
1、创建FileInputStream对象，构造方法中绑定要读取的数据源
2、使用FileInputStream对象重点方法read，读取文件
3、释放资源
import java.io.FileInputStream;
import java.io.IOException;
public class demo03 {
public static void main(String[] args) throws IOException {
//创建FileInputStream对象，构造方法中绑定要读取的数据源
FileInputStream fis=new FileInputStream("E:\\编程");
int len=fis.read();//使用FileInputStream对象中的方法read读取文件，这个方法只读取一个文件就返回，读到末尾返回-1
System.out.println(len);
/*可以使用循环优化的方法来读取文件，用while来循环
布尔表达式(len =fis.read())!=-1
1、fis。read():读取一个字节
2、len=fis.read():把读到的字节赋值给变量len
3、(len=fis.read())!=-1:判断len是否不等-1
*/
int len1=0;//记录读取到的字节
while((len1=fis.read())!=-1){
System.out.println((char) len1);
}
fis.close();//释放资源
}
}
字节输入流一次输入多个字节的方法
字节输入流一次输入多个字节的方法：
int read(byte[] b)从输入流中读取一定数量的字节，并且将其存储在缓冲区数组b中
明确两件事：1、方法参数byte[]作用？
起到缓冲作用，存储每次读取到的多个字节，数组长度把定义为1024（1Kb）或者1024的整数倍
2、方法返回值是什么？
每次读取的字节数
String类的构造方法：String(byte[] bytes):把字节数组转换为字符串
String(byte[] bytes,int offset,int length)把字节数组的一部分转换为字符串offset：数组开始索引 length：转换的字节个数
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;
public class demo05 {
public static void main(String[] args) throws IOException {
//创建FileInputStream对象，构造方法中绑定要读取的数据源
FileInputStream fis=new FileInputStream("E:\\编程\\a.txt");
//使用FileInputStream对象中的read读取文件
//int read(byte[] b)从输入流中读取一定数量的字节，并且将其存储在缓冲区数组b中
byte [] bytes=new byte[2];
int len=fis.read(bytes);
System.out.println(len);
System.out.println(Arrays.toString(bytes));
System.out.println(new String(bytes));
//可以用一个while循环
byte[] bytes1=new byte[1024];
int len1=0;
while((len1=fis.read(bytes))!=-1){
//String(byte[] bytes,int offset,int length)把字节数组的一部分转换为字符串offset：数组的开始索引length：转换的字节个数
System.out.println(new String(bytes,0,len1));
}
fis.close();
}
}
练习
练习复制：一读一写
明确数据源和数据源的目的地
复制文件步骤：1、创建一个字节输入流对象，构造方法绑定要读取的数据源
2、创建一个字节输出流对象，构造方法中绑定要写入的数据的目的地
3、使用字节输入流对象，构造方法中绑定要写入的目的地
4、使用字节输出流中的方法write，把读取到的字节写入到目的地等的文件中
5、释放资源
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class demo04 {
public static void main(String[] args) throws IOException {
long time1=System.currentTimeMillis();
//创建一个字节输入流对象，构造方法绑定要读取的数据源
FileInputStream fis=new FileInputStream("E:\\编程");
//创建一个字节输出流对象，构造方法中绑定要写入的数据的目的地
FileOutputStream fos=new FileOutputStream("D:\\编程");
/*一次读取一个字节写入一个字节的方法
使用字节输入流对象，构造方法中绑定要写入的目的地
int len=0;
while((len=fis.read())!=-1){
fos.write(len);
}*/
/*使用数组缓冲读取多个字节，写入多个字节*/
byte[] bytes=new byte[1024];
int len=0;//每次读取的有效字节个数
while((len=fis.read(bytes))!=-1) {
fos.write(bytes, 0, len);
}
long time2=System.currentTimeMillis();
System.out.println("程序运行时间："+(time2-time1));
fos.close();
fis.close();
}
}
字符输出流
java.io.writer: 字符输出流，是所有字符输出流的最顶层父类，是一个抽象类
共性的成员方法：1、void writer(int c)写入单个字符
2、void writer(char[] cbuf)写入字符数组
3、abstract void writer(char[] cbuf,int off,int len)写入字符数组的某一部分，off数组开始索引，len写的字符个数
4、void writer(String str)写入字符串
5、void writer(String str,int off,int len)写入字符串的某一部分，off字符串的开始索引，len写的字符个数
6、void flush()刷新该流的缓冲
7、void close()关闭此流，但是要刷新它
java.io.FileWriter extends OutputStreamWriter extends Writer
FileWriter:文件字符输出流
作用：把内存中字符数据写入到文件中
构造方法：1、FileWriter(File file)根据给定的File对象构造一个FileWriter对象
2、FileWriter(String fileName)根据给定的文件名构造一个FileWriter对象
参数：写入数据的目的地
String fileName：文件路径。File file：是一个文件
构造方法的作用：1、会创建一个FileWriter对象
2、会根据构造方法中传递文件或者文件夹的路径，创建文件夹
3、会根把FileWriter对象指向创建好的文件
字符输出流的使用步骤（重点）：1、创建FileWriter对象，构造方法中绑定要写如数据的目的地
2、使用FileWriter中的方法writer，把数据写入到内存缓冲区中（字符转换城子街的过程）
3、使用FileWriter中的方法flush，把内存缓冲区中的数据，刷新到文件中
4、释放资源（会先把内存缓冲区的数据刷新到文件中）
import java.io.FileWriter;
import java.io.IOException;
public class demo02 {
public static void main(String[] args) throws IOException {
//创建FileWriter对象，构造方法中绑定要写如数据的目的地
FileWriter fe=new FileWriter("C:\\");
//使用FileWriter中的方法writer，把数据写入到内存缓冲区中（字符转换城子街的过程）
//void writer(int c)：写入单个字符
fe.write(97);
//使用FileWriter中的方法flush，把内存缓冲区中的数据，刷新到文件中
fe.flush();
fe.close();
}
}
字符输出流写数据的其他方法
1、void writer(int c)写入单个字符
2、void writer(char[] cbuf)写入字符数组
3、abstract void writer(char[] cbuf,int off,int len)写入字符数组的某一部分，off数组开始索引，len写的字符
4、void writer(String str)写入字符串
5、void writer(String str,int off,int len)写入字符串的某一部分，off字符串的开始索引，len写的字符个数
import java.io.FileWriter;
import java.io.IOException;
public class demo03 {
public static void main(String[] args) throws IOException {
FileWriter fr=new FileWriter("C:\\123.txt");
char[] cs={'a','d','g'};//void writer(char[] cbuf)写入字符数组
fr.write(cs);
//abstract void writer(char[] cbuf,int off,int len)写入字符数组的某一部分，off数组开始索引，len写的字符
fr.write(cs,1,2);
//void writer(String str)写入字符串
fr.write("我的名字");
//void writer(String str,int off,int len)写入字符串的某一部分，off字符串的开始索引，len写的字符个数
fr.write("wodmingz",2,3);
fr.close();
}
}
续写和换行
续写，追加写：使用两个参数的构造方法：
FileWriter(String fileName,boolean append)
FileWriter(File file,boolean)
参数：String fileName，File file：写入数据的目的地
boolean append：续写开关 true：不会创建新文件覆盖原文件，可以续写。false：创建新文件覆盖原文件
换行：换行符号windows：\r\n。linux：/n。mac：/r
import java.io.FileWriter;
import java.io.IOException;
public class demo04 {
public static void main(String[] args) throws IOException {
FileWriter fw=new FileWriter("C:\\123.txt");
for(int i=0;i<5;+i+){
fw.write("helloWorld"+i+"\r\n");
}
}
}
扫一扫
6万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
