Java에서 문자열을 분할하는 방법

나는 문자열을 가지고 "004-034556"나는 두 개의 문자열로 분할 할 것을 :

string1="004";
string2="034556";

즉, 첫 번째 문자열에는 이전 문자가 포함 '-'되고 두 번째 문자열에는 이후 문자가 포함됩니다 '-'. 또한 문자열에 포함되어 있는지 확인하고 싶습니다 '-'. 그렇지 않다면 예외를 던질 것입니다. 어떻게해야합니까?

적절한 방법을 사용하십시오 : String#split().

String string = "004-034556";
String[] parts = string.split("-");
String part1 = parts[0]; // 004
String part2 = parts[1]; // 034556

정규 표현식 이 필요 하므로 필요한 경우 특수 문자 를 이스케이프 해야합니다.

이 백 슬래시 : 특별한 의미 12 개 문자는 \, 캐럿 ^, 달러 기호 $, 기간은 나 도트 ., 세로 막대 또는 파이프 기호 |, 물음표 ?, 별표 또는 스타 *, 더하기 기호 +, 여는 괄호 (, 닫는 괄호를 ), 및 여는 대괄호 [, 여는 중괄호이 {특수 문자를 종종 "메타 문자"라고합니다.

당신은 예를 들어 기간에 분할 싶다면, / 점 ."어떤 의미 모든 문자 정규식에서"이, 하나를 사용 백 슬래시를\ 개별 특수 그래서 같은 문자 탈출 split("\\."), 또는 사용 문자 클래스를[] 과 같이 리터럴 문자 (들)을 표현하기 위해 split("[.]"), 또는 사용 Pattern#quote()에 전체 문자열을 이스케이프 처리하십시오 split(Pattern.quote(".")).

String[] parts = string.split(Pattern.quote(".")); // Split on period.

문자열에 특정 문자가 포함되어 있는지 미리 테스트하려면을 사용하십시오 String#contains().

if (string.contains("-")) {
    // Split it.
} else {
    throw new IllegalArgumentException("String " + string + " does not contain -");
}

이것은 정규 표현식을 사용하지 않습니다. 이를 위해 String#matches()대신 사용하십시오.

결과 부분에 분할 문자를 유지하려면 긍정적 인 둘러보기를 사용 하십시오 . 분할 문자를 왼쪽으로 끝내 ?<=려면 패턴에서 접두사 그룹을 지정하여 긍정적 인 lookbehind를 사용 하십시오.

String string = "004-034556";
String[] parts = string.split("(?<=-)");
String part1 = parts[0]; // 004-
String part2 = parts[1]; // 034556

분할 문자를 오른쪽으로 끝내 ?=려면 패턴에 그룹 접두사를 지정하여 긍정적 인 미리보기를 사용 하십시오.

String string = "004-034556";
String[] parts = string.split("(?=-)");
String part1 = parts[0]; // 004
String part2 = parts[1]; // -034556

결과 부분의 수를 제한하려면 원하는 수를 split()방법의 두 번째 인수로 제공 할 수 있습니다 .

String string = "004-034556-42";
String[] parts = string.split("-", 2);
String part1 = parts[0]; // 004
String part2 = parts[1]; // 034556-42

문자열을 직접 처리하는 대안은 캡처 그룹과 함께 정규식을 사용하는 것입니다. 이것은 입력에 대한보다 복잡한 제약을 암시하는 것이 간단하다는 장점이 있습니다. 예를 들어, 다음은 문자열을 두 부분으로 나누고 둘 다 숫자로만 구성되도록합니다.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

class SplitExample
{
    private static Pattern twopart = Pattern.compile("(\\d+)-(\\d+)");

    public static void checkString(String s)
    {
        Matcher m = twopart.matcher(s);
        if (m.matches()) {
            System.out.println(s + " matches; first part is " + m.group(1) +
                               ", second part is " + m.group(2) + ".");
        } else {
            System.out.println(s + " does not match.");
        }
    }

    public static void main(String[] args) {
        checkString("123-4567");
        checkString("foo-bar");
        checkString("123-");
        checkString("-4567");
        checkString("123-4567-890");
    }
}

이 인스턴스에서 패턴이 고정되면 패턴을 미리 컴파일하여 정적 멤버 (예 : 클래스로드 시간에 초기화 됨)로 저장할 수 있습니다. 정규식은 다음과 같습니다.

(\d+)-(\d+)

괄호는 캡처 그룹을 나타냅니다. 정규 표현식의 해당 부분과 일치하는 문자열은 표시된대로 Match.group () 메서드로 액세스 할 수 있습니다. \ d는 10 진수와 일치하며, +는 "이전 식의 하나 이상 일치"를 의미합니다.-특별한 의미가 없으므로 입력에서 해당 문자와 ​​일치합니다. 백 슬래시를 두 번 이스케이프해야합니다. 이것을 Java 문자열로 쓸 때 다른 몇 가지 예 :

([A-Z]+)-([A-Z]+)          // Each part consists of only capital letters 
([^-]+)-([^-]+)            // Each part consists of characters other than -
([A-Z]{2})-(\d+)           // The first part is exactly two capital letters,
                           // the second consists of digits

String[] result = yourString.split("-");
if (result.length != 2) 
     throw new IllegalArgumentException("String not in correct format");

이렇게하면 줄이 두 부분으로 나뉩니다. 배열의 첫 번째 요소는의 앞에 물건 -을 포함하는 부분이되고 배열의 두 번째 요소는의 뒤에 문자열 부분을 포함합니다 -.

배열 길이가 2가 아닌 경우 문자열은 형식이 아닙니다 string-string.

수업 에서 split()방법을 확인하십시오 String.

https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#split-java.lang.String-int-

String[] out = string.split("-");

당신이 원하는 일을해야합니다. 문자열 클래스에는 문자열로 작동하는 많은 방법이 있습니다.

// This leaves the regexes issue out of question
// But we must remember that each character in the Delimiter String is treated
// like a single delimiter        

public static String[] SplitUsingTokenizer(String subject, String delimiters) {
   StringTokenizer strTkn = new StringTokenizer(subject, delimiters);
   ArrayList<String> arrLis = new ArrayList<String>(subject.length());

   while(strTkn.hasMoreTokens())
      arrLis.add(strTkn.nextToken());

   return arrLis.toArray(new String[0]);
}

자바 8 :

    List<String> stringList = Pattern.compile("-")
            .splitAsStream("004-034556")
            .collect(Collectors.toList());

    stringList.forEach(s -> System.out.println(s));

요구 사항은 해석의 여지가되었습니다. 방법을 쓰는 것이 좋습니다.

public final static String[] mySplit(final String s)

이 기능을 캡슐화합니다. 물론 구현에 대한 다른 답변에서 언급 한 것처럼 String.split (..)을 사용할 수 있습니다.

입력 문자열과 원하는 결과 및 동작에 대한 단위 테스트를 작성해야합니다.

좋은 시험 응시자는 다음을 포함해야합니다.

 - "0022-3333"
 - "-"
 - "5555-"
 - "-333"
 - "3344-"
 - "--"
 - ""
 - "553535"
 - "333-333-33"
 - "222--222"
 - "222--"
 - "--4555"

해당 테스트 결과를 정의하면 동작을 지정할 수 있습니다.

예를 들어, 반환 "-333"해야 [,333]하거나 오류 인 경우. "333-333-33"분리 할 수 있습니까 [333,333-33] or [333-333,33]아니면 오류입니까? 등등.

이것도 시도해 볼 수 있습니다

 String concatenated_String="hi^Hello";

 String split_string_array[]=concatenated_String.split("\\^");

가정하면

• 분할에 정규식이 필요하지 않습니다.
• 이미 앱에서 Apache Commons Lang을 사용하고 있습니다.

가장 쉬운 방법은 StringUtils # split (java.lang.String, char)를 사용하는 것 입니다. 정규 표현식이 필요하지 않은 경우 즉시 Java에서 제공하는 것보다 편리합니다. 매뉴얼이 말했듯이 다음과 같이 작동합니다.

A null input String returns null.

 StringUtils.split(null, *)         = null
 StringUtils.split("", *)           = []
 StringUtils.split("a.b.c", '.')    = ["a", "b", "c"]
 StringUtils.split("a..b.c", '.')   = ["a", "b", "c"]
 StringUtils.split("a:b:c", '.')    = ["a:b:c"]
 StringUtils.split("a b c", ' ')    = ["a", "b", "c"]

일반적으로 사용 가능한 많은 것들이 포함되어 있기 때문에 commong-lang을 사용하는 것이 좋습니다. 그러나 분할을 수행하는 것 외에 다른 것이 필요하지 않은 경우 자신을 구현하거나 정규 표현식을 탈출하는 것이 더 나은 옵션입니다.

분할하려는 문자 또는 문자열을 기준으로 문자열을 분할 할 수있는 org.apache.commons.lang.StringUtils의 split 메소드를 사용하십시오 .

메소드 서명 :

public static String[] split(String str, char separatorChar);

귀하의 경우 "-"가있을 때 문자열을 분할하려고합니다.

다음과 같이 간단하게 수행 할 수 있습니다.

String str = "004-034556";

String split[] = StringUtils.split(str,"-");

산출:

004
034556

-문자열에 존재하지 않으면 주어진 문자열을 반환하고 예외 는 발생 하지 않는다고 가정하십시오 .

요약 : Java에서 문자열을 분할하는 방법은 최소한 다섯 가지가 있습니다.

1. String.split () :

   String[] parts ="10,20".split(",");

2. Pattern.compile (regexp) .splitAsStream (input) :

   List<String> strings = Pattern.compile("\\|")
         .splitAsStream("010|020202")
         .collect(Collectors.toList());

3. StringTokenizer (레거시 클래스) :

   StringTokenizer strings = new StringTokenizer("Welcome to EXPLAINJAVA.COM!", ".");
   while(strings.hasMoreTokens()){
       String substring = strings.nextToken();
       System.out.println(substring);
   }

4. 구글 구아바 스플리터 :

   Iterable<String> result = Splitter.on(",").split("1,2,3,4");

5. Apache Commons StringUtils :

   String[] strings = StringUtils.split("1,2,3,4", ",");

따라서 반환 유형 (배열, 목록 또는 반복 가능)과 같이 필요한 항목에 따라 가장 적합한 옵션을 선택할 수 있습니다.

다음 은 이러한 방법과 가장 일반적인 예 (점, 슬래시, 물음표 등으로 나누는 방법)에 대한 큰 개요입니다.

가장 적은 리소스를 사용하는 가장 빠른 방법은 다음과 같습니다.

String s = "abc-def";
int p = s.indexOf('-');
if (p >= 0) {
    String left = s.substring(0, p);
    String right = s.substring(p + 1);
} else {
  // s does not contain '-'
}

정규식을 사용하여 여러 문자로 문자열 분할

public class StringSplitTest {
     public static void main(String args[]) {
        String s = " ;String; String; String; String, String; String;;String;String; String; String; ;String;String;String;String";
        //String[] strs = s.split("[,\\s\\;]");
        String[] strs = s.split("[,\\;]");
        System.out.println("Substrings length:"+strs.length);
        for (int i=0; i < strs.length; i++) {
            System.out.println("Str["+i+"]:"+strs[i]);
        }
     }
  }

산출:

Substrings length:17
Str[0]:
Str[1]:String
Str[2]: String
Str[3]: String
Str[4]: String
Str[5]: String
Str[6]: String
Str[7]:
Str[8]:String
Str[9]:String
Str[10]: String
Str[11]: String
Str[12]:
Str[13]:String
Str[14]:String
Str[15]:String
Str[16]:String

그러나 모든 JDK 버전에서 동일한 출력을 기대하지는 마십시오. 내가 본 한 버그 최초의 널 (null) 문자열이 무시되었습니다 일부 JDK 버전에 존재합니다. 이 버그는 최신 JDK 버전에는 없지만 JDK 1.7 최신 버전과 1.8 초기 버전의 일부 버전에 존재합니다.

간단한 유스 케이스의 경우 String.split()작업을 수행해야합니다. 구아바를 사용하는 경우 다른 문자열 작업을 연결하고 CharMatcher를 지원 하는 Splitter 클래스도 있습니다 .

Splitter.on('-')
       .trimResults()
       .omitEmptyStrings()
       .split(string);

public class SplitTest {

    public static String[] split(String text, String delimiter) {
        java.util.List<String> parts = new java.util.ArrayList<String>();

        text += delimiter;

        for (int i = text.indexOf(delimiter), j=0; i != -1;) {
            String temp = text.substring(j,i);
            if(temp.trim().length() != 0) {
                parts.add(temp);
            }
            j = i + delimiter.length();
            i = text.indexOf(delimiter,j);
        }

        return parts.toArray(new String[0]);
    }


    public static void main(String[] args) {
        String str = "004-034556";
        String delimiter = "-";
        String result[] = split(str, delimiter);
        for(String s:result)
            System.out.println(s);
    }
}

다음 명령문을 사용하여 줄 바꿈으로 문자열을 분할 할 수 있습니다.

String textStr[] = yourString.split("\\r?\\n");

다음 명령문을 사용하여 문자열을 하이픈 / 문자로 분할 할 수 있습니다.

String textStr[] = yourString.split("-");

import java.io.*;

public class BreakString {

  public static void main(String args[]) {

    String string = "004-034556-1234-2341";
    String[] parts = string.split("-");

    for(int i=0;i<parts.length;i++) ｛
      System.out.println(parts[i]);
    }
  }
}

Split ()을 사용할 수 있습니다 :

import java.io.*;

public class Splitting
{

    public static void main(String args[])
    {
        String Str = new String("004-034556");
        String[] SplittoArray = Str.split("-");
        String string1 = SplittoArray[0];
        String string2 = SplittoArray[1];
    }
}

그렇지 않으면 StringTokenizer를 사용할 수 있습니다.

import java.util.*;
public class Splitting
{
    public static void main(String[] args)
    {
        StringTokenizer Str = new StringTokenizer("004-034556");
        String string1 = Str.nextToken("-");
        String string2 = Str.nextToken("-");
    }
}

실제로 고려해야 할 두 가지 방법이 있습니다.

한 문자 구분 기호로 String.split을 사용하거나 성능에 신경 쓰지 마십시오.

성능이 문제가 아니거나 분리 문자가 정규 표현식 특수 문자가 아닌 단일 문자 (예 : 중 하나가 아닌 .$|()[{^?*+\) 인 경우을 사용할 수 있습니다 String.split.

String[] results = input.split(",");

분할 방법은 델리 미터가 단일 문자이고 위 목록에없는 경우 정규식을 사용하지 않도록 최적화되었습니다. 그렇지 않으면 정규식을 컴파일해야하며 이는 이상적이지 않습니다.

복잡한 구분 기호를 사용하고 성능에 관심이있는 경우 Pattern.split을 사용하고 패턴을 사전 컴파일하십시오.

성능이 문제이고 분리 문자가 위의 것이 아닌 경우 정규 표현식 패턴을 사전 컴파일 한 후 재사용 할 수 있습니다.

// Save this somewhere
Pattern pattern = Pattern.compile("[,;:]");

/// ... later
String[] results = pattern.split(input);

이 마지막 옵션은 여전히 ​​새 Matcher개체를 만듭니다 . 최대 성능을 위해이 객체를 캐시하고 각 입력에 대해 재설정 할 수도 있지만 다소 복잡하고 스레드로부터 안전하지 않습니다.

이를 수행하는 한 가지 방법은 for-each 루프에서 문자열을 실행하고 필요한 분할 문자를 사용하는 것입니다.

public class StringSplitTest {

    public static void main(String[] arg){
        String str = "004-034556";
        String split[] = str.split("-");
        System.out.println("The split parts of the String are");
        for(String s:split)
        System.out.println(s);
    }
}

산출:

The split parts of the String are:
004
034556

호환성을 위해 유지되는 레거시 클래스이므로 StringTokenizer 클래스를 사용하지 마십시오 . 새 코드에서는 사용하지 않는 것이 좋습니다. 그리고 우리는 다른 사람들이 제안한 split 방법을 사용할 수 있습니다.

String[] sampleTokens = "004-034556".split("-");
System.out.println(Arrays.toString(sampleTokens));

그리고 예상대로 인쇄됩니다.

[004, 034556]

이 답변 에서 Java 8의 메소드에 대해 한 가지 변경 사항split 을 지적하고 싶습니다 . 문자열 # 분할 () 메소드 차종은의 사용 Pattern.split, 지금은 결과 배열의 시작 부분에 빈 문자열을 제거합니다. Java 8에 대한 설명서 에서이 변경 사항을 확인하십시오 .

입력 시퀀스의 시작 부분에 양의 너비가 일치하면 결과 배열의 시작 부분에 빈 선행 부분 문자열이 포함됩니다. 그러나 처음에 너비가 0이면 일치하는 빈 선행 부분 문자열이 생성되지 않습니다.

다음 예제를 의미합니다.

String[] sampleTokensAgain = "004".split("");
System.out.println(Arrays.toString(sampleTokensAgain));

우리는 세 개의 문자열을 얻을 것이다 : [0, 0, 4]Java 7 이전과는 달리 네 개가 아니다. 이 비슷한 질문 도 확인하십시오 .

두 가지 방법으로 달성 할 수 있습니다.

WAY 1 : 특수 문자로 두 숫자를 나눌 때 정규식을 사용할 수 있습니다

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class TrialClass
{
    public static void main(String[] args)
    {
        Pattern p = Pattern.compile("[0-9]+");
        Matcher m = p.matcher("004-034556");

        while(m.find())
        {
            System.out.println(m.group());
        }
    }
}

WAY 2 : 문자열 분리 방법 사용

public class TrialClass
{
    public static void main(String[] args)
    {
        String temp = "004-034556";
        String [] arrString = temp.split("-");
        for(String splitString:arrString)
        {
            System.out.println(splitString);
        }
    }
}

구분자 유형이 있는지 여부에 관계없이 StringTokenizer를 사용하여 문자열을 둘 이상의 부분으로 분할 할 수 있습니다.

StringTokenizer st = new StringTokenizer("004-034556", "-");
while(st.hasMoreTokens())
{
    System.out.println(st.nextToken());
}

javadoc split()의 String클래스에서 메소드를 확인하십시오 .

https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#split(java.lang.String)

String data = "004-034556-1212-232-232";
int cnt = 1;
for (String item : data.split("-")) {
        System.out.println("string "+cnt+" = "+item);
        cnt++;
}

분할 문자열에 대한 많은 예제가 있지만 코드 최적화가 거의 없습니다.

String str="004-034556"
String[] sTemp=str.split("-");// '-' is a delimiter

string1=004 // sTemp[0];
string2=034556//sTemp[1];

Java 내장 함수를 사용하는 대신 알고리즘을 작성하고 싶었습니다.

public static List<String> split(String str, char c){
    List<String> list = new ArrayList<>();
    StringBuilder sb = new StringBuilder();

    for (int i = 0; i < str.length(); i++){
        if(str.charAt(i) != c){
            sb.append(str.charAt(i));
        }
        else{
            if(sb.length() > 0){
                list.add(sb.toString());
                sb = new StringBuilder();
            }
        }
    }

    if(sb.length() >0){
        list.add(sb.toString());
    }
    return list;
}

당신은 방법을 사용할 수 있습니다 split:

public class Demo {
    public static void main(String args[]) {
        String str = "004-034556";

        if ((str.contains("-"))) {
            String[] temp = str.split("-");
            for (String part:temp) {
                System.out.println(part);
            }
        }
        else {
            System.out.println(str + " does not contain \"-\".");
        }
    }
}

문자열을 분할하려면 String.split (regex)를 사용하십시오. 다음 예를 검토하십시오.

String data = "004-034556";
String[] output = data.split("-");
System.out.println(output[0]);
System.out.println(output[1]);

산출

004
034556

노트 :

이 분할 (정규식)은 정규식을 인수로 사용합니다. 마침표 / 점과 같은 정규 표현식 특수 문자를 피하십시오.

String s="004-034556";
for(int i=0;i<s.length();i++)
{
    if(s.charAt(i)=='-')
    {
        System.out.println(s.substring(0,i));
        System.out.println(s.substring(i+1));
    }
}

모두가 언급했듯이 split ()은 귀하의 경우에 사용될 수있는 최상의 옵션입니다. 다른 방법으로 substring ()을 사용할 수 있습니다.

문자열을 나누려면 다음을 사용하십시오 String.split(regex).

String phone = "004-034556";
String[] output = phone.split("-");
System.out.println(output[0]);
System.out.println(output[1]);

산출:

004
034556