一、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();
}
}
![]()
![]()
![]()
![]()
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 ++);
}
}
}
![]()
