一、RandomAccessFile
java.io.RandomAccessFile：随机存取文件。这个功能很强大，可以随机跳着读写。
import java.io.RandomAccessFile;
public class RandomAccessFileTest {
public static void main(String[] args) throws Exception {
test1();
test2();
}
//往指定的文件中写入三个学生的信息。
static void test1() throws Exception{
RandomAccessFile raf = new RandomAccessFile("./res/students.txt", "rw");
raf.seek(40);//可以来回跳
// raf.skipBytes(n)//只能往前跳
raf.writeUTF("小明");
raf.writeInt(21);
raf.writeInt(90);
raf.seek(0);
//每个人的信息占用的字节数为 20
raf.writeUTF("小刚");
raf.writeInt(20);
raf.writeInt(100);
//跳到第20个字节开始继续写
raf.seek(20);
raf.writeUTF("小花");
raf.writeInt(17);
raf.writeInt(99);
raf.close();
}
//读取学生的信息
static void test2() throws Exception{
RandomAccessFile raf = new RandomAccessFile("./res/students.txt", "r");
raf.seek(20);
System.out.println(raf.readUTF());
System.out.println(raf.readInt());
System.out.println(raf.readInt());
raf.seek(0);
System.out.println(raf.readUTF());
System.out.println(raf.readInt());
System.out.println(raf.readInt());
raf.close();
}
}
二、ObjectInputStream-ObjectOutputStream
对象字节输入输出流。
需求：将一个内存中的对象写入到一个本地文件中。实现对对象的持久化存储。还要将磁盘中的文件中保存的对象数据，还原到内存中对象数据来。
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class ObjectStreamTest {
public static void main(String[] args) throws Exception {
writeObj();
readObj();
}
//将一个Student 对象写入到指定的文件中，持久化存储
static void writeObj() throws Exception{
ObjectOutputStream oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("./res/student.obj")));
//
Student student = new Student("小刚", 19, Gender.MALE);
oos.writeInt(10);
oos.writeObject(student);
oos.close();
}
//将一个文件中的对象数据，还原到程序的内存中。
static void readObj() throws Exception{
ObjectInputStream ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream("./res/student.obj")));
System.out.println(ois.readInt());
Student student = (Student)ois.readObject();
System.out.println(student);
ois.close();
}
}
class Student implements Serializable{
/**
* 最好将类型信息版本号显式的定义
*/
private static final long serialVersionUID = 1L;
private String name;
private int age;
private transient Gender gender;
private int score;
private Book book = new Book("鲁滨逊漂流记");
public Student() {
System.out.println("Student.Student()");
}
Student(String name, int age, Gender gender) {
super();
System.out.println("Student.Student()");
this.name = name;
this.age = age;
this.gender = gender;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", gender=" + gender + ", score=" + score + "]";
}
}
class Book implements Serializable{
private String name;
public Book(String name) {
this.name = name;
}
}
enum Gender{
FEMALE,MALE
}
三、序列化---反序列化
序列化：将内存中的对象，转换为字节数组的过程。称为对象的序列化。
字节数组包含的内容：对象的类型信息。属性的类型信息。还包含了用于将字节数据还原为对象的信息。
反序列化：将字节数组还原为对象的过程。反序列化。
作用：
1：对象的持久化存储。
2：可以在网络中传输对象,网络中传输的都是字节信息。必须将对象序列化之后传输过去，对方收到字节数据之后再反序列化，得到对象的信息。
1：如果一个对象可以被序列化和反序列化，那么该对象的类型 必须 实现 接口 java.io.Serializable.该接口是一个空接口，标记性接口。
类通过实现java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本 身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。
2：反序列化 还原对象的时候，并不会调用对象类中的构造方法。所有对象的生成的过程，全部依赖于序列化的字节数据。
3：如果想反序列化成功，那么被序列化的时候类中的 serialVersionUID 字段的值，必须和反序列化的时候，类中的serialVersionUID 值相同。不然会抛出类型版本号不一致的异常，导致不能反序列化成功。
所以建议，在序列化的类中，显式的定义 serialVersionUID 值，指定一个随意的long类型的值即可。
private static final long serialVersionUID = 1L;
4：静态的类的成员变量是不会被序列化的。因为不再对象的内部，依赖于类存在的。
5：如果类中的某些实例变量也不想被序列化，那么将该实例成员使用关键字 transient 修饰即可。
如果一个实例变量，被 transient 修饰，那么被反序列化的时候，该字段的值是该类型的默认值。
6：如果一个对象可以被序列化，那么该对象的所有的成员都必须是可以被序列化的。基本数据类型可以直接被序列化，那么引用数据类型必须实现接口Serializable。
7：如果想将字节数据反序列化成功，那么字节码中的类型信息（包名+类名）必须和本地的一致。还有的类型的版本号必须一致。
四、ByteArrayInputStream --- ByteArrayOutputStream
字节数组输入输出流。
如何将一个对象的序列化之后的字节数组得到？
1：将对象序列化到一个文件中。
2：然后再使用字节流读取出来就行了。
作用：1：ByteArrayOutputStream 可以将任意类型的数据得到对应的字节数组形式。
2：ByteArrayInputStream 可以将字节数组中包含的我们需要的类型的信息，还原回来。
ByteArrayOutputStream流中包含的字节数组信息，这个流关闭之后，ByteArrayOutputStream对象中包含的字节数组仍然可以获得。
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class ByteArrayStreamTest {
public static void main(String[] args) throws Exception {
test();
}
static void test() throws Exception{
//将写出的数据，写出到了 baos 对象中的字节数组中了。
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(new BufferedOutputStream(baos));
oos.writeInt(10);
oos.writeObject(new Student("小明",21,Gender.MALE));
oos.flush();
//关闭之后，baos 对象仍然可以使用。
oos.close();
byte[] array = baos.toByteArray();
System.out.println(array.length);
//以字节数组为数据源读取数据
ByteArrayInputStream bais = new ByteArrayInputStream(array);
ObjectInputStream ois = new ObjectInputStream(new BufferedInputStream(bais));
System.out.println(ois.readInt());
System.out.println(ois.readObject());
ois.close();
}
}
五、IO体系及总结
1：对文件读写操作
读取文件的内容：
1：如果是文本文件
new BufferedReader(new FileReader(file));
readLine();方法
2: 非文本文件
new BufferedInputStream(new FileInputStream(file));
read(byte[]);方法
往文件中写数据：
1：文本数据：
new BufferedWriter(new FileWriter(file,append));
write(String);方法
newLine();方法
2：字节数据：
new BufferedOutputStream(new FileOutputStream(file,append));
wirete(byte[]);方法
flush();方法
2 : 使用流接收键盘输入的信息
new BufferedReader(new InputStreamReader(System.in));
readLine();
3: 想对八种基本数据类型进行读写，还可以包括 String
DataInputStream、DataOutputStream
4：对对象进行序列化和反序列化
ObjectInputStream、ObjectOutputStream
5：内存和内存之间的数据的交互。
想操作的数据和字节数组之间的相互的转换。
ByteArrayInputStream
ByteArrayOutputStream
6：如果想将字符序列使用指定的字符集编码为字节数据
OutputStreamWriter
六、进程和线程
1：程序 是一个静态的概念。 是一系列 计算机指令的集合。
2：进程：是一个动态的概念，程序的一次执行，会产生一个进程。或者进程可以看作是运行的程序。
进程特点：
1：进程可以并发（不是并行执行）执行。
并行执行：两个程序在同一个时间一起被执行。
2：进程是cpu和 操作系统进行资源分配的最小单元。
当程序执行的时候，进程被创建，然后系统会对该进程分配只供它自己使用的资源，多个进程之间不共享资源。
3：线程：是进程中的一条完整的执行的路径。可以看作是进程中的一条任务线程。
进程是运行的程序，进程是为了完成某些任务的。
1：进程可以看作是一个线程的容器，所有进程中的任务都是依赖于进程中的线程来完成的。
2：一个进程中至少要包含一个线程。
3：一个进程中可以包含多个线程，那么这多个线程就共享了所在的进程的资源。
4：一个进程中的第一个线程，称为是主线程。java 中的主线程 是 main 线程。
5：线程可以并发执行。一个进程中可以同时运行多个线程。
举个栗子：
把进程看作高速公路，把线程看作高速公路上的车道。
把一个车道看作一个线程。
进程和线程的关系：
1：线程是不能独立存在的，必须在进程中存活。
2：进程的所有的任务都依赖于进程中的线程来完成。
3：进程是线程的载体，线程负责完成进程的任务。
4：一个进程可以有任意个线程，至少一个线程。第一个线程称为主线程。 java 中的第一个线程为main线程。
5：进程是cpu进行资源分配的最小单位。
6：线程是cpu进行调度执行的最小单位。
7：可以将线程看作轻量级的进程。系统创建进程，销毁进程 都会消耗比较大的资源。但是创建线程，销毁线程消耗资源比较小。
8：一个进程中的所有的线程共享所在进程的资源。
单线程程序的问题：
1：如果程序中存在阻塞式方法。。nextInt，线程就被阻塞了。程序就不能继续执行了。
2：多线程程序中，如果一个线程被阻塞了，其他的线程不受任何的影响。
在java 中提供了类 java.lang.Thread 用来描述线程对象。
java 中被执行的代码，都是被某一个线程执行的。
A; 是一条代码语句，那么当前线程的意思，就是执行 A 语句的线程对象。
java 中创建线程的方式：3种方式。
1：继承 java.lang.Thread 类。
2：实现 java.lang.Runnable 接口。
3: 实现 java.util.concurrent.Callable.(jdk 1.5之后出现的)。
/**
* 使用继承线程类的方式，实现创建线程
*
*/
public class MyThreadTest {
//main 主线程 执行的主体代码就是main 方法的方法体。
public static void main(String[] args) {
//先创建一个自定义线程对象
MyThread thread = new MyThread();
//启动线程对象，开始执行run。通过调用线程对象的start 方法启动线程，千万不要调用run 方法。
thread.start();
//主线程 完成的任务 也是 不断累加
int counter = 0;
while(true){
System.out.println(Thread.currentThread().getName()+"-->"+counter ++);
}
}
}
//自定义线程类 线程完成的任务是 让一个计数器不断的累加输出。
class MyThread extends Thread{
//就是该线程的任务的主体部分
public void run() {
int counter = 0;
while(true){
System.out.println(Thread.currentThread().getName()+"-->"+counter ++);
}
}
}
