Tương đương với Java của C # String.Format () và String.Join ()

Tôi biết đây là một câu hỏi hơi thắc mắc của người mới, nhưng có tương đương với các hoạt động chuỗi của C # trong Java không?

Cụ thể, tôi đang nói về String.Formatvà String.Join.

Đối tượng Chuỗi Java có một formatphương thức (kể từ 1.5), nhưng không có joinphương thức nào .

Để có được một loạt các phương thức tiện ích chuỗi hữu ích chưa được bao gồm, bạn có thể sử dụng org.apache.commons.lang.StringUtils .

String.format . Đối với tham gia, bạn cần viết của riêng bạn:

 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();
 }

Ở trên đến từ http://snippets.dzone.com/posts/show/91

Ổi đi kèm với các Joinerlớp .

import com.google.common.base.Joiner;

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

Kể từ Java 8, join() hiện có sẵn dưới dạng hai phương thức lớp trên lớp String. Trong cả hai trường hợp, đối số đầu tiên là dấu phân cách.

Bạn có thể chuyển từng CharSequences làm đối số bổ sung :

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

Hoặc bạn có thể vượt quaIterable<? extends CharSequence> :

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 cũng thêm một lớp mới StringJoiner, bạn có thể sử dụng lớp này như sau:

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 có sẵn trên Android

Bạn cũng có thể sử dụng các đối số biến cho các chuỗi như sau:

  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();
  }

Đối với tham gia, tôi tin rằng điều này có thể trông ít phức tạp hơn một chút:

public String join (Collection<String> c) {
    StringBuilder sb=new StringBuilder();
    for(String s: c)
        sb.append(s);
    return sb.toString();
}

Tôi không thể sử dụng cú pháp Java 5 nhiều như tôi muốn (Tin hay không, tôi đang sử dụng 1.0.x gần đây) vì vậy tôi có thể hơi thiếu hiểu biết, nhưng tôi chắc chắn khái niệm này là đúng .

chỉnh sửa bổ sung: Phần bổ sung chuỗi có thể hơi chậm, nhưng nếu bạn đang làm việc trên mã GUI hoặc một số quy trình chạy ngắn, sẽ thực sự không thành vấn đề nếu bạn mất .005 giây hoặc .006, vì vậy nếu bạn có một bộ sưu tập có tên "joinMe" mà bạn muốn nối thêm vào một chuỗi hiện có "target" thì sẽ không kinh khủng nếu chỉ nội dòng thế này:

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

Nó khá kém hiệu quả (và là một thói quen xấu), nhưng không phải bất cứ thứ gì bạn có thể cảm nhận được trừ khi có hàng nghìn chuỗi hoặc điều này nằm trong một vòng lặp lớn hoặc mã của bạn thực sự quan trọng về hiệu suất.

Quan trọng hơn, nó dễ nhớ, ngắn gọn, nhanh chóng và rất dễ đọc. Hiệu suất không phải lúc nào cũng tự động chiến thắng trong các lựa chọn thiết kế.

Đây là một câu trả lời khá đơn giản. Sử dụng +=vì nó là mã ít hơn và để trình tối ưu hóa chuyển đổi nó thành a StringBuildercho bạn. Sử dụng phương pháp này, bạn không phải thực hiện bất kỳ kiểm tra "là cuối cùng" nào trong vòng lặp của mình (cải thiện hiệu suất) và bạn không phải lo lắng về việc loại bỏ bất kỳ dấu phân cách nào ở cuối.

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

Tôi không muốn nhập toàn bộ thư viện Apache để thêm một chức năng tham gia đơn giản, vì vậy đây là bản hack của tôi.

    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();
        }
    }

Nếu bạn muốn nối (nối) nhiều chuỗi thành một, bạn nên sử dụng StringBuilder. Nó tốt hơn nhiều so với việc sử dụng

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

Cũng có một chút hiệu suất thắng StringBuffer, vì StringBuilder không sử dụng đồng bộ hóa.

Đối với một phương thức tiện ích có mục đích chung như thế này, nó sẽ (cuối cùng) được gọi nhiều lần trong nhiều tình huống, vì vậy bạn nên làm cho nó hiệu quả và không phân bổ nhiều đối tượng tạm thời. Chúng tôi đã lập hồ sơ rất nhiều ứng dụng Java khác nhau và hầu như luôn nhận thấy rằng việc nối chuỗi và phân bổ chuỗi / char [] chiếm một lượng thời gian / bộ nhớ đáng kể.

Phương thức collection -> string có thể tái sử dụng của chúng tôi trước tiên sẽ tính toán kích thước của kết quả được yêu cầu và sau đó tạo một StringBuilder với kích thước ban đầu đó; điều này tránh nhân đôi / sao chép không cần thiết của char nội bộ [] được sử dụng khi nối các chuỗi.

Tôi đã viết riêng:

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();
}

nhưng Collectionkhông được hỗ trợ bởi JSP, vì vậy đối với chức năng thẻ, tôi đã viết:

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();
}

và đưa vào .tldtệp:

<?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>

và sử dụng nó trong các tệp JSP như:

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

StringUtils là một lớp khá hữu ích trong thư viện Apache Commons Lang.

Có MessageFormat.format()cái nào hoạt động giống như C # String.Format().

Tôi thấy rất nhiều triển khai quá phức tạp của String.Join ở đây. Nếu bạn không có Java 1.8 và bạn không muốn nhập thư viện mới, thì việc triển khai bên dưới là đủ.

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();
}

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

Vì vậy, về cơ bản, chuỗi ntop lưu trữ giá trị của toàn bộ tập hợp bằng dấu phẩy và dấu ngoặc.

Tôi sẽ chỉ sử dụng toán tử nối chuỗi "+" để nối hai chuỗi. s1 += s2;