求急！如何让字符串 "user_name_length" -> "userNameLength"

Question

如题！我不希望用for循环来一个一个的遍历哈！
最好是直接用一句正则表达式给实现

Answer 1

哥们，用for循环比你用正则快，... ...而且这个也不是正则可以完成的。

Answer 2

public class RegexTest {
public static void main(String[] args) {
String str="user_name_length";
String regex="_";
str=str.replaceAll(regex, "");
System.out.println(str); }}
测试结果：usernamelength

Answer 3

str=str.replaceAll(regex, "");
写这种过滤字符的，一般都用这个

Answer 4

replaceAll的第一个参数是一个正则，所以符合楼主的要求啊

Answer 5

用正则,还是要循环String str = "user_name_length";
StringBuffer s = new StringBuffer();
Matcher m = Pattern.compile("(?i)\\_([a-z])").matcher(str);
while (m.find())
m.appendReplacement(s, m.group(1).toUpperCase());
str = m.appendTail(s).toString();

Answer 6

/**
 * @param args
 */
public static void main(String[] args) { String str = "user_name_length";
String[] temp = str.split("_");
StringBuffer tmp = new StringBuffer(); for (int i = 0; i < temp.length; i++) { if (i == 0) {
tmp.append(temp[i]); }
{
tmp.append(firstLetterUpperCaset(temp[i])); }
} System.out.println(tmp); } public static String firstLetterUpperCaset(String str) {
char[] ch = str.toCharArray();
for (int i = 0; i < ch.length; i++) {
if (i == 0) {
ch[i] = (char) (ch[i] - 32);
}
}
return new String(ch);
}

Answer 7

/**
 * @(#)Regex.java  2008-3-25 上午01:12:55
 */
package cn.ialvin.util;import java.util.Iterator;
import java.util.Properties;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;/**
 * 正则表达式常用包装类
 * @author 林志斌(<b>ialvin.cn</b>) 广东 普宁 里湖
 */
public class Regex {
Pattern p;
private String reg = "";
private boolean GLOBAL = false;
private int mode = 0; /**
 * 构造一个 Regex 对象
 * @param reg 正则表达式
 * @param md 表达式的匹配模式
 */
public Regex(String reg, String md) {
if (reg != null)
this.reg = reg;
else
this.reg = "";
this.setMode(md);
} /**
 * 构造一个 Regex 对象
 * @param reg 正则表达式
 */
public Regex(String reg) { this(reg, null); } /**
 * 设置正则表达式的匹配模式
 * @param md 匹配模式
 */
private void setMode(String md) {
if (md == null) md = "";
md = md.toLowerCase();
if (md.indexOf("i") != -1) {
this.mode = (this.mode | Pattern.CASE_INSENSITIVE);
}
if (md.indexOf("g") != -1) {
this.GLOBAL = true;
}
if (md.indexOf("m") != -1) {
this.mode = this.mode | Pattern.MULTILINE;
}
if (md.indexOf("s") != -1) {
this.mode = this.mode | Pattern.DOTALL;
}
if (md.indexOf("c") != -1) {
this.mode = this.mode | Pattern.COMMENTS;
}
p = Pattern.compile(this.reg, this.mode);
} /**
 * 测试本正则表达式能否匹配 src 字符串
 * @param src 要测试的字符串对象
 * @return boolean value
 */
public boolean test(String src) {
return p.matcher(src).find();
} /**
 * 测试源字串能否被正则完全匹配
 * @param src 源字串
 * @return 匹配结果
 */
public boolean match(String src) {
return p.matcher(src).matches();
} /**
 * 使用本对象对 src 进行匹配替换为 to. 如:
 * <b><pre>
 * Regex regex = new Regex("\\d+", "ig");
 * String src = "abcde138ddef256asdf";
 * String res = regex.replace(src, "[Number]");
 * 结果: (true == res.equals("abcde[Number]ddef[Number]asdf"))
 * </pre></b>
 * @param src 源字符串内容
 * @param to 将匹配到字符串段替换的内容
 * @return String Object
 */
public String replace(String src, String to) {
if (src == null) return null;
if (to == null) to = "";
Matcher m = p.matcher(src);
if (this.GLOBAL)
return m.replaceAll(to);
return m.replaceFirst(to);
} /**
 * 相当于: <b>String result = (new Regex(reg, mode)).replace(src, to);</b>
 * @param reg 正则表达式
 * @param src 源字符串内容
 * @param to 将匹配到字符串段替换的内容
 * @param mode 正则表达式匹配模式
 * @return String Object
 */
public static String replace(String reg, String src, String to, String mode) {
if (src == null) return null;
if (reg == null) return src;
if (to == null) to = "";
Regex regex = new Regex(reg);
if (mode != null) regex.setMode(mode);
return regex.replace(src, to);
} /**
 * 相当于 Regex.replace(reg, src, to, "g");
 * @param reg 正则表达式
 * @param src 源字符串内容
 * @param to 将匹配到字符串段替换的内容
 * @return String Object
 */
public static String replace(String reg, String src, String to) {
return Regex.replace(reg, src, to, "g");
} /**
 * 例子: <b><pre>
 * String src = "xxxxxxx5Add6xxxx721add3xxxx";
 * Regex reg = new Regex("(\\d+)add(\\d+)", "ig");
 * String result = reg.replace(src, new Replacement() {
 *  public String getReplacement(Matcher m) {
 *  int i = Integer.parseInt(m.group(1)) + Integer.parseInt(m.group(2));
 *  return String.valueOf(i);
 *  }
 * });
 * result.equals("xxxxxxx11xxxx724xxxx")
 * </pre></b>
 * @param src 源字串
 * @param mp 取代内容处理器
 * @return 替换结果
 */
public String replace(String src, Replacement mp) {
StringBuffer sb = new StringBuffer();
Matcher m = this.p.matcher(src);
if (m.find()) {
m.appendReplacement(sb, Matcher.quoteReplacement(mp.getReplacement(m)));
}
if (this.GLOBAL) {
while(m.find()) {
m.appendReplacement(sb, Matcher.quoteReplacement(mp.doProcess(m)));
}
}
return m.appendTail(sb).toString();
}
}
package cn.ialvin.util;import java.util.regex.Matcher;public interface Replacement {
public String getReplacement(Matcher m);
}
上面是自己粗糙的包装有了之后,同样问题就可以简洁点处理
str = new Regex("\\_(.)", "ig").replace(str, new Replacement() {
public String getReplacement(Matcher m) {
return m.group(1).toUpperCase();
}
});

