大家都来找茬啊！看看这个程序那里错了（逻辑错误哦！）

[yakoo5]

package rhymingWords;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;
import java.io.PrintWriter;
import java.io.Reader;

public class RhymingWords {

	/**
	 * 本类是个单词处理程序。该程序从文件中读取一组单词，先将每个单词逆序
	 * (reverse)，在将所有单词排序(sort),再将这些单词逆序输出。最后输
	 * 出的单词列表能够押韵。
	 * RhymingWords.java——包含main()、reverse()与sort()方法。在
	 * main()方法中调用reverse()与sort()方法对单词进行处理，并将处理
	 * 结果输出显示。
	 * ReverseThread.java——包含执行逆序的线程类
	 * SortThread.java——包含执行排序的线程类
	 */
	public static void main(String[] args) throws IOException{
		// TODO Auto-generated method stub
		FileReader words = new FileReader("words.txt");
		
		//进行单词的逆序、排序、再逆序还原
		Reader rhymedWords = reverse(sort(reverse(words)));
		
		//将处理后的单词列表输出显示
		BufferedReader in = new BufferedReader(rhymedWords);
		String input;
		
		while ((input=in.readLine())!=null) {
			System.out.println(input);
		}
		in.close();
	}

	//创建管道，创建并启动单词逆序线程
	public static Reader reverse(Reader source)throws IOException{
		BufferedReader in = new BufferedReader(source);
		
		PipedWriter pipeOut = new PipedWriter();
		PipedReader pipeIn = new PipedReader(pipeOut);
		PrintWriter out = new PrintWriter(pipeOut);
		
		new ReverseThread(out,in).start();
		
		return pipeIn;
		
	}
	
	//创建管道，创建并启动单词排序线程
	public static Reader sort(Reader source) throws IOException{
		BufferedReader in = new BufferedReader(source);
		
		PipedWriter pipeOut = new PipedWriter();
		PipedReader pipeIn = new PipedReader(pipeOut);
		PrintWriter out = new PrintWriter(pipeOut);
		
		new SortThread(out,in).start();
		
		return pipeIn;
		
	}
}

package rhymingWords;

import java.io.*;

public class ReverseThread extends Thread {

	private PrintWriter out=null;
	private BufferedReader in=null;
	
	public ReverseThread(PrintWriter out, BufferedReader in) {
		super();
		this.out = out;
		this.in = in;
	}
	
	//逆序线程的线程体
	public void run() {
		if (out!=null&&in!=null) {
			try {
				String input;
				while ((input=in.readLine())!=null) {
					out.println(reverseIt(input));
					out.flush();
				}
				out.close();
			} catch (IOException e) {
				System.err.println("ReverseThread run:"+e);
			}
		}
	}
	
	//实现单词的逆序算法
	private String reverseIt(String source) {
		int i,len=source.length();
		StringBuffer dest = new StringBuffer(len);
		
		for (i = (len-1); i >= 0; i--) {
			dest.append(source.charAt(i));
		}
		return dest.toString();
	}
	
	
}

package rhymingWords;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;

public class SortThread extends Thread {
	private PrintWriter out=null;
	private BufferedReader in=null;
	
	public SortThread(PrintWriter out, BufferedReader in) {
		super();
		this.out = out;
		this.in = in;
	}
	
	//排序线程的线程体
	public void run() {
		int MAXWORDS=50;
		
		if (out!=null&&in!=null) {
			try {
				String [] listOfWords=new String[MAXWORDS];
				int numwords=0;
				while ((listOfWords[numwords]=in.readLine())!=null) {
					numwords++;
					quickSort(listOfWords, 0, numwords-1);
					for (int i = 0; i < numwords; i++) {
						out.println(listOfWords[i]);
					}
					out.close();
				}
			} catch (IOException e) {
				System.err.println("SortThread run:"+e);
			}
		}
	}
	
