Java等价的C#String.Format()和String.Join()

Java equivalents of C# String.Format() and String.Join()

我知道这是一个新的问题,但是在Java中是否有等价于C的字符串操作呢?

具体来说,我说的是String.FormatString.Join


JavaString对象具有EDCOX1×0的方法(如1.5),但没有EDCOX1×1的方法。

要获得一组尚未包含的有用字符串实用程序方法,可以使用org.apache.commons.lang.stringutils。


格式。至于join,您需要编写自己的:

1
2
3
4
5
6
7
8
9
10
11
12
 static String join(Collection<?> s, String delimiter) {
     StringBuilder builder = new StringBuilder();
     Iterator<?> iter = s.iterator();
     while (iter.hasNext()) {
         builder.append(iter.next());
         if (!iter.hasNext()) {
           break;                  
         }
         builder.append(delimiter);
     }
     return builder.toString();
 }

以上内容来自http://snippets.dzone.com/posts/show/91


瓜瓦岛和Joiner班一起上。

1
2
3
import com.google.common.base.Joiner;

Joiner.on(separator).join(data);

在Java 8中,EDCOX1 OR 6 }现在可以作为字符串类上的两种类方法。在这两种情况下,第一个参数都是分隔符。

您可以将单个CharSequence作为附加参数传递:

1
2
String joined = String.join(",","Antimony","Arsenic","Aluminum","Selenium");
//"Antimony, Arsenic, Alumninum, Selenium"

或者你可以通过一个Iterable

1
2
3
4
5
6
7
8
List<String> strings = new LinkedList<String>();
strings.add("EX");
strings.add("TER");
strings.add("MIN");
strings.add("ATE");

String joined = String.join("-", strings);
//"EX-TER-MIN-ATE"

Java 8还添加了一个新类EDCOX1×9,您可以这样使用:

1
2
3
4
5
6
7
StringJoiner joiner = new StringJoiner("&");
joiner.add("x=9");
joiner.add("y=5667.7");
joiner.add("z=-33.0");

String joined = joiner.toString();
//"x=9&y=5667.7&z=-33.0"

textutils.join在Android上可用


还可以对字符串使用变量参数,如下所示:

1
2
3
4
5
6
7
8
9
  String join (String delim, String ... data) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < data.length; i++) {
      sb.append(data[i]);
      if (i >= data.length-1) {break;}
      sb.append(delim);
    }
    return sb.toString();
  }


这里有一个非常简单的答案。使用+=,因为它的代码更少,所以让优化器为您将其转换为StringBuilder。使用此方法,您不必在循环中执行任何"最后一次"检查(性能改进),也不必担心在结束时剥离任何分隔符。

1
2
3
4
5
        Iterator<String> iter = args.iterator();
        output += iter.hasNext() ? iter.next() :"";
        while (iter.hasNext()) {
            output +="," + iter.next();
        }


至于join,我认为这看起来可能不那么复杂:

1
2
3
4
5
6
public String join (Collection<String> c) {
    StringBuilder sb=new StringBuilder();
    for(String s: c)
        sb.append(s);
    return sb.toString();
}

我不太可能使用Java 5的语法(不管信不信由你,我最近一直使用1。x)所以我可能有点生疏,但我确信这个概念是正确的。

编辑添加:字符串附加可能很慢,但如果您正在处理GUI代码或一些短时间运行的例程,那么花费0.005秒或0.006并不重要,因此,如果您有一个名为"joinme"的集合,要附加到现有的字符串"target"中,那么只将其内联并不可怕:

1
2
for(String s : joinMe)
    target += s;

这是非常低效的(也是一个坏习惯),但是除非有数千个字符串,或者这是在一个巨大的循环中,或者您的代码确实是性能关键的,否则您将无法感知任何东西。

更重要的是,它很容易记住,简短,快速,可读性强。性能并不总是设计选择中的自动赢家。


我不想导入整个Apache库来添加一个简单的连接函数,所以这里是我的黑客。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
    public String join(String delim, List<String> destinations) {
        StringBuilder sb = new StringBuilder();
        int delimLength = delim.length();

        for (String s: destinations) {
            sb.append(s);
            sb.append(delim);
        }

        // we have appended the delimiter to the end
        // in the previous for-loop. Let's now remove it.
        if (sb.length() >= delimLength) {
            return sb.substring(0, sb.length() - delimLength);
        } else {
            return sb.toString();
        }
    }


如果要将多个字符串连接到一个字符串中,则应使用StringBuilder。比用好多了

1
2
for(String s : joinMe)
    target += s;

由于StringBuilder不使用同步,因此对StringBuffer的性能也略有优势。

对于这样的通用实用程序方法,在许多情况下(最终)会多次调用它,因此您应该使其高效,而不分配许多临时对象。我们已经描述了许多不同的Java应用程序,并且几乎总是发现字符串连接和字符串/ char []分配占用大量的时间/内存。

我们的reusable collection->string方法首先计算所需结果的大小,然后使用该初始大小创建一个StringBuilder;这避免了在附加字符串时使用的内部char[]的不必要的加倍/复制。


我自己写的:

1
2
3
4
5
6
7
8
9
10
11
public static String join(Collection<String> col, String delim) {
    StringBuilder sb = new StringBuilder();
    Iterator<String> iter = col.iterator();
    if (iter.hasNext())
        sb.append(iter.next().toString());
    while (iter.hasNext()) {
        sb.append(delim);
        sb.append(iter.next().toString());
    }
    return sb.toString();
}

但是jsp不支持Collection,所以对于tag函数我写了:

1
2
3
4
5
6
7
8
9
10
11
public static String join(List<?> list, String delim) {
    int len = list.size();
    if (len == 0)
        return"";
    StringBuilder sb = new StringBuilder(list.get(0).toString());
    for (int i = 1; i < len; i++) {
        sb.append(delim);
        sb.append(list.get(i).toString());
    }
    return sb.toString();
}

并提交.tld文件:

1
2
3
4
5
6
7
8
<?xml version="1.0" encoding="UTF-8"?>
<taglib version="2.1" xmlns="http://java.sun.com/xml/ns/javaee"
    <function>
        <name>join</name>
        <function-class>com.core.util.ReportUtil</function-class>
        <function-signature>java.lang.String join(java.util.List, java.lang.String)</function-signature>
    </function>
</taglib>

并在JSP文件中使用它,如下所示:

1
2
<%@taglib prefix="funnyFmt" uri="tag:com.core.util,2013:funnyFmt"%>
${funnyFmt:join(books,",")}


我看到很多过于复杂的字符串实现。请加入这里。如果没有Java 1.8,并且不想导入新的库,下面的实现就足够了。

1
2
3
4
5
6
7
8
public String join(Collection<String> col, String delim) {
    StringBuilder sb = new StringBuilder();
    for ( String s : col ) {
        if ( sb.length() != 0 ) sb.append(delim);
        sb.append(s);
    }
    return sb.toString();
}

在ApacheCommonsLang库中,StringUtils是一个非常有用的类。


有一个像c的String.Format()一样工作的MessageFormat.format()


1
2
3
4
5
ArrayList<Double> j=new ArrayList<>;
j.add(1);
j.add(.92);
j.add(3);
String ntop=j.toString(); //ntop="[1, 0.92, 3]"

因此,基本上,字符串ntop使用逗号分隔符和括号存储整个集合的值。


我只需要使用字符串连接操作符"+"来连接两个字符串。s1 += s2;