วิธีการแยกสตริงใน 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 ตัวที่มีความหมายพิเศษคือเครื่องหมายแบ็กสแลชเครื่องหมาย\รูปหมวกเครื่องหมาย^ดอลลาร์$จุดหรือจุด.แถบแนวตั้งหรือสัญลักษณ์ท่อแนวตั้ง|เครื่องหมายคำถามเครื่องหมาย?ดอกจันหรือดาว*เครื่องหมายบวกเครื่องหมาย+วงเล็บเปิดวงเล็บวงเล็บ(ปิด)และวงเล็บเหลี่ยม[เปิด{, วงเล็บปีกกาเปิด, อักขระพิเศษเหล่านี้มักจะเรียกว่า "metacharacters"

ดังนั้นหากคุณต้องการแยกเช่นจุด / จุด.ซึ่งหมายถึง " อักขระใด ๆ " ใน regex ให้ใช้เครื่องหมายแบ็กสแลช\เพื่อหลีกเลี่ยงอักขระพิเศษแต่ละตัวเช่นนั้นsplit("\\.")หรือใช้คลาสอักขระ[]เพื่อแทนอักขระตามตัวอักษรsplit("[.]")หรือใช้Pattern#quote()เพื่อ split(Pattern.quote("."))หลบหนีสตริงทั้งหมดเช่นดังนั้น

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

ในการทดสอบก่อนถ้าสตริงมีอักขระบาง (s) String#contains()เพียงแค่การใช้งาน

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

หมายเหตุนี่ไม่ได้ใช้การแสดงออกปกติ เพื่อที่จะใช้String#matches()แทน

หากคุณต้องการที่จะรักษาตัวอักษรแยกในส่วนที่เกิดขึ้นแล้วทำให้การใช้LookAround บวก ในกรณีที่คุณต้องการแยกตัวอักษรให้จบที่ด้านซ้ายมือให้ใช้ lookbehind เชิงบวกโดยการใส่คำนำหน้า?<=กลุ่มลงบนลวดลาย

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

ในกรณีที่คุณต้องการให้ตัวอักขระแยกส่วนจบลงทางด้านขวามือให้ใช้ lookahead ที่เป็นบวกโดยนำหน้า?=กลุ่มบนลวดลาย

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

หากคุณต้องการ จำกัด จำนวนชิ้นส่วนที่เกิดขึ้นคุณสามารถระบุจำนวนที่ต้องการเป็นอาร์กิวเมนต์ที่ 2 ของ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+)

วงเล็บแสดงถึงกลุ่มการจับภาพ สตริงที่ตรงกับส่วนของ regexp สามารถเข้าถึงได้โดยวิธี Match.group () ดังที่แสดง \ d จับคู่และหลักทศนิยมเดียวและ + หมายถึง "จับคู่หนึ่งหรือมากกว่าของการแสดงออกก่อนหน้านี้) - ไม่มีความหมายพิเศษดังนั้นเพียงแค่ตรงกับตัวละครที่อยู่ในการป้อนข้อมูลโปรดทราบว่าคุณต้องหลบหนี backslash สองครั้ง เมื่อเขียนสิ่งนี้เป็นสตริง 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 ส่วน องค์ประกอบแรกในอาร์เรย์จะเป็นส่วนหนึ่งที่มีสิ่งก่อนที่-และองค์ประกอบที่ 2 -ในอาร์เรย์จะมีส่วนหนึ่งของสายของคุณหลังจากที่

ถ้าความยาวอาร์เรย์ที่ไม่ได้เป็นที่ 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]);
}

ด้วย Java 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 คอมมอนส์ lang ในแอปของคุณแล้ว

วิธีที่ง่ายที่สุดคือการใช้StringUtils # Split (java.lang.String ถ่าน) สะดวกกว่า 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 เนื่องจากโดยปกติจะมีหลายสิ่งที่ใช้งานได้ อย่างไรก็ตามหากคุณไม่ต้องการสิ่งอื่นนอกจากทำการแยกแล้วนำตัวคุณเองไปใช้หรือหนีออกจาก regex เป็นตัวเลือกที่ดีกว่า

ใช้วิธีการแยก'org.apache.commons.lang.StringUtils'ซึ่งสามารถแยกสตริงตามตัวละครหรือสตริงที่คุณต้องการแยก

ลายเซ็นวิธีการ:

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. Google Guava Splitter:

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

5. Apache Commons StringUtils:

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

ดังนั้นคุณสามารถเลือกตัวเลือกที่ดีที่สุดสำหรับคุณขึ้นอยู่กับสิ่งที่คุณต้องการเช่นชนิดส่งคืน (อาร์เรย์, รายการ, หรือ iterable)

ที่นี่นี้เป็นภาพรวมขนาดใหญ่ของวิธีการเหล่านี้และตัวอย่างที่พบบ่อยที่สุด (วิธีแยกโดยจุด, เครื่องหมายทับ, เครื่องหมายคำถาม ฯลฯ )

