给定一个字符串String str=“aAbebBssE”,自己实现以个算法，输出字符串为“AaBbbEess”

给定一个字符串String str=“aAbebBssE”,自己实现以个算法，输出字符串为“AaBbbEess”；
谁给个答案。。。。

20 个解决方案

#1

什么 规律啊 总要 说说 吧。。。

#2

对各个字符循环，比较，插入，
先不说算法效率好不好，单要实现不是很容易吗？

#3

package str;

public class StringUpDown {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String str="aAbebBssE";
		char[] strArray = null;
		for(int i=0;i<str.length();i++){
			strArray = str.toCharArray();
			strArray[i] = getReverseChar(strArray[i]);
			str = new String(strArray);
		}
		System.out.println(str);
	}

	private static char getReverseChar(char c) {
		if(Character.isLowerCase(c)){
			return Character.toUpperCase(c);
		}else{
			return Character.toLowerCase(c);
		}
	}
}

#4

哦，错了，以为是大小写转换。。

#5

貌似没学数据结构与算法？

#6

LZ的要求大概是，要进行字符串排序，首先是从a-z的排序，然后里面包含有大写在小写前面的排序。
这个从实现角度来说应该不难，但是关键是考虑效率问题吧。

#7

就是按ASCII码排序嘛

#8

就是排序啊。按照字母的顺序排序。并且大写的放前面！

#9

同LS。。。。

#10

我也知道是大的字母放前面。。就像上面说的应该是根据ASCII码排序。。
可，怎么把字母转成ASCII码啊？

#11

莫非这很难？
如果大于等于‘A’的，那么就减除32比较，如果此时等于了，那就比较实际值呗~~~~

#12

import java.util.*;

class bijiao 
{
	public static void main(String[] args) 
	{
		System.out.println(run("shkajyFskjhSDAKisjkSjkhsdHSAhjksASDhjklaa"));
	}

	public static StringBuffer run(String temp){
		char m[]=temp.toCharArray();
		Arrays.sort(m);		
		for(int y=0;y<m.length;y++){
			for(int z=0;z<m.length;z++){

				if (m[y]+32==m[z])
				{	
					while(m[y]==m[y+1]){
						y++;
					}
					char l=m[z];

						for(int w=z;w>y+1;w--){
							m[w]=m[w-1];
						}
						m[y+1]=l;
				}
			}
		}
		StringBuffer sb = new StringBuffer("");
		for(int x =0;x<m.length;x++){
			sb.append(m[x]);
		}
		return sb;
	}
}

---------- java run ----------
AAAaaaDDdFHhhhhhKkkkkkkSSSSsssssijjjjjjly

输出完成 (耗时 1 秒) - 正常终止

#13

package number;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class number {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String source = "hbaBACDEFGHIJKabcdefghijklmnopqrLMNOPQRSTYVWSYZstsyz";
		byte [] by = source.getBytes();
		ByteCompare [] bc = new ByteCompare[by.length];
		for(int i = 0 ; i< by.length ; i ++){
			bc[i] = new ByteCompare(by[i]);
		}
		Arrays.sort(bc,Collections.reverseOrder());

		System.out.println("by = " + Arrays.toString(bc));
	}

}

class ByteCompare implements Comparable {

	private byte a ;

	ByteCompare(byte a ){
		this.a = a; 
	}

	public byte getByte(){
		return this.a;
	}

	public int compareTo(Object o) {
		byte b = ((ByteCompare)o).getByte();
		int re = 0;
		if(a>96){  //a为小写
			if(b>96){  //b为小写
				re = a<b?1:(a==b?0:-1);
			}else{	   //b为大写
				re = (a-32)<b?1:-1;
			}
		}else{	//a为大写
			if(b>96){  //b为小写
				re = (a+32)<b?1:((a+32)==b?1:-1);
			}else{	   //b为大写
				re = a<b?1:(a==b?0:-1);
			}
		}
		return re;
	}

	public String toString(){
		return String.valueOf((char)a);
	}

}

引用thinking in java 中的一段话 “程序设计的基本目标是“将保持不变的事物与会发生改变的事物相分离”，而这里，不变的是通用的排序算法，变化的是各种对象相互比较的方式。因此，不是将进行比较的代码编写成为不同的子程序，而是使用回调技术（callback）。通过使用回调，可以将会发生变化的代码分离出来，然后由不会发生变化的代码回头调用会发生变化的代码。”

#14

引用 13 楼 zhaining522 的回复:

