Java IO流 原理:
一、IO流的分类: ①:按流向不同:输入流、输出流(以程序<内存>为主体) ②:按数据类型不同:字节流、字符流(字符流用于操作文本文件:txt .java)(字节流用于操作非文本文件 .avi .jpg .mp3) ③:按角色不同:节点流、处理流 二、IO流的体系结构 抽象基类 节点流 InputStream FileInputStream OutputStream FileOutputStream Reader FileReader Writer FileWriter
package IO;
import org.testng.annotations.Test;
import java.io.FileInputStream;
import java.io.IOException;
/*
一、IO流的分类:
①:按流向不同:输入流、输出流(以程序<内存>为主体)
②:按数据类型不同:字节流、字符流(字符流用于操作文本文件:txt .java)(字节流用于操作非文本文件 .avi .jpg .mp3)
③:按角色不同:节点流、处理流
二、IO流的体系结构
抽象基类 节点流
InputStream FileInputStream
OutputStream FileOutputStream
Reader FileReader
Writer FileWriter
*/
public class IOTest {
@Test
public void test1() throws IOException {
//1、创建FileInputStream 的实例,同时打开指定文件
FileInputStream fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
//2、读取指定文件的内容
int read = fis.read();
System.out.println(read);
//3、关闭流
fis.close();
}
}
package IO;
import org.testng.annotations.Test;
import java.io.FileInputStream;
import java.io.IOException;
/*
一、IO流的分类:
①:按流向不同:输入流、输出流(以程序<内存>为主体)
②:按数据类型不同:字节流、字符流(字符流用于操作文本文件:txt .java)(字节流用于操作非文本文件 .avi .jpg .mp3)
③:按角色不同:节点流、处理流
二、IO流的体系结构
抽象基类 节点流
InputStream FileInputStream
OutputStream FileOutputStream
Reader FileReader
Writer FileWriter
*/
public class IOTest {
@Test
public void test1() throws IOException {
//1、创建FileInputStream 的实例,同时打开指定文件
FileInputStream fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
//2、读取指定文件的内容
int i = fis.read();
while (i!=-1){
System.out.println((char) i);
i=fis.read();
}
//3、关闭流
fis.close();
}
}
出现乱码
package IO;
import org.testng.annotations.Test;
import java.io.FileInputStream;
import java.io.IOException;
/*
一、IO流的分类:
①:按流向不同:输入流、输出流(以程序<内存>为主体)
②:按数据类型不同:字节流、字符流(字符流用于操作文本文件:txt .java)(字节流用于操作非文本文件 .avi .jpg .mp3)
③:按角色不同:节点流、处理流
二、IO流的体系结构
抽象基类 节点流
InputStream FileInputStream
OutputStream FileOutputStream
Reader FileReader
Writer FileWriter
*/
public class IOTest {
@Test
public void test1() throws IOException {
//1、创建FileInputStream 的实例,同时打开指定文件
FileInputStream fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
//2、读取指定文件的内容
int i = fis.read();
while (i!=-1){
System.out.println((char) i);
i=fis.read();
}
//3、关闭流
fis.close();
}
@Test
public void test2() throws IOException {
//1、创建FileInputStream实例,同时打开指定文件
FileInputStream fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
//2、读取指定文件的内容
byte[] b=new byte[3];//{a、b、c}=>{d、e、c}
int len = fis.read(b);
while (len!=-1){
// System.out.print(new String(b));//abcdec
System.out.print(new String(b,0,len));
len=fis.read(b);
}
//3、关闭流
fis.close();
}
}
package IO;
import org.testng.annotations.Test;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/*
一、IO流的分类:
①:按流向不同:输入流、输出流(以程序<内存>为主体)
②:按数据类型不同:字节流、字符流(字符流用于操作文本文件:txt .java)(字节流用于操作非文本文件 .avi .jpg .mp3)
③:按角色不同:节点流、处理流
二、IO流的体系结构
抽象基类 节点流
InputStream FileInputStream
OutputStream FileOutputStream
Reader FileReader
Writer FileWriter
*/
public class IOTest {
//字节流操作文本文件的弊端:一次读取一个字节的效率低
@Test
public void test1() throws IOException {
//1、创建FileInputStream 的实例,同时打开指定文件
FileInputStream fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
//2、读取指定文件的内容
int i = fis.read();
while (i!=-1){
System.out.println((char) i);
i=fis.read();
}
//3、关闭流
fis.close();
}
//异常处理的方式不能保证close()一定执行
@Test
public void test2() throws IOException {
//1、创建FileInputStream实例,同时打开指定文件
FileInputStream fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
//2、读取指定文件的内容
byte[] b=new byte[3];//{a、b、c}=>{d、e、c}
int len = fis.read(b);
while (len!=-1){
// System.out.print(new String(b));//abcdec
System.out.print(new String(b,0,len));
len=fis.read(b);
}
//3、关闭流
fis.close();
}
@Test
public void test3(){
FileInputStream fis=null;
try {
//1、创建FileInputStream实例,同时打开指定文件
fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
//2、读取指定文件的内容
byte[] b=new byte[3];
int len=0;
while ((len=fis.read(b))!=-1){
System.out.print(new String(b,0,len));
}
}catch (FileNotFoundException e){
e.printStackTrace();
}catch (IOException e){
e.printStackTrace();
}finally {
//3、关闭流
if (fis!=null){
try {
fis.close();//null.close()
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
package IO;
import org.testng.annotations.Test;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
/*
一、IO流的分类:
①:按流向不同:输入流、输出流(以程序<内存>为主体)
②:按数据类型不同:字节流、字符流(字符流用于操作文本文件:txt .java)(字节流用于操作非文本文件 .avi .jpg .mp3)
③:按角色不同:节点流、处理流
二、IO流的体系结构
抽象基类 节点流
InputStream FileInputStream
OutputStream FileOutputStream
Reader FileReader
Writer FileWriter
*/
public class IOTest {
//字节流操作文本文件的弊端:一次读取一个字节的效率低
@Test
public void test1() throws IOException {
//1、创建FileInputStream 的实例,同时打开指定文件
FileInputStream fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
//2、读取指定文件的内容
int i = fis.read();
while (i!=-1){
System.out.println((char) i);
i=fis.read();
}
//3、关闭流
fis.close();
}
//异常处理的方式不能保证close()一定执行
@Test
public void test2() throws IOException {
//1、创建FileInputStream实例,同时打开指定文件
FileInputStream fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
//2、读取指定文件的内容
byte[] b=new byte[3];//{a、b、c}=>{d、e、c}
int len = fis.read(b);
while (len!=-1){
// System.out.print(new String(b));//abcdec
System.out.print(new String(b,0,len));
len=fis.read(b);
}
//3、关闭流
fis.close();
}
//完善写法
@Test
public void test3(){
FileInputStream fis=null;
try {
//1、创建FileInputStream实例,同时打开指定文件
fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
//2、读取指定文件的内容
byte[] b=new byte[3];
int len=0;
while ((len=fis.read(b))!=-1){
System.out.print(new String(b,0,len));
}
}catch (FileNotFoundException e){
e.printStackTrace();
}catch (IOException e){
e.printStackTrace();
}finally {
//3、关闭流
if (fis!=null){
try {
fis.close();//null.close()
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//将指定内容写到目标文件中去
@Test
public void test4(){
String str="HelloWorld";
FileOutputStream fos= null;
try {
//1、创建FileOutputStream实例,同时打开指定文件
fos = new FileOutputStream("./hello2.txt");
//2、将指定内容写入目标地点去
fos.write(str.getBytes(StandardCharsets.UTF_8));//getBytes():将字符串转换成字节数组
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fos != null) {
try {
//3、关闭流
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//非文本文件的复制
@Test
public void test5(){
FileInputStream fis= null;
FileOutputStream fos= null;
try {
//1、创建FileInputStream的实例,同时打开指定文件
fis = new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\1.jpg");
//2、创建FileOutputStream的实例,同时打开指定文件
fos = new FileOutputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\2.jpg");
//3、读取指定文件的内容
byte[] b=new byte[3];
int len=0;
while ((len=fis.read(b))!=-1){
//4、将读取的内容写到目标地址去
fos.write(b);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//5、关闭流
if (fis!=null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fos!=null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/*
//非文本文件的复制
@Test
public void test5(){
//1、创建FileInputStream的实例,同时打开指定文件
FileInputStream fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\1.jpg");
//2、创建FileOutputStream的实例,同时打开指定文件
FileOutputStream fos=new FileOutputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\2.jpg");
//3、读取指定文件的内容
byte[] b=new byte[3];
int len=0;
while ((len=fis.read(b))!=-1){
//4、将读取的内容写到目标地址去
fos.write(b);
}
//5、关闭流
fis.close();
fos.close();
}
*/
}
package IO;
import org.testng.annotations.Test;
import java.io.*;
import java.nio.charset.StandardCharsets;
/*
一、IO流的分类:
①:按流向不同:输入流、输出流(以程序<内存>为主体)
②:按数据类型不同:字节流、字符流(字符流用于操作文本文件:txt .java)(字节流用于操作非文本文件 .avi .jpg .mp3)
③:按角色不同:节点流、处理流
二、IO流的体系结构
抽象基类 节点流
InputStream FileInputStream
OutputStream FileOutputStream
Reader FileReader
Writer FileWriter
*/
public class IOTest {
//字节流操作文本文件的弊端:一次读取一个字节的效率低
@Test
public void test1() throws IOException {
//1、创建FileInputStream 的实例,同时打开指定文件
FileInputStream fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
//2、读取指定文件的内容
int i = fis.read();
while (i!=-1){
System.out.println((char) i);
i=fis.read();
}
//3、关闭流
fis.close();
}
//异常处理的方式不能保证close()一定执行
@Test
public void test2() throws IOException {
//1、创建FileInputStream实例,同时打开指定文件
FileInputStream fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
//2、读取指定文件的内容
byte[] b=new byte[3];//{a、b、c}=>{d、e、c}
int len = fis.read(b);
while (len!=-1){
// System.out.print(new String(b));//abcdec
System.out.print(new String(b,0,len));
len=fis.read(b);
}
//3、关闭流
fis.close();
}
//完善写法
@Test
public void test3(){
FileInputStream fis=null;
try {
//1、创建FileInputStream实例,同时打开指定文件
fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
//2、读取指定文件的内容
byte[] b=new byte[3];
int len=0;
while ((len=fis.read(b))!=-1){
System.out.print(new String(b,0,len));
}
}catch (FileNotFoundException e){
e.printStackTrace();
}catch (IOException e){
e.printStackTrace();
}finally {
//3、关闭流
if (fis!=null){
try {
fis.close();//null.close()
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//将指定内容写到目标文件中去
@Test
public void test4(){
String str="HelloWorld";
FileOutputStream fos= null;
try {
//1、创建FileOutputStream实例,同时打开指定文件
fos = new FileOutputStream("./hello2.txt");
//2、将指定内容写入目标地点去
fos.write(str.getBytes(StandardCharsets.UTF_8));//getBytes():将字符串转换成字节数组
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fos != null) {
try {
//3、关闭流
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//非文本文件的复制
@Test
public void test5(){
FileInputStream fis= null;
FileOutputStream fos= null;
try {
//1、创建FileInputStream的实例,同时打开指定文件
fis = new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\1.jpg");
//2、创建FileOutputStream的实例,同时打开指定文件
fos = new FileOutputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\2.jpg");
//3、读取指定文件的内容
byte[] b=new byte[3];
int len=0;
while ((len=fis.read(b))!=-1){
//4、将读取的内容写到目标地址去
/*fos.write(b);*/
fos.write(b,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//5、关闭流
if (fis!=null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fos!=null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/*
//非文本文件的复制
@Test
public void test5(){
//1、创建FileInputStream的实例,同时打开指定文件
FileInputStream fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\1.jpg");
//2、创建FileOutputStream的实例,同时打开指定文件
FileOutputStream fos=new FileOutputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\2.jpg");
//3、读取指定文件的内容
byte[] b=new byte[3];
int len=0;
while ((len=fis.read(b))!=-1){
//4、将读取的内容写到目标地址去
fos.write(b);
}
//5、关闭流
fis.close();
fos.close();
}
*/
public void copyFile(String src,String dest){
FileInputStream fis= null;
FileOutputStream fos= null;
try {
//1、创建FileInputStream的实例,同时打开指定文件
fis = new FileInputStream(src);
//2、创建FileOutputStream的实例,同时打开指定文件
fos = new FileOutputStream(dest);
//3、读取指定文件的内容
byte[] b=new byte[1024];//一般1024或者2048
int len=0;
while ((len=fis.read(b))!=-1){
//4、将读取的内容写到目标地址去
/*fos.write(b);*/
fos.write(b,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//5、关闭流
if (fis!=null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fos!=null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//文本文件的复制
@Test
public void test6(){
String src="你要复制文件的路径.txt";
String dest="要复制到哪的位置/1.txt";
}
public void copyTextFile(String src,String dest){
FileReader fr= null;
FileWriter fw= null;
try {
fr = new FileReader(src);
fw = new FileWriter(dest);
char[] cb=new char[100];
int len=0;
while ((len=fr.read(cb))!=-1){
fw.write(cb,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fr!=null){
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fw!=null){
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}