如何简化java中的字符串连接?

Question

给定以下代码:

private static final String DELIMITER = " ";
@AfterMapping
protected void createCompactInfo(@MappingTarget User user) {
String vorname = Optional.ofNullable(user.getVorname()).orElse(Strings.EMPTY);
String nachname = Optional.ofNullable(user.getNachname()).orElse(Strings.EMPTY);
String email = Optional.ofNullable(user.getEmail()).orElse(Strings.EMPTY);
String compactInfo =
(vorname
+ DELIMITER
+ nachname
+ DELIMITER
+ (email.isEmpty() ? Strings.EMPTY : "(" + email + ")"))
.trim();
if (compactInfo.isEmpty()) {
user.setCompakt(
Optional.ofNullable(user.getId()).orElse(Strings.EMPTY));
} else {
user.setCompakt(compactInfo);
}

我正在团队中尝试和讨论最简单的代码看起来像什么，而一个人也可以使用这样的结构:

• org.apache.commons.lang3.StringUtils: defaultString ()
• MoreObjects.firstNonNull (user.getVorname (), Strings.EMPTY)

一个可能的测试可能是这样的(预期的结果也在这里可见):

private static Stream<Arguments> arguments() {
return Stream.of(
Arguments.of("Peter", "Silie", "[e-mail]", "BOND", "Peter Silie ([e-mail])"),
Arguments.of(null, "Silie", "[e-mail]", "BOND", "Silie ([e-mail])"),
Arguments.of("Peter", null, "[e-mail]", "BOND", "Peter ([e-mail])"),
Arguments.of("Peter", "Silie", null, "BOND", "Peter Silie"),
Arguments.of(null, "Silie", null, "BOND", "Silie"),
Arguments.of(null, null, "[e-mail]", "BOND", "([e-mail])"),
Arguments.of("Peter", null, null, "BOND", "Peter"),
Arguments.of(null, null, null, "BOND", "BOND"));
}
@ParameterizedTest(
name = "{index}" + ". Test: vorname={0}, nachname={1}, email={2}; expected: {3}")
@MethodSource(value = "arguments")
void verifyUserKompakt(
String vorname, String nachname, String email, String kuerzel, String expectedResult) {
// arrange
Base base =
Base.builder()
.vorname(vorname)
.nachname(nachname)
.email(email)
.kuerzel(kuerzel)
.build();
// act
User userResult =
userMapperImpl.doIt(base);
// assert
assertThat(userResult.getUserKompakt()).isEqualTo(expectedResult);
}

欢迎任何想法…我能试什么呢?

BTW: java 17是允许的:-)

下面的代码看起来很接近，但是如果存在，则不处理email的大括号:

String compactInfo =
(Stream.of(
user.getVorname(),
user.getNachname(),
user.getEmail())
.map(s -> s != null ? s : "")
.collect(Collectors.joining(" ")))
.trim();
user.setUserKompakt(
compactInfo.isEmpty()
? Optional.ofNullable(user.getKuerzel()).orElse("")
: compactInfo);

Answer 1

既然你有重复的代码来转换vorname,nachname和userId，你可能想提取逻辑到一个函数或UnaryOperator，因为它是一个字符串到字符串的转换和一个额外的电子邮件。示例

import java.util.function.UnaryOperator;
....
private static final String EMPTY = "";
private static final String DELIMITER = " ";
UnaryOperator<String> nameOp = o -> Optional.ofNullable(o).orElse(EMPTY);
UnaryOperator<String> mailOp = o -> Optional.ofNullable(o).map(s -> String.format("(%s)", s)).orElse(EMPTY);
@AfterMapping
protected void createCompactInfo(@MappingTarget User user) {
String compactInfo = Stream.of(nameOp.apply(user.getVorname()),
nameOp.apply(user.getNachname()),
mailOp.apply(user.getEmail()))
.filter(Predicate.not(String::isEmpty))
.collect(Collectors.joining(DELIMITER));
user.setCompakt(compactInfo.isEmpty() ? nameOp.apply(user.getId()) : compactInfo);
}

Answer 2

Java普通连接和StringBuilder/StringBuffer之间存在巨大的性能差异。

观察你的方法createCompactInfo当你正在做字符串连接:compactInfo =…会导致性能不佳。

我建议你试试StringBuilder或StringBuffer。

String是一个不可变的对象，这意味着它的值不能被改变，所以每次你做一个连接strA + strB将会产生一个新的object。

与StringBuilder比较普通连接的性能结果:

public class ConcatenateString {
public static void main (String[] args){
String strFinal = "";
long tStart = System.currentTimeMillis();
for(int i = 0; i < 100000; i ++){
strFinal += "a";
}
long tEnd = System.currentTimeMillis();
long tResult = tEnd - tStart;
System.out.println("Runtime with operator + = "+tResult+" ms");

StringBuilder strBuilder = new StringBuilder();
tStart = System.currentTimeMillis();
for(int i = 0; i < 100000; i ++){
strBuilder.append("a");
}
tEnd = System.currentTimeMillis();
tResult = tEnd - tStart;
System.out.println("Runtime with StringBuilder= "+tResult+" ms");
}
}

result (at: Darwin mac - imac Darwin Kernel Version 20.6.0: Mon Aug 30 06:12:21 PDT 2021;RELEASE_X86_64 x86_64 - Intel I5处理器2.5ghz):

Runtime with operator + = 1469 ms
Runtime with StringBuilder= 2 ms