วิธีที่เร็วที่สุดซึ่งใช้ทรัพยากรน้อยที่สุดก็คือ:

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

String Split พร้อมตัวละครหลายตัวโดยใช้ Regex

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 ฉันได้เห็นข้อผิดพลาดหนึ่งที่มีอยู่ในบางรุ่น JDK ที่สตริง null แรกได้ถูกละเว้น ข้อผิดพลาดนี้ไม่ปรากฏในรุ่น JDK ล่าสุด แต่มันมีอยู่ในบางรุ่นระหว่างรุ่นล่าสุดของ JDK 1.7 และรุ่นก่อน 1.8

สำหรับกรณีที่ใช้ง่ายString.split()ควรทำงาน หากคุณใช้ฝรั่งก็มีคลาสSplitterซึ่งอนุญาตให้มีการโยงการดำเนินงานสตริงที่แตกต่างกันและรองรับCharMatcher :

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(",");

วิธีการแยกมีการเพิ่มประสิทธิภาพเพื่อหลีกเลี่ยงการใช้การแสดงออกปกติถ้า delimeter เป็นตัวละครเดียวและไม่ได้อยู่ในรายการข้างต้น มิฉะนั้นจะต้องคอมไพล์นิพจน์ทั่วไปและนี่ก็ไม่เหมาะ

ใช้ Pattern.split และคอมไพล์รูปแบบล่วงหน้าหากใช้ตัวคั่นที่ซับซ้อนและคุณให้ความสำคัญกับประสิทธิภาพ

หากประสิทธิภาพเป็นปัญหาและตัวคั่นของคุณไม่ใช่หนึ่งในข้างต้นคุณควรรวบรวมรูปแบบนิพจน์ทั่วไปซึ่งคุณสามารถนำมาใช้ซ้ำได้

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

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

ตัวเลือกสุดท้ายนี้ยังคงสร้างMatcherวัตถุใหม่ คุณยังสามารถแคชวัตถุนี้และรีเซ็ตสำหรับแต่ละอินพุตเพื่อประสิทธิภาพสูงสุด แต่นั่นค่อนข้างซับซ้อนและไม่ปลอดภัยต่อเธรด

วิธีหนึ่งในการทำเช่นนี้คือการเรียกใช้ผ่านสายอักขระในแต่ละวงและใช้อักขระแบ่งที่ต้องการ

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เนื่องจากเป็นคลาสดั้งเดิมที่ถูกเก็บไว้เพื่อเหตุผลด้านความเข้ากันได้และการใช้งานจะไม่ได้รับการสนับสนุนในรหัสใหม่ และเราสามารถใช้วิธีแยกตามที่ผู้อื่นแนะนำเช่นกัน

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

และตามที่คาดไว้มันจะพิมพ์:

[004, 034556]

ในคำตอบนี้ฉันยังต้องการที่จะชี้ให้เห็นหนึ่งในการเปลี่ยนแปลงที่เกิดขึ้นสำหรับsplitวิธีการในชวา 8 String # แยก ()วิธีที่ทำให้การใช้Pattern.splitและตอนนี้ก็จะลบสตริงที่ว่างเปล่าในช่วงเริ่มต้นของอาร์เรย์ผลลัพธ์ สังเกตการเปลี่ยนแปลงนี้ในเอกสารคู่มือสำหรับ Java 8:

เมื่อมีการจับคู่ความกว้างเป็นบวกที่จุดเริ่มต้นของลำดับการป้อนข้อมูลสตริงย่อยนำว่างจะรวมอยู่ที่จุดเริ่มต้นของอาร์เรย์ผลลัพธ์ การจับคู่ความกว้างเป็นศูนย์ที่จุดเริ่มต้นอย่างไรก็ตามจะไม่สร้างสตริงย่อยนำว่างเปล่าดังกล่าว

มันหมายถึงตัวอย่างต่อไปนี้:

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

เราจะได้สามสาย: [0, 0, 4]และไม่ใช่สี่อย่างในกรณีของ Java 7 และก่อน ตรวจสอบคำถามที่คล้ายกันนี้ด้วย

นี่คือสองวิธีที่สองบรรลุ

วิธีที่ 1: เมื่อคุณต้องแยกตัวเลขสองตัวด้วยอักขระพิเศษคุณสามารถใช้ regex

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

คุณสามารถใช้ StringTokenizer เพื่อแยกสตริงออกเป็นสองส่วนหรือมากกว่าไม่ว่าจะมีตัวคั่นประเภทใด:

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

ลองใช้split()วิธีการในStringคลาสบน javadoc

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

บันทึก:

การแยก (regex) นี้ใช้ regex เป็นอาร์กิวเมนต์ อย่าลืมหลีกเลี่ยงอักขระพิเศษ regex เช่นจุด / จุด

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 () เป็นตัวเลือกที่ดีที่สุดซึ่งอาจใช้ในกรณีของคุณ วิธีการทางเลือกสามารถใช้สตริงย่อย ()

ในการแยกสตริงให้ใช้String.split(regex):

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

เอาท์พุท:

004
034556