一、 File 类
·一个File类的对象，表示了磁盘上的 文件或目录。
package com.bob.io;
import java.io.File;
import java.io.IOException;
public class FileTest1 {
public static void main(String[] args) throws IOException {
File file = new File("C:/testjava.txt");
System.out.println(file.createNewFile());
File file1 = new File("C:" + File.separator + "testjava.txt");
File file2 = new File(file1, "/testjava.txt"); //在file1目录下创建文件。第一个参数作为一个file对象
// File file2 = new File("C:/test", "/testjava.txt"); //第二种构造方式。第一个参数作为一个字符串
System.out.println(file2.createNewFile());
}
}
package com.bob.io;
import java.io.File;
//创建目录
public class FileTest3 {
public static void main(String[] args) {
File file = new File("C:/test/newdir"); //创建一层目录，上一层目录必须存在
System.out.println(file.mkdir());
System.out.println(file.mkdirs()); //创建所有层次目录
System.out.println("--------------------------------------");
// File fileList = new File("C:/Windows");
//
// String[] names = fileList.list(); //当前目录下一层目录的所有文件和文件夹名称
// for(String name : names){
// System.out.println(name);
// }
//listFiles()方法与此方法雷同，一个是返回file对象，一个是String数组
File fileList = new File("C:/Windows");
File[] files = fileList.listFiles();
for(File f : files){
System.out.println(f.getName());
}
}
}
二、 流 类
输入/输出：输入和输出是相对你的程序或者操作内存来说的。从外部（文件）流向程序的叫输入，从程序流向外部的叫输出。
Lesson89
·从功能上分为两大类： 输入流 和 输出流。
·从流结构可以分为字节流和字符流，对应InputerStream 和 OutputStream 这两个抽象类。
· 字符流输入输出基础是抽象类 Reader 和 Writer。
字符流底层也是通过字节流实现的。
`流的分类：
节点流：从特定地方读写的流类。 （例如：file文件，键盘）
过滤流：使用节点流作为输入或输出。 （过滤流一般是用来包装节点流，节点流是第一层。现有节点流再有过滤流，过滤流也可以保证过滤流）
程序都是直接和节点流打交道，然后通过过滤流包装节点流，达到过滤。
·InputStream
package com.bob.io;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
//输入流
public class InputStreamTest1 {
public static void main(String[] args) throws Exception {
File file = new File("C:" + File.separator + "testjava.txt");
InputStream is = new FileInputStream(file);
byte[] buffer = new byte[200];
int length;
while(-1 != (length = is.read(buffer, 0, 200))){
String str = new String(buffer, 0, length);
System.out.println(str);
System.out.println("read over");
System.out.println(length);
}
}
}
·过滤流：过滤流的主要特点是在输入输出数据的同时能对所传输的数据做指定类型或格式的转换，即可实现对二进制字节数据的理解和编码转换。
DataInputStream： 数据输入流中定义了多个针对不同类型数据的读写方法，如readByte()、readBoolean()、readChar()等
DataOutputStream：数据输出流中定义了多个针对不同类型数据的写的方法，如writeByte()、writeBoolean()、writeChar() 等
package com.bob.io;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class DateStreamTest1 {
public static void main(String[] args) throws Exception {
DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(
new FileOutputStream(new File("data.txt")))); // 当前项目路径
byte b = 8;
int i = 5;
float f = 1.9f;
double d = 2.003;
boolean bl = true;
// 使用DateOutputStream()向文件写基本的数据类型
dos.writeByte(b);
dos.writeInt(i);
dos.writeFloat(f);
dos.writeDouble(d);
dos.writeBoolean(bl);
dos.close();
// 读和写的顺序要保持一致
DataInputStream dis = new DataInputStream(new BufferedInputStream(
new FileInputStream(new File("data.txt"))));
System.out.println(dis.readByte());
System.out.println(dis.readInt());
System.out.println(dis.readFloat());
System.out.println(dis.readDouble());
System.out.println(dis.readBoolean());
}
}
三、字符流
·字节流不能直接操作 Unicode字符。字符流层次结构的顶层是 Reader 和 Writer 抽象类。
· Java程序语言使用 Unicode 来表示字符串和字符，Unicode使用两个字节来表示一个字符，既一个字符占16位。
package com.bob.io;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public class ReaderTest1 {
public static void main(String[] args) throws Exception {
FileOutputStream fos = new FileOutputStream(new File("file.txt"));
OutputStreamWriter osw = new OutputStreamWriter(fos);
BufferedWriter bw = new BufferedWriter(osw);
bw.write("www.google.com");
bw.write("\n");
bw.write("www.baidu.com");
bw.close();
FileInputStream fis = new FileInputStream(new File("file.txt"));
InputStreamReader isr = new InputStreamReader(fis);
BufferedReader br = new BufferedReader(isr);
String str = br.readLine();
while(null != str){
System.out.println(str);
str = br.readLine();
}
br.close();
}
}
四、序列化
· 将对象转换为字节流保存起来，并在以后还原这个对象，这种机制叫做对象序列化。
· 将一个对象保存到永久存储设备上称为持久化。
· 一个类若要想被实现序列化，必须实现 java.io.Serializable 接口或Externalizable 接口，该接口中没有定义任何方法，是一个标识性接口（Marker Interface），当一个类实现了该接口，就表示这个类的对象是可以序列化。
· 在序列化时，static 变量是无法序列化的（因为static的变量是属于类的而不是对象）；如果A包含了对B的引用，那么在序列化A的时候也会将B一并地序列化；如果此时A可以序列化，B无法序列化，那么当序列化A的时候就会发生异常，这时就需要将对B的引用设为 transient， 该关键字表示变量不会被序列化。
//序列化
package com.bob.io;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class SerializableTest {
public static void main(String[] args) throws Exception {
FileOutputStream fos = new FileOutputStream(new File("object.txt"));
ObjectOutputStream oos = new ObjectOutputStream(fos);
Person p1 = new Person(20, "zhagnsan", 22.23); //将对象写入到流里的过程叫序列化
Person p2 = new Person(30, "lisi", 33.33);
Person p3 = new Person(10, "wangwu", 21.99);
oos.writeObject(p1);
oos.writeObject(p2);
oos.writeObject(p3);
oos.close();
System.out.println("------------反序列化-----------");
FileInputStream fis = new FileInputStream("object.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
Person per = null;
for(int i = 0; i < 3; i++){
per = (Person)ois.readObject();
System.out.println(per.age + "," + per.name + "," + per.height);
}
}
}
class Person implements Serializable{
int age;
// String name;
transient String name;
double height;
public Person(int age, String name, double height){
this.age = age;
this.name = name;
this.height = height;
}
}
4141
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
