-------

用java.io.RandomAccessFile的readLine()方法 

------

FileReader对象只有read方法
---------------
/* 
* 简单的读/写文本文件的示例 
* 这里包含了三个例子，即 
* 1. 将文件读入到内存（这里是StringBuffer）的例子 
* 2. 将内容中的文本写到文件 
* 3. 将一个文件的内容读出来写入另一个文件中 
* 同时也展示了如果从输入流中读出来内容写入输出流中（仅限文本流） 
* 三个例子可以独立存在，所以根据需要只看其中一个就行了。 
*/ 

import java.io.BufferedReader; 
import java.io.FileInputStream; 
import java.io.FileOutputStream; 
import java.io.IOException; 
import java.io.InputStream; 
import java.io.InputStreamReader; 
import java.io.OutputStream; 
import java.io.OutputStreamWriter; 
import java.io.PrintStream; 
import java.io.PrintWriter; 

public final class AccessTextFile { 

/** 
* 1. 演示将流中的文本读入一个 StringBuffer 中 
* @throws IOException 
*/ 
public void readToBuffer(StringBuffer buffer, InputStream is) 
throws IOException { 
String line; // 用来保存每行读取的内容 
BufferedReader reader = new BufferedReader(new InputStreamReader(is)); 
line = reader.readLine(); // 读取第一行 
while (line != null) { // 如果 line 为空说明读完了 
buffer.append(line); // 将读到的内容添加到 buffer 中 
buffer.append("\n"); // 添加换行符 
line = reader.readLine(); // 读取下一行 
} 
} 

/** 
* 2. 演示将 StringBuffer 中的内容读出到流中 
*/ 
public void writeFromBuffer(StringBuffer buffer, OutputStream os) { 
// 用 PrintStream 可以方便的把内容输出到输出流中 
// 其对象的用法和 System.out 一样 
// （System.out 本身就是 PrintStream 对象） 
PrintStream ps = new PrintStream(os); 
ps.print(buffer.toString()); 
} 

/** 
* 3*. 从输入流中拷贝内容到输入流中 
* @throws IOException 
*/ 
public void copyStream(InputStream is, OutputStream os) throws IOException { 
// 这个读过过程可以参阅 readToBuffer 中的注释 
String line; 
BufferedReader reader = new BufferedReader(new InputStreamReader(is)); 
PrintWriter writer = new PrintWriter(new OutputStreamWriter(os)); 
line = reader.readLine(); 
while (line != null) { 
writer.println(line); 
line = reader.readLine(); 
} 
writer.flush(); // 最后确定要把输出流中的东西都写出去了 
// 这里不关闭 writer 是因为 os 是从外面传进来的 
// 既然不是从这里打开的，也就不从这里关闭 
// 如果关闭的 writer，封装在里面的 os 也就被关了 
} 

/** 
* 3. 调用 copyStream(InputStream, OutputStream) 方法拷贝文本文件 
*/ 
public void copyTextFile(String inFilename, String outFilename) 
throws IOException { 
// 先根据输入/输出文件生成相应的输入/输出流 
InputStream is = new FileInputStream(inFilename); 
OutputStream os = new FileOutputStream(outFilename); 
copyStream(is, os); // 用 copyStream 拷贝内容 
is.close(); // is 是在这里打开的，所以需要关闭 
os.close(); // os 是在这里打开的，所以需要关闭 
} 

public static void main(String[] args) throws IOException { 
int sw = 1; // 三种测试的选择开关 
AccessTextFile test = new AccessTextFile(); 

switch (sw) { 
case 1: // 测试读 
{ 
InputStream is = new FileInputStream("E:\\test.txt"); 
StringBuffer buffer = new StringBuffer(); 
test.readToBuffer(buffer, is); 
System.out.println(buffer); // 将读到 buffer 中的内容写出来 
is.close(); 
break; 
} 
case 2: // 测试写 
{ 
StringBuffer buffer = new StringBuffer("Only a test\n"); 
test.writeFromBuffer(buffer, System.out); 
break; 
} 
case 3: // 测试拷贝 
{ 
test.copyTextFile("E:\\test.txt", "E:\\r.txt"); 
} 
break; 
} 
} 

} 

