IT박스

java String.split ()의 효과를 되 돌리는 방법은 무엇입니까?

itboxs 2020. 7. 10. 08:10
반응형

java String.split ()의 효과를 되 돌리는 방법은 무엇입니까? [복제]


이 질문에는 이미 답변이 있습니다.

문자열 배열을 구분 된 문자열로 결합하는 방법을 찾고 있습니다. split ()과 반대입니다.

JDK에 모든 것이 있기 때문에 직접 작성하기 전에 포럼에 문의하고 싶었습니다


JDK에는 내가 알고있는 방법이 없습니다. Apache Commons Lang 에는 클래스 join()에서 원하는 오버로드 된 다양한 메소드가 StringUtils있습니다.


최소 2009 년 이후로 공개 기능 요청이있었습니다. 길고 짧은 것은 JDK 8의 java.util.StringJoiner 클래스의 기능 중 일부라는 것입니다. http://download.java.net/lambda/b81/docs/api/java/util/StringJoiner.html

관심있는 경우 Oracle 문제가 있습니다. http://bugs.sun.com/view_bug.do?bug_id=5015163

최신 정보

다음은 String 배열의 새로운 JDK 8 StringJoiner의 예입니다.

String[] a = new String[]{"first","second","third"};
StringJoiner sj = new StringJoiner(",");
for(String s:a) sj.add(s);
System.out.println(sj); //first,second,third

String의 유틸리티 메소드는 이것을 훨씬 간단하게 만듭니다.

String s = String.join(",", stringArray);

Arrays유틸리티 패키지 에서이 기능을 몰래 사용할 수 있습니다 .

import java.util.Arrays;
...
    String  delim = ":",
            csv_record = "Field0:Field1:Field2", 
            fields[] = csv_record.split(delim);

    String rebuilt_record = Arrays.toString(fields).replace(", ", delim).replaceAll("[\\[\\]]", "");

여기에 다음 예가 있습니다.

/*
7) Join Strings using separator >>>AB$#$CD$#$EF

 */

import org.apache.commons.lang.StringUtils;

public class StringUtilsTrial {
  public static void main(String[] args) {

    // Join all Strings in the Array into a Single String, separated by $#$
    System.out.println("7) Join Strings using separator >>>"
        + StringUtils.join(new String[] { "AB", "CD", "EF" }, "$#$"));
  }
}

Google은 또한 Google 컬렉션 라이브러리에서 조인 클래스를 제공합니다.

결합 자 API

Google 컬렉션


컬렉션과 함께 작동하는 롤백하려는 경우 DZone 스 니펫 에 몇 가지 예가 있습니다 . 예를 들면 다음과 같습니다.

public static String join(AbstractCollection<String> s, String delimiter) {
    if (s == null || s.isEmpty()) return "";
    Iterator<String> iter = s.iterator();
    StringBuilder builder = new StringBuilder(iter.next());
    while( iter.hasNext() )
    {
        builder.append(delimiter).append(iter.next());
    }
    return builder.toString();
}

int []가 있다면 Arrays.toString()가장 쉬운 방법입니다.


이전의 모든 답변을 기반으로 :

public static String join(Iterable<? extends Object> elements, CharSequence separator) 
{
    StringBuilder builder = new StringBuilder();

    if (elements != null)
    {
        Iterator<? extends Object> iter = elements.iterator();
        if(iter.hasNext())
        {
            builder.append( String.valueOf( iter.next() ) );
            while(iter.hasNext())
            {
                builder
                    .append( separator )
                    .append( String.valueOf( iter.next() ) );
            }
        }
    }

    return builder.toString();
}

Android의 경우 android.text.TextUtils 에 메소드가 있습니다.

public static String join (CharSequence delimiter, Iterable tokens)
public static String join (CharSequence delimiter, Object[] tokens)

구분 기호로 결합 된 토큰이 포함 된 문자열을 반환합니다.

tokens-결합 할 배열 객체. 문자열은 object.toString ()을 호출하여 객체에서 형성됩니다.


JDK8부터 Streams와 Lambdas를 많이 좋아하므로 다음과 같이 제안합니다.

public static String join( String delimiter, String[] array )
{
    return Arrays.asList( array ).stream().collect( Collectors.joining( delimiter ) );
}

이것도 나쁘지 않습니다.

public static String join(String delimitor,String ... subkeys) {
    String result = null;
    if(null!=subkeys && subkeys.length>0) {
        StringBuffer joinBuffer = new StringBuffer(subkeys[0]);
        for(int idx=1;idx<subkeys.length;idx++) {
            joinBuffer.append(delimitor).append(subkeys[idx]);
        }
        result = joinBuffer.toString();
    }
    return result;
}

나는 이것을 썼다 :

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());
    while (iter.hasNext()) {
        sb.append(delim);
        sb.append(iter.next());
    }
    return sb.toString();
}

Collection JSP에서 지원하지 않으므로 TLD에 대해 다음과 같이 썼습니다.

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파일에 넣으십시오 :

<?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 파일에서 다음과 같이 사용하십시오.

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

For the sake of completeness, I'd like to add that you cannot reverse String#split in general, as it accepts a regular expression.

"hello__world".split("_+"); Yields ["hello", "world"].
"hello_world".split("_+"); Yields ["hello", "world"].

These yield identical results from a different starting point. splitting is not a one-to-one operation, and is thus non-reversible.

This all being said, if you assume your parameter to be a fixed string, not regex, then you can certainly do this using one of the many posted answers.


Below code gives a basic idea. This is not best solution though.

public static String splitJoin(String sourceStr, String delim,boolean trim,boolean ignoreEmpty){
    return join(Arrays.asList(sourceStr.split(delim)), delim, ignoreEmpty);
}


public static String join(List<?> list, String delim, boolean ignoreEmpty) {
    int len = list.size();
    if (len == 0)
        return "";
    StringBuilder sb = new StringBuilder(list.get(0).toString());
    for (int i = 1; i < len; i++) {
        if (ignoreEmpty && !StringUtils.isBlank(list.get(i).toString())) {
            sb.append(delim);
            sb.append(list.get(i).toString().trim());
        }
    }
    return sb.toString();
}

If you use jdk8 see @Nathaniel Johnson's answer as that is better.

I think that many of the answer here are complex or not easily read. With branch prediction so efficient why you simply not use a if statement?

public static String join(List<String> fooList){

    if (fooList.isEmpty()) return "";

    StringBuilder sb = null;

    for (String element : fooList) {

        if (sb == null) {
            sb = new StringBuilder();
        } else {
            sb.append(", ");
        }

        sb.append(element);
    }
    return sb.toString();
}

Something that should be mentioned is that Apache uses a simple for loop with an if statement inside it like this (it uses an array as its index to know the first element), and openjdk 8 does the same but in separated methods calls instead of a simple loop.


I like this better:

public String join(Collection<String> strCollection, String delimiter) {
    String joined = "";
    int noOfItems = 0;
    for (String item : strCollection) {
        joined += item;
        if (++noOfItems < strCollection.size())
            joined += delimiter;
    }
    return joined;
}

It is the neatest solution I have found so far. (Don't worry about the use of raw String objects instead of StringBuilder. Modern Java compilers use StringBuilder anyway, but this code is more readable).

참고URL : https://stackoverflow.com/questions/794248/a-method-to-reverse-effect-of-java-string-split

반응형