	//实现快速排序算法
	private static void quickSort(String[] a, int lo0, int hi0) {
		int lo=lo0;
		int hi=hi0;
		
		if (lo>=hi) {
			return;
		}
		
		String mid=a[(lo+hi)/2];
		while (lo<hi) {
			while (lo<hi&&a[lo].compareTo(mid)<0)	
				lo++;
			while (lo<hi&&a[lo].compareTo(mid)>0)
				hi--;
			if (lo<hi) {
				String T=a[lo];
				a[lo]=a[hi];
				a[hi]=T;
				lo++;
				hi--;
			}
		}
		
		if (hi<lo) {
			int T=hi;
			hi=lo;
			lo=T;			
		}
		quickSort(a, lo0, lo);
		quickSort(a, lo==lo0?lo+1:lo,hi0);
	}
	
	
	
	
}

文本文件words.txt（在工程根目录下）中的内容为：

anatomy
animation
applet
application
argument
bolts
class
comunicate
container
environment
garphics
image
intergrate
language

运行环境：Eclipse3.2 JDK1.5
输出结果：anatomy

正确的结果应为：

image
language
communicate
integrate
application
container
graphics
class
bolts
applet
environment
argument
anatomy

所有的注释都在代码中了，大家可要细心哦！
程序比较长，大家可要耐心点哦！

[zero1111]

怎么感觉在考大家呢

[kugou1314]

晕了怎么办

[yakoo5]

楼上说的很对！

小弟已经将错误改正

并且做了个小小的扩展

可以将结果保存到外存文件中

一下是修改和扩展后的代码：

package rhymingWords;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;

public class SortThread extends Thread {
	private PrintWriter out=null;
	private BufferedReader in=null;
	
	public SortThread(PrintWriter out, BufferedReader in) {
		super();
		this.out = out;
		this.in = in;
	}
	
	//排序线程的线程体
	public void run() {
		int MAXWORDS=50;
		
		if (out!=null&&in!=null) {
			try {
				String [] listOfWords=new String[MAXWORDS];
				int numwords=0;
				while ((listOfWords[numwords]=in.readLine())!=null) 
					numwords++;
				quickSort(listOfWords, 0, numwords-1);
				/*也可用下面这一个排序方法，它是Arrays类中的方法
				 * 使用时要添加import java.util.Arrays;代码行*/
				/*Arrays.sort(listOfWords,0,numwords);*/
				for (int i = 0; i < numwords; i++) {
					out.println(listOfWords[i]);
				}
				out.close();
				
			} catch (IOException e) {
				System.err.println("SortThread run:"+e);
			}
		}
	}
	
	//实现快速排序算法
	private static void quickSort(String[] a, int lo0, int hi0) {
		int lo=lo0;
		int hi=hi0;
		
		if (lo>=hi) {
			return;
		}
		
		String mid=a[(lo+hi)/2];
		while (lo<hi) {
			while (lo<hi&&a[lo].compareTo(mid)<0)	
				lo++;
			while (lo<hi&&a[hi].compareTo(mid)>0)
				hi--;
			if (lo<hi) {
				String T=a[lo];
				a[lo]=a[hi];
				a[hi]=T;
				lo++;
				hi--;
			}
		}
		
		if (hi<lo) {
			int T=hi;
			hi=lo;
			lo=T;			
		}
		quickSort(a, lo0, lo);
		quickSort(a, lo==lo0?lo+1:lo,hi0);
	}
}

package rhymingWords;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;
import java.io.PrintWriter;
import java.io.Reader;

public class RhymingWords {

