1.java.io包下
File类：java程序中的此类的一个对象，就对应着硬盘中的一个文件或网络中的一个资源。
File file1 = new File("d:\\io\\helloworld.txt");
File file2 = new File("d:\\io\\io1");
>1.File既可以表示一个文件（.doc .xls .mp3 .avi .jpg .dat），也可以表示一个文件目录！
>2.File类的对象是与平台无关的。
>3.File类针对于文件或文件目录，只能进行新建、删除、重命名、上层目录等等的操作。如果涉及到访问文件的内容，File
是无能为力的，只能使用IO流下提供的相应的输入输出流来实现。
>4.常把File类的对象作为形参传递给相应的输入输出流的构造器中！
file类下的基本常用方法：
boolean exists();判断这个文件是否存在
boolean mkdir();创建文件夹路径（只能一层）
directory
boolean mkdirs();创建文件夹路径（可过层的）
creatNewFile创建一个文件
delete删除一个文件
renameTo(File File)重命名
getName获取文件名称
getPath获取文件路径
length文件的长度
isDirectory：判断是不是一个目录
isFile是不是一个文件
File[] listFiles获取当前文件夹下的所有文件与文件目录
import java.io.File;
public class TestFile {
public static void main(String[] args){
File filet=new File("E:\\BaiduYunDownload");
/*Boolean b=filet.isDirectory();
System.out.println(b);
File[] fil=filet.listFiles();
for(File f:fil){
System.out.println(f);
}*/
TestFile.printf(filet,1);
}
public static void printf(File f,int len){
if(f.exists()){//文件是否存在
File[] file=f.listFiles();//创建文件数组
for(File fi:file){//遍历数组
if(fi.isDirectory()){//如果是数组继续进入方法并打印出文件夹名
kongge(len);
System.out.println(fi.getName());
printf(fi,len+1);
}else{
kongge(len);
System.out.println(fi.getName());
}
}
}}
public static void kongge(int len){//给文件夹前边加空格
for(int i=0;i<len;i++){
System.out.print(" ");
}
}
}
io流分类 ：
3.IO流的划分
1) 按照流的流向的不同：输入流 输出流 (站位于程序的角度)
2) 按照流中的数据单位的不同：字节流 字符流 （纯文本文件使用字符流 ，除此之外使用字节流）
3) 按照流的角色的不同：节点流 处理流 （流直接作用于文件上是节点流（4个），除此之外都是处理流）
4.重点掌握
* 抽象基类（InputStream、OurputStream、Reader、Writer） 节点流（文件流） 缓冲流（处理流的一种,可以提升文件操作的效率）
* InputStreamFileInputStream （int read(byte[] b)）BufferedInputStream (int read(byte[] b))
* OutputStreamFileOutputStream (void write(b,0,len))BufferedOutputStream (flush()) (void write(b,0,len))
* Reader FileReader (int read(char[] c))BufferedReader (readLine()) (int read(char[] c))或String readLine()
* WriterFileWriter (void write(c,0,len))BufferedWriter (flush()) (void write(c,0,len)或void write(String str))
注： 1.从硬盘中读入一个文件，要求此文件一定得存在。若不存在，报FileNotFoundException的异常
2.从程序中输出一个文件到硬盘，此文件可以不存在。若不存在，就创建一个实现输出。若存在，则将已存在的文件覆盖
3.真正开发时，就使用缓冲流来代替节点流
4.主要最后要关闭相应的流。先关闭输出流，再关闭输入流。将此操作放入finally
package day31;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
public class iotext {
public static void main(String[] args){
File fi=new File("C:\\Users\\gaofangquan\\Desktop\\新建文件夹\\新建文本文档.txt");
File fi1=new File("C:\\Users\\gaofangquan\\Desktop\\新建文件夹\\新建文本文档 (3).txt");
try {
Reader r=new FileReader(fi);
Writer w=new FileWriter(fi1);
BufferedReader br=new BufferedReader(r);
BufferedWriter bw=new BufferedWriter(w);
//char[] c=new char[5];
String str=null;
@SuppressWarnings("unused")
int len=0;
//while((len=br.read(c))!=-1){//可以使用字符数组接收
while((str=br.readLine())!=null){
bw.write(str);
bw.newLine();
bw.flush();//刷新一下
}
bw.close();
br.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
5.其它的流
1.转换流：实现字节流与字符流之间的转换
InputStreamReader:输入时，实现字节流到字符流的转换，提高操作的效率（前提是，数据是文本文件） ===>解码：字节数组--->字符串
OutputStreamWriter：输出时，实现字符流到字节流的转换。 ===>编码： 字符串---->字节数组
例子：从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续进行输入操作，直至当输入“e”或者“exit”时，退出程序。
package day31;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Writer;
public class zhuanhuan {
public static void main(String[] args){
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
try {
Writer w=new FileWriter("C:\\Users\\gaofangquan\\Desktop\\新建文件夹\\新建文本文档 (5).txt");
BufferedWriter bw=new BufferedWriter(w);
String s=null;
while((s=br.readLine())!=null){
if(s.equalsIgnoreCase("exit")){
break;
}
bw.write(s);
bw.newLine();//换行
bw.flush();
}
bw.close();
br.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
2.标准的输入输出流
System.in: The "standard" input stream:从键盘输入数据
System.out:The "standard" output stream：从显示器输出数据
3.打印流 (都是输出流) PrintStream(处理字节) PrintWriter(处理字符)
可以使用System.setOut（PrintStream p）重新设置一下输出的位置。
PrintStream p = new PrintStream(new FileOutputStream("hello.txt"),true);
package print;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintStream;
import java.io.Reader;
public class TestPrintStream2 {
public static void main(String[] args) {
String fileName = "C:\\Users\\gaofangquan\\Desktop\\新建文件夹\\新建文本文档 (6).txt";
list(fileName, System.out);
}
private static void list(String fileName, PrintStream ps) {
try {
Reader r=new FileReader(fileName);
BufferedReader br = new BufferedReader(r);
String s = null;
while((s = br.readLine()) != null) {
// System.out.println();
ps.println(s);//等同于System.out.println();
}
br.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
ps.println("无法读取文件 !");
e.printStackTrace();
}
}
}
4.数据流（处理基本数据类型、String类、字节数组）
DataInputStream DataOutputStream
package data;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
public class TestDataStream {
public static void main(String[] args) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream dos = new DataOutputStream(baos);
try {
dos.writeDouble(Math.random());
dos.writeBoolean(true);
ByteArrayInputStream bais =
new ByteArrayInputStream(baos.toByteArray());
System.out.println(bais.available());
DataInputStream dis = new DataInputStream(bais);
/*
* 先进先出---队列
* 先进后出---栈
*/
System.out.println(dis.readBoolean());
System.out.println(dis.readDouble());//两种数据占用的空间不同必须遵守先进后出
dos.close();
dis.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
5.对象流(用来处理对象的)
>对象的序列化机制：允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，
或通过网络将这种二进制流传输到另一个网络节点。当其它程序获取了这种二进制流，就可以恢复成原来的Java对象
ObjectInputStream（Object readObject();） ObjectOutputStream (void writeObject(Object obj))
如何创建流的对象：ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("person.txt")));
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("person.txt")));
实现序列化机制的对象对应的类的要求：①要求类要实现Serializable接口②同样要求类的所有属性也必须实现Serializable接口
③ 要求给类提供一个序列版本号：private static final long serialVersionUID;
④属性声明为static 或transient的，不可以实现序列化
package object;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class TestObjectStream {
public static void main(String[] args) {
try {
Test t = new Test();
t.i += 5;
FileOutputStream fos =
new FileOutputStream("C:\\Users\\gaofangquan\\Desktop\\新建文件夹\\新建文本文档 (6).txt");
ObjectOutputStream oos =
new ObjectOutputStream(fos);
oos.writeObject(t);
oos.flush();
oos.close();
FileInputStream fis =
new FileInputStream("C:\\Users\\gaofangquan\\Desktop\\新建文件夹\\新建文本文档 (6).txt");
ObjectInputStream ois =
new ObjectInputStream(fis);
Test t_read = (Test)ois.readObject();
System.out.println(t_read);
ois.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
// Serializable--标记型接口, 没有实际的方法, 只是用来表示这个类可以被序列化
class Test implements Serializable {
private static final long serialVersionUID = 1L;
String name = "hanqi";
int i = 3;
int j = 15;
transient // 透明的, 表示这个属性在写入流的时候不予考虑
double d = 12.345;
@Override
public String toString() {
return "Test [name=" + name + ", i=" + i + ", j=" + j + ", d=" + d + "]";
}
}
6.随机存取文件流:RandomAccessFile
6.1既可以充当一个输入流，又可以充当一个输出流：public RandomAccessFile(File file, String mode)
6.2支持从文件的开头读取、写入。若输出的文件不存在，直接创建。若存在，则是对原有文件内容的覆盖。
6.3 支持任意位置的“插入”。