精华内容
下载资源
问答
  • 字符串反转的两种方法: (1)将字符串倒着遍历,得到的每一个字符拼接成字符串 (2)将字符串转为字符数组,然后对字符数组进行反转,最后将字符数组转为字符串 来个示例: package cn.it_06; import java.util....

    字符串反转的两种方法:

    (1)将字符串倒着遍历,得到的每一个字符拼接成字符串
    (2)将字符串转为字符数组,然后对字符数组进行反转,最后将字符数组转为字符串

    来个示例:

    package cn.it_06;
    
    import java.util.Scanner;
    
    /*
     * 	字符串反转
     * 	举例:键盘录入"abc"
     * 		输出结果"cba"
     * 
     * 分析:
     * 		(1)键盘录入一个字符串
     * 		(2)写方法实现字符串反转
     * 				A:将字符串倒着遍历,得到的每一个字符拼接成字符串
     * 				B:将字符串转为字符数组,然后对字符数组进行反转,最后将字符数组转为字符串
     * 		(3)调用方法
     * 		(4)输出结果
     */
    public class StringTest2 {
    	public static void main(String[] args) {
    		//键盘录入一个字符串
    		Scanner sc=new Scanner(System.in);
    		System.out.println("请输入一个字符串:");
    		String s=sc.nextLine();
    		
    		//写方法实现字符串反转
    		
    		//调用方法
    		String result=reverse(s);
    		
    		//输出结果
    		System.out.println("result:"+result);
    		
    	}
    	
    	/*
    	 * 将字符串倒着遍历,得到的每一个字符拼接成字符串
    	 * 
    	 * 两个明确:
    	 * 		(1)返回值类型:String
    	 * 		(2)参数列表:String s
    	 */
    	/*
    	public static String reverse(String s) {
    		String ss="";
    		
    		for(int i=s.length()-1;i>=0;i--) {
    			ss+=s.charAt(i);
    		}
    		return ss;
    	}
    	*/
    	
    	/*
    	 * 将字符串转为字符数组,然后对字符数组进行反转,最后将字符数组转为字符串
    	 * 
    	 * 两个明确:
    	 * 		(1)返回值类型:String
    	 * 		(2)参数列表:String s
    	 * 
    	 */
    	public static String reverse(String s) {
    		char[] chs=s.toCharArray();
    		for(int start=0,end=chs.length-1;start<=end;start++,end--) {
    			char temp;
    			temp=chs[start];
    			chs[start]=chs[end];
    			chs[end]=temp;
    		}
    		String ss=new String(chs);
    		return ss;
    	}
    }
    
    

    结果:
    在这里插入图片描述

    展开全文
  • Java中经常会用到将字符串进行反转的时候,程序员孔乙己总结了7种反转方法,如下: //方法1 递归方法 public static String reverse1(String s) { int length = s.length(); if (length <= 1){ return...

    Java中经常会用到将字符串进行反转的时候,程序员孔乙己总结了7种反转方法,如下:

    //方法1 递归方法

     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);
     }

    //方法2 通过 charAt(int index)返回char值进行字符串拼接

     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;
     }

    //方法3 把字符串转换成字符数组倒叙拼接然后返回值

     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;
     }

    //方法4 调用StringBuffer中的reverse方法

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

    //方法5 把字符串转换成字符数组首位对调位置

     public static String reverse5(String orig) {
      char[] s = orig.toCharArray();
      int n = s.length - 1;
      int halfLength = n / 2;
      for (int i = 0; i <= halfLength; i++) {
       char temp = s[i];
       s[i] = s[n - i];
       s[n - i] = temp;
      }
      return new String(s);
     }

    //方法6

    public static String reverse6(String s) {
      char[] str = s.toCharArray(); 
      int begin = 0;
      int end = s.length() - 1;  
      while (begin < end) {
       str[begin] = (char) (str[begin] ^ str[end]);
       str[end] = (char) (str[begin] ^ str[end]);
       str[begin] = (char) (str[end] ^ str[begin]);
       begin++;
       end--;
      }
    return new String(str);
    }

    //方法7

    import java.util.Stack;
    public class StringReverse {    
     public static String reverse7(String s) {
      char[] str = s.toCharArray();
      Stack<Character> stack = new Stack<Character>();
      for (int i = 0; i < str.length; i++)
       stack.push(str[i]);
      
      String reversed = "";
      for (int i = 0; i < str.length; i++)
       reversed += stack.pop();
      return reversed;
     } 
    }

    转载于:https://www.cnblogs.com/lanseyitai1224/p/6955609.html

    展开全文
  • // 借助其他包含反转方法的类 public static String reverse3(String str) { if (str == null || str.length() ) { return str; } StringBuffer array = new StringBuffer(str) ; System.out.println(...

    package cglib;

    import java.util.Stack;

    public class Reverse {

        public static void main(String[] args) {
            // TODO Auto-generated method stub
            
            System.out.println("数组首位调换方法一输出:"+reverse1("傻瓜大傻瓜"));
            System.out.println("递归方法二输出:"+reverse2("123456"));
            System.out.println("StringBuffer方法三输出:"+reverse3("白痴大白痴"));
            System.out.println("栈方法四输出:"+reverse4("帅极了"));
            System.out.println("使用StringBuffer的append方法五输出:"+reverse5("大师哥"));
            System.out.println("StringBuffer使用StringBuffer的setCharAt方法六输出:"+reverse6("李易峰"));
        }

        // 方法一:直接使用数组首位调换,放到另外的数组中
        public static String reverse1(String str){
            if(str==null||str.length()<2){
                return str;
            }
            
            char[] arry=str.toCharArray();
            char[] reverseArray=new char[arry.length];
            for(int i=0;i<arry.length;i++){
                reverseArray[arry.length-i-1]=arry[i];
            }
            return new String(reverseArray);
            
            
        }
        // 巧妙使用递归的方式,把字符串的第一位挪到最后。配合
        //reverseString(s.substring(1))递归调用,每次都把字符串的第一位挪到最后。直到递归的参数只剩下一个字符为止。  
        
        public static String reverse2(String str) {
            //System.out.println(str);
            //System.out.println(str.substring(1));
            //System.out.println(str.charAt(0));
            if (str == null || str.length() <2) {  
                return str;  
            }  
            return reverse2(str.substring(1))+str.charAt(0);  
        }  
        // 借助其他包含反转方法的类  
        public static String reverse3(String str) {  
            if (str == null || str.length() <2) {  
                return str;  
            }  
            StringBuffer array = new StringBuffer(str) ;
            System.out.println("方法三:"+array);
            array=array.reverse();
            return array.toString();
        }
        
        public static String reverse4(String str) {  
            if (str == null || str.length() <2) {  
                return str;  
            }  
            String result="";
            char[] array=str.toCharArray();
            Stack<Character> stack = new Stack<>();
            
            for(char a:array){
                stack.push(a);
            }
            int length = stack.size(); //注意这个地方必须要先把length暂存起来,因为在遍历的过程中,pop()堆的时候,会改变堆的大小,//注意这个地方必须要先把length暂存起来,因为在遍历的过程中,pop()堆的时候,会改变堆的大小。stack.size()会变化,不能作为条件 。或者用str.length作为条件
            for(int i=0;i<length;i++){
                result+=stack.pop();
            }
            
            return result;  
        }  
        public static String reverse5(String str) {  
            if (str == null || str.length() <2) {  
                return str;  
            }  
            StringBuffer array = new StringBuffer(str.length()) ;
            //System.out.println("方法五:"+array);
            for(int i=str.length()-1;i>=0;i--){
                //System.out.println("i="+i);
                //System.out.println("str.charAt(i):"+str.charAt(i));
                array.append(str.charAt(i));
                //System.out.println("array:"+array);
            }
            
            return array.toString();
        }
        public static String reverse6(String str) {  
            if (str == null || str.length() <2) {  
                return str;  
            }  
            StringBuffer array = new StringBuffer(str) ;

            for (int i = 0; i < (str.length() / 2); i++) {  
                int swapIndex = str.length() - 1 - i;
                System.out.println("swapIndex:"+swapIndex);
                char swap = array.charAt(swapIndex);
                System.out.println("swap:"+swap);
                array.setCharAt(swapIndex, array.charAt(i));
                System.out.println("array:"+array);
                System.out.println("i:"+i);
                array.setCharAt(i, swap);
                System.out.println("array="+array);
            }  
            
            return array.toString();
        }
    }

    输出:

    数组首位调换方法一输出:瓜傻大瓜傻
    递归方法二输出:654321
    方法三:白痴大白痴
    StringBuffer方法三输出:痴白大痴白
    栈方法四输出:了极帅
    使用StringBuffer的append方法五输出:哥师大
    swapIndex:2
    swap:峰
    array:李易李
    i:0
    array=峰易李
    StringBuffer使用StringBuffer的setCharAt方法六输出:峰易李

     

    转载于:https://my.oschina.net/u/2822116/blog/780518

    展开全文
  • 一般的for循环字符串反转省略 Java: StringBuffer的reverse()方法 Collections.reverse()方法 public static void reverseStr(Char[] str) {//先把字符串转数组 List listStr = Arrays.asList(str); listStr...

    一般的for循环字符串反转省略

    Java:

    StringBuffer的reverse()方法




    Collections.reverse()方法

    public static void reverseStr(Char[] str) {//先把字符串转数组
    		List<Char> listStr = Arrays.asList(str);
    		listStr.forEach(System.out::println);//java8流的特性
    		Collections.reverse(listStr);
    		listStr.forEach(System.out::println);
    	}
    Python:

    列表reverse()方法,改变原列表,无返回值

    str = "123"
    listStr = list(str)#字符串转list
    listStr.reverse()
    print listStr #['3', '2', '1']
    列表逆序遍历,不改变原列表,返回逆序后的新列表

    str = "123"
    listStr = list(str)
    x = listStr[::-1]
    print x #['3', '2', '1']
    reversed()方法,返回迭代器,需要转为list改变原列表

    str = "123"
    listStr = list(str)
    print(list(reversed(listStr)))
    






    展开全文
  • 字符串反转-java实现

    2019-05-10 13:34:18
    将一个字符串反转 解决思路 这是一个常见的问题,在实际的开发中也经常用到,解决的方法有很多种。我使用下面四种方法进行,并且最后比较其中的效率。 利用系统自带的StringBuilder.reverse() 进行反转。 使用将...
  • java字符串反转方法【全】

    千次阅读 2016-08-07 17:39:44
    搜集的java字符串反转方法,一般用于面试,项目中用的很少··· package com.wsheng.aggregator.algorithm.string; import java.util.Stack; /** * 8 种字符串反转的方法, 其实可以是9种方法,第9种是使用...
  • import java.util.Stack; public class StringReverse { public static String reverse1(String s) { int length = s.length(); if (length <= 1) return s; String left = s.substring..
  • Java中的字符串反转方法

    万次阅读 2018-08-06 10:42:09
    ·首先介绍一下最简单的,利用Java种的StringBuffer来进行反转。 public class Test{ ... //字符串反转 String string = "hello world"; String reverse = new StringBuffer(string).reverse().t...
  • java.util.Stack; public class StringReverse {    public static String reverse1(String s) {  int length = s.length();  if (length 1)  return s;  String left = s.substring(0,
  • 字符串反转Java

    2019-04-27 17:02:02
    方法一:利用toCharArray方法,将字符串变为数组。 方法二:利用StringBuffer/StringBuilder的reverse方法
  • java.util.Stack; public class StringReverse {    public static String reverse1(String s) {  int length = s.length();  if (length 1)  return s;  
  • 主要介绍了JAVA字符串反转的三种方法,帮助大家更好的理解和学习Java,感兴趣的朋友可以了解下
  • 引用:... [代码] [Java]代码 view sourceprint?01 import java.util.Stack; 02 public class StringReverse { 03 04 public static String reverse1(String...
  • 描述:给我一个字符串,例如I love java,输出: java love I 方法一 [java] view plaincopy public class StringReverse {     public void swap(char[] arr, int...
  • 转载地址:... import java.util.Stack; public class StringReverse {  1. 思想是递归折半+拼接  public static String reverse1(String s) {  int length = s.length
  • 在开发的过程中遇到了要将字符串反转的问题,故整理出我所知道的几种反转字符串的方法

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 828
精华内容 331
关键字:

字符串反转方法java

java 订阅