	/**
	 * 本类是个单词处理程序。该程序从文件中读取一组单词，先将每个单词逆序
	 * (reverse)，在将所有单词排序(sort),再将这些单词逆序输出。最后输
	 * 出的单词列表能够押韵。
	 * RhymingWords.java——包含main()、reverse()与sort()方法。在
	 * main()方法中调用reverse()与sort()方法对单词进行处理，并将处理
	 * 结果输出显示。
	 * ReverseThread.java——包含执行逆序的线程类
	 * SortThread.java——包含执行排序的线程类
	 */
	public static void main(String[] args) throws IOException{
		// TODO Auto-generated method stub
		FileReader words = new FileReader("words.txt");
		
		//进行单词的逆序、排序、再逆序还原
		Reader rhymedWords = reverse(sort(reverse(words)));
		
		//将处理后的单词列表输出显示
		BufferedReader in = new BufferedReader(rhymedWords);
		String input;
		
               //一下是拓展，将结果保存到文件wordsResult.txt中
		saveResultAsFile(rhymedWords);
		
		while ((input=in.readLine())!=null) {
			System.out.println(input);
		}
		in.close();
		
		
	}

	//创建管道，创建并启动单词逆序线程
	public static Reader reverse(Reader source)throws IOException{
		BufferedReader in = new BufferedReader(source);
		
		PipedWriter pipeOut = new PipedWriter();
		PipedReader pipeIn = new PipedReader(pipeOut);
		PrintWriter out = new PrintWriter(pipeOut);
		
		new ReverseThread(out,in).start();
		
		return pipeIn;
		
	}
	
	//创建管道，创建并启动单词排序线程
	public static Reader sort(Reader source) throws IOException{
		BufferedReader in = new BufferedReader(source);
		
		PipedWriter pipeOut = new PipedWriter();
		PipedReader pipeIn = new PipedReader(pipeOut);
		PrintWriter out = new PrintWriter(pipeOut);
		
		new SortThread(out,in).start();
		
		return pipeIn;
		
	}
	
	//一下是拓展部分，将结果保存到wordsReslut.txt文件中
	public static void saveResultAsFile(Reader rhymedWords) {
		BufferedReader br = new BufferedReader(rhymedWords);
		String str;
		try {
			FileWriter f = new FileWriter("wordsReslut.txt");
			while ((str=br.readLine())!=null) {
				f.write(str);
				f.write("\n");
			}
			f.close();
		} catch (IOException e) {
			System.err.println(e);
		}
	}
	
}

[yakoo5]

由于部分ubb效果没有显示
且UBB代码在其中妨碍阅读
所有重新发一下，还望大家谅解！

package rhymingWords;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;
import java.io.PrintWriter;
import java.io.Reader;

public class RhymingWords {

	/**
	 * 本类是个单词处理程序。该程序从文件中读取一组单词，先将每个单词逆序
	 * (reverse)，在将所有单词排序(sort),再将这些单词逆序输出。最后输
	 * 出的单词列表能够押韵。
	 * RhymingWords.java——包含main()、reverse()与sort()方法。在
	 * main()方法中调用reverse()与sort()方法对单词进行处理，并将处理
	 * 结果输出显示。
	 * ReverseThread.java——包含执行逆序的线程类
	 * SortThread.java——包含执行排序的线程类
	 */
	public static void main(String[] args) throws IOException{
		// TODO Auto-generated method stub
		FileReader words = new FileReader("words.txt");
		
		//进行单词的逆序、排序、再逆序还原
		Reader rhymedWords = reverse(sort(reverse(words)));
		
		//将处理后的单词列表输出显示
		BufferedReader in = new BufferedReader(rhymedWords);
		String input;
		
                //一下是拓展，将结果保存到文件wordsResult.txt中           // <------拓展部分               
		saveResultAsFile(rhymedWords);
		
		while ((input=in.readLine())!=null) {
			System.out.println(input);
		}
		in.close();
		
		
	}

	//创建管道，创建并启动单词逆序线程
	public static Reader reverse(Reader source)throws IOException{
		BufferedReader in = new BufferedReader(source);
		
		PipedWriter pipeOut = new PipedWriter();
		PipedReader pipeIn = new PipedReader(pipeOut);
		PrintWriter out = new PrintWriter(pipeOut);
		
		new ReverseThread(out,in).start();
		
		return pipeIn;
		
	}
	
