求个正则表达式

Question

需求： 比如很多地址都是  控江三村114号5室 ，长桥二村35号20室，天钥桥十二村15号802但是有的人可能 输入这样 地址：  控江3村114号5室 ，长桥2村35号20室，天钥桥12村15号802麻烦把 数字 转成 汉字 

Answer 1

源码已经写好, 已经测试过了. 由于有些问题没搞清楚, 所以代码写的有点散乱. 另外写了个专门的类, 本来是想做我的预定义类的, 不过完成的不是很好, 具体方法里已经说明了. 能力有限, 望海涵. 由于太累了, 所以方法内注释没有写.
import java.util.*;class YClass {
  /**这就是你要的方法了. 在这里, 我对正则有点疑惑了, 例如我使用message.split("\\D+")进行分割, 结果
    *得到的String数组的第一个值总为""(一个空字符串), 请各位指教.
    */
  public static String check(String message) {
    if(message.matches(".*\\d+村.*")) {
      String[] strArray = message.split("\\D+");
      System.out.println(Arrays.toString(strArray));
      String numString = null;
      for(int i = 0; i < strArray.length; i++) {
        boolean carryout = true;
        try {
          Integer.parseInt(strArray[i]);
        }
        catch(NumberFormatException ex) {
          carryout = false;
        }
        if(carryout && message.matches(".*" + strArray[i] + "村" + ".*")) {
          numString = strArray[i];
          break;
        }
      }
      System.out.println(numString);
      return message.replace(numString + "村", MNumber.getChinese(Integer.parseInt(numString)) + "村");
    }
    else
      return message;
  }
  
  //测试方法
  public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    
    while(true) {  
      String message = scan.next();
      System.out.println(check(message));
    }
  }
}public class MNumber {
  private static final char[] CHINESE_NUMBER = {'零', '一', '二', '三', '四', '五', '六', '七', '八', '九'};
  private static final char[] CHINESE_SCALE = {'十', '百', '千'};
  
  /**返回一个整数的位数*/
  public static int length(long number) {
    number = Math.abs(number);
    int length = 0;
    do {
      number /= 10;
      length++;
    }while(number > 0);
    return length;
  }
  
  /**将这个整数每个数位上的从左至右转化成数组, 如12345678转化为new int[]{1，2, 3, 4, 5, 6, 7，8}*/
  public static int[] toArray(long number) {
    number = Math.abs(number);
    int[] array = new int[length(number)];
    for(int i = array.length - 1; i >= 0; i--) {
      array[i] = (int)(number % 10);
      number /= 10;
    }
    return array;
  }
  
  /**将一个表示整数的字符串从左至右转化为数组, 如"1234"转化为new int[]{1,2,3,4}. 程序首先将字符串
    *转化为数值, 如果字符串不能成功转化为数值,将抛出NumberFormatException.详情参见Integer.parseInt.
    */
  public static int[] toArray(String number) {
    return toArray(Long.parseLong(number));
  }
  
  /**返回一个数值的中文表示, 如1234将返回字符串"一千二百三十四". 作者在写该方法时考虑欠妥, 没有充分
    *弄清阿拉伯数字的中文读法, 使得方法对于接收的数字相当有限. 目前基本测试完毕万亿以内(不包括)的数
    *字, 程序不能接收超过这些的数字.事实上, 由于方法参数为int型, 其只能接收约21亿以内的数字(本来参
    *型是long). 方法总体实现有些笨拙, 因为方法本来是为long型设计, 有些东西只能如此了.
    */
  public static String getChinese(int number) {
    int[] array = toArray(number);
    StringBuffer chinese = new StringBuffer();
    chinese.append(CHINESE_NUMBER[array[array.length - 1]]);
    for(int i = array.length - 2; i >= 0; i--) {
      char valueOfScale;
      int indexOfScale;
      if((indexOfScale = (array.length - 1 - i) % 4) == 0)
        valueOfScale = ((array.length - 1 - i) % 8 == 0)?'亿':'万';
      else
        valueOfScale = CHINESE_SCALE[indexOfScale - 1];
      chinese.append(valueOfScale);
      chinese.append(CHINESE_NUMBER[array[i]]);
    }
    //chinese.append('零');
    chinese.reverse();
    String s = chinese.toString();
    s = s.replaceAll("零十", "零");
    if(number % 100000000 != 0) {
      s = s.replaceAll("零万", "万");
    }
    else {
      s = s.replaceAll("零万", "零");
    }
    s = s.replaceAll("零千", "零");
    s = s.replaceAll("零百", "零");
    s = s.replaceAll("零亿", "亿");
    s = s.replaceAll("零{2,}", "零");
    s = s.replaceAll("(一十)", "A");
    chinese = new StringBuffer(s);
    int index;
    while((index = chinese.indexOf("A")) != -1) {
      if(index - 1 >= 0 && chinese.charAt(index - 1) == '零') {
        chinese.replace(index, index + 1, "一十");
      }
      else
        chinese.setCharAt(index, '十');
    }
    if(chinese.charAt(0) == '零') 
      chinese.deleteCharAt(0);
    if(chinese.charAt(chinese.length() - 1) == '亿' && number % 10000000 != 0)
      chinese.deleteCharAt(chinese.length() - 1);
    while(chinese.charAt(chinese.length() - 1) == '零') {
      chinese.deleteCharAt(chinese.length() - 1);
    }
    return chinese.toString();
  }
}

