什么是流
* 数据的流动，称为流，硬盘和内存之间的数据交互
* 流按照方向分，分为输入流和输出流，以内存作为参照物。将数据从数据源读取到内存，为输入流，也称为读取流。将数据从内存中写入数据源，为输出流，也称为写入流。
* 流放在I/O包里
流的分类
按照类型分类可以分为字节流，字符流和对象流。
1. 字节流：以字节方式传输，所有类型均能传输
2. 字符流：只能传输字符串
3. 对象流：传输对象
由于计算机采用二进制。数据的传输都是以字节为单位传输。所以，无论那种流，其本质都是字节流。不过，为了方便字符数据和对象数据的传输，可以在字节流基础上进行封装，形成字符流和对象流，所有的流都使用int类型去接收
InputStream和OutputStrem
InputStream和OutpuuStrem是字节流的两个父类，这个两个类是抽象类，提供了read()和write(）两个抽象方法。由子类根据自己数据源的特点分别做实现
流操作的步骤
1. 建立流
2. 操作流
3. 关闭流
当做文件流操作时，读取流会抛出文件问找到FileNotFoundException异常。写入流会新建文件，但是前提是文件所在目录必须存在。否则也会抛出FileNotFoundException
创建读取流
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class InputText {
public InputText() {
//外面声明变量，内部实例化，方便在finlly中关闭
InputStream in = null;
try {
//创建文件读取字节流
in = new FileInputStream("D:\\文档\\图片\\素材\\1.jpg");
int data=0;
//一次只读一个字节，读取完毕返回-1
// while((data=in.read())!=-1){
// System.out.println(data);
// }
//使用byte数组接收
int len=0;
byte[]by=new byte[1024];
//一次读取1024个字节，放入byte数组，返回本次读取的字节数
while((len=in.read(by))!=-1){
System.out.println(len);
}
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
//关闭流通道方法
in.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public static void main(String[] args) {
// 对象没有被变量指向会被垃圾回收，但是当对象正在运行则不会回收
new InputText();
}
}
创建写入流
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class OutputTest {
public OutputTest(){
OutputStream out=null;
try {
//创建写入字节流
out =new FileOutputStream("1.txt");
//默认为覆盖写入，如果第二个参数为真，表示追加写入
out =new FileOutputStream("1.txt",true);
// //写入数据,只能是byte类型
// out.write(100);
//写入字节数组
out.write("努力一点，多挣点钱。".getBytes());
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
try {
out.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public static void main(String[] args) {
OutputTest o=new OutputTest();
}
}
Reader和Write
Reader和Write是字符流的两个父类。可以直接对字符串进行操作
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class ReaderTest {
public ReaderTest() {
// 字符流只能读取文本文件
Reader r = null;
//Reader与BufferedReader配合使用
BufferedReader br = null;
try {
r = new FileReader("img/1.txt");
br = new BufferedReader(r);
String str = null;
while ((str = br.readLine()) != null) {
System.out.println(str);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
br.close();
r.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public static void main(String[] args) {
ReaderTest r = new ReaderTest();
}
}
Write代码
import java.io.FileWriter;
import java.io.FilterWriter;
import java.io.IOException;
import java.io.Writer;
public class WriteTest {
public WriteTest(){
Writer w=null;
try {
//第二个参数如果不写表示默认覆盖，写了真表示换行输入
w=new FileWriter("3.txt");
w.write("你好，欢迎光临\n");
w.write("今天下雨");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
try {
w.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public static void main(String[] args) {
WriteTest w=new WriteTest();
}
}
File 文件类
写入流会新建文件，但是前提是文件所在目录必须存在。否则也会抛出FileNotFoundException
import java.io.File;
public class FileText {
public static void main(String[] args) {
// 创建一个文件对象
File f = new File("D:/文档/JAVA/朗沃/作业");
// 得到文件对象描述的绝对路径
System.out.println(f.getAbsolutePath());
// 判断文件是否存在，返回boolean值,存在返回真
boolean isHas = f.exists();
System.out.println(isHas);
// 判断指定目录是否存在，如果不存在，系统自动创建一个对应目录
if (f.exists() == false) {
f.mkdirs();
}
// 判断文件对象代表的是文件还是目录, 是文件返回真，目录返回假
System.out.println(f.isFile());
// 判断文件对象代表的是文件还是目录，是目录返回真，文件返回假
System.out.println(f.isDirectory());
//删除文件或目录，如果删除文件可以直接删除，删除目录必须保证目录为空目录
File s=new File("D:/文档/JAVA/朗沃/作业/Test.txt");
s.delete();
File w=new File("C:/Recovery");
//得到目录中的所有文件对象，不包括子目录中的文件或目录
File[] farray=w.listFiles();
for(File x:farray){
System.out.println(x.getAbsolutePath());
}
// list(new File("C:/Recovery"));
}
//递归循环，自己调用自己
public static void list(File dirFile){
File[] farray=dirFile.listFiles();
for(File f: farray){
if(f.isFile()){
System.out.println(f.getAbsolutePath());
}else{
list(f);
}
}
}
//递归循环，删除所有文件
public static void delList(File dirFile){
File[] farray=dirFile.listFiles();
for(File f: farray){
if(f.isFile()){
f.delete();
}else{
delList(f);
}
}
dirFile.delete();
}
}