(完整word版)Java知识总结完整版,推荐文档

try {

BufferedReader br = new BufferedReader(new FileReader(f)); String s = null;

while((s=br.readLine())!=null){ fs.println(s); }

br.close();

} catch (IOException e) { fs.println(\无法读取文件\ } } }

import java.util.*; import java.io.*;

public class TestPrintStream3 {

public static void main(String[] args) { String s = null;

BufferedReader br = new BufferedReader(

new InputStreamReader(System.in)); try {

FileWriter fw = new FileWriter

(\ PrintWriter log = new PrintWriter(fw); while ((s = br.readLine())!=null) { if(s.equalsIgnoreCase(\ System.out.println(s.toUpperCase()); log.println(\

log.println(s.toUpperCase()); log.flush(); }

log.println(\ log.flush(); log.close();

} catch (IOException e) { e.printStackTrace(); } } }

Objectl流

直接将Object写入或读出 transient关键字 //透明的 serializable接口

externalizable接口

import java.io.*;

public class TestObjectIO {

public static void main(String args[]) throws Exception { T t = new T(); t.k = 8;

FileOutputStream fos = new FileOutputStream(\

ObjectOutputStream oos = new ObjectOutputStream(fos); oos.writeObject(t); oos.flush(); oos.close();

FileInputStream fis = new FileInputStream(\

ObjectInputStream ois = new ObjectInputStream(fis); T tReaded = (T)ois.readObject();

System.out.println(tReaded.i + \+ \ } }

class T implements Serializable //标记对象序列化 {

int i = 10; int j = 9;

double d = 2.3;

transient int k = 15; }

第9章 多线程机制

线程是一个程序内部的顺序控制流（线程是一个程序里面不同的执行路径）main方法：主线程 线程和进程的区别

每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销

线程可以看成轻量级的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC），线程切换的开销小 多进程：在操作系统中能同时运行多个任务（程序）（进程是一个静态的概念） 多线程：在同一个应用程序中有多个顺序流同时执行（在一个时间点上，CPU只能执行一个线程，只是CPU的运算速度很快，开始同时执行多个线程，多核CPU另说）

Java的线程时通过java.lang.Thread类来实现的 VM启动时会有一个由主方法main所定义的线程 可以通过创建Thread的实例来创建新的线程

每个线程都是通过某个特定Thread对象所对应的方法run()来完成操作的，方法run()称为线程体

通过调用Thread类的start()方法来启动一个线程（直接执行run时方法调用）

线程的创建和启动 a.

定义线程类实现Runnable接口

Thread myThread = new Thread(target) //target为Runnable接口类型 Runnable中只有一个方法：public void run（）：用以定义线程的运行体 使用Runnable接口可以为多个线程提供共享的数据

在实现Runnable接口的类的run方法定义中可以使用Thread的静态方法：public static Thread currentThread()获取当前线程的引用 b.

可以定义一个Thread的子类并重写run方法： class MyThread extends Thread { public void run() {} }

然后生成该类的对象：

MyThread myThread = new MyThread(…)

public class TestThread1 {

public static void main(String args[]) { Runner1 r = new Runner1();

//r.start();//继承Thread，可直接启动线程，不需创建Thread对象 //r.run();

Thread t = new Thread(r); t.start(); //并行运行

for(int i=0; i<100; i++) {

System.out.println(\ } } }

class Runner1 implements Runnable { //class Runner1 extends Thread { public void run() {

for(int i=0; i<100; i++) {

System.out.println(\ } } }

线程状态转换

创

建 start()

阻塞状态 终止 阻塞解除 导致阻塞的事件 就绪状态 xi 调度 运行状态

线程控制的基本方法 isAlive（）：判断线程是否还“活”着，即线程时候还未终止 getPriority（）：获得线程的优先级数值 setPriority（）：设置线程的优先级数值 Thread.sleep（）：将当前线程睡眠指定毫秒数 join（）：调用某线程的该方法，将当前线程与该线程“合并”，即等待该线程结束，再恢复当前线程的运行 yield（）：让出CPU，当前线程进入就绪队列等待调度 wait（）：当前线程进入对象的wait pool notify/notifyAll（）：唤醒对象的wait pool中的一个/所有等待线程

sleep

可以调用Thread的静态方法：

public static void sleep(long mills) throws InterruptedException使得当前线程休眠（暂停执行时间mills毫秒），由于是静态方法，sleep可以由类名直接调用：Thread.sleep（…）

import java.util.*;

public class TestInterrupt {

public static void main(String[] args) { MyThread thread = new MyThread(); thread.start();

try {Thread.sleep(10000);}

catch (InterruptedException e) {}

thread.interrupt();//中断线程 //thread.flag = false; } }

class MyThread extends Thread { boolean flag = true;