Java字符串串联-有更好的方法吗？

Question

Just a quick form question. In the following code, is there a better way to concatinate the strings (ie can I just set tmpError equal to the new string rather than adding it?)

public void validate () throws Exception {
    String tmpError = "";
    if(paramA == null) tmpError = tmpError + "paramA was not set";

    if(paramB == null) tmpError = tmpError + "paramB was not set";

    if(paramC == null) tmpError = tmpError + "paramC was not set";


    if(!tmpError.equalsIgnoreCase("")){
        tmpError = "error occured" + tmpError;
        throw new Exception(tmpError);
    }
}

Thanks in advance

Answer 1

It can be easily improved in efficiency by using StringBuilder .

Due to the immutable nature of String , every time you use the addition ( + ) operator for String concatenation, a new String object is allocated (it also does when using String.concat() ).

StringBuilder keeps an internal character array, so that concatenation operations work on that array and only one String object is allocated when you call its toString() method. Use its append() method to append text to the end of the String, and use insert() with offset 0 to prepend text.

However, you should also take into account readability. Dasblinkenlight made a good point in his answer . And as Anthony has already pointed out, you could also use the += compound assignment operator to enhance readability.

public void validate () throws Exception {
    StringBuilder tmpError = new StringBuilder();
    if(paramA == null) tmpError.append("paramA was not set");

    if(paramB == null) tmpError.append("paramB was not set");

    if(paramC == null) tmpError.append("paramC was not set");


    if(tmpError.length() > 0){
        tmpError.insert(0,"error occured");
        throw new Exception(tmpError.getString());
    }
}

Answer 2

I would always advise the use of the StringBuilder

something like this:

public void validate() throws Exception {
    StringBuilder error = new StringBuilder();
    if(paramA == null)
        error.append("paramA was not set");

    if(paramB == null)
        error.append("paramB was not set");

    if(paramC == null)
        error.append("paramC was not set");


    if(error.length() > 0) {

        throw new Exception("error occured " + error.toString());
    }
}

Answer 3

您可以使用+= （添加/串联和赋值）运算符：

if(paramA == null) tmpError += "paramA was not set";

Answer 4

This is not efficient, because with all three params missing you will create four string objects. You would be better off appending to a single StringBuilder object.

However, this is error reporting code which gets executed only when your code detects a programming error. Efficiency does not matter much in situations like that, because they are not supposed to happen in the first place. Use whatever you believe to be easier to understand.

Answer 5

Do it like this:

public void validate () throws Exception {
    String tmpError = "";
    if(paramA == null) tmpError += "paramA was not set";

    if(paramB == null) tmpError += "paramB was not set";

    if(paramC == null) tmpError += "paramC was not set";


    if(!tmpError.equalsIgnoreCase("")){
        tmpError = "error occured" + tmpError;
        throw new Exception(tmpError);
    }
}

Or alternatively, you can use a StringBuilder as pointed out by Xavi, but to me that would only make sense, if you were appending text inside some sort of loop.

Answer 6

Fastest way to concatenation two strings is concat function of String class.

public void validate () throws Exception {
    String tmpError = "";

    if(paramA == null) tmpError = tmpError.concat("paramA was not set");
    if(paramB == null) tmpError = tmpError.concat("paramB was not set");
    if(paramC == null) tmpError = tmpError.concat("paramC was not set");
    if(!tmpError.equalsIgnoreCase("")){
        tmpError = "error occured".concat(tmpError);
        throw new Exception(tmpError);
    }
}

Answer 7

Rather than any of the above, you might want to use Guava Preconditions . Then you could write code like this:

import static com.google.common.base.Preconditions.*;
...
public void doSomething(String strA, String strB) {
  checkNotNull(strA, "strA is missing");
  checkArgument(strB.length() >= 6, "strB is too short");
  ...
}

If the check fails, then an Exception is thrown. It might not be quite as succinct as your original solution, but your intention is semantically obvious.

Answer 8

I would do something as below public void validate () throws Exception {

public void validate () throws Exception {
    String tmpError = "";
    if(paramA == null) tmpError += "paramA was not set";
    if(paramB == null) tmpError += "paramB was not set";
    if(paramC == null) tmpError += "paramC was not set";

    if(!(tmpError.trim()).equalsIgnoreCase("")){
        tmpError = "error occured" + tmpError;
        throw new Exception(tmpError);
    }
}

See I've used += and trimmed the tmpError variable before checking its empty.

I don't think here you don't need to worry much about StringBuilder as not much memory is being handled in this scenario.

If you are insisting on StringBuilder then you may do something as below

public void validate () throws Exception {
    StringBuilder sb = new StringBuilder();
    if(paramA == null) sb.append("paramA was not set");
    if(paramB == null) sb.append("paramB was not set");
    if(paramC == null) sb.append("paramC was not set");

    if(!(sb.toString().trim()).equalsIgnoreCase("")){
        sb.Insert(0,"error occured");
        throw new Exception(sp.toString());
    }
}