一些常见的字符串和数组的题

1.字符串转化（压缩）“aaabbccd"->“a3b2c2d1”
分析：从0号下标开始查起，统计连续字符的个数，比较当前字符和前一个字符，若当前字符和前一个字符相等，个数清零，count++,然后将字符和count进行拼接即可。

import java.util.Scanner;
public class Compress {

    public static String stringCompress(String str){
        StringBuilder S=new StringBuilder();
        char n1=str.charAt(0);  //索引从0开始
        int count=1;    //连续的个数统计
        for(int i=1;i<str.length();i++){  //从一号开始遍历
            char n2= str.charAt(i);
            if(n1==n2) {
                count++;
                continue;
            }
           S.append(n1).append(count);   //拼接字符
            n1=n2;
            count=1;   //若当前字符和前一个字符相等，个数清零，到新的字符
            }

        return  S.append(n1).append(count).toString();  //最后大于长度的最后一个还要在拼接一次

    }
    public static void main(String[] args){
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入要压缩的字符串：");
        String str=scan.nextLine();
        stringCompress(str);
        System.out.println(stringCompress(str));
    }
}

2.统计字符串中数字个数
分析：从0号下边开始循环，若是数字则计数加1.

import java.util.Scanner;

public class Numeric {
    public static int isNumeric(String str) {
        int count=0;
        for(int i=0;i<str.length();i++){
            char n= str.charAt(i);
            if('1'<n&&n<'9'){
                count++;
                continue;
            }
        }

        return count;

    }
        public static void main(String[] args){
            Scanner scan=new Scanner(System.in);
            System.out.println("请输入要统计的字符串：");
            String str=scan.nextLine();
            System.out.println(isNumeric(str));
    }
}

3.数组逆置，即将i am a girl 逆置为：girl a am i.
方法一：分析，先定义一个交换字符的方法，然后在逆置函数中调用。首先引入toCharArray()方法，将字符串化为字符数组。
第一步：逆置整个数组
第二步：每个词由空格隔开，因此在整个数组逆置后再将每个词的各个单词逆置。

import java.util.Scanner;

public class Reverse {
    public static void Swap(char[] a,int b,int c){
        char t;  //引入中间变量
        for(;b<c;b++,c--){
            t=a[b];
            a[b]=a[c];
            a[c]=t;
        }
    }
    public static String reverseSentence(String str) {
        char[] c=str.toCharArray();    //将字符串转化为字符数组
        Swap(c,0,c.length-1);    //逆置整个数组
        int start=0;
        for(int i=1;i<c.length;i++){
            if(c[i]==' '){
                Swap(c,start,i-1);
                start=i+1;
            }
        }
        Swap(c,start,c.length-1);
        return String.valueOf(c);

        }

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入要逆置的字符串：");
        String str = scan.nextLine();
        System.out.println(reverseSentence(str));
    }
}

方法二：引入栈，栈是先进后出，因此可以先入栈然后出栈即可

import java.util.Scanner;
import java.util.Stack;

public class Reverse2 {

    public static String reverseSentence(String str) {
        String[] split = str.split(" ");  //通过空格分割
        int len = split.length;
        StringBuffer stringbuffer = new StringBuffer();
        Stack<String> stack = new Stack<>();  //创建栈对象
        for (int i = 0; i < len; i++) {
            stack.push(split[i]);  //入栈
        }
        for (int i = 0; i < len; i++) {
            String pop = stack.pop();  //出栈
            stringbuffer = stringbuffer.append(pop + " ");
        }
        String s = stringbuffer.toString();
        return s;
    }

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入要逆置的字符串：");
        String str = scan.nextLine();
        System.out.println(reverseSentence(str));
    }
}

4.将一个数组从左开始第几位之前进行旋转：左旋数组
分析：假设数组为abcdef 第二位之前
第一步：引入逆置函数，将字符串转化为字符数组，进行交换，然后再将字符数组转换成字符串返回。
第二步：在方法体内：先逆置旋转前面部分的字符串，结果为：bacdef
再逆置旋转后面部分的字符串,结果为：bafedc
最后逆置整体,结果为：cdefab

import java.util.Scanner;

public class Rotate {
    public static String reverse(String str,int first,int last) {
        char[] c = str.toCharArray();    //将字符串转化为字符数组
        char t;
        for (; first < last; first++, last--) {
            t = c[first];
            c[first] = c[last];
            c[last] = t;
        }
        return String.copyValueOf(c);   //将字符数组转换成字符串
    }
    public static String leftRotateString(String str,int n){
        if(str!=null&&n<str.length()) {
            int left1 = 0;
            int right1 = n - 1;
            int left2 = n;
            int right2 = str.length() - 1;
            str = reverse(str, left1, right1);//先逆置旋转前面部分的字符串
            str = reverse(str, left2, right2);//再逆置旋转后面部分的字符串
            str = reverse(str, left1, right2);  //最后逆置整体
        }
        return str;
    }

    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入要旋转的字符串：");
        String str=scan.nextLine();
        System.out.println(leftRotateString(str,2));
    }

}

5.实现把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素

import java.util.Scanner;

/*实现把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。

 */
public class Xuan {
    public static int order(int[] a,int left,int right ){   //顺序查找
        int min=a[left];
        for(int i=left+1;i<=right;i++){
            if(a[i]<a[left]){
                min=a[i];
            }
        }
        return min;
    }
    public static int minNumberRotate(int[] a){
        if(a.length==0){
            return -1;
        }
        int left=00;
        int right=a.length-1;
        int mid=left;
        while(a[left]>=a[right]){
            if(right-left==1){  //如果此时数组只剩下两个数值
                mid=right;    //最小的即为右边的值
                break;
            }
            mid=(left+right)/2;   //在数组的长度是两个以上的情况下
            if(a[left]==a[mid]&&a[left]==a[right]){
                return order(a,left,right);   //都相等，进行顺序查找
            }
            if(a[mid]>=a[left]){    //最小值在后半部分
                left=mid;
            }
            else if(a[mid]<=a[left]){
                right=mid;
            }
        }
        return a[mid];
    }

    public static void main(String[] args) {
        Xuan x=new Xuan();
        int[] a={3,6,9,1,2};
        System.out.println(x.minNumberRotate(a));
    }
}