发布时间 : 星期四 文章(完整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;