Answer 2

问题：村前面的洋马数字转换为汉字，如2村，变为二村，数字的位数为两位以内
思路：仿照编译器的原理，把符号提前，这里的符号是“村”，数字颠倒过来，多一位数字，一次加上单位“十”、“百”...最后再把字符串颠倒过来
程序：/*
 * 村前面的洋马数字转换为汉字，如12村，变为十二村，数字的位数为两位以内
 */
import java.util.regex.*;/**
 *
 * @author banalitylife
 */
public class Test {
    private static void replace(StringBuilder sb, int start, int end) {
        String toBeReplaced = sb.substring(start, end);
        StringBuilder newNum = new StringBuilder();
        char[] toBeReplacedCharArray = toBeReplaced.toCharArray();
        for(int i = 0; i < toBeReplacedCharArray.length; i++) {
            switch(i) {
                case 0:break;
                case 1:newNum.append("十");break;
                case 2:newNum.append("百");break;
                case 3:newNum.append("千");break;
                case 4:newNum.append("万");break;
                default:throw new RuntimeException(toBeReplaced + "超过了十万，输入可能有错");
            }
            switch(toBeReplacedCharArray[i]) {
                case '0':break;
                case '1':newNum.append("一");break;
                case '2':newNum.append("二");break;
                case '3':newNum.append("三");break;
                case '4':newNum.append("四");break;
                case '5':newNum.append("五");break;
                case '6':newNum.append("六");break;
                case '7':newNum.append("七");break;
                case '8':newNum.append("八");break;
                case '9':newNum.append("九");break;
            }
        }
        sb.replace(start, end, newNum.toString());
    }
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("天钥桥882912村15号802");
        sb = sb.reverse();
        Pattern p = Pattern.compile("村\\d+");
        Matcher m = p.matcher(sb);
        if(m.find()) {
            String group = m.group();
            int start = sb.indexOf(group);
            replace(sb, start+1, start + group.length());
        }
        System.out.println(sb.reverse());
    }
}
呵呵，比较粗糙的版本，lz自己再整理一下。

Answer 3

这个是挺烦的，我写了个简单的方法，楼主有兴趣的话就运行一下看看，这个能解决的关键就是XX村是确定的，否则的话就真不好解决了。
public static void main(String[] args) throws IOException {
String[] danwei=new String[]{"零","十","百","千","万","十万","百万","千万","亿","十亿","百亿","千亿"};
String[] shuzi=new String[]{"零","一","二","三","四","五","六","七","八","九",""};
Pattern p=Pattern.compile("(\\d+)村");
String s="控江一村114号5室";
Matcher m=p.matcher(s);
//通过正则提取村前面的数字
String ii="";
if(m.find()){
ii=m.group(1);
}
char[] cc=ii.toCharArray();
//ret存放把数字转化为大写的字符串
String ret="";
int l=cc.length;
for(int i=0;i<cc.length-1;i++){
int sz=cc[i]-'0';
if(i>0 && sz==0 && cc[i-1]-'0'==0) continue;
ret+=shuzi[sz];
if(sz!=0){
ret+=danwei[l-i-1];
}
}
if(l>0 && '0'!=cc[l-1]){
int sz=cc[l-1]-'0';
ret+=shuzi[sz];
}
//处理两位数时十位为1时的情况如11应读为十一，但上面的处理为读成一十一，把前面的一去掉
if(l==2 && cc[0]-'0'==1){
ret=ret.replaceFirst("一", "");
}
//把最后的一位零去了，如100，上面的处理会生成一百零
if(ret.endsWith("零"))
ret=ret.substring(0,ret.length()-1);
//最后的结果
ret=m.replaceFirst(ret+"村");
System.out.println(ret);
}

