it-swarm.dev

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

"004-034556" 문자열을 두 문자열로 나누고 싶습니다.

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

즉, 첫 번째 문자열에는 '-' 앞에있는 문자가 포함되고 두 번째 문자열에는 '-' 뒤에 문자가 포함됩니다. 또한 문자열에 '-'가 있는지 확인하려고합니다. 그렇지 않으면 예외를 throw합니다. 어떻게해야합니까?

1408
riyana

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

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

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

there 는 특별한 의미를 가진 12 자입니다 : 백 슬래시 \, 캐럿 ^, 달러 기호 $, 마침표 또는 점 ., 수직 막대 또는 파이프 기호 |, 물음표 ?, 별표 또는 별표 *, 더하기 부호 +, 여는 괄호 (, 닫는 괄호 ) 및 여는 대괄호 [, 여는 중괄호 {, 이러한 특수 문자는 종종 "메타 문자"라고합니다.

예를 들어 분할하려는 경우 마침표/도트 . 정규식에서 " 임의의 문자 "를 의미하는 경우 backslash \ 를 사용하여 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() 을 대신 사용하십시오.

결과 부분에 분할 문자를 유지하려면 positive lookaround 를 사용하십시오. 분할 문자를 왼쪽으로 끝내려면 패턴에 ?<= 그룹을 접두어로 붙여서 긍정적 인 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
2734
BalusC

문자열을 직접 처리하는 대신 캡처 그룹과 함께 정규식을 사용하는 것이 좋습니다. 이것은 입력에보다 정교한 제약을 함축하는 것이 쉽다는 장점이 있습니다. 예를 들어, 다음은 문자열을 두 부분으로 나눕니다. 두 부분 모두 숫자로만 구성됩니다.

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는 하나의 십진수와 일치하고 +는 "이전 표현식 중 하나 이상과 일치 함을 의미합니다.) -는 특별한 의미가 없으므로 입력의 해당 문자와 ​​일치합니다. 백 슬래시를 두 번 이스케이프해야합니다. 이것을 자바 문자열로 쓸 때. 다른 몇 가지 예 :

([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
70
Rob Hague
String[] result = yourString.split("-");
if (result.length != 2) 
     throw new IllegalArgumentException("String not in correct format");

이것은 당신의 끈을 두 부분으로 나눌 것입니다. 배열의 첫 번째 요소는 - 앞에있는 내용을 포함하는 부분이고 배열의 두 번째 요소는 - 뒤에 문자열의 일부를 포함합니다.

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

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

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

40
jjnguy
// 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]);
}
27
Mnyikka
String[] out = string.split("-");

네가 원하는 걸해야 해. 문자열 클래스는 문자열로 작동하는 많은 메소드를 가지고 있습니다. 

24
secmask

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

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]에서 분리 될 수 있습니까? 아니면 오류입니까? 등등.

18
Michael Konietzka

자바 8 :

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

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

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

문자열에 -가 없으면 주어진 문자열을 반환하고 아무런 예외도 발생하지 않는다고 가정합니다.

15
sandeep vanama

가정하면,

  • 분할을 위해 정규식이 필요하지 않습니다.
  • 당신은 이미 아파치 공유를 사용하여 응용 프로그램에서 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을 사용하는 것이 좋습니다. 일반적으로 사용 가능한 많은 것들이 포함되어 있기 때문입니다. 그러나 분할을 수행하는 것 이외에 다른 작업을 수행 할 필요가 없다면 자신을 구현하거나 정규식을 이스케이프 처리하는 것이 더 나은 방법입니다.

15
eis

너도 이것처럼해볼 수있어.

 String concatenated_String="hi^Hello";

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

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

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 버전 사이의 일부 버전에 존재합니다.

13
Ravindra babu

간단한 사용을 위해 String.split() 이 (가) 작업을 수행해야합니다. 구아바를 사용하는 경우 Splitter 클래스가 있습니다.이 클래스는 서로 다른 문자열 연산의 체인을 허용하고 CharMatcher 를 지원합니다.

Splitter.on('-')
       .trimResults()
       .omitEmptyStrings()
       .split(string);
13
Vitalii Fedorenko
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);
    }
}
10

가장 적은 자원을 소비하는 가장 빠른 방법은 다음과 같습니다.

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 '-'
}
10
David

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

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

다음 문을 사용하여 문자열을 하이픈/문자로 나눌 수 있습니다.

