和求a中有的字符而求b中没有的字符 如:a

解决方案 »

  1.   

    你可以先把两个字符串截开成一个一个的元素,当到一个两个Set中,通过比较两个Set中的元素,Set带了类似的方法,很简单也很方便的。
      

  2.   

    很简单嘛
    class Temp{
    public static void main(String args[]){
         String a = "abc";
                  String b = "ecf";
                  String output="";
                  outer:for(int i=0;i<a.length();i++){
                      for(int j=0;j<b.length();j++){
                 if(b.charAt(j)==a.charAt(i))
             break outer;
                      }
                      output+=a.charAt(i);
                  }
         System.out.print(output);
         System.exit(0);
    }
    }
      

  3.   

    问题是ab不是定长的,上面的程序只是用于a.leng= b.leng的情况!否则会出现空指针!
      

  4.   

    static void testString(){
    String a = "abcde";
    String b = "cefbgh";

    String allIn = "";
    String aOnly = "";
    String bOnly = "";

    for(int i=0;i<a.length();i++){
    if(b.indexOf(a.charAt(i))>=0){
    if(allIn.indexOf(a.charAt(i))<0){
    allIn += a.charAt(i);
    }
    }else{
    if(aOnly.indexOf(a.charAt(i))<0){
    aOnly += a.charAt(i);
    }
    }
    } for(int j=0;j<b.length();j++){
    if(allIn.indexOf(b.charAt(j))<0){
    if(bOnly.indexOf(b.charAt(j))<0){
    bOnly += b.charAt(j);
    }
    }
    }

    System.out.println("a特有的: " + aOnly);
    System.out.println("b特有的: " + bOnly);
    System.out.println("共有的: " + allIn);
    }
      

  5.   

    用正则表达式,这样比较快
     
      String aA[]={"a","b","c","d"};
            String bA[]={"a","d","f"};
            String patten="[";
            for(int i=0;i<bA.length;i++)
            {
              patten=patten+bA[i];
            }
            patten=patten+"]";        String tmpStr="";
            for(int i=0;i<aA.length;i++)
            {
              tmpStr=tmpStr+aA[i];
            }
            tmpStr=tmpStr.replaceAll(patten,"");
            System.err.println("tmpStr="+tmpStr);
      

  6.   

    楼上的使用正则表达式是个主意,但是由于需要转义特殊字符,所以反而麻烦了。
    还是使用传统的方法比较快。
    import java.util.Arrays;
    ......
            String a = "abcdefg";
            String b = "bdfhj";
            char[] achars = a.toCharArray();  //使用char比String快
            char[] bchars = b.toCharArray();
            Arrays.sort(achars);  // 排序,便于下面二分查找
            Arrays.sort(bchars);
            //使用StringBuffer避免产生大量String对象
            StringBuffer ab = new StringBuffer(); //ab共有
            StringBuffer ap = new StringBuffer(); //a独有
            StringBuffer bp = new StringBuffer(); //b独有
            for (int i = 0; i < achars.length; i++) {
                if (Arrays.binarySearch(bchars, achars[i]) < 0) { //二分查找
                    ap.append(achars[i]);
                } else {
                    ab.append(achars[i]);
                }
            }
            for (int i = 0; i < bchars.length; i++) {
                if (Arrays.binarySearch(achars, bchars[i]) < 0) {
                    bp.append(bchars[i]);
                }
            }
            System.out.println(ab);
            System.out.println(ap);
            System.out.println(bp);
      

  7.   

    空间换时间:public class Temp
    {
        public static void main(String[] args)
        {
            String a = "a,b,c";
            String b = "e,c,f";        System.out.println("not in a: " + check(a, b, ','));
            System.out.println("not in b: " + check(b, a, ','));
        }    public static String check(String a, String b, char ignore)
        {
            StringBuffer result = new StringBuffer();
            boolean[] flags = new boolean[Character.MAX_VALUE];
            flags[ignore] = true;
            int len1 = a.length();
            int len2 = b.length();        for (int i = 0; i < len1; i++)
                flags[a.charAt(i)] = true;        for (int i = 0; i < len2; i++)
            {
                char c = b.charAt(i);
                if (!flags[c])
                    result.append(c);
            }
            return result.toString();
        }
    }
      

  8.   

    楼上使用的空间未免太大了些吧! Character.MAX_VALUE = 65535
    90%以上的空间都未使用!
    而且,当一个数组过大,其下标操作速度也比较慢!
    所以,没有实用性!
      

  9.   

    楼上使用的空间未免太大了些吧! Character.MAX_VALUE = 65535
    90%以上的空间都未使用!
    而且,当一个数组过大,其下标操作速度也比较慢!
    所以,没有实用性!--------------------------------
    64K相对于现在机器的配置来说可以忽略不计。有什么证据能证明“当一个数组过大,其下标操作速度也比较慢”。我只知道flags[0]和flags[65535]的速度是一样的,就算是flags[65535 * 100],速度也不会有什么变化,对应到汇編的话还不都是一条语句。我这个方法好处在于:速度不会随字符串长度的增加而明显下降。
      

  10.   

    虽然64k可以忽略不计,但是如果该程序片断在一段时间内反复多次调用的话,由于gc的不确定性,在这里还是可能会出现内存不够的现象的。关于“当一个数组过大,其下标操作速度也比较慢”涉及到指针的定位,移动以及操作系统的内存管理等等多方面,不是一两句话能说清楚的就不详细解释了。关于字符串长度问题,理论上n可以无限大,但是实际上n过大之后会采取别的算法。(有兴趣你可以去研究一下文件比较工具使用的算法。)
    所以该算法只是对应n不是太大的情况。