Java程序员面试笔试宝典之字符串

import java.util.ArrayList;
import java.util.Arrays;

public class MyString {

    /**
     * 字符串反转
     * 问题描述：把一个句子中的单词进行反转，例如，"how are you"，进行反转后为"you are how"。
     */
    public String reverse(String s){
        if(s==null || s.length()<1){
            return "";
        }
        String [] strArr=s.split(" ");
        String result="";
        for(int i=strArr.length-1;i>=1;i--){
            result+=strArr[i]+" ";
        }
        result+=strArr[0];
        return result;
    }

    /**
     * 判断两个字符串是否由相同的字符组成
     * 问题描述：由相同的字符组成是指组成两个字符串的字母以及各个字母的个数是一样的，只是排序顺序不同而已。
     * 方法1：排序法。对两个字符串中的字符进行排序，比较两个排序后的字符串是否相等。如相等，则表明它们是由相同的字符组成的。
     *否者不是由相同字符组成。
     * 方法2：空间换时间。
     */
    public boolean compare1(String s1,String s2){
        byte [] b1=s1.getBytes();
        byte [] b2=s2.getBytes();
        Arrays.sort(b1);
        Arrays.sort(b2);
        s1=new String(b1);
        s2=new String(b2);
        if(s1.equals(s2)){
            return true;
        }else{
            return false;
        }
    }
    public boolean compare2(String s1,String s2){
        byte [] b1=s1.getBytes();
        byte [] b2=s2.getBytes();
        int [] bCount=new int[256];//ASCII编码共有256个(0~255)
        for(int i=0;i<b1.length;i++){
            bCount[i]=0;
        }
        for(int i=0;i<b1.length;i++){
            bCount[b1[i]-'0']++;
        }
        for(int i=0;i<b2.length;i++){
            bCount[b2[i]-'0']--;
        }
        for(int i=0;i<256;i++){
            if(bCount[i]!=0){
                return false;
            }
        }
        return true;        
    }

    /**
     * 删除字符串中重复的字符
     * 问题描述：删除字符中重复的字符，例如，"good"，去掉重复的字符后变为"god"
     */
    public String removeDuplicate(String s){
        if(s==null || s.length()<1){
            return "";
        }
        ArrayList<Character> list=new ArrayList<>();
        char [] chars=s.toCharArray();
        for(int i=0;i<chars.length;i++){
            if(!list.contains(chars[i])){
                list.add(chars[i]);
            }
        }
        String str="";
        for(int i=0;i<list.size();i++){
            str+=list.get(i);
        }
        return str;
    }

    /**
     * 如何统计一行字符中有多少个单词
     * 方法1：利用split(" ")函数
     * 方法2：统计空格数
     * 
     * 这里给出方法2的实现
     */
    public int wordCount(String s){
        int count=0;
        int word=0;//空格标志
        for(int i=0;i<s.length();i++){
            if(s.charAt(i)==' '){
                word=0;
            }else if(word==0){
                word=1;
                count++;
            }
        }
        return count;
    }

    /**
     * 如何输出字符串的所有组合
     * 问题描述：假设字符串中的所有字符都不重复，如何输出字符串的所有组合？例如，输入abc,则输出a,b,c,ab,ac,bc,abc，共7中组合。
     * 方法1：递归。遍历字符串，每个字符串只能取或不取，若取该字符，就把它放到结果字符串中，遍历完毕后，输出到结果字符串。
     * 方法2：构造一个长度为n的01字符串表示输出结果是否包含某个字符，例如，“001”表示输出结果中不含a,b，只含c。可以把题目转换为要求输出“001”到“111”这些组合对应的字符串。
     */
    public void combineRecursiveImpl1(String s){
        char [] c=s.toCharArray();
        StringBuffer sb=new StringBuffer("");
        int len=c.length;
        for(int i=1;i<len;i++){
            combineRecursive(c,0,i,sb);
        }
    }
    public void combineRecursive(char[] c,int begin,int len,StringBuffer sb){
        if(len==0){
            System.out.println(sb+" ");
            return ;
        }
        if(begin==c.length){
            return ;
        }
        sb.append(c[begin]);
        combineRecursive(c,begin+1,len-1,sb);
        sb.deleteCharAt(sb.length()-1);
        combineRecursive(c,begin+1,len,sb);
    }
    //
    public void combineRecursiveImpl2(String s){
        if(s==null || s.length()<1){
            return ;
        }
        char [] c=s.toCharArray();
        int n=c.length;
        boolean [] used=new boolean[n];
        char [] cache=new char[n];
        int result=n;
        while(true){
            int index=0;
            while(used[index]){
                used[index]=false;
                ++result;
                if(++index==n){
                    return ;
                }
            }
            used[index]=true;
            cache[--result]=c[index];
            System.out.println(new String(cache).substring(result)+" ");
        }
    }

}

本博客内容来自《Java程序员面试笔试宝典》