==============

//这个是用reader的，这个不会出现异常

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

public class Test {
    public static void main(String[] args) throws Exception {
        File file = new File("Test.java");
        BufferedReader reader = new BufferedReader(new FileReader(file));
        String line = null;
        
        while ((line = reader.readLine()) != null) {
            System.out.println(line);
        }
        reader.close();
    }
}

class MyCompare implements Comparator //实现Comparator，定义自己的比较方法
{
public int compare(Object o1, Object o2) {
Elem e1=(Elem)o1;
Elem e2=(Elem)o2;

if(e1.get() > e2.get())//这样比较是降序,如果把-1改成1就是升序.
{
   return -1;
}
else if(e1.get()<e2.get())
{
   return 1;
}
else
{
   return 0;
}
}
}

class Elem {
private int iVal;

public Elem(int i) {
   this.iVal = i;
}

public int get() {
   return this.iVal;
}
}

public class Vector1 {
public static void main(String[] args) {
   List v = new Vector();
   v.add(new Elem(1));
   v.add(new Elem(22));
   v.add(new Elem(3));
   v.add(new Elem(14));
   Comparator ct = new MyCompare();
   Collections.sort(v, ct);
   for (int i = 0; i < v.size(); i++)
    System.out.println(((Elem) v.get(i)).get());

}

}

　　在本例中，我们可以看到一个简单的程序，它按两个不同的时间间隔（1 秒和 3 秒）在屏幕上显示当前时间。这是通过创建两个新线程来完成的，包括 main() 共三个线程。但是，因为有时要作为线程运行的类可能已经是某个类层次的一部分，所以就不能再按这种机制创建线程。虽然在同一个类中可以实现任意数量的接口，但 Java 编程语言只允许一个类有一个父类。同时，某些程序员避免从 Thread 类导出，因为它强加了类层次。对于这种情况，就要 runnable 接口。

　　Runnable 接口

　　此接口只有一个函数，run()，此函数必须由实现了此接口的类实现。但是，就运行这个类而论，其语义与前一个示例稍有不同。我们可以用 runnable 接口改写前一个示例。（不同的部分用黑体表示。）

　　创建两个新线程而不强加类层次

　　请注意，当使用 runnable 接口时，您不能直接创建所需类的对象并运行它；必须从 Thread 类的一个实例内部运行它。许多程序员更喜欢 runnable 接口，因为从 Thread 类继承会强加类层次。

　　synchronized 关键字

　　到目前为止，我们看到的示例都只是以非常简单的方式来利用线程。只有最小的数据流，而且不会出现两个线程访问同一个对象的情况。但是，在大多数有用的程序中，线程之间通常有信息流。试考虑一个金融应用程序，它有一个 Account 对象，如下例中所示：

　　一个银行中的多项活动

　　在此代码样例中潜伏着一个错误。如果此类用于单线程应用程序，不会有任何问题。但是，在多线程应用程序的情况中，不同的线程就有可能同时访问同一个 Account 对象，比如说一个联合帐户的所有者在不同的 ATM 上同时进行访问。在这种情况下，存入和支出就可能以这样的方式发生：一个事务被另一个事务覆盖。这种情况将是灾难性的。但是，Java 编程语言提供了一种简单的机制来防止发生这种覆盖。每个对象在运行时都有一个关联的锁。这个锁可通过为方法添加关键字 synchronized 来获得。这样，修订过的 Account 对象（如下所示）将不会遭受像数据损坏这样的错误：

　　对一个银行中的多项活动进行同步处理

　　deposit() 和 withdraw() 函数都需要这个锁来进行操作，所以当一个函数运行时，另一个函数就被阻塞。请注意， checkBalance() 未作更改，它严格是一个读函数。因为 checkBalance() 未作同步处理，所以任何其他方法都不会阻塞它，它也不会阻塞任何其他方法，不管那些方法是否进行了同步处理