	//创建管道，创建并启动单词排序线程
	public static Reader sort(Reader source) throws IOException{
		BufferedReader in = new BufferedReader(source);
		
		PipedWriter pipeOut = new PipedWriter();
		PipedReader pipeIn = new PipedReader(pipeOut);
		PrintWriter out = new PrintWriter(pipeOut);
		
		new SortThread(out,in).start();
		
		return pipeIn;
		
	}
	
	//一下是拓展部分，将结果保存到wordsReslut.txt文件中                  //<------拓展部分          
	public static void saveResultAsFile(Reader rhymedWords) {
		BufferedReader br = new BufferedReader(rhymedWords);
		String str;
		try {
			FileWriter f = new FileWriter("wordsReslut.txt");
			while ((str=br.readLine())!=null) {
				f.write(str);
				f.write("\n");
			}
			f.close();
		} catch (IOException e) {
			System.err.println(e);
		}	
	}
	
}

package rhymingWords;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;

public class SortThread extends Thread {
	private PrintWriter out=null;
	private BufferedReader in=null;
	
	public SortThread(PrintWriter out, BufferedReader in) {
		super();
		this.out = out;
		this.in = in;
	}
	
	//排序线程的线程体
	public void run() {
		int MAXWORDS=50;
		
		if (out!=null&&in!=null) {
			try {
				String [] listOfWords=new String[MAXWORDS];
				int numwords=0;
				while ((listOfWords[numwords]=in.readLine())!=null) 
					numwords++;
				quickSort(listOfWords, 0, numwords-1);
				/*也可用下面这一个排序方法，它是Arrays类中的方法
				 * 使用时要添加import java.util.Arrays;代码行*/
				/*Arrays.sort(listOfWords,0,numwords);*/
				for (int i = 0; i < numwords; i++) {
					out.println(listOfWords[i]);
				}
				out.close();
				
			} catch (IOException e) {
				System.err.println("SortThread run:"+e);
			}
		}
	}
	
	//实现快速排序算法
	private static void quickSort(String[] a, int lo0, int hi0) {
		int lo=lo0;
		int hi=hi0;
		
		if (lo>=hi) {
			return;
		}
		
		String mid=a[(lo+hi)/2];
		while (lo<hi) {
			while (lo<hi&&a[lo].compareTo(mid)<0)	
				lo++;
			while (lo<hi&&a[hi].compareTo(mid)>0)          //<------将a[lo]改为a[hi]即可
				hi--;
			if (lo<hi) {
				String T=a[lo];
				a[lo]=a[hi];
				a[hi]=T;
				lo++;
				hi--;
			}
		}
		
		if (hi<lo) {
			int T=hi;
			hi=lo;
			lo=T;			
		}
		quickSort(a, lo0, lo);
		quickSort(a, lo==lo0?lo+1:lo,hi0);
	}
}

[gongziy]

已经下载了....回家去学习,明天给你结果~!!!

[云上飞翔]

答：程序已测试通过。错误原因是：１）快速排序写得不对　２）SortThread 中run()代码中while循环括号不对
代码修改如下：（程序运行结果与你给出的完全相同）不需要的代码，我没有删，而是注释掉。

package rhymingWords;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;
import java.io.PrintWriter;
import java.io.Reader;

public class RhymingWords {

    /**
     * 本类是个单词处理程序。该程序从文件中读取一组单词，先将每个单词逆序
     * (reverse)，在将所有单词排序(sort),再将这些单词逆序输出。最后输
     * 出的单词列表能够押韵。
     * RhymingWords.java——包含main()、reverse()与sort()方法。在
     * main()方法中调用reverse()与sort()方法对单词进行处理，并将处理
     * 结果输出显示。
     * ReverseThread.java——包含执行逆序的线程类
     * SortThread.java——包含执行排序的线程类
     */
    public static void main(String[] args) throws IOException{
        // TODO Auto-generated method stub
        FileReader words = new FileReader("words.txt");
        
        //进行单词的逆序、排序、再逆序还原
        
        Reader rhymedWords = reverse(sort(reverse(words)));
        
        
        //将处理后的单词列表输出显示
        
        BufferedReader in = new BufferedReader(rhymedWords);
        String input;
        
        while ((input=in.readLine())!=null) {
            System.out.println(input);
        }
        in.close();
    }

