2018-06-08 第三十三天

一、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 ++);

}

}

}