Java基础----【字节流、字符流】
主要内容
- IO流
- 字节流
- 字符流
- 异常处理
第一章 IO概述
1.1 什么是IO
生活中,你肯定经历过这样的场景。当你编辑一个文本文件,忘记了ctrl+s
,可能文件就白白编辑了。当你电脑上插入一个U盘,可以把一个视频,拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢?键盘、内存、硬盘、外接设备等等。
我们把这种数据的传输,可以看做是一种数据的流动,按照流动的方向,以内存为基准,分为输入input
和输出output
,即流向内存是输入流,流出内存的输出流。
Java中I/O操作主要是指使用java.io
包下的内容,进行输入、输出操作。输入也叫做读取数据,输出也叫做作写出数据。
1.2 IO的分类
根据数据的流向分为:输入流和输出流。
- 输入流 :把数据从
其他设备
上读取到内存
中的流。 - 输出流 :把数据从
内存
中写出到其他设备
上的流。
格局数据的类型分为:字节流和字符流。
- 字节流 :以字节为单位,读写数据的流。
- 字符流 :以字符为单位,读写数据的流。
1.3 IO的流向说明图解
1.4 顶级父类们
输入流 | 输出流 | |
---|---|---|
字节流 |
字节输入流 InputStream |
字节输出流 OutputStream |
字符流 |
字符输入流 Reader |
字符输出流 Writer |
第二章 字节流
2.1 一切皆为字节
一切文件数据(文本、图片、视频等)在存储时,都是以二进制数字的形式保存,都一个一个的字节,那么传输时一样如此。所以,字节流可以传输任意文件数据。在操作流的时候,我们要时刻明确,无论使用什么样的流对象,底层传输的始终为二进制数据。
2.2 字节输出流【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方法,当完成流的操作时,必须调用此方法,释放系统资源。
2.3 FileOutputStream类
OutputStream
有很多子类,我们从最简单的一个子类开始。
java.io.FileOutputStream
类是文件输出流,用于将数据写出到文件。
构造方法
public FileOutputStream(File file)
:创建文件输出流以写入由指定的 File对象表示的文件。public FileOutputStream(String name)
: 创建文件输出流以指定的名称写入文件。
当你创建一个流对象时,必须传入一个文件路径。该路径下,如果没有这个文件,会创建该文件。如果有这个文件,会清空这个文件的数据。
- 构造举例,代码如下:
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;public class FileOutputStreamTest1 {public static void main(String[] args) throws FileNotFoundException {// 1. 创建一个文件字节输出流对象// 1.1 FileOutputStream(String name); 父目录存在, 文件才能写入成功.FileOutputStream out = new FileOutputStream("D:/aaa.txt");System.out.println(out);// 1.2 FileOutputStream(File file); 说明 : 如果父目录不存在, 文件对象都会创建失败.// 前提条件 : 必须要保证父目录的存在.File file = new File("D:/aaa/bbb/aaa.txt");// 1.2.1 先获取 file 对象的父目录File parentFile = file.getParentFile();// System.out.println("parentFile = " + parentFile);// 1.2.2 判断父目录是否存在if (parentFile.exists() == false) {// 1.2.3 父目录不存在, 需要手动创建parentFile.mkdirs();}FileOutputStream out2 = new FileOutputStream(file);System.out.println(out2);}
}输出结果 :
out1 = java.io.FileOutputStream@1d251891
out2 = java.io.FileOutputStream@48140564
写出字节数据
- 写出字节:
write(int b)
方法,每次可以写出一个字节数据,代码使用演示:
import java.io.FileOutputStream;
import java.io.IOException;public class Test2 {public static void main(String[] args) throws IOException {// 需求 : 写出字节数据FileOutputStream out = new FileOutputStream("a.txt");// write(int) 一个字节一个字节写出out.write(97);out.write(98);out.write(99);// 关闭资源out.close();}
}结果:
abc
小贴士:
- 虽然参数为int类型四个字节,但是只会保留一个字节的信息写出。
- 流操作完毕后,必须释放系统资源,调用close方法,千万记得。
- 写出字节数组:
write(byte[] b)
,每次可以写出数组中的数据,代码使用演示:
import java.io.FileOutputStream;
import java.io.IOException;public class Test2 {public static void main(String[] args) throws IOException {// 需求 : 写出字节数据FileOutputStream out = new FileOutputStream("a.txt");// write(byte[] b) 写入一个字节数组的长度byte[] b = "黑马程序员".getBytes();out.write(b);// 关闭资源out.close();}
}结果:
黑马程序员
- 写出指定长度字节数组:
write(byte[] b, int off, int len)
,每次写出从off索引开始,len个字节,代码使用演示:
import java.io.FileOutputStream;
import java.io.IOException;public class Test2 {public static void main(String[] args) throws IOException {// 需求 : 写出字节数据FileOutputStream out = new FileOutputStream("a.txt");// write(byte[] b, int off, int len) 从一个字节数组的 0 位置开始, 取 2 个长度.byte[] b = "abcdefg".getBytes();out.write(b, 0, 2);// 关闭资源out.close();}
}结果:
ab
数据追加续写
经过以上的演示,每次程序运行,创建输出流对象,都会清空目标文件中的数据。如何保留目标文件中数据,还能继续添加新数据呢?
public FileOutputStream(File file, boolean append)
: 创建文件输出流以写入由指定的 File对象表示的文件。public FileOutputStream(String name, boolean append)
: 创建文件输出流以指定的名称写入文件。
这两个构造方法,参数中都需要传入一个boolean类型的值,true
表示追加数据,false
表示清空原有数据。这样创建的输出流对象,就可以指定是否追加续写了,代码使用演示:
import java.io.FileOutputStream;
import java.io.IOException;public class Test2 {public static void main(String[] args) throws IOException {// 需求 : 写出字节数据FileOutputStream out = new FileOutputStream("a.txt", true);// write(byte[] b)byte[] b = "我爱上海明珠塔".getBytes();out.write(b);// 关闭资源out.close();}
}文件操作前:ab
文件操作后:ab我爱上海明珠塔
写出换行
Windows系统里,换行符号是\r\n
。把
以指定是否追加续写了,代码使用演示:
import java.io.FileOutputStream;
import java.io.IOException;public class Test2 {public static void main(String[] args) throws IOException {// 需求 : 写出字节数据FileOutputStream out = new FileOutputStream("a.txt", true);// write(byte[] b)// 换行 : 1. \r\n 2. System.lineSeparator();byte[] b = "\r\n我爱上海黄浦江".getBytes();out.write(b);String lineSeparator = System.lineSeparator();b = (lineSeparator + "我爱上海大传智").getBytes();out.write(b);// 关闭资源out.close();}
}输出结果:
ab我爱上海明珠塔
我爱上海黄浦江
我爱上海大传智
- 回车符
\r
和换行符\n
:- 回车符:回到一行的开头(return)。
- 换行符:下一行(newline)。
- 系统中的换行:
- Windows系统里,每行结尾是
回车+换行
,即\r\n
;- Unix系统里,每行结尾只有
换行
,即\n
;- Mac系统里,每行结尾是
回车
,即\r
。从 Mac OS X开始与Linux统一。
2.4 字节输入流【InputStream】
java.io.InputStream
抽象类是表示字节输入流的所有类的超类,可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。
public void close()
:关闭此输入流并释放与此流相关联的任何系统资源。public abstract int read()
: 从输入流读取数据的下一个字节。public int read(byte[] b)
: 从输入流中读取一些字节数,并将它们存储到字节数组 b中 。
小贴士:
close方法,当完成流的操作时,必须调用此方法,释放系统资源。
2.5 FileInputStream类
java.io.FileInputStream
类是文件输入流,从文件中读取字节。
构造方法
FileInputStream(File file)
: 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的 File对象 file命名。FileInputStream(String name)
: 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的路径名 name命名。
当你创建一个流对象时,必须传入一个文件路径。该路径下,如果没有该文件,会抛出FileNotFoundException
。
- 构造举例,代码如下:
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;public class Test3 {public static void main(String[] args) throws FileNotFoundException {// FileInputStream(File file): 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的 File对象 file命名。File file = new File("a.txt");FileInputStream in = new FileInputStream(file);System.out.println("in = " + in);// FileInputStream(String name): 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的路径名 name命名。FileInputStream in2 = new FileInputStream("a.txt");System.out.println("in2 = " + in2);}
}输出结果 :
in = java.io.FileInputStream@1d251891
in2 = java.io.FileInputStream@48140564
读取字节数据
- 读取字节:
read
方法,每次可以读取一个字节的数据,提升为int类型,读取到文件末尾,返回-1
,代码使用演示:
import java.io.FileInputStream;
import java.io.IOException;public class Test4 {public static void main(String[] args) throws IOException {// 1. 创建一个文件读取对象FileInputStream in = new FileInputStream("a.txt");// 2. read(); 一个一个字节读取数据int read = in.read();System.out.println("read = " + read);read = in.read();System.out.println("read = " + read);read = in.read();System.out.println("read = " + read);read = in.read();System.out.println("read = " + read);// 3. close(); 关闭资源in.close();}
}输出结果:
read = 97
read = 98
read = 99
read = -1
循环改进读取方式,代码使用演示:
import java.io.FileInputStream;
import java.io.IOException;public class Test4 {public static void main(String[] args) throws IOException {// 1. 创建一个文件读取对象FileInputStream in = new FileInputStream("a.txt");// 2. read(); 一个一个字节读取数据int read = -1;while ((read = in.read()) != -1) {System.out.println("read = " + read);}// 3. close(); 关闭资源in.close();}
}输出结果:
read = 97
read = 98
read = 99
小贴士:
- 虽然读取了一个字节,但是会自动提升为int类型。
- 流操作完毕后,必须释放系统资源,调用close方法,千万记得。
2.6 字节流练习:图片复制
复制原理图解
复制案例实现1 : 读取一个字节,写入一个字节
复制图片文件,代码使用演示:
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class Test4 {public static void main(String[] args) throws IOException {long start = System.currentTimeMillis();// 1.1 创建一个文件读取对象FileInputStream in = new FileInputStream("D:\\1.jpg");// 1.2 创建一个文件写出对象FileOutputStream out = new FileOutputStream("1.jpg");// 2. 读写数据int read = -1;while ((read = in.read()) != -1) {out.write(read);out.flush();}// 3. close(); 关闭资源out.close();in.close();long end = System.currentTimeMillis();System.out.println("共耗时 : " + (end - start) + "毫秒.");}
}输出结果 :
图片 : 共耗时 : 3821毫秒. 视频: 共耗时 : 51683毫秒.
小贴士:
流的关闭原则:先开后关,后开先关。
read方法的区别 : 读取字节数组
- 使用字节数组读取:
read(byte[] b)
,每次读取b的长度个字节到数组中,返回读取到的有效字节个数,读取到末尾时,返回-1
,代码使用演示:
说明 :
由于最后一次读取时,只读取了 len 的长度, 但是写入了整个字节数组 buf, 造成了数据的错误, 因为为, 读取多少长度, 就应该写入多少长度, 因为代码需要修正为 write(b, off, len);
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class Test5 {public static void main(String[] args) throws IOException {FileInputStream in = new FileInputStream("a.txt");FileOutputStream out = new FileOutputStream("b.txt");byte[] buf = new byte[8];int len = -1;while ((len = in.read(buf)) != -1) {// out.write(buf);out.write(buf, 0, len); // 写入数组中的数据, 从 0 (开头) 开始写, 写入读取的 len 长度.}/*int len = in.read(buf);System.out.println("Arrays.toString(buf) = " + Arrays.toString(buf));System.out.println("len = " + len);len = in.read(buf);System.out.println("Arrays.toString(buf) = " + Arrays.toString(buf));System.out.println("len = " + len);*/out.close();in.close();}
}写入结果:
abcdefghijklmnopqrstuvwxyz
小贴士:
使用数组读取,每次读取多个字节,减少了系统间的IO操作次数,从而提高了读写的效率,建议开发中使用。
复制案例实现2 : 读取字节数组,写入字节数组
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;public class Test4 {public static void main(String[] args) throws IOException {long start = System.currentTimeMillis();// 1.1 创建一个文件读取对象FileInputStream in = new FileInputStream("D:\\1.jpg");// 1.2 创建一个文件写出对象FileOutputStream out = new FileOutputStream("1.jpg");// 2. 读写数据byte[] buf = new byte[1024];int len = -1;while ((len = in.read(buf)) != -1) {out.write(buf, 0, len);out.flush();}// 3. close(); 关闭资源out.close();in.close();long end = System.currentTimeMillis();System.out.println("共耗时 : " + (end - start) + "毫秒.");}
}输出结果 :
图片 : 共耗时 : 16毫秒. 视频 : 共耗时 : 79毫秒.
复制案例实现3 : 字节缓冲流包装in,out
构造方法
public BufferedInputStream(InputStream in)
:创建一个 新的缓冲输入流。public BufferedOutputStream(OutputStream out)
: 创建一个新的缓冲输出流。
构造举例,代码如下:
// 创建字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
// 创建字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));
效率测试
import java.io.*;public class Test4 {public static void main(String[] args) throws IOException {long start = System.currentTimeMillis();// 1.1 创建一个文件读取对象BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\福利赠送.flv"));// 1.2 创建一个文件写出对象BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("福利赠送.flv"));// 2. 读写数据byte[] buf = new byte[1024];int len = -1;while ((len = bis.read(buf)) != -1) {bos.write(buf, 0, len);bos.flush();}// 3. close(); 关闭资源bos.close();bis.close();long end = System.currentTimeMillis();System.out.println("共耗时 : " + (end - start) + "毫秒.");}
}输出结果 :
视频 : 共耗时 : 63毫秒.
第三章 字符流
当使用字节流读取文本文件时,可能会有一个小问题。就是遇到中文字符时,可能不会显示完整的字符,那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类,以字符为单位读写数据,专门用于处理文本文件。
3.1 字符输入流【Reader】
java.io.Reader
抽象类是表示用于读取字符流的所有类的超类,可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。
public void close()
:关闭此流并释放与此流相关联的任何系统资源。public int read()
: 从输入流读取一个字符。public int read(char[] cbuf)
: 从输入流中读取一些字符,并将它们存储到字符数组 cbuf中 。
3.2 FileReader类
java.io.FileReader
类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
小贴士:
- 字符编码:字节与字符的对应规则。Windows系统的中文编码默认是GBK编码表。
idea中UTF-8
- 字节缓冲区:一个字节数组,用来临时存储字节数据。
构造方法
FileReader(File file)
: 创建一个新的 FileReader ,给定要读取的File对象。FileReader(String fileName)
: 创建一个新的 FileReader ,给定要读取的文件的名称。
当你创建一个流对象时,必须传入一个文件路径。类似于FileInputStream 。
- 构造举例,代码如下:
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;public class Test1 {public static void main(String[] args) throws FileNotFoundException {// 方式1. 创建一个字符输入流File file = new File("a.txt");FileReader reader = new FileReader(file);System.out.println("reader = " + reader);// 方式2. 创建一个字符输入流FileReader reader2 = new FileReader("a.txt");System.out.println("reader2 = " + reader2);}
}输出结果 :
reader = java.io.FileReader@48140564
reader2 = java.io.FileReader@58ceff1
读取字符数据
- 读取字符:
read
方法,每次可以读取一个字符的数据,提升为int类型,读取到文件末尾,返回-1
,循环读取,代码使用演示:
import java.io.FileReader;
import java.io.IOException;public class Test2 {public static void main(String[] args) throws IOException {// 1. 创建一个字符输入流FileReader reader = new FileReader("a.txt");// 2. 读取数据int read = -1;while ((read = reader.read()) != -1) {System.out.println((char) read);}// 3. 关闭资源reader.close();}
}输出结果:
黑
马
程
序
员
小贴士:虽然读取了一个字符,但是会自动提升为int类型。
- 使用字符数组读取:
read(char[] cbuf)
,每次读取b的长度个字符到数组中,返回读取到的有效字符个数,读取到末尾时,返回-1
,代码使用演示:
import java.io.FileReader;
import java.io.IOException;public class Test2 {public static void main(String[] args) throws IOException {// 1. 创建一个字符输入流FileReader reader = new FileReader("a.txt");// 2. 读取数据char[] ch = new char[2];int len = -1;while ((len = reader.read(ch)) != -1) {String str = new String(ch);System.out.println(str);}// 3. 关闭资源reader.close();}
}输出结果:
黑马
程序
员序
获取有效的字符改进,代码使用演示:
import java.io.FileReader;
import java.io.IOException;public class Test2 {public static void main(String[] args) throws IOException {// 1. 创建一个字符输入流FileReader reader = new FileReader("a.txt");// 2. 读取数据char[] ch = new char[2];int len = -1;while ((len = reader.read(ch)) != -1) {String str = new String(ch, 0, len);System.out.println(str);}// 3. 关闭资源reader.close();}
}输出结果:
黑马
程序
员
3.3 字符输出流【Writer, FileWriter】
java.io.Writer
抽象类是表示用于写出字符流的所有类的超类,将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。
public abstract void close()
:关闭此输出流并释放与此流相关联的任何系统资源。public abstract void flush()
:刷新此输出流并强制任何缓冲的输出字符被写出。public void write(int c)
:写出一个字符。public void write(char[] cbuf)
:将 b.length字符从指定的字符数组写出此输出流。public abstract void write(char[] b, int off, int len)
:从指定的字符数组写出 len字符,从偏移量 off开始输出到此输出流。public void write(String str)
:写出一个字符串。
import java.io.FileWriter;
import java.io.IOException;public class Test3 {public static void main(String[] args) throws IOException {// 1. 创建一个字符输出流FileWriter writer = new FileWriter("b.txt");// public void write(int c) :写出一个字符。writer.write(97);// public void write(char[] cbuf):将 b.length字符从指定的字符数组写出此输出流。char[] cbuf = new char[]{'A', 'B', 'C', 'D', 'E'};writer.write(cbuf);// public abstract void write(char[] b, int off, int len) :从指定的字符数组写出 len字符,从偏移量 off开始输出到此输出流。writer.write(cbuf, 0, 2);// public void write(String str) :写出一个字符串。writer.write("黑马程序员");// 关闭资源writer.close();}
}写出结果 :
aABCDEAB黑马程序员
3.4 续写和换行与读取:字符缓冲流
代码演示 :
// 创建字节缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("br.txt", true));
// 创建字节缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt", true));
特有方法
字符缓冲流的基本方法与普通字符流调用方式一致,不再阐述,我们来看它们具备的特有方法。
- BufferedReader:
public String readLine()
: 读一行文字。 - BufferedWriter:
public void newLine()
: 写一行行分隔符,由系统属性定义符号。
newLine
方法演示,代码如下:
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;public class Test4 {public static void main(String[] args) throws IOException {BufferedWriter writer = new BufferedWriter(new FileWriter("c.txt"));// 写入数据三部曲 : (写入, 换行, 刷新)writer.write("我爱上海明珠塔.");writer.newLine();writer.flush();writer.write("我爱北京天安门.");writer.newLine();writer.flush();writer.close();}
}输出结果:
我爱上海明珠塔.
我爱北京天安门.
续写 :
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;public class Test4 {public static void main(String[] args) throws IOException {BufferedWriter writer = new BufferedWriter(new FileWriter("c.txt", true));// 写入数据三部曲 : (写入, 换行, 刷新)writer.write("我爱广州小蛮腰.");writer.newLine();writer.flush();writer.close();}
}输出结果 :
我爱上海明珠塔.
我爱北京天安门.
我爱广州小蛮腰.
小贴士:字符流,只能操作文本文件,不能操作图片,视频等非文本文件。
readLine
方法演示,代码如下:
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;public class Test5 {public static void main(String[] args) throws IOException {// 1. 创建一个缓冲字符流对象BufferedReader reader = new BufferedReader(new FileReader("c.txt"));// 2. 一行一行读取String line = reader.readLine();System.out.println(line);line = reader.readLine();System.out.println(line);line = reader.readLine();System.out.println(line);line = reader.readLine();System.out.println(line);// 3. 关闭资源reader.close();}
}输出结果 :
我爱上海明珠塔.
我爱北京天安门.
我爱广州小蛮腰.
null
优化读取代码 :
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;public class Test5 {public static void main(String[] args) throws IOException {// 1. 创建一个缓冲字符流对象BufferedReader reader = new BufferedReader(new FileReader("c.txt"));// 2. 一行一行读取String line = null;while ((line = reader.readLine()) != null) {System.out.println(line);}// 3. 关闭资源reader.close();}
}输出结果 :
我爱上海明珠塔.
我爱北京天安门.
我爱广州小蛮腰.
第四章 IO异常的处理
JDK7前处理
之前的入门练习,我们一直把异常抛出,而实际开发中并不能这样处理,建议使用 try...catch...finally
代码块,处理异常部分,代码使用演示:
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;public class Test6 {public static void main(String[] args) {// 1. 定义一个 writer 对象BufferedWriter writer = null;try {// 2. 初始化 writer 对象writer = new BufferedWriter(new FileWriter("d.txt"));// 写入三部曲 :writer.write("黑马程序员");writer.newLine();writer.flush();} catch (IOException e) {e.printStackTrace();} finally {// 3. 关闭 writer 对象if (writer != null) {try {writer.close();} catch (IOException e) {e.printStackTrace();}}}}
}写入结果 :
黑马程序员
JDK7的处理
还可以使用JDK7优化后的try-with-resources
语句,该语句确保了每个资源在语句结束时关闭。所谓的资源(resource)是指在程序完成后,必须关闭的对象。
格式:
try (创建流对象语句,如果多个,使用';'隔开) {// 读写数据
} catch (IOException e) {e.printStackTrace();
}
代码使用演示:
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;public class Test6 {public static void main(String[] args) {// () 括号中解决的是 `流` 资源关闭的问题.try (BufferedWriter writer = new BufferedWriter(new FileWriter("d.txt"))) {// 写入三部曲 :writer.write("黑马程序员");writer.newLine();writer.flush();} catch (IOException e) {e.printStackTrace();}}
}写出结果 :
黑马程序员
JDK9的改进(了解内容)
JDK9中try-with-resources
的改进,对于引入对象的方式,支持的更加简洁。被引入的对象,同样可以自动关闭,无需手动close,我们来了解一下格式。
改进前格式:
import java.io.*;public class Test7 {public static void main(String[] args) {// () 小括号中定义需要释放的资源对象.try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:/1.jpg"));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("1.jpg"))) {// 读写操作 :byte[] buf = new byte[1024];int len = -1;while ((len = bis.read(buf)) != -1) {bos.write(buf, 0, len);bos.flush();}} catch (IOException e) {e.printStackTrace();}}
}
改进后格式:
import java.io.*;public class Test7 {public static void main(String[] args) throws FileNotFoundException {BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:/1.jpg"));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("1.jpg"));// () 小括号中定义需要释放的资源对象.try (bis; bos) {// 读写操作 :byte[] buf = new byte[1024];int len = -1;while ((len = bis.read(buf)) != -1) {bos.write(buf, 0, len);bos.flush();}} catch (IOException e) {e.printStackTrace();}}
}
Java基础----【字节流、字符流】相关推荐
- 学Java基础19 字符流 编码表 转换流 字符高效流 对象流 序列化 以及所有的IO流总结
一.字符流概述 1.字符流 就是用于来读写字符操作的流 2.字符流使用的原因: 使用字节流来读取文件中中文会出现乱码 因为中文不是一个字节组成的 所以读取中文的时候 需要使用字符流 字符实际上也是使用 ...
- java io 字节流 字符流
1.流的概念 在程序中,所有的数据都是以流的形式进行传输和保存的,当程序需要数据的时候要使用输入流读取数据,而当程序需要保存数据时要使用输出流写数据 2.字节流和字符流 字节流:处理单元为1个字节,操 ...
- java 字符流 utf8,JAVA基础(字符流设置编码读写字符)
1,使用指定的码表读写字符 FileReader是使用默认码表读取文件, 如果需要使用指定码表读取, 那么可以使用InputStreamReader(字节流,编码表) FileWriter是使用默认码 ...
- java基础---IO字符流
package com.henu.io;import java.io.FileNotFoundException; import java.io.FileReader;/** •FileReader( ...
- java基础练习复习二:递归字节流字符流二
本篇是基于java基础练习复习一:递归&字节流&字符流一, 如果对您有帮助 ,请多多支持.多少都是您的心意与支持,一分也是爱,再次感谢!!!打开支付宝首页搜"55672346 ...
- java基础 io流 字节流 字符流 节点流 包装流 转换流 缓冲流 对象流 打印流 Properties类
目录 1.概念 2.常用的文件操作 2.1 创建文件 2.2 获取文件相关信息 2.3 目录的操作和文件删除 3. IO流原理及流的分类 3.1 流的分类 4.InputStream 字节输入流 4. ...
- java基础学习_IO流03_字符流、IO流小结、案例_day21总结
java基础学习_IO流03_字符流.IO流小结.案例_day21总结 ================================================================ ...
- -1-4 java io java流 常用流 分类 File类 文件 字节流 字符流 缓冲流 内存操作流 合并序列流...
File类 •文件和目录路径名的抽象表示形式 构造方法 •public File(String pathname) •public File(String parent,Stringchild) •p ...
- io包下 文件类 字节流 字符流 缓冲流 转换流 序列化流 打印流
第一章 File类 1.1 概述 java.io.File 类是文件和目录路径名的抽象表示,主要用于文件和目录的创建.查找和删除等操作. 1.2 构造方法 public File(String pat ...
- 【java基础】IO流是啥?有啥用?(上)
今天我们说说java代码中对文件的操作,比如新建删除文件,读取文件内容等. File类 File类用于操作文件和目录,可对文件或目录进行新建,删除和重命名等操作.但是如果要访问文件内容本身,就需要用到 ...
最新文章
- 第二篇:salt-api使用填坑指南
- Good Luck!_JAVA
- python 网页登录selenium_使用selenium登录网页
- 算法设计与分析(第四周)大整数相乘 分治法【不能解决溢出问题】
- 计算机动画的主要应用领域,简述计算机的主要特点和主要应用领域
- 助力全站WebP ,阿里云云上FPGA 团队发布 WebP图片解决方案
- Angularjs 观察者模式 理解
- WWDC心愿单:新版OS X或将有这些变化
- android配置多个url,Retrofit中使用多个baseUrl
- XmlDocument,XDocument相互转换
- SDL2源代码分析4:纹理(SDL_Texture)
- python 百度cpc点击
- 为什么量子计算机是锥形,科学家制作超高精度微腔为量子计算机铺垫
- Android 双卡双待支持检验SIM信息获取
- sprintf() 用法
- 十分有用的cut剪切命令
- 对微分方程的特征描述及其称呼
- 手把手教你开发人工智能微信小程序(1):线性回归模型
- 51nod 1153 选择子序列
- showModalDialog参数详解
热门文章
- 计算机vf有用吗,计算机二级有用吗
- [NOIP2008] 火柴棒等式
- 【图像分辨率大探析】 关于图像尺寸、分辨率、像素密度、格式的理解
- 历年计算机应用,历年全国自考计算机应用基础真题及答案
- 给服装制造企业提供一点绵薄之力(ERP)
- [230530] 托福TPO口语真题| TPO66~TPO72|XPO|Task1|20:30~21:00
- 频谱仪 RBW与VBW的区别
- 有人的地方就有江湖,有江湖就有恩怨,人就是恩怨,程序员也是人
- MapReduce项目案例4——乘用车辆和商用车辆销售数据分析
- c语言套题答案 中国铁道出版社,《C语言程序设计验指导与习题集》练习题的参考答案(中国铁道出版社).doc...