String textStr[] = yourString.split("-");
9
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]);
    }
  }
}
9
Ravi Pandey

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

  1. String.split () :

    String[] parts ="10,20".split(",");
    
  2. Pattern.compile (정규식) .splitAsStream (입력) :

    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. Google 구아바 분배기 :

    Iterable<String> result = Splitter.on(",").split("1,2,3,4");
    
  5. Apache Commons StringUtils :

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

따라서 당신은 당신이 필요로하는 것에 따라 당신을위한 최선의 선택을 선택할 수 있습니다. 반환 유형 (배열, 목록 또는 반복 가능).

여기 는이 방법과 가장 일반적인 예에 ​​대한 큰 개요입니다 (점, 슬래시, 물음표 등으로 분리하는 방법)

8
Dmytro Shvechikov

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

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

예상대로 인쇄됩니다.

[004, 034556]

이 대답에서 나는 또한Java 8에서 split 메소드에 대해 수행 된 하나의 변경을 지적하고자합니다. String # split () 메소드는 Pattern.split를 사용하며 결과 배열의 시작 부분에서 빈 문자열을 제거합니다. 이 change in Java 8 문서를 확인하십시오.

입력 시퀀스의 시작 부분에 양수 폭의 일치가 있으면 결과 배열의 시작 부분에 공백의 선행 하위 문자열이 포함됩니다. 그러나 처음에는 제로 너비 일치를 사용하지만 는 빈 선두 행을 생성하지 않습니다.

다음 예를 의미합니다.

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

우리는 3 개의 문자열을 얻을 것이다 : [0, 0, 4]와 4가 아닌 Java 7의 경우와 이전. 또한 이와 유사한 question 을 확인하십시오.

7
i_am_zero

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

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

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

두 사람이 그것을 성취하는 두 가지 방법이 있습니다.

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

방법 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);
        }
    }
}
7
Akshay Gaikwad

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

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

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

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++;
}

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

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

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

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

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

성능에 문제가 없거나 delimeter가 정규 표현식 특수 문자가 아닌 단일 문자 (즉, .$|()[{^?*+\ 중 하나가 아닌) 인 경우 String.split를 사용할 수 있습니다.

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

Split 메서드는 delimeter가 위의 목록에없는 단일 문자 인 경우 정규식을 사용하지 않도록 최적화되어 있습니다. 그렇지 않으면 정규 표현식을 컴파일해야하며 이상적이지 않습니다.

Pattern.split을 사용하고 복잡한 delimeter를 사용하고 성능에 신경 쓰면 패턴을 사전 컴파일하십시오.

성능이 문제이고 delimeter가 위와 같지 않은 경우 재사용 할 수있는 정규 표현식 패턴을 미리 컴파일해야합니다.

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

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

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

2
rghome

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;
}
1
None

문자열을 분할하려면 String.split(regex)을 사용하십시오.

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

산출:

004
034556
0
KIBOU Hassan
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 ()을 사용할 수 있습니다.

0
SAM Jr

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

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

산출

004
034556

참고 이 스플릿 (정규식)은 정규식을 인수로 사용하며 마침표/점과 같은 정규식 특수 문자를 이스케이프해야합니다.

0
KIBOU Hassan

나는 stringValue이라는 끈을 사용했고, "코인을 가지고 있고, 비를 즐기고, 메모를 가지고있는 사람들이 대피소를 찾는 데 바빴던"것과 같은 형태입니다.

콜론으로 ","를 사용하여 stringValue을 분할합니다.

그런 다음 단순히 3 개의 다른 TextViews의 SetText ()를 사용하여 해당 문자열을 표시하고 싶습니다.

String stringValue = "Those who had coins, enjoyed in the rain, those who had notes were busy looking for the shelter";
            String ValueSplitByColon[] = stringValue.split(",");

            String firstValue = ValueSplitByColon[0];
            String secondValue = ValueSplitByColon[1];
            String thirdValue = ValueSplitByColon[2];

            txtV1.setText(firstValue);
            txtV2.setText(secondValue;
            txtV3.setText(thirdValue;

다음과 같이 출력합니다.

  1. txtV1 가치는 :-동전을 가진 사람

  2. txtV2 값은 :-비가 내렸다

  3. txtV3 Value is :-쉼터를 찾는 데 바빴던 사람들

0
PRAMESH BHALALA

분할 방법을 사용할 수 있습니다.

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 \"-\".");
        }

    }
}
0
Jamith Nimantha