java 面试题:不用库函数实现字符串逆序

题目:
    不用库函数实现字符串逆序
解答: 
    由于数组的大小空间是固定的所以无法应对各种输入情况，并且最后显示的字符串的单词之间间隔变大，如果同志们有更好的办法请不吝指教。
-更正一下:
    方法二中使用了栈因此可以完全不使用String.length,通过判空来达到同样的效果,特此更正一下。
方法一:

 1 import java.io.BufferedInputStream;
 2 import java.io.BufferedReader;   
 3 import java.io.IOException;   
 4 import java.io.InputStreamReader;   
 5   
 6 public class ReverseApp{   
 7    public static void main(String args[]) {  
 8       //使用数组的弊端是只能创建固定大小空间的数组，不灵活
 9       String[] str = new String[20];
10       char[] charstr = new char[10];
11       int i = 0,j = 0,k = 0;
12       //最后得到的目标字符串
13       String dest = "";
14       BufferedInputStream in=new BufferedInputStream(System.in);   
15       System.out.println("请输入字符串:");
16       try
17       {
18        //char(10)表示换行  char(13)表示回车  必须两个一起判断
19        while((i = in.read()) != 10 && i != 13)
20        {
21           if((char)i != ' ')
22           {
23               charstr[j] = (char)i;
24               j++;
25           }
26           else
27           {
28             str[k] = new String(charstr);
29             k++;
30             charstr = new char[10];
31             j = 0;
32           }
33        }
34       
35       } catch (Exception e) {   
36        e.printStackTrace();   
37       } 
38      //回车后最后一单词未能放入字符串数组
39      if(j != 0)
40      {
41 
42           str[k] = new String(charstr);
43      }
44      //字符串数组从尾迭代将非空字符串加到目标字符串
45      for(j = str.length-1;j >= 0;j--)
46      {
47          if(str[j] != null)
48          {
49            dest = dest + str[j];
50          }
51      }
52      System.out.println("逆序后的字符串:");
53      System.out.println(dest);
54   }
55 }

方法二:

  1 import java.io.BufferedInputStream;
  2 import java.io.BufferedReader;   
  3 import java.io.IOException;   
  4 import java.io.InputStreamReader;   
  5   
  6   
  7   
  8 public class ReverseApp{   
  9    public static void main(String args[]) {  
 10       //使用数组的弊端是只能创建固定大小空间的数组，不灵活
 11       String[] str = new String[20];
 12       char[] charstr = new char[10];
 13       int i = 0,j = 0,k = 0;
 14       //最后得到的目标字符串
 15       String dest = "";
 16       BufferedInputStream in=new BufferedInputStream(System.in);   
 17       System.out.println("请输入字符串:");
 18       try
 19       {
 20        //char(10)表示换行  char(13)表示回车  必须两个一起判断
 21        while((i = in.read()) != 10 && i != 13)
 22        {
 23           if((char)i != ' ')
 24           {
 25               charstr[j] = (char)i;
 26               j++;
 27           }
 28           else
 29           {
 30             str[k] = new String(charstr);
 31             k++;
 32             charstr = new char[10];
 33             j = 0;
 34           }
 35        }
 36       
 37       } catch (Exception e) {   
 38        e.printStackTrace();   
 39       } 
 40      //回车后最后一单词未能放入字符串数组
 41      if(j != 0)
 42      {
 43 
 44           str[k] = new String(charstr);
 45      }
 46        
 47     //方法二:创建栈的实例用来逆序字符串
 48     Stackx stringStack = new Stackx(str.length); 
 49     j = 0;
 50     while(str[j] != null)
 51    {
 52       stringStack.push(str[j]);
 53       j++;
 54    }
 55 
 56  /*for(j = 0;j < str.length;j++)
 57    {
 58       //由于str.length表示的是数组的初始化长度，所以要把null都去掉
 59        if(str[j] != null)
 60       {
 61      stringStack.push(str[j]);
 62       }
 63     }*/
 64 
 65     while(!stringStack.isEmpty())
 66     {
 67        dest = dest + stringStack.pop();
 68     }
 69     System.out.println("逆序后的字符串:");
 70     System.out.println(dest);
 71   }   
 72        
 73 }
 74        
 75 //栈     
 76 class Stackx{   
 77     //三个必须元素   
 78     private int maxSize;   
 79     private String[] stackArray;       
 80     private int top;       
 81        
 82     //构造栈   
 83     public Stackx(int s){   
 84      maxSize=s;   
 85      stackArray=new String[maxSize];   
 86      top=-1;//栈为空   
 87     }   
 88        
 89     //栈所具有的动作   
 90     public void push(String j){   
 91     stackArray[++top]=j;//创建顶层空间并插入值   
 92     }          
 93     public String pop(){   
 94      return stackArray[top--];   
 95     }   
 96     public String peek(){   
 97      return stackArray[top];   
 98     }              
 99     public boolean isEmpty(){   
100      return (top==-1);   
101     }   
102     public boolean isFull(){   
103      return (top==maxSize-1);   
104     }   
105            
106 }     
107