Java codepackage number;import java.util.Arrays;import java.util.Collections;import java.util.List;publicclass number {/**
     *@param args*/publicstaticvoid main(String[] args) {
        String source="hbaBACDEFGHIJKabcdefghijklmnopqrLMNOPQRSTYVWSYZstsyz";byte [] by= source.getBytes();
        ByteCompare [] bc=new ByteCompare[by.length];for(int i=0 ; i< by.length ; i++){
            bc[i]=new ByteCompare(by[i]);
        }
        Arrays.sort(bc,Collections.reverseOrder());
        
        System.out.println("by ="+ Arrays.toString(bc));
    }

}class ByteCompareimplements Comparable {privatebyte a ;
    
    ByteCompare(byte a ){this.a= a; 
    }publicbyte getByte(){returnthis.a;
    }publicint compareTo(Object o) {byte b= ((ByteCompare)o).getByte();int re=0;if(a>96){//a为小写if(b>96){//b为小写                re= a<b?1:(a==b?0:-1);
            }else{//b为大写                re= (a-32)<b?1:-1;
            }
        }else{//a为大写if(b>96){//b为小写                re= (a+32)<b?1:((a+32)==b?1:-1);
            }else{//b为大写                re= a<b?1:(a==b?0:-1);
            }
        }return re;
    }public String toString(){return String.valueOf((char)a);
    }
    
}

 引用thinking in java 中的一段话 “程序设计的基本目标是“将保持不变的事物与会发生改变的事物相分离”，而这里，不变的是通用的排序算法，变化的是各种对象相互比较的方式。因此，不是将进行比较的代码编写成为不同的子程序，而是使用回调技术（callback）。通过使用回调，可以将会发生变化的代码分离出来，然后由不会发生变化的代码回头调用会发生变化的代码。”

哥们说的对。顶一个。
这方式常用，并不代表有用，效率低

#15

集思广意

package str;

import java.util.Arrays;

public class StringOrder {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String str ="FDSAJFWEIQsdfjslakdweijdskajkerwqEWERQdsafjfdsa";
		char[] strArray = str.toCharArray();
		Arrays.sort(strArray);

		int index = 0;
		for (int i = 0; i < strArray.length; i++) {
			for (int k = 0; k < strArray.length - 1; k++) {
				char indexC = strArray[i];
				if (indexC == strArray[k + 1]) {
					index = k+1;
				}

			}
			char currentChar = strArray[i];
			for (int j = 0; j < strArray.length; j++) {
				if (strArray[j] - 32 == currentChar) {
					str = new String(strArray);
					String stra = str.substring(0, index + 1);
					String strb = str.substring(index + 1, j);
					String strc = str.substring(j, j + 1);
					String strd = str.substring(j + 1, strArray.length);
					str = stra + strc + strb + strd;
					strArray = str.toCharArray();
				}
			}
		}
		System.out.println(str);
	}
}

#16

对英文字母，char强转int就得到ASCII码了。

#17

  

string s="aAbebBssE";
            char[] ss=s.ToCharArray();

            Array.Sort(ss,new Comparer());
            MessageBox.Show(new String(ss));






class Comparer : IComparer<char> 
    {

    

        public int Compare(char x, char y)
        {
            return char.ToUpper(x).CompareTo(char.ToUpper(y));
        }


    }

#18

        public int Compare(char x, char y)
        {
            return char.ToUpper(x).CompareTo(char.ToUpper(y));
        }


--------------------->>>>>

        public int Compare(char x, char y)
        {
            int ret= char.ToUpper(x).CompareTo(char.ToUpper(y));
            if(ret==0)
            {
                ret= x.CompareTo(y);
            }
            return ret;
        }

#19

楼主，不好意思，我用到的是C#。。。。。但思想是一样的哈。。。

#20

import java.util.Arrays;
import java.util.Comparator;

class MyComparator implements Comparator {

	@Override
	public int compare(Object o1, Object o2) {
		if (o1 instanceof Character && o2 instanceof Character) {
			Character c1 = (Character) o1;
			Character c2 = (Character) o2;
			if (Character.toUpperCase(c1) == Character.toUpperCase(c2))
				return c1 - c2;
			return Character.toUpperCase(c1) - Character.toUpperCase(c2);
		}
		return 0;
	}

}

public class test {

	public static void main(String... args) {
		String str = "FDSAJFWEIQsdfjslakdweijdskajkerwqEWERQdsafjfdsa";
		char[] c1 = str.toCharArray();
		Character[] c = new Character[c1.length];
		for (int i = 0; i < c1.length; i++)
			c[i] = c1[i];
		Arrays.sort(c, new MyComparator());
		for (int i = 0; i < c1.length; i++)
			c1[i] = c[i];
		System.out.println(new String(c1));
	}
}

输出结果：
AaaaaDdddddEEEeeFFfffIiJjjjjkkklQQqRrSsssssWWww

#21

• 判断一个字符串是否是IP地址