编写程序，循环接收用户从键盘输入多个字符串，直到输入“end”时循环结束，并将所有已输入的字符串按字典顺序倒序打印。

1. public class Test7 {
   
2.         /**
   
3.          * @param args
   
4.          */
   
5.         public static void main(String[] args){
   
6.                 //创建一个list来装用户输入的字符串的集合
   
7.                 List<String> list = new ArrayList<String>();
   
8.                 BufferedReader br = null;
   
9.                 while(true){
   
10.                         //创建一个输入流，从键盘上读取输入的内容
    
11.                         br = new BufferedReader(new InputStreamReader(System.in));
    
12.                         //临时变量，记录每一次循环用户输入的字符串
    
13.                         String sb = null;
    
14.                         try {
    
15.                                 //读取用户输入的每一行
    
16.                                 if ((sb = br.readLine()) != null) {
    
17.                                         //将每一行的字符串都添加到list集合中
    
18.                                         list.add(sb);
    
19.                                         //判断，当用户输入字符串是"end"的时候，将所有字符串按字典倒序排列并打印输出
    
20.                                         if ("end".equals(sb)) {
    
21.                                                 //调用sort()方法将一个装有String类型的list集合排序后返回
    
22.                                                 List<String> tempList = sort(list);
    
23.                                                 //循环遍历打印输出集合中的元素
    
24.                                                 for (String word : tempList) {
    
25.                                                         System.out.println(word);
    
26.                                                 }
    
27.                                                 //关闭流
    
28.                                                 br.close();
    
29.                                                 return;
    
30.                                         }
    
31.                                 }
    
32.                         } catch (IOException e) {
    
33.                                 e.printStackTrace();
    
34.                         }
    
35.                 }
    
36.     }
    
37. 
    
38.         //一个对装有String类型的集合按字典倒序排序的方法
    
39.         private static List<String> sort(List<String> list) {
    
40.                 for (int i = 0; i < list.size() - 1; i++) {
    
41.                         for (int j = i + 1; j < list.size(); j++) {
    
42.                                 //双层for循环拿到相邻的两个字符串，调用compareToIgnoreCase()方法做忽略大小写的比较
    
43.                                 if (list.get(j).compareToIgnoreCase(list.get(i)) > 0) {
    
44.                                         //如果第二个比第一个要大，就调换它们的位置
    
45.                                         String temp = list.get(i);
    
46.                                         list.set(i, list.get(j));
    
47.                                         list.set(j, temp);
    
48.                                 }
    
49.                         }
    
50.                 }
    
51.                 return list;
    
52.         }
    
53. }

复制代码

走起，还有没

sort方法里for循环是不是写错了~

错的 。。。

双层for循环拿到相邻的两个字符串，调用compareToIgnoreCase()方法做忽略大小写的比较,这个方法从API中没有查到，有些不明白

你的排序错 了

/**
*
*/
package myTestDir;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Collections;
import java.util.Comparator;
import java.util.TreeSet;
/**
* @author LinP
*第十三题：编写程序，循环接收用户从键盘输入多个字符串，
* 直到输入“end”时循环结束，并将所有已输入的字符串按字典顺序倒序打印。
*/
public class TestD {

        /**
         * @param args
         */
        public static void main(String[] args) {
                Comparator<String> cmp = Collections.reverseOrder();
                // TODO 自动生成的方法存根
                BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
               
                TreeSet<String> set = new TreeSet<String>(cmp);
               
                String line = null;
                try {
                        while((line=bufr.readLine())!=null){
                                if("end".equals(line)){
                                        break;
                                }
                                set.add(line);
                        }
                        System.out.println(set);
                } catch (IOException e) {
                        // TODO 自动生成的 catch 块
                        throw new RuntimeException("输入流打印异常!");
                }
                finally{
                        if(bufr!=null){
                                try {
                                        bufr.close();
                                } catch (IOException e) {
                                        // TODO 自动生成的 catch 块
                                        throw new RuntimeException("输入流关闭异常!");
                                }
                        }
                }
               
        }

}