流的分类：
按照流的方向:输入流 输出流
按照传输的单位:字节流 字符流
字节流：可以处理各种文件
字符流：只能复制有文字的文件
组合情况：
字节输入流：
InputStream--抽象父级，不可实例化
FileInputStream--操作字节输入流--构造函数:File/String
BufferedinputStream--高效字节输入流--构造函数：InputStream
read():每次都会读取一个字节，如果读取了数据的末尾，打印出-1
package cn.tedu.file;
import java.io.*;
//本类用于测试字节输入流·
public class TestIn {
public static void main(String[] args) {
//Method1();//普通字节输入流
Method2();//高效字节输入流
}
private static void Method2() {
InputStream in=null;
try {
in=new BufferedInputStream(new FileInputStream("D:\read\1.txt"));
int a;
while((a=in.read())!=-1){
System.out.println(a);
}
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private static void Method1() {
InputStream in = null;
try {
in=new FileInputStream(new File("D:\read\1.txt"));
int b;
while((b=in.read())!=-1){
System.out.println(b);
}
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果：
98
98
97
字符输入流：
Reader--抽象父类，不可实例化
FileReader--字符输入流--构造函数：File/String
BufferReader--高效字符输入流--构造函数：Reader
package cn.tedu.file;
import java.io.*;
import java.lang.reflect.Method;
//用于测试字符流的读取
public class Testin2 {
public static void main(String[] args) {
//method1();//普通字符输入流
method2();//高效字符输入流
}
private static void method2() {
Reader r= null;
try {
r = new BufferedReader(new FileReader("D:\read\1.txt"));
int a;
while ((a=r.read())!=-1){
System.out.println(a);
}
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
r.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private static void method1() {
Reader r=null;
try {
r=new FileReader("D:\read\1.txt");
int b;
while((b=r.read())!=-1){
System.out.println(b);
}
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
r.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果：
98
98
97
字节输出流
OutputStream--抽象父级，不可实例化
FileOutputStream--字节输出流--构造函数:File/String/File,append/String,append
BufferOutputStream--高效字节输出流--构造函数：OutputStream
write():写人文件
package cn.tedu.file;
import java.io.*;
//本类用于练习字节输出流
public class TestOut {
public static void main(String[] args) {
//method1();//普通字节输出流
method2();//高效字节输出流
}
private static void method2() {
BufferedOutputStream out=null;
try {
//out=new BufferedOutputStream(new FileOutputStream("D:\read\1.txt"));//覆盖输出
//out=new BufferedOutputStream(new FileOutputStream(new File("D:\read\1.txt")));//覆盖输出
//out=new BufferedOutputStream(new FileOutputStream("D:\read\1.txt",true));//追加输出
out=new BufferedOutputStream(new FileOutputStream(new File("D:\read\1.txt"),true));
out.write(121);
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private static void method1() {
OutputStream o=null;
try {
//o=new FileOutputStream("D:\read\1.txt");//覆盖输出
o=new FileOutputStream("D:\read\1.txt",true);//追加输出
int a;
o.write(97);
o.write(100);
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
o.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
字符输出流：
Writer--抽象父类，不可实例化
FileWriter--字符流输出--构造函数：File/String
BufferedWriter--高效字符流输出--构造函数--Writer
package cn.tedu.file;
import java.io.*;
public class TestOut2 {
public static void main(String[] args) {
//method1();//普通字符的输出流
method2();//高效字符的输出流
}
private static void method2() {
BufferedWriter w=null;
try {
//w=new BufferedWriter(new FileWriter("D:\read\1.txt"));
//w=new BufferedWriter(new FileWriter(new File("D:\read\1.txt")));
//w=new BufferedWriter(new FileWriter(new File("D:\read\1.txt"),true));
w=new BufferedWriter(new FileWriter("D:\read\1.txt",true));
w.write(102);
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
w.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private static void method1() {
Writer w=null;
try {
//w=new FileWriter("D:\read\1.txt");
//w=new FileWriter(new File("D:\read\1.txt"));
//w=new FileWriter("D:\read\1.txt",true);
w=new FileWriter(new File("D:\read\1.txt"),true);
w.write(123);
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
w.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
文件的复制：
package cn.tedu.file;
import java.io.*;
import java.util.Scanner;
//实现IO综合练习之文件复制案例
public class TestCopyFile {
public static void main(String[] args) {
System.out.println("请输入源文件路径");
String f=new Scanner(System.in).nextLine();
System.out.println("请输入新文件的路径");
String t=new Scanner(System.in).nextLine();
//ZFCopy(f,t);
ZJCopy(f,t);
}
private static void ZJCopy(String f, String t) {
BufferedInputStream in=null;
BufferedOutputStream out=null;
try {
in=new BufferedInputStream(new FileInputStream(f));
out=new BufferedOutputStream(new FileOutputStream(t));
int b;
while ((b=in.read())!=-1){
out.write(b);
}
System.out.println("文件复制成功");
} catch (Exception e) {
System.out.println("文件复制失败");
e.printStackTrace();
}finally {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private static void ZFCopy(String f, String t) {
Reader in=null;
Writer out=null;
try {
in=new BufferedReader(new FileReader(f));
out=new BufferedWriter(new FileWriter(t));
int b;
while((b=in.read())!=-1){
out.write(b);
}
System.out.println("文件复制成功");
}catch (Exception e){
System.out.println("文件复制失败");
e.printStackTrace();
}finally {
//关流是有顺序的，如果有多个流，最后创建的流要最先关闭
//多条关流语句需要各自的try-catch
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
JUnit单元测试框架
要求：public +void +没有参数+@Test
package cn.tedu.file;
import org.junit.Test;
//学习JUnit单元测试框架
public class Demo {
@Test
public void eat(){
System.out.println("哈哈哈");
}
@Test
public void eat2(){
System.out.println("哈哈哈2");
}
}
