精华内容
下载资源
问答
  • 如何将字符串反转?

    2021-03-31 15:19:23
    如何将字符串反转? import java.util.Stack; /** * 8 种字符串反转的方法, 其实可以是9种方法,第9种是使用StringBuffer和StringBuilder中实现的方法 * @author Josh Wang(Sheng) * * @email swang6@...

    面试题汇总

    如何将字符串反转?

    import java.util.Stack;  
      
    /** 
     * 8 种字符串反转的方法, 其实可以是9种方法,第9种是使用StringBuffer和StringBuilder中实现的方法 
     * @author Josh Wang(Sheng) 
     *  
     * @email  swang6@ebay.com 
     *  
     */  
    public class StringReverse {  
      
        /** 
         * 二分递归地将后面的字符和前面的字符连接起来。 
         *  
         * @param s 
         * @return 
         */  
        public static String reverse1(String s) {  
            int length = s.length();  
            if (length <= 1)  
                return s;  
            String left = s.substring(0, length / 2);  
            String right = s.substring(length / 2, length);  
            return reverse1(right) + reverse1(left);  
        }  
          
        /** 
         * 取得当前字符并和之前的字符append起来 
         * @param s 
         * @return 
         */  
        public static String reverse2(String s) {  
            int length = s.length();  
            String reverse = "";  
            for (int i=0; i<length; i++)  
                reverse = s.charAt(i) + reverse;  
            return reverse;  
        }  
          
        /** 
         * 将字符从后往前的append起来 
         * @param s 
         * @return 
         */  
        public static String reverse3(String s) {  
            char[] array = s.toCharArray();  
            String reverse = "";  
            for (int i = array.length - 1; i >= 0; i--) {  
                reverse += array[i];  
            }  
            return reverse;  
        }  
          
        /** 
         * 和StringBuffer()一样,都用了Java自实现的方法,使用位移来实现 
         * @param s 
         * @return 
         */  
        public static String reverse4(String s) {  
            return new StringBuilder(s).reverse().toString();  
        }  
          
        /** 
         * 和StringBuilder()一样,都用了Java自实现的方法,使用位移来实现 
         * @param s 
         * @return 
         */  
        public static String reverse5(String s) {  
            return new StringBuffer(s).reverse().toString();  
        }  
          
        /** 
         * 二分交换,将后面的字符和前面对应的那个字符交换 
         * @param s 
         * @return 
         */  
        public static String reverse6(String s) {  
            char[] array = s.toCharArray();  
            int end = s.length() - 1;  
            int halfLength = end / 2;  
            for (int i = 0; i <= halfLength; i++) {  
                char temp = array[i];  
                array[i] = array[end-i];  
                array[end-i] = temp;  
            }  
              
            return new String(array);  
        }  
          
        /** 
         * 原理是使用异或交换字符串 
         * a=a^b;  
         * b=b^a;  
         * a=b^a; 
         *  
         * @param s 
         * @return 
         */  
        public static String reverse7(String s) {  
            char[] array = s.toCharArray();  
                
              int begin = 0;  
              int end = s.length() - 1;  
                
              while (begin < end) {  
                   array[begin] = (char) (array[begin] ^ array[end]);  
                   array[end] = (char) (array[end] ^ array[begin]);  
                   array[begin] = (char) (array[end] ^ array[begin]);  
                   begin++;  
                   end--;  
              }  
                
              return new String(array);  
        }  
          
        /** 
         * 基于栈先进后出的原理 
         *  
         * @param s 
         * @return 
         */  
        public static String reverse8(String s) {  
            char[] array = s.toCharArray();  
            Stack<Character> stack = new Stack<Character>();  
            for (int i = 0; i < array.length; i++)  
                stack.push(array[i]);  
      
            String reverse = "";  
            for (int i = 0; i < array.length; i++)  
                reverse += stack.pop();  
                
            return reverse;  
        }  
          
        public static void main(String[] args) {  
            System.out.println(reverse1("Wang Sheng"));  
            System.out.println(reverse2("Wang Sheng"));  
            System.out.println(reverse3("Wang Sheng"));  
            System.out.println(reverse4("Wang Sheng"));  
            System.out.println(reverse5("Wang Sheng"));  
            System.out.println(reverse6("Wang Sheng"));  
            System.out.println(reverse7("Wang Sheng"));  
            System.out.println(reverse8("Wang Sheng"));  
        }  
    }  
    
    
    展开全文
  • 09 JAVA如何将字符串反转? 答: 1.StringBuilder的reverse()方法,最简单 ```sql public static String reverse4(String s) { return new StringBuffer(s).reverse().toString(); } 2.使用字符串数组,实现从尾部...

    09 JAVA如何将字符串反转?

    答:

    1.StringBuilder的reverse()方法,最简单

    ```sql
    public static String reverse4(String s) {
    
      return new StringBuffer(s).reverse().toString();
    }
    

    2.使用字符串数组,实现从尾部开始逐个逆序放入字符串

    sublic static String reverse3(String s) {
    
      char[] array = s.toCharArray();
    
      String reverse = "";
    
      for(int i = array.length - 1; i >= 0; i--)
    
      reverse += array[i];
    
      return reverse;
    
    }
    

    3.使用String的CharAt方法,使用String的CharAt方法取出字符串中的各个字符,然后插入到字符串中,调用StringBuilder的insert()方法进行操作。

    public static String reverse2(String s) {
    
      int length = s.length();
    
      String reverse = "";
    
      for(int i = 0; i < length; i++)
    
      reverse = s.charAt(i) + reverse;
    
      return reverse;
    
    }
    

    4.使用递归的方法,实现字符串反转。

    public static String reverse1(String s) {
    
      int length = s.length();
    
      if(length <= 1){
    
        return s;
    
        }
    
      String left = s.substring(0, length / 2);
    
      String right = s.substring(length / 2, length);
    
      return reverse1(right) + reverse1(left);
    
    }
    

    看到最后的帮忙点个👍🙏 谢谢,这个对我真的很重要!
    在这里插入图片描述

    展开全文
  • java基础:8、如何将字符串反转?

    如何将字符串反转?

    先上效率对比

    多次超长字符串实验后,效率:方法一>方法三>方法二。
    在这里插入图片描述

    方法一:使用StringBuilder的reverse方法(最快)

    		String str1 = new String("123456789");
    		/**
    		 * 使用StringBuilder的reverse方法
    		 */
    		String str2 = new StringBuilder(str1).reverse().toString();
    		System.out.println("原字符串:" + str1);
    		System.out.println("字符串反转后:" + str2);
    

    方法二:转换成字符数组,再使用StringBuilder拼接

    		/**
    		 * 转换成字符数组,后通过StringBuilder拼接
    		 */
    		char[] mychar=str1.toCharArray();
    		StringBuilder sb=new StringBuilder("");
    		for(int i=mychar.length-1;i>=0;i--){
    			sb.append(mychar[i]);
    		}
    		String str2=sb.toString();
    		System.out.println("原字符串:" + str1);
    		System.out.println("字符串反转后:" + str2);
    

    方法三:使用charAt(),并用StringBuilder拼接

    		String str1 = new String("123456789");
    		StringBuilder sb=new StringBuilder("");
    		
    		for(int i=str1.length()-1;i>=0;i--){
    			sb.append(str1.charAt(i));
    		}
    		String str2=sb.toString();
    		System.out.println("原字符串:" + str1);
    		System.out.println("字符串反转后:" + str2);
    

    方法四:subString结合递归?尝试后当字符串超长时失败。

    此方法字符串较短时正常运行,但是字符串很长时,报内存溢出。本人太懒没有找到原因,有大神的话求指教。

    private static String reverse(String str, StringBuilder sb) {
    
    		// 省略掉一些长度判断
    		if (str.length() != 1) {
    			String str01 = str.substring(0, str.length() - 1);
    			String str02 = str.substring(str.length() - 1);
    			sb.append(str02);
    			reverse(str01, sb);
    		} else {
    			sb.append(str);
    		}
    		return sb.toString();
    
    	}
    
    展开全文
  • 9.如何将字符串反转?

    2020-07-24 20:20:49
    8 种字符串反转的方法, 其实可以是9种方法,第9种是使用StringBuffer和StringBuilder中实现的方法 二分递归地后面的字符和前面的字符连接起来 /** * 二分递归地后面的字符和前面的字符连接起来。 * * @...

    8 种字符串反转的方法, 其实可以是9种方法,第9种是使用StringBuffer和StringBuilder中实现的方法

    二分递归地将后面的字符和前面的字符连接起来

        /** 
         * 二分递归地将后面的字符和前面的字符连接起来。 
         *  
         * @param s 
         * @return 
         */  
        public static String reverse1(String s) {  
            int length = s.length();  
            if (length <= 1)  
                return s;  
            String left = s.substring(0, length / 2);  
            String right = s.substring(length / 2, length);  
            return reverse1(right) + reverse1(left);  
        }  
    

    取得当前字符并和之前的字符append起来

    /** 
         * 取得当前字符并和之前的字符append起来 
         * @param s 
         * @return 
         */  
        public static String reverse2(String s) {  
            int length = s.length();  
            String reverse = "";  
            for (int i=0; i<length; i++)  
                reverse = s.charAt(i) + reverse;  
            return reverse;  
        }
    

    将字符从后往前的append起来

    /** 
         * 将字符从后往前的append起来 
         * @param s 
         * @return 
         */  
        public static String reverse3(String s) {  
            char[] array = s.toCharArray();  
            String reverse = "";  
            for (int i = array.length - 1; i >= 0; i--) {  
                reverse += array[i];  
            }  
            return reverse;  
        } 
    

    和StringBuffer()一样,都用了Java自实现的方法,使用位移来实现

    /** 
         * 和StringBuffer()一样,都用了Java自实现的方法,使用位移来实现 
         * @param s 
         * @return 
         */  
        public static String reverse4(String s) {  
            return new StringBuilder(s).reverse().toString();  
        } 
    

    和StringBuilder()一样,都用了Java自实现的方法,使用位移来实现

    /** 
         * 和StringBuilder()一样,都用了Java自实现的方法,使用位移来实现 
         * @param s 
         * @return 
         */  
        public static String reverse5(String s) {  
            return new StringBuffer(s).reverse().toString();  
        }  
    

    二分交换,将后面的字符和前面对应的那个字符交换

    /** 
         * 二分交换,将后面的字符和前面对应的那个字符交换 
         * @param s 
         * @return 
         */  
        public static String reverse6(String s) {  
            char[] array = s.toCharArray();  
            int end = s.length() - 1;  
            int halfLength = end / 2;  
            for (int i = 0; i <= halfLength; i++) {  
                char temp = array[i];  
                array[i] = array[end-i];  
                array[end-i] = temp;  
            }  
              
            return new String(array);  
        }  
    

    原理是使用异或交换字符串

    /** 
         * 原理是使用异或交换字符串 
         * a=a^b;  
         * b=b^a;  
             * a=b^a; 
         *  
         * @param s 
         * @return 
         */  
        public static String reverse7(String s) {  
            char[] array = s.toCharArray();  
                
              int begin = 0;  
              int end = s.length() - 1;  
                
              while (begin < end) {  
                   array[begin] = (char) (array[begin] ^ array[end]);  
                   array[end] = (char) (array[end] ^ array[begin]);  
                   array[begin] = (char) (array[end] ^ array[begin]);  
                   begin++;  
                   end--;  
              }  
                
              return new String(array);  
        }  
    

    基于栈先进后出的原理

    /** 
         * 基于栈先进后出的原理 
         *  
         * @param s 
         * @return 
         */  
        public static String reverse8(String s) {  
            char[] array = s.toCharArray();  
            Stack<Character> stack = new Stack<Character>();  
            for (int i = 0; i < array.length; i++)  
                stack.push(array[i]);  
      
            String reverse = "";  
            for (int i = 0; i < array.length; i++)  
                reverse += stack.pop();  
                
            return reverse;  
        }  
    

    整体

    import java.util.Stack;  
      
    /** 
     * 8 种字符串反转的方法, 其实可以是9种方法,第9种是使用StringBuffer和StringBuilder中实现的方法 
     * @author Josh Wang(Sheng) 
     *  
     * @email  swang6@ebay.com 
     *  
     */  
    public class StringReverse {  
      
        /** 
         * 二分递归地将后面的字符和前面的字符连接起来。 
         *  
         * @param s 
         * @return 
         */  
        public static String reverse1(String s) {  
            int length = s.length();  
            if (length <= 1)  
                return s;  
            String left = s.substring(0, length / 2);  
            String right = s.substring(length / 2, length);  
            return reverse1(right) + reverse1(left);  
        }  
          
        /** 
         * 取得当前字符并和之前的字符append起来 
         * @param s 
         * @return 
         */  
        public static String reverse2(String s) {  
            int length = s.length();  
            String reverse = "";  
            for (int i=0; i<length; i++)  
                reverse = s.charAt(i) + reverse;  
            return reverse;  
        }  
          
        /** 
         * 将字符从后往前的append起来 
         * @param s 
         * @return 
         */  
        public static String reverse3(String s) {  
            char[] array = s.toCharArray();  
            String reverse = "";  
            for (int i = array.length - 1; i >= 0; i--) {  
                reverse += array[i];  
            }  
            return reverse;  
        }  
          
        /** 
         * 和StringBuffer()一样,都用了Java自实现的方法,使用位移来实现 
         * @param s 
         * @return 
         */  
        public static String reverse4(String s) {  
            return new StringBuilder(s).reverse().toString();  
        }  
          
        /** 
         * 和StringBuilder()一样,都用了Java自实现的方法,使用位移来实现 
         * @param s 
         * @return 
         */  
        public static String reverse5(String s) {  
            return new StringBuffer(s).reverse().toString();  
        }  
          
        /** 
         * 二分交换,将后面的字符和前面对应的那个字符交换 
         * @param s 
         * @return 
         */  
        public static String reverse6(String s) {  
            char[] array = s.toCharArray();  
            int end = s.length() - 1;  
            int halfLength = end / 2;  
            for (int i = 0; i <= halfLength; i++) {  
                char temp = array[i];  
                array[i] = array[end-i];  
                array[end-i] = temp;  
            }  
              
            return new String(array);  
        }  
          
        /** 
         * 原理是使用异或交换字符串 
         * a=a^b;  
         * b=b^a;  
             * a=b^a; 
         *  
         * @param s 
         * @return 
         */  
        public static String reverse7(String s) {  
            char[] array = s.toCharArray();  
                
              int begin = 0;  
              int end = s.length() - 1;  
                
              while (begin < end) {  
                   array[begin] = (char) (array[begin] ^ array[end]);  
                   array[end] = (char) (array[end] ^ array[begin]);  
                   array[begin] = (char) (array[end] ^ array[begin]);  
                   begin++;  
                   end--;  
              }  
                
              return new String(array);  
        }  
          
        /** 
         * 基于栈先进后出的原理 
         *  
         * @param s 
         * @return 
         */  
        public static String reverse8(String s) {  
            char[] array = s.toCharArray();  
            Stack<Character> stack = new Stack<Character>();  
            for (int i = 0; i < array.length; i++)  
                stack.push(array[i]);  
      
            String reverse = "";  
            for (int i = 0; i < array.length; i++)  
                reverse += stack.pop();  
                
            return reverse;  
        }  
          
        public static void main(String[] args) {  
            System.out.println(reverse1("Wang Sheng"));  
            System.out.println(reverse2("Wang Sheng"));  
            System.out.println(reverse3("Wang Sheng"));  
            System.out.println(reverse4("Wang Sheng"));  
            System.out.println(reverse5("Wang Sheng"));  
            System.out.println(reverse6("Wang Sheng"));  
            System.out.println(reverse7("Wang Sheng"));  
            System.out.println(reverse8("Wang Sheng"));  
        }  
    }  
    
    展开全文
  • 使用 StringBuilder 或者 stringBuffer 的 reverse() 方法。 示例代码: // StringBuffer reverse StringBuffer stringBuffer = new StringBuffer(); stringBuffer. append("abcdefg"); System....
  • 使用 StringBuilder 或者 stringBuffer 的 reverse() 方法。 示例代码: // StringBuffer reverse StringBuffer stringBuffer = new StringBuffer(); stringBuffer.append("abcdefg...
  • 使用 StringBuilder 或者 stringBuffer 的 reverse() 方法。 示例代码: // StringBuffer reverse StringBuffer stringBuffer = new StringBuffer(); stringBuffer.append("abcdefg");...System.out.println...
  • 第一种方式:StringBuilder的reverse方法 StringBuilder str = new ...第二种方式:使用数组char[]从尾部开始读取字符拼接 String str = "abcd"; char [] chars = str.toCharArray(); String result =

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 208
精华内容 83
关键字:

如何将字符串反转?