    //创建管道，创建并启动单词逆序线程
    public static Reader reverse(Reader source)throws IOException{
        BufferedReader in = new BufferedReader(source);
        
        PipedWriter pipeOut = new PipedWriter();
        PipedReader pipeIn = new PipedReader(pipeOut);
        PrintWriter out = new PrintWriter(pipeOut);
        
        new ReverseThread(out,in).start();
        
        return pipeIn;
        
    }
    
    //创建管道，创建并启动单词排序线程
    public static Reader sort(Reader source) throws IOException{
        BufferedReader in = new BufferedReader(source);
        
        PipedWriter pipeOut = new PipedWriter();
        PipedReader pipeIn = new PipedReader(pipeOut);
        PrintWriter out = new PrintWriter(pipeOut);
        
        new SortThread(out,in).start();
        
        return pipeIn;
        
    }
}

package rhymingWords;

import java.io.*;

public class ReverseThread extends Thread {

    private PrintWriter out=null;
    private BufferedReader in=null;
    
    public ReverseThread(PrintWriter out, BufferedReader in) {
        super();
        this.out = out;
        this.in = in;
    }
    
    //逆序线程的线程体
    public void run() {
        if (out!=null&&in!=null) {
            try {
                String input;
                while ((input=in.readLine())!=null) {
                    out.println(reverseIt(input));
                    out.flush();
                }
                out.close();
            } catch (IOException e) {
                System.err.println("ReverseThread run:"+e);
            }
        }
    }
    
    //实现单词的逆序算法
    private String reverseIt(String source) {
    	
        int i,len=source.length();
        StringBuffer dest = new StringBuffer(len);        
        for (i = (len-1); i >= 0; i--) {
            dest.append(source.charAt(i));
        }        
        return dest.toString();
    }
    
    
}

package rhymingWords;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.*;

public class SortThread extends Thread {
    private PrintWriter out=null;
    private BufferedReader in=null;
    
    public SortThread(PrintWriter out, BufferedReader in) {
        super();
        this.out = out;
        this.in = in;
    }
    
    //排序线程的线程体
    public void run() {
        int MAXWORDS=50;
        
        if (out!=null&&in!=null) {
            try {
                String [] listOfWords=new String[MAXWORDS];
                int numwords=0;
                while ((listOfWords[numwords]=in.readLine())!=null) {
                    numwords++;
                }//<--
                 //   quickSort(listOfWords, 0, numwords-1);
                Arrays.sort(listOfWords, 0, numwords);
                    for (int i = 0; i < numwords; i++) {
                        out.println(listOfWords[i]);
                        out.flush();
                        
                    }
                    out.close(); 
                //} <--
            } catch (IOException e) {
                System.err.println("SortThread run:"+e);
            }
        }
    }
    
    //实现快速排序算法
    /*
    private static void quickSort(String[] a, int lo0, int hi0) {
        int lo=lo0;
        int hi=hi0;
        
        if (lo>=hi) {
            return;
        }
        
        String mid=a[(lo+hi)/2];
        while (lo<hi) {
            while (lo<hi&&a[lo].compareTo(mid)<0)    
                lo++;
            while (lo<hi&&a[lo].compareTo(mid)>0)
                hi--;
            if (lo<hi) {
                String T=a[lo];
                a[lo]=a[hi];
                a[hi]=T;
                lo++;
                hi--;
            }
        }
        
        if (hi<lo) {
            int T=hi;
            hi=lo;
            lo=T;            
        }
        quickSort(a, lo0, lo);
        quickSort(a, lo==lo0?lo+1:lo,hi0);
    }
    */
    
    
    
}

[云上飞翔]

答：补充说明：你给出的“正确”结果中其实漏掉了一个：正确的应该是：
image
language
comunicate
intergrate
application
animation//<--这个是你漏掉的
container
garphics
class
bolts
applet
environment
argument
anatomy