Answer 8

在贴一个，第一个没看清LZ的题
import java.util.regex.Matcher;
import java.util.regex.Pattern;public class RegexTest {
public static void main(String[] args) {
String str="user_name_length";
String regex="_\\w";
String s=null;
Matcher m=Pattern.compile(regex).matcher(str);
while(m.find()){
s=m.group();
str=str.replace(s,(s.charAt(1)+"").toUpperCase());
}

System.out.println(str); }}
测试结果：userNameLength

Answer 9

如果是 _user_name_length 或者是 __user__name__length 或者是 user_name_length_ 这样的呢？

Answer 10

你马虎了 少了一个else    现在的运行结果是userUserNameLength

Answer 11

csdn这种问题越来越多了，这都因人而宜啊，你感觉哪个方便就用哪个吧，没有太多讨论的意义

Answer 12

实际上应该有必须用循环来做的事情 因为你解析的时候必须需要那个首字母 而后面替换的值正则是获得不到的看样子你是想将表字段的命名方式换成对象命名的方式啊(也就是说"___"情况不需要考虑 除非意外..)replaceAll还是需要的 还是要用正则 当然 判断条件为过滤一个或多个"_" 全替换掉不行 得留点 我先写个样子 但是正则我不行 所以就是把大写字母那里搞好
package com.bluefish.hr.wage.input.bean;import java.util.HashSet;
import java.util.Set;public class Test {
private final static Set<String> replacestrings = new HashSet<String>();
static {
for (int i = 65; i < 91; i++) {
replacestrings.add("_" + (char) i);
}
} public static void main(String[] args) {
System.out.println(changeUseArray("user_name_length"));
System.out.println(changeUseSet("_user__name_length"));
} /** 如果说出现类似 user__name_length或者_user_name_length的字符串会出现问题 不过可以换另一种方法解析成数组 */
public final static String changeUseArray(String string) {
if (string == null || string.trim().equals("")
|| string.indexOf("_") == -1) {
return string;
} else {
String[] strings = string.trim().split("_");
for (int i = 1; i < strings.length; i++) {
String str = strings[i];
str = str.substring(0, 1).toUpperCase() + str.substring(1);
strings[i] = str;
}
StringBuffer stringbuffer = new StringBuffer(strings[0]);
for (int i = 1; i < strings.length; i++) {
stringbuffer.append(strings[i]);
}
return stringbuffer.toString();
}
} /** 还有一种就是写死的 这个比较容易 而且也能避免那些错误 而且最多替换26次(最糟糕的是必须得比较26次...) */
public final static String changeUseSet(String string) {
if (string == null || string.trim().equals("")
|| string.indexOf("_") == -1) {
return string;
} else {
if (string.indexOf("_") == 0) {
string = string.replaceFirst("_", "");
}
for (String repalceString : replacestrings) {
string = string.replace(repalceString.toLowerCase(),
repalceString.toUpperCase());
}
string = string.replace("_", "");
return string;
}
}
}如果说是过滤的字符串数量多的话我建议用第一个(前提是过滤的字符串比较短)
如果说是过滤单个字符串比较长 那必须用第二个
虽然没用正则 但小弟尽力了

Answer 13

要我做就split成数组，
然后从第2个开始，把第一个字母变成大写
最后一拼（过滤掉空的数组）
完事儿good luck

Answer 14

方法在上头我写了 但是有个坏处 至少分析成数组的时候不要用split 如果用了的话 出现与火龙果所说的一样的字符串的时候 就会出异常

Answer 15

有那么复杂么？ 用split函数就可以了！分开后在连接起来就可了