Answer 4

你需求我看得不是很明白，是否村之前的要用中文的，村后面的用阿拉伯数字呢？
如果是这样的话，正则表达式如何解决这个我是不懂了。java不是很简单吗，
把你那个地址按村或者你定义的字进行截取，然后分别使用10个replaceAll（），如：replaceAll("1","一")或replaceAll("一","1")。

Answer 5

1 无责任猜想村前数字小于100
2 只负责从数字转换成汉字
3 已测试通过import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class TestPattern {
public static void main(String[] args){

String s="控江3村114号5室 ，长桥2村35号20室，天钥桥12村15号802";
Pattern p=Pattern.compile("(\\d{1,2})(村)");
StringBuffer sbuf = new StringBuffer();
Matcher m= p.matcher(s);
while(m.find()){

m.appendReplacement(sbuf, EnToCn(m.group(1))+m.group(2));         
}
m.appendTail(sbuf);
System.out.println(sbuf);
}
public static String EnToCn(String s){
char[] en={'0','1','2','3','4','5','6','7','8','9'};
char[] cn={'零', '一', '二', '三', '四', '五', '六', '七', '八', '九'};
if(s.length()==2&&s.endsWith("0")){
int i=0;
for(;i<10;i++){
if(en[i]==s.charAt(0))
break;
}
return cn[i]+"十";
}
else if(s.length()==2){
int i=0;
for(;i<10;i++){
if(en[i]==s.charAt(0))
break;
}
int j=0;
for(;j<10;j++){
if(en[j]==s.charAt(1))
break;
}
return cn[i]+"十"+cn[j];

}
else if(s.length()==1){
int j=0;
for(;j<10;j++){
if(en[j]==s.charAt(0))
break;
}
return cn[j]+"";

}
return "error";
}
}

Answer 6

1 会替换掉所有的x村或XX村
2 11我这里会读成一十一,楼主自己改一下吧

Answer 7

/**
需求： 比如很多地址都是 控江三村114号5室 ，长桥二村35号20室，天钥桥十二村15号802但是有的人可能 输入这样 地址： 控江3村114号5室 ，长桥2村35号20室，天钥桥12村15号802麻烦把 数字 转成 汉字 
*//*
*@author ricky
*@date 2010-12-24
*/import java.util.regex.Matcher;
import java.util.regex.Pattern;public class Test{
public static void main(String[] args){
String address = "控江60400村114号5室";
String change = getResult(address);
System.out.println(change);
} private static String getResult(String address){
String regex = "(\\d+)村";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(address);
String num = null;
if(matcher.find()){
num = matcher.group(1);
}else{
throw new IllegalArgumentException("不符合要求");
}
String change = change(num);

address = address.replaceFirst(num,change);
return address;
} private static String change(String number){
//这里只判断万以内的数字
int num = Integer.parseInt(number);
//String[] nums = new String[]{
// "零","一","二","三","四","五","六","七","八","九"
//};
String[] signs = new String[]{
"十","百","千","万"
}; if(num > 99999){
throw new IllegalArgumentException("数字太大,无法继续!");
} StringBuffer sb = new StringBuffer(number);
sb = sb.reverse();
number = sb.toString(); String regex = "(.*?\\d)(\\d.*)"; Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(number); while(matcher.find()){
number = matcher.group(1) + "," + matcher.group(2);
matcher = pattern.matcher(number);
} int index = 0; while(number.indexOf(",") > 0){
number = number.replaceFirst(",",signs[index ++]);
} sb = new StringBuffer(number);
sb = sb.reverse();
number = sb.toString(); //下面需要排除几种可能
//1.刚好是整十或者整百、整千、整万的
number = number.replaceAll("0.","0");
//2.连续两个零的情况
while(number.indexOf("00") > 0){
number = number.replaceAll("00","0");
}
//3.结尾刚好为零
regex = "(.*)0$";
pattern = Pattern.compile(regex);
matcher = pattern.matcher(number); if(matcher.find()){
number = matcher.group(1);
} number = number.replaceAll("1","一");
number = number.replaceAll("2","二");
number = number.replaceAll("3","三");
number = number.replaceAll("4","四");
number = number.replaceAll("5","五");
number = number.replaceAll("6","六");
number = number.replaceAll("7","七");
number = number.replaceAll("8","八");
number = number.replaceAll("9","九");
number = number.replaceAll("0","零"); //下面需要排除几种可能
//1.刚好是整十或者整百、整千、整万的
return number;
}}