篇首语:本文由编程笔记#小编为大家整理,主要介绍了Java之IO初识(字节流和字符流)相关的知识,希望对你有一定的参考价值。
构造方法参数(写入数据的目的)
构造方法的作用:
写入数据的原理(内存-->硬盘)
package demo01;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo01OutputStream {
//方法有异常必须处理
public static void main(String[] args) throws IOException {
//1.创建一个FileOutputStream对象,构造方法中传递写入数据的目的地
FileOutputStream fos = new FileOutputStream("C:UsersAdministratorIdeaProjectsasic_codeday20字节输出流测试文件.txt");
//2.调用FileOutputStream对象中的方法write,把数据写入到文件中
fos.write(98);
//3.释放资源(流使用会占用一定的内存,使用完毕要把内存清空,提供程序的效率)
fos.close();
}
}
结论:
我们打开上面代码存储的数据看到的结果如下图所示:
package demo01;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo02OutputStream {
public static void main(String[] args) throws IOException {
/*
public void write(byte[] b):将 b.length字节从指定的字节数组写入此输出流。
一次写多个字节:
如果数组中的第一个字节是正数(0-127),那么显示的时候会查询ASCII表
如果数组中的一个字节是负数,那第一个字节会和第二个字节,两个字节组成一个中文显示,查询系统默认码表(GBK)
*/
//创建FileOutputStream对象,构造方法中绑定要写入数据的目的地
FileOutputStream fos = new FileOutputStream(new File("C:UsersAdministratorIdeaProjectsasic_codeday20字节输出流测试文件1.txt"));
//调用FileOutputStream对象中的方法write,把数据写入到文件中
byte[] b1 = {98, 55, -44, 97, 99};
fos.write(b1);//数组作为参数
//释放资源
fos.close();
}
}
package demo01;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo03OutputStream {
public static void main(String[] args) throws IOException {
/*
public void write(byte[] b, int off, int len) :把字节数组的一部分写入到文件中
参数:
int off:数组的开始索引
int len:写几个字节
*/
//创建FileOutputStream对象,构造方法中绑定要写入数据的目的地
FileOutputStream fos = new FileOutputStream(new File("C:UsersAdministratorIdeaProjectsasic_codeday20字节输出流测试文件2.txt"));
//字符串转换为字节数组
byte[] bytes = "abcdefg".getBytes();
fos.write(bytes, 0, 4);
//关闭资源
fos.close();
}
}
代码举例
package demo01;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo04OutputStream {
public static void main(String[] args) throws IOException {
//创建FileOutputStream对象,构造方法中绑定要写入数据的目的地
FileOutputStream fos = new FileOutputStream(new File("C:UsersAdministratorIdeaProjectsasic_codeday20字节输出流测试文件3.txt"), true);
// 定义字节数组
byte[] words = {97, 98, 99, 100, 101};
//遍历数组
for (int i = 0; i
fos.write(words[i]);
//写出一个换行, 换行符号转成数组写出
fos.write("
".getBytes());
}
// 关闭资源
fos.close();
}
}
构造方法参数:读取文件的数据源
构造方法的作用:
读取数据的原理(硬盘-->内存)
代码实现
package demo02;
import java.io.FileInputStream;
import java.io.IOException;
public class Demo01FileInputStream {
public static void main(String[] args) throws IOException {
//1:创建FileInputStream对象,构造方法中绑定要读取的数据源
FileInputStream fis = new FileInputStream("C:UsersAdministratorIdeaProjectsasic_codeday20字节输入流测试文件1.txt");
/*2:使用FileInputStream对象中的方法read,读取文件
int read()读取文件中的一个字节并返回,读取到文件的末尾返回-1
读取文件是一个重复的过程,所以可以使用循环优化-
不知道文件中有多少字节,使用while循环
while循环结束条件,读取到-1的时候结束
布尔表达式(len = fis.read())!=-1
1.fis.read():读取一个字节
2.len = fis.read():把读取到的字节赋值给变量len
3.(len = fis.read())!=-1:判断变量len是否不等于-1
*/
// 定义变量,记录读取到的字节
int len = 0;
while ((len = fis.read()) != -1) {
//int类型的数据转化为char类型输出
System.out.print((char) len);
}
//3:关闭资源
fis.close();
}
}
代码执行后的结果
package demo02;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class Demo02FileInputStream {
public static void main(String[] args) throws IOException {
/*
字节输入流一次读取多个字节的方法:
int read(byte[] b) 从输入流中读取一定数量的字节,并将其存储在缓冲区数组 b 中。
明确两件事情:
1.方法的参数byte[]的作用?
起到缓冲作用,存储每次读取到的多个字节
数组的长度一把定义为1024(1kb)或者1024的整数倍
2.方法的返回值int是什么?
每次读取的有效字节个数
String类的构造方法
String(byte[] bytes) :把字节数组转换为字符串
String(byte[] bytes, int offset, int length) 把字节数组的一部分转换为字符串 offset:数组的开始索引 length:转换的字节个数
*/
//相对路径创建FileInputStream对象
FileInputStream fis = new FileInputStream(new File("day20字节输入流测试文件1.txt"));
// 定义变量存储有效个数
int len = 0;
// 定义字节数组,作为装字节数据的容器
byte[] b = new byte[1024];
// 循环读取
while ((len = fis.read(b)) != -1) {
// 每次读取后,把数组变成字符串打印
System.out.println(new String(b, 0, len));
}
// 关闭资源
fis.close();
}
}
代码执行后结果
原理:从已有文件中读取字节,将该字节写入到我们的目的地
代码实现
package demo02;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
文件复制练习:一读一写
明确:
数据源: c:1.jpg
数据的目的地: d:1.jpg
文件复制的步骤:
1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
2.创建一个字节输出流对象,构造方法中绑定要写入的目的地
3.使用字节输入流对象中的方法read读取文件
4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
5.释放资源
*/
public class Demo01CopyFile {
public static void main(String[] args) throws IOException {
long s = System.currentTimeMillis();
//1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
FileInputStream fis = new FileInputStream("c:1.jpg");
//2.创建一个字节输出流对象,构造方法中绑定要写入的目的地
FileOutputStream fos = new FileOutputStream("d:1.jpg");
/*一次读取一个字节写入一个字节的方式
使用字节输入流对象中的方法read读取文件
int len = 0;
while((len = fis.read())!=-1){
//4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
fos.write(len);
}*/
//使用数组缓冲读取多个字节,写入多个字节
byte[] bytes = new byte[1024];
//3.使用字节输入流对象中的方法read读取文件
int len = 0;//每次读取的有效字节个数
while ((len = fis.read(bytes)) != -1) {
//4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
fos.write(bytes, 0, len);
}
//5.释放资源(先关写的,后关闭读的;如果写完了,肯定读取完毕了)
fos.close();
fis.close();
long e = System.currentTimeMillis();
System.out.println("复制文件共耗时:" + (e - s) + "毫秒");
}
}
因为在GBK中:中文占用两个字节,UTF-8中:中文占用3个字节,而字节流只能一次读取一个字节。当我们把读取到的字节重新转化为字符的时候,会产生乱码问题。
准备测试文件
代码演示乱码问题
package demo03;
import java.io.FileInputStream;
import java.io.IOException;
public class Demo01FileInputStream {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("day20中文文件.txt");
int len = 0;
while ((len = fis.read()) != -1) {
System.out.print((char) len);
}
fis.close();
}
}
代码执行后结果
当使用字节流读取文本文件时,可能会有一个小问题。就是遇到中文字符时,可能不会显示完整的字符,那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类,以字符为单位读写数据,专门用于处理文本文件。
FileReader构造方法的作用:
准备要读取的测试文件
package demo03;
import java.io.FileReader;
import java.io.IOException;
public class Demo01FileReader {
public static void main(String[] args) throws IOException {
//1:创建FileReader对象,构造方法中绑定要读取的数据源
FileReader fi = new FileReader("day20字符输入流测试文件.txt");
//创建变量,记录每次读取的有效个数
int len = 0;
//public int read() : 从输入流读取一个字符。
while ((len = fi.read()) != -1) {
System.out.print((char) len);
}
//关闭资源
fi.close();
}
}
代码执行后结果
package demo03;
import java.io.FileReader;
import java.io.IOException;
public class Demo02Reader {
public static void main(String[] args) throws IOException {
//1.创建FileReader对象,构造方法中绑定要读取的数据源
FileReader fr = new FileReader("day20字符输入流测试文件.txt");
//int read(char[] cbuf)一次读取多个字符,将字符读入数组。
char[] cs = new char[1024];//存储读取到的多个字符
int len = 0;//记录的是每次读取的有效字符个数
while ((len = fr.read(cs)) != -1) {
/*
String类的构造方法
String(char[] value) 把字符数组转换为字符串
String(char[] value, int offset, int count) 把字符数组的一部分转换为字符串 offset数组的开始索引 count转换的个数
*/
System.out.println(new String(cs, 0, len));
}
//3.释放资源
fr.close();
}
}
构造方法参数:写入数据的目的地
构造方法的作用:
package demo04;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class Demo01FileWriter {
public static void main(String[] args) throws IOException {
//创建对象,绑定目的地
FileWriter fw = new FileWriter(new File("day20字符文件输出流测试文件.txt"));
//2.使用FileWriter中的方法write,把数据写入到内存缓冲区中(字符转换为字节的过程)
//void write(int c) 写入单个字符。
fw.write(97);
//3.使用FileWriter中的方法flush,把内存缓冲区中的数据,刷新到文件中
//fw.flush();
//4.释放资源(会先把内存缓冲区中的数据刷新到文件中)
fw.close();
}
}
代码执行后的结果
package demo04;
import java.io.FileWriter;
import java.io.IOException;
public class Demo02FileWriter {
public static void main(String[] args) throws IOException {
FileWriter fw = new FileWriter("day20字符文件输出流测试文件1.txt");
char[] cs = {‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘};
//void write(char[] cbuf)写入字符数组。
fw.write(cs); //abcde
//void write(char[] cbuf, int off, int len)写入字符数组的某一部分,off数组的开始索引,len写的字符个数。
fw.write(cs, 1, 3);//bcd
//void write(String str)写入字符串。
fw.write("山东舰,国产航母");//山东舰,国产航母
//void write(String str, int off, int len) 写入字符串的某一部分,off字符串的开始索引,len写的字符个数。
fw.write("国产航母山东舰", 2, 2);//航母
fw.close();
}
}
注意:
续写,追加写:使用两个参数的构造方法
参数:
package demo04;
import java.io.FileWriter;
import java.io.IOException;
/*
在jdk1.7之前使用try catch finally 处理流中的异常
格式:
try{
可能会产出异常的代码
}catch(异常类变量 变量名){
异常的处理逻辑
}finally{
一定会指定的代码
资源释放
}
*/
public class Demo01TryCatch {
public static void main(String[] args) {
//提高变量fw的作用域,让finally可以使用
//变量在定义的时候,可以没有值,但是使用的时候必须有值
//fw = new FileWriter("09_IOAndPropertiesg.txt",true); 执行失败,fw没有值,fw.close会报错
FileWriter fw = null;
try {
//可能会产出异常的代码
fw = new FileWriter("w:day20g.txt", true);
for (int i = 0; i <10; i++) {
fw.write("HelloWorld" + i + "
");
}
} catch (IOException e) {
//异常的处理逻辑
System.out.println(e);
} finally {
//一定会指定的代码
//创建对象失败了,fw的默认值就是null,null是不能调用方法的,会抛出NullPointerException,需要增加一个判断,不是null在把资源释放
if (fw != null) {
try {
//fw.close方法声明抛出了IOException异常对象,所以我们就的处理这个异常对象,要么throws,要么try catch
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
代码演示
package demo04;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
JDK7的新特性
在try的后边可以增加一个(),在括号中可以定义流对象
那么这个流对象的作用域就在try中有效
try中的代码执行完毕,会自动把流对象释放,不用写finally
格式:
try(定义流对象;定义流对象....){
可能会产出异常的代码
}catch(异常类变量 变量名){
异常的处理逻辑
}
*/
public class Demo02JDK7 {
public static void main(String[] args) {
try (//1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
FileInputStream fis = new FileInputStream("c:1.jpg");
//2.创建一个字节输出流对象,构造方法中绑定要写入的目的地
FileOutputStream fos = new FileOutputStream("d:1.jpg");) {
//可能会产出异常的代码
//一次读取一个字节写入一个字节的方式
//3.使用字节输入流对象中的方法read读取文件
int len = 0;
while ((len = fis.read()) != -1) {
//4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
fos.write(len);
}
} catch (IOException e) {
//异常的处理逻辑
System.out.println(e);
}
}
}
package demo04;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
JDK9新特性
try的前边可以定义流对象
在try后边的()中可以直接引入流对象的名称(变量名)
在try代码执行完毕之后,流对象也可以释放掉,不用写finally
格式:
A a = new A();
B b = new B();
try(a,b){
可能会产出异常的代码
}catch(异常类变量 变量名){
异常的处理逻辑
}
*/
public class Demo03JDK9 {
public static void main(String[] args) throws IOException {
//1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
FileInputStream fis = new FileInputStream("c:1.jpg");
//2.创建一个字节输出流对象,构造方法中绑定要写入的目的地
FileOutputStream fos = new FileOutputStream("d:1.jpg");
try (fis; fos) {
//一次读取一个字节写入一个字节的方式
//3.使用字节输入流对象中的方法read读取文件
int len = 0;
while ((len = fis.read()) != -1) {
//4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
fos.write(len);
}
} catch (IOException e) {
System.out.println(e);
}
//fos.write(1);//Stream Closed
}
}