java io字节流,java文件io流
这篇文章给你带来了一些关于java的知识，主要是关于IO流、文件、字节流和字符流。下面就来看看吧，希望对你有帮助。
如何解决写爬虫IP受阻的问题？立即使用。
IO简介
1 Stream
在学习IO流之前，我们需要学习的第一个概念是Stream stream stream。
为了便于理解，我们可以将数据读写操作抽象为“管道”中的数据流，但请注意：
1.水流只能向一个方向流动
2.输入流用于读入 in
3.输出流用于写出出
4.数据从头到尾只能按顺序读写一次。
所以从程序的角度来说，In/out就是相对于程序的输入(读)/输出(写)的过程。
2 IO流的继承结构
在java中，根据数据单元的不同，流可以分为字节流和字符流。
字节流：对于二进制文件
字符流：对于文本文件
结合相应类型的输入和输出方向，常用的流有：
3 File文件类
3.1概述
封装一个磁盘路径字符串，可以操作一次。
您可以封装文件路径、文件夹路径和不存在的路径。
3.2创建对象
File(String pathname)通过将给定的路径名字符串转换为抽象路径名来创建新的文件实例。
新文件(" d:/ABC/a . txt ")；
新文件(" d:/abc "，" a . txt ")；
3.3常用方法
3.4 练习：测试常用方法
创建包：cn.tedu.file
创建类：TestFile.java
包cn . tedu . file；导入Java . io . file；导入Java . io . io exception；导入Java . util . arrays；/*这个类用于测试文件类File*/public类TestFile {
公共静态void main(String[] args)引发IOException {
//1.创建文件类对象
/*1.ready目录和1.txt需要手动创建。
* 2.需要导入的文件：导入Java . io . file；
* 3.路径是字符串类型，必须写正确，否则找不到文件。
* 4.一个完整的文件名包含两部分：文件名后缀*/
File File=new File( E:\ \ ready \ \ 1 . txt )；
//2.1测试文件中的常用方法
system . out . println(file . length())；//3，获取文件的字节
system . out . println(file . exists())；//true，确定文件是否存在。
system . out . println(file . is file())；//true，确定是否是文件。
system . out . println(file . is directory())；//false，确定是否是文件夹。
system . out . println(file . getname())；//1.txt来获取文件名
system . out . println(file . get parent())；//E:\准备获取父路径
system . out . println(file . getabsolutepath())；//E:\ready\1.txt获取带盘符的完整路径：绝对路径
//2.2测试创建和删除
/*new只会帮助您在内存中创建一个File类型的对象
*不会帮你在磁盘中创建一个真正的2.txt文件*/
file=新文件( E:\ \ ready \ \ 2 . txt )；
//创建一个之前不存在的文件2.txt。如果创建成功，它将返回true
/*如果创建文件的指定路径错误，将抛出异常：java.io.Exception
*所以我们需要提前处理这个问题。我们暂时选择在main()上抛出它
*这个IO异常是我们目前遇到的，要求必须提前处理。
*如果不处理它，方法的调用将报告一个错误并导致编译失败*/
system . out . println(file . create new file())；//创建一个以前不存在的文件
file=新文件( E:\ \ ready \ \ m )；
system . out . println(file . mkdir())；//创建一个以前不存在的单级文件夹
file=新文件( E:\ \ ready \ \ a \ \ b \ \ c )；
system . out . println(file . mkdirs())；//创建以前不存在的多级文件夹
system . out . println(file . delete())；//c被删除，删除空的文件夹或文件。
file=新文件( E:\ \ ready \ \ a )；
system . out . println(file . delete())；//false，文件夹A不是空的，它有内容。
file=新文件( E:\ \ ready \ \ 2 . txt )；
system . out . println(file . delete())；//2.txt被删除，可以删除文件。
//2.3测试演示文件列表
file=新文件( E:\ \ ready )；
string[]list=file . list()；/*不常用*/
system . out . println(arrays . tostring(list))；
//这句话会报错，因为这是一个String[]，所以数组中的每个元素都是String类型。
//那么只能使用String类中的方法，而isDirectory()是File类中的方法
//System.out.println(list[0])。is directory())；
file[]fs=file . list files()；/*常用*/
system . out . println(arrays . tostring(fs))；
System.out.println(fs[0])。is directory())；
}}
4 字节流读取
字节流由字节组成，字符流由字符组成。
Java字符由两个字节组成。字节流是基本流，主要用于处理二进制数据。
因此，字节流是常用的，可以处理许多不同种类的文件，如文本文档/音频/视频等。
4.1 InputStream抽象类
这个抽象类是一个超类/抽象类，表示字节输入流的所有类。您不能创建对象。
4.2 FileInputStream子类
直接插入文件，直接读取文件数据。
4.3 BufferedInputStream子类
BufferedInputStream向另一个输入流添加一些函数。创建BufferedInputStream时，会创建一个内部缓冲区数组(默认大小为8k)。当读取或跳过流中的字节时，可以根据需要从包含的输入流中再次填充内部缓冲区，一次可以填充多个字节。
4.4 练习：字节流读取案例
创建包：cn.tedu.file
创建类：TestIn.java
包cn . tedu . file；导入Java . io . *；/*该类用于练习字节输入流*/公共类TestIn {
公共静态void main(String[] args) {
//方法()；//读取字节流
method 2()；//高效的字节流读取
}
//该方法用于测试高效字节流的读取。
私有静态void方法2() {
//在中定义一个在此方法中生效的局部变量。注意手动初始化，值为空。
InputStream in=null
尝试{
//1.创建一个高效的字节输入流对象//inputstream in=new buffered inputstream(//newfile inputstream(new file( e:\ \ ready \ \ 1 . txt ))；
in=新缓冲区输入流
(new file inputstream( E:\ \ ready \ \ 1 . txt )；
//2.使用流进行阅读
int b；
while ((b=in.read())！=-1){
system . out . println(b)；
}
} catch(异常e) {
e . printstacktrace()；
}finally {//流关闭操作写入finally{}
//3.一定要在流用完之后关闭它！
尝试{
in . close()；
} catch (IOException e) {
e . printstacktrace()；
}
}
}
//此方法用于测试字节流的读取。
私有静态void方法(){
//创建在此方法中生效的局部变量。注意手动初始化。
InputStream in=null
尝试{
//1.创建用于读取的字节输入流对象
//InputStream in=new InputStream()；//错误原因：抽象类无法实例化。
//InputStream in=new File InputStream(new File( E:\ \ ready \ \ 1 . txt )；
in=new file inputstream( E:\ \ ready \ \ 1 . txt )；
//2.开始阅读
/*read()每次被调用时都会读取一个字节。如果读取数据的结尾，则返回-1 *//system . out . println(in . read())；//system . out . println(in . read())；//system . out . println(in . read())；//system . out . println(in . read())；
//要求：需要循环读取文件中的所有内容，直到读完为止。
//定义变量并记录读取的数据
int b；
while((b=in.read())！=-1){
system . out . println(b)；
}
} catch(异常e) {
e . printstacktrace()；//打印错误信息
/*try-catch结构中的第三部分：finally{}
*无论是否捕获到异常，这部分都是将要执行的代码，通常用于关闭流*/
}最后{
尝试{
//3.释放资源。当流资源用完了，必须释放！
in . close()；
} catch (IOException e) {
e . printstacktrace()；
}
}
}}
5 字符流读取
常用于处理纯文本数据，读写时容易出现乱码。读写时，最好指定UTF-8作为编码集。
5.1 Reader抽象类
用于读取字符流的抽象类。
5.2 FileReader子类
用于读取字符文件的方便类。这个类的构造方法假定默认的字符编码和默认的字节缓冲区大小都是合适的。要自己指定这些值，可以首先在FileInputStream上构造一个InputStreamReader。
5.3 BufferedReader子类
从字符输入流中读取文本并缓冲每个字符，从而实现字符、数组、行的高效读取。
您可以指定缓冲区的大小，也可以使用默认大小。在大多数情况下，默认值足够大。
5.4 练习：字符流读取案例
创建包：cn.tedu.file
创建类：TestIn2.java
包cn . tedu . file；导入Java . io . *；/*该类用于测试字符流的读取*/公共类TestIn2 {
公共静态void main(String[] args) {
//方法()；//测试普通字符输入流
method 2()；//测试有效的字符输入流
}
//创建测试有效字符输入流的方法
私有静态void方法2() {
//1.定义一个在此方法中生效的局部变量，并手动初始化null值。
Reader in=null
尝试{
//1.创建一个高效的字符读取流对象
//in=new buffered reader(new File reader(new File( E:\ \ ready \ \ 1 . txt ))；
in=new buffered reader(new file reader( E:\ \ ready \ \ 1 . txt )；
//2.使用流对象
int b；
while((b=in.read())！=-1){
system . out . println(b)；
}
}catch(异常e){
e . printstacktrace()；
}最后{
//3.关闭流对象
尝试{
in . close()；
} catch (IOException e) {
e . printstacktrace()；
}
}
}
//创建测试普通字符输入流的方法
私有静态void方法(){
//1.1创建一个在此方法中生效的局部变量。请注意，初始化值为空。
Reader in=null
尝试{
//1.2创建一个字符输入流对象。请注意，您需要捕捉异常。
//Reader in=new Reader()；//错误原因：无法实例化抽象父级。
//in=new File reader(new File( E:\ \ ready \ \ 1 . txt )；
in=new file reader( E:\ \ ready \ \ 1 . txt )；
//2.使用流对象
//system . out . println(in . read())；
//要求：循环读取文件中的所有内容。只要不是-1，就说明还有数据。继续读。
//3.1定义变量，记录读取的数据。
int b；
while((b=in.read())！=-1){
system . out . println(b)；
}
} catch(异常e) {
e . printstacktrace()；
}最后{//3。关掉水流
尝试{
in . close()；
} catch (IOException e) {
e . printstacktrace()；
}
}
}}
6 字节流写出
6.1 OutputStream抽象类
这个抽象类是一个超类，表示输出字节流的所有类。输出流接受输出字节，并将它们发送到接收器。
6.2 FileOutputStream 子类
直接插入文件，直接写出文件数据。
6.3 BufferedOutputstream 子类
这个类实现了一个缓冲的输出流。通过设置这个输出流，应用程序可以将每个字节写入底层输出流，而无需每次都调用底层系统进行字节写入。
6.4 练习： 字节输出流测试：
创建包：cn.tedu.file
创建类：TestOut.java
包cn . tedu . file；导入Java . io . *；/*此类用于测试字节输出流*/公共类TestOut {
公共静态void main(String[] args) {
方法()；//用于测试普通字节输出流
//method 2()；//用于测试有效的字节输出流
}
//创建测试有效字节输出流的方法
私有静态void方法2() {
//1.创建一个在此方法中生效的局部变量。注意手动初始化。
OutputStream out=null
尝试{
//2.创建一个高效的字节输出流对象//out=new buffered output stream(new file( e:\ \ ready \ \ 2 . txt )；
out=new BufferedOutputStream(new file output stream( E:\ \ ready \ \ 2 . txt )；
//3.使用流对象-写出。
out . write(97)；
out . write(97)；
out . write(97)；
}catch(异常e){
e . printstacktrace()；
}finally {//关闭操作应该放在finally{}中
尝试{
//4.关掉水流
out . close()；
} catch (IOException e) {
e . printstacktrace()；
}
}
}
//创建测试普通字节输出流的方法
私有静态void方法(){
//1.创建一个在该方法中生效的局部变量，注意手动初始化null。
OutputStream out=null
//2.创建一个try-catch-finally结构，因为IO操作可能会生成异常。
尝试{
//3.创建一个普通的字节输出流对象
//out=new File output stream(new File( E:\ \ ready \ \ 2 . txt )；
//out=new file output stream( E:\ \ ready \ \ 2 . txt )；
out=new file output stream( E:\ \ ready \ \ 2 . txt ，true)；
//4.使用流对象-写出。
out . write(99)；//对应ASCII码表中的A
out . write(99)；//对应ASCII码表中的B
out . write(99)；//对应ASCII码表中的C
}catch(异常e){
e . printstacktrace()；
}finally {//如果想让代码执行，需要把它写入finally。
尝试{
//5.关闭操作
out . close()；
} catch (IOException e) {
e . printstacktrace()；
}
}
}}
7 字符流写出
7.1 Writer 抽象类
写字符流抽象类
7.2 FileWriter 子类
一个用于编写字符文件的方便的类。这个类的构造方法假设默认的字符编码和默认的字节缓冲区大小都是可以接受的。如果需要自己定制这些值，可以先在FileOutputStream上构造一个OutputStreamWriter。
7.3 BufferedWriter子类
将文本写入字符输出流，缓冲单个字符，从而提供单个字符、数组和字符串的高效写入。您可以指定缓冲区的大小，也可以接受默认大小，这在大多数情况下已经足够大了。
7.4 练习： 字符输出流测试：
创建包：cn.tedu.file
创建类：TestOut2.java
包cn . tedu . file；导入Java . io . *；/*此类用于测试字符输出流*/公共类TestOut2 {
公共静态void main(String[] args) {
//方法()；//用于测试通用字符输出流
method 2()；//用于测试有效的字符输出流
}
//创建测试有效字符输出流的方法
私有静态void方法2() {
//1.创建一个在此方法中生效的局部变量。该值为空。注意手动初始化！
Writer out=null
//2.由于程序可能会抛出异常，您需要编写一个try-catch-finally结构。
尝试{//存储可能引发异常的代码
//3.创建一个普通字符输出流对象
//out=new buffered writer(new File writer(new File( E:\ \ ready \ \ 2 . txt ))；
//out=new buffered writer(new file writer( E:\ \ ready \ \ 2 . txt )；
out=new buffered writer(new file writer( E:\ \ ready \ \ 2 . txt ，true))；
//4.使用流对象
out . write(100)；
out . write(100)；
out . write(100)；
out . write(100)；
out . write(100)；
}catch (Exception e){//匹配并捕获异常
e . printstacktrace()；//如果捕获到异常，则打印一条错误消息
}finally {//一个将要执行的代码块，常用来关闭流量。
尝试{
out . close()；
} catch (IOException e) {
e . printstacktrace()；
}
}
}
//创建测试普通字符输出流的方法
私有静态void方法(){
//1.创建一个在此方法中生效的局部变量。该值为空。注意手动初始化！
Writer out=null
//2.由于程序可能会抛出异常，您需要编写一个try-catch-finally结构。
尝试{//存储可能引发异常的代码
//3.创建一个普通字符输出流对象
//out=new FileWriter(新文件( E:\ \ ready \ \ 2 . txt )；
//out=new file writer( E:\ \ ready \ \ 2 . txt )；
out=new file writer( E:\ \ ready \ \ 2 . txt ，true)；
//4.使用流对象
out . write(98)；
out . write(98)；
out . write(98)；
out . write(98)；
}catch (Exception e){//匹配并捕获异常
e . printstacktrace()；//如果捕获到异常，则打印一条错误消息
}finally {//一个将要执行的代码块，常用来关闭流量。
尝试{
out . close()；
} catch (IOException e) {
e . printstacktrace()；
}
}
}}
8 拓展
通过学习上面的流，我们还可以扩展并尝试复制下面的文件：
创建包：cn.tedu.file
创建类：TestCopyFile.java
包cn . tedu . file；导入Java . io . *；导入Java . util . scanner；/*该类用于练习文件复制的综合情况*/公共类TestCopyFile {
公共静态void main(String[] args) {
//1.提示并接收用户输入的两条路径
System.out.println(请输入源文件路径)；//-复制的文件
字符串f=新扫描仪(System.in)。next line()；
System.out.println(请输入新的文件路径：)；//-复制新文件。
字符串t=新扫描仪(System.in)。next line()；
//2.调用创建的自定义方法来完成文件复制。
//ZFCopy(f，t)；//用字符流完成文件复制案例
ZJCopy(f，t)；//用字节流完成文件复制案例
}
//使用字节流完成文件复制案例
私有静态void ZJCopy(字符串f，字符串t) {
//1.定义在整个方法中生效的局部变量。注意手动初始化。引用类型的默认值为null。
InputStream in=null
OutputStream out=null
//2.因为代码可能有异常，所以您需要编写一个try-catch-finally结构。
尝试{
//3.1创建一个高效的字节输入流对象-的参数- FIS是用户传入的源文件路径F
in=new BufferedInputStream(new file inputstream(f))；
//3.2创建一个高效的字节输出流对象- FOS的参数是用户传入的新文件路径T
out=new BufferedOutputStream(new file output stream(t))；
//4.使用创建的流对象完成业务。
//4.1定义变量保存读取的数据。
int b；
//4.2循环读取源文件中的数据。只要不是-1，就说明还有数据循环在进行。
while((b=in.read())！=-1){
//4.3将读取的数据写入新文件
out . write(b)；
}
system . out . println(‘恭喜！成功复制文件！);
}catch(异常e){
system . out . println(‘对不起！文件复制失败！);
e . printstacktrace()；
}最后{
尝试{
out . close()；
} catch (IOException e) {
e . printstacktrace()；
}
尝试{
in . close()；
} catch (IOException e) {
e . printstacktrace()；
}
}
}
//使用字符流完成文件复制案例
私有静态void ZFCopy(字符串f，字符串t) {
//1.定义在整个方法中生效的局部变量。注意手动初始化。默认值为null。
Reader in=null
Writer out=null
//2.因为代码可能有异常，所以您需要编写一个try-catch-finally结构。
尝试{
//3.1创建一个高效的字符输入流对象
in=new buffered reader(new FileReader(f))；
//3.2创建一个高效的字符输出流对象
out=new buffered writer(new file writer(t))；
//4.得到流对象后，就可以使用流对象来完成业务。
//4.1定义变量保存读取的数据。
int b；
//4.2循环读取源文件，直到返回值为-1，表示没有数据，然后结束循环。
while ((b=in.read())！=-1) {
//4.3将本次循环读取的数据写入新文件。
out . write(b)；
}
system . out . println(‘恭喜！成功复制文件！);
}catch(异常e){
system . out . println(‘对不起！文件复制失败！);
e . printstacktrace()；
}最后{
/*按顺序关闭流：如果有多个流，则首先关闭最后创建的流。
*多个流结束语句需要它们自己的try-catch*/
尝试{
out . close()；
} catch (IOException e) {
e . printstacktrace()；
}
尝试{
in . close()；
} catch (IOException e) {
e . printstacktrace()；
}
}
}}
9 总结：IO的继承结构
1.主流分类
按方向分类：输入流输出流(相对于程序，将数据从程序写入文件为输出)按传输类型分类：字节流字符流组合：字节输入流字节输出流字符输入流字符输出流2。学习方法：学习抽象父类中的一般方法，以及如何在子类中创建对象。
3.字节输入流：
InputStream 抽象类，不能new,可以作为超类，学习其所提供的共性方法
- FileInputStream子类，操作文件的字节输入流，普通类
- BufferedInputStream子类，缓冲字节输入流，普通类4。字符输入流
Reader 抽象类，不能new,可以作为超类，学习其所提供的共性方法
- FileReader，子类，操作文件的字符输入流，公共类
- BufferedReader，子类，缓冲字符输入流，普通类5。字节输出流：
OutputStream 抽象类，不能new,可以作为超类，学习其所提供的共性方法
- FileOutputStream子类，操作文件的字节输出流，普通类
- BufferedOutputStream子类，缓冲字节输出流，普通类6。字符输出流
Writer 抽象类，不能new,可以作为超类，学习其所提供的共性方法
- FileWriter，子类，操作文件的字符输出流，公共类
- BufferedWriter，子类，缓冲字符输出流，常用类推荐学习：《java教程》以上是JAVA详细分析的IO流，文件，字节流，字符流的详细内容。更多请关注我们的其他相关文章！
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。