public class Fanzhuang
{
        public static void main(String[] args)
        {
               
                String str="abcde";
                resever(str);
        }

        public static void resever(String str)
        {
                //将字符串转换成字符数组
                char[] ch=str.toCharArray();
                //定义ArrayList集合       
                ArrayList<Character> al=new ArrayList<Character>();
                //将字符串中的元素逆序添加到ArrayList集合
                for(int x=0;x<ch.length;x++)
                {
                        al.add(ch[ch.length-1-x]);
                }
                //遍历ArrayList集合，并打印
                Iterator<Character> it=al.iterator();
                while(it.hasNext())
                {
                        System.out.print(it.next());
                }
        }
}
这是我的代码，你还有更好的方法吗？

反转有很多方法的我觉得这样方法比较简单

1.         public class Test2
   
2.         {
   
3.                 public static void main (String[]args)
   
4.                         {
   
5.                         String str="abcde";
   
6.                         reverse(str);
   
7.                         }
   
8.                         public static void  reverse(String s)
   
9.                                 {
   
10.                                 String a=new StringBuffer(s).reverse().toString();
    
11.                                 System.out.println(a);
    
12.                                 }
    
13.                 }
    
14.   

复制代码

StringBuffer的reverse()多好用啊，都封装好的

楼上是一种好的方法、
另外，可以直接写：

1.                 for(int i=str.length()-1;i>=0;i--){
   
2.                         System.out.println(str.charAt(i));
   
3.                 }

复制代码

还有一种思想就是用栈的LIFO，将字符串的字符入栈，在出栈，自然为逆序。
---------------接分钟-----------

这个是我自己写的

1. public class Test {
   
2.         public static void main(String[] args)
   
3.         {
   
4.                 String str = "abcde";
   
5.                 char[] arr = str.toCharArray();
   
6. 
   
7.                 System.out.println("字符串反转前：" + str);
   
8.                
   
9.                 reverseArray(arr);
   
10.                
    
11.                 str = new String(arr);
    
12.                 System.out.println("字符串反转后：" + str);
    
13.         }
    
14. 
    
15.         public static void reverseArray(char[] arr)
    
16.         {
    
17.                 int len = arr.length;
    
18.                 for (int i=0; i<len/2; i++)
    
19.                 {
    
20.                         char temp = arr[i];
    
21.                         arr[i] = arr[len-i-1];
    
22.                         arr[len-i-1] = temp;
    
23.                 }
    
24.         }
    
25.        
    
26. }
    

复制代码

我怎么感觉这道题好熟悉啊，怎么像是一道**题！

感觉你这么做不如用linkedlist集合，使用addFirst方法将元素按正序添加进集合，遍历一次取出的就是倒序的了，而且在整个反转动作中只涉及到集合元素的存取操作，对于这类增删操作，使用ArrayList速度低于LinkedList。个人见解，若有不对请指出。

感觉你这么做不如用linkedlist集合，使用addFirst方法将元素按正序添加进集合，遍历一次取出的就是倒序的了，而且在整个反转动作中只涉及到集合元素的存取操作，对于这类增删操作，使用ArrayList速度低于LinkedList。个人见解，若有不对请指出。

class TestReverse{
   public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        String restr = reverse(str);
        System.out.println(restr);
  }
   public static String reverse(String str){
        List<Character> list = new ArrayList<Character>();
        String restr = "";
        char[] ch = str.toCharArray();
        for(int i = 0 ; i < ch.length ; i++)
               list.add(ch[i]);
        while(list.size()>0)
        restr = restr + list.remove(list.size()-1);
        return restr;
    }
}

这个用字符串函数不就可以换取了吗？？先获取字符串长度，然后循环反向输出。