Cara membagi string di Jawa

Saya memiliki string,, "004-034556"yang ingin saya bagi menjadi dua string:

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

Itu berarti string pertama akan berisi karakter sebelumnya '-', dan string kedua akan berisi karakter setelahnya '-'. Saya juga ingin memeriksa apakah ada string '-'di dalamnya. Jika tidak, saya akan melemparkan pengecualian. Bagaimana saya bisa melakukan ini?

Hanya menggunakan metode yang sesuai: String#split().

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

Perhatikan bahwa ini membutuhkan ekspresi reguler , jadi ingatlah untuk menghindar dari karakter khusus jika perlu.

ada 12 karakter dengan makna khusus: garis miring terbalik \, tanda sisipan ^, tanda dolar $, titik atau titik ., tanda garis vertikal atau pipa |, tanda tanya ?, tanda bintang atau bintang *, tanda tambah +, tanda kurung pembuka (, tanda kurung penutup ), dan kurung siku [pembuka {, kurung kurawal pembuka , Karakter khusus ini sering disebut "metacharacters".

Jadi, jika Anda ingin membagi misalnya periode / titik .yang berarti " karakter apa pun " di regex, gunakan backslash\ untuk melarikan diri dari karakter khusus individu seperti itu split("\\."), atau gunakan kelas karakter[] untuk mewakili karakter literal seperti itu split("[.]"), atau gunakan Pattern#quote()untuk lepaskan seluruh string seperti itu split(Pattern.quote(".")).

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

Untuk menguji sebelumnya jika string berisi karakter tertentu, gunakan saja String#contains().

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

Catatan, ini tidak mengambil ekspresi reguler. Untuk itu, gunakan String#matches()saja.

Jika Anda ingin mempertahankan karakter pemisah di bagian yang dihasilkan, maka manfaatkan pencarian positif . Jika Anda ingin memiliki karakter split berakhir di sisi kiri, gunakan tampilan positif di belakang dengan mengawali ?<=grup pada pola.

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

Jika Anda ingin memiliki karakter split untuk berakhir di sisi kanan, gunakan lookahead positif dengan awalan ?=grup pada polanya.

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

Jika Anda ingin membatasi jumlah bagian yang dihasilkan, maka Anda dapat memberikan angka yang diinginkan sebagai argumen ke-2 split()metode.

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

Alternatif untuk memproses string secara langsung adalah dengan menggunakan ekspresi reguler dengan menangkap grup. Ini memiliki keuntungan yang membuatnya mudah untuk menyiratkan kendala yang lebih canggih pada input. Misalnya, berikut ini membagi string menjadi dua bagian, dan memastikan bahwa keduanya hanya terdiri dari digit:

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

Karena pola diperbaiki dalam contoh ini, ia dapat dikompilasi terlebih dahulu dan disimpan sebagai anggota statis (diinisialisasi pada waktu buka kelas dalam contoh). Ekspresi reguler adalah:

(\d+)-(\d+)

Tanda kurung menunjukkan kelompok penangkap; string yang cocok dengan bagian regexp dapat diakses dengan metode Match.group (), seperti yang ditunjukkan. The \ d cocok dengan digit desimal tunggal, dan tanda + berarti "cocok dengan satu atau lebih dari ekspresi sebelumnya). The - tidak memiliki arti khusus, jadi cocokkan karakter tersebut di input. Perhatikan bahwa Anda perlu melarikan diri dua kali garis miring terbalik saat menulis ini sebagai string Java. Beberapa contoh lain:

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

Ini akan membagi string Anda menjadi 2 bagian. Elemen pertama dalam array akan menjadi bagian yang berisi hal-hal sebelum -, dan elemen ke-2 dalam array akan berisi bagian dari string Anda setelah -.

Jika panjang array tidak 2, maka string tidak dalam format: string-string.

Lihat split()metode di Stringkelas.

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

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

harus melakukan hal yang Anda inginkan. Kelas string memiliki banyak metode untuk beroperasi dengan string.

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

Dengan Java 8:

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

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

Persyaratan meninggalkan ruang untuk interpretasi. Saya sarankan menulis metode,

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

yang merangkum fungsi ini. Tentu saja Anda dapat menggunakan String.split (..) seperti yang disebutkan dalam jawaban lain untuk implementasi.

Anda harus menulis beberapa unit-test untuk string input dan hasil serta perilaku yang diinginkan.

Kandidat ujian yang baik harus mencakup:

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

Dengan menentukan hasil tes yang sesuai, Anda dapat menentukan perilaku.

Misalnya, apakah "-333"harus kembali [,333]atau jika itu adalah kesalahan. Dapat "333-333-33"dipisahkan [333,333-33] or [333-333,33]atau itu kesalahan? Dan seterusnya.

Anda dapat mencoba seperti ini juga

 String concatenated_String="hi^Hello";

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

Berasumsi bahwa

• Anda tidak benar-benar membutuhkan ekspresi reguler untuk pemisahan Anda
• Anda kebetulan sudah menggunakan apache commons lang di aplikasi Anda

Cara termudah adalah dengan menggunakan StringUtils # split (java.lang.String, char) . Itu lebih nyaman daripada yang disediakan oleh Java di luar kotak jika Anda tidak memerlukan ekspresi reguler. Seperti yang dikatakan dalam manualnya, ini berfungsi seperti ini:

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"]

Saya akan merekomendasikan menggunakan commong-lang, karena biasanya berisi banyak hal yang dapat digunakan. Namun, jika Anda tidak membutuhkannya selain melakukan split, maka menerapkan diri sendiri atau melarikan diri dari regex adalah pilihan yang lebih baik.

Gunakan metode split org.apache.commons.lang.StringUtils yang dapat membagi string berdasarkan karakter atau string yang ingin Anda bagi.

Metode tanda tangan:

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

Dalam kasus Anda, Anda ingin membagi string ketika ada "-".

Anda dapat melakukannya sebagai berikut:

String str = "004-034556";

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

Keluaran:

004
034556

Asumsikan bahwa jika -tidak ada dalam string Anda, itu mengembalikan string yang diberikan, dan Anda tidak akan mendapatkan pengecualian.

Untuk meringkas: setidaknya ada lima cara untuk membagi string di Jawa:

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 (kelas lawas):

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

Jadi, Anda dapat memilih opsi terbaik untuk Anda tergantung pada apa yang Anda butuhkan, misalnya tipe pengembalian (array, daftar, atau dapat diubah).

Berikut ini adalah ikhtisar besar dari metode ini dan contoh paling umum (bagaimana membaginya dengan titik, garis miring, tanda tanya, dll.)

Cara tercepat, yang juga mengkonsumsi sumber daya paling sedikit adalah:

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 dengan beberapa karakter menggunakan 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]);
        }
     }
  }

Keluaran:

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

Tetapi jangan mengharapkan output yang sama di semua versi JDK. Saya telah melihat satu bug yang ada di beberapa versi JDK di mana string nol pertama telah diabaikan. Bug ini tidak ada dalam versi JDK terbaru, tetapi ada di beberapa versi antara JDK 1.7 versi terakhir dan 1.8 versi awal.

Untuk kasus penggunaan sederhana String.split()harus melakukan pekerjaan. Jika Anda menggunakan jambu biji, ada juga kelas Splitter yang memungkinkan rantai operasi string yang berbeda dan mendukung 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);
    }
}

Anda dapat membagi string dengan satu baris dengan menggunakan pernyataan berikut:

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

Anda dapat membagi string dengan tanda hubung / karakter dengan menggunakan pernyataan berikut:

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

Anda dapat menggunakan 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];
    }
}

Selain itu, Anda dapat menggunakan 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("-");
    }
}

Hanya ada dua metode yang benar-benar perlu Anda pertimbangkan.

Gunakan String.split untuk pembatas satu karakter atau Anda tidak peduli dengan kinerja

Jika kinerja bukan masalah, atau jika pembatas adalah karakter tunggal yang bukan karakter khusus ekspresi reguler (yaitu, bukan salah satu dari .$|()[{^?*+\) maka Anda dapat menggunakan String.split.

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

Metode split memiliki optimisasi untuk menghindari penggunaan ekspresi reguler jika delimeter adalah karakter tunggal dan tidak ada dalam daftar di atas. Kalau tidak, ia harus menyusun ekspresi reguler, dan ini tidak ideal.

Gunakan Pattern.split dan prakompilasi pola jika menggunakan pembatas yang kompleks dan Anda peduli dengan kinerja.

Jika kinerja adalah masalah, dan pembatas Anda bukan salah satu dari yang di atas, Anda harus melakukan pra-kompilasi pola ekspresi reguler yang kemudian dapat Anda gunakan kembali.

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

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

Opsi terakhir ini masih membuat Matcherobjek baru . Anda juga dapat men-cache objek ini dan mengatur ulangnya untuk setiap input untuk kinerja maksimum, tetapi itu agak lebih rumit dan tidak aman.

Salah satu cara untuk melakukan ini adalah dengan menjalankan melalui String dalam untuk setiap loop dan menggunakan karakter split yang diperlukan.

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

Keluaran:

The split parts of the String are:
004
034556

Tolong jangan gunakan kelas StringTokenizer karena ini adalah kelas warisan yang dipertahankan karena alasan kompatibilitas, dan penggunaannya tidak disarankan dalam kode baru. Dan kita dapat menggunakan metode split seperti yang disarankan oleh orang lain juga.

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

Dan seperti yang diharapkan akan dicetak:

[004, 034556]

Dalam jawaban ini saya juga ingin menunjukkan satu perubahan yang telah terjadi untuk splitmetode di Java 8 . Metode String # split () memanfaatkan Pattern.split, dan sekarang itu akan menghapus string kosong di awal array hasil. Perhatikan perubahan dokumentasi ini untuk Java 8:

Ketika ada kecocokan dengan lebar positif di awal urutan input, maka substring depan kosong dimasukkan di awal array yang dihasilkan. Namun, kecocokan dengan lebar nol di awal tidak pernah menghasilkan substring kosong seperti itu.

Artinya untuk contoh berikut:

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

kita akan mendapatkan tiga string: [0, 0, 4]dan bukan empat seperti yang terjadi di Jawa 7 dan sebelumnya. Periksa juga pertanyaan serupa ini .

Berikut adalah dua cara dua mencapainya.

CARA 1: Karena Anda harus membagi dua angka dengan karakter khusus, Anda dapat menggunakan 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());
        }
    }
}

CARA 2: Menggunakan metode string split

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

Anda bisa menggunakan StringTokenizer untuk membagi string menjadi dua atau lebih bagian apakah ada jenis pembatas:

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

Lihat split()metode di Stringkelas di 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++;
}

Di sini banyak contoh untuk string split tetapi saya sedikit kode dioptimalkan.

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

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

Saya hanya ingin menulis algoritma alih-alih menggunakan fungsi bawaan 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;
}

Anda dapat menggunakan metode ini 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 \"-\".");
        }
    }
}

Untuk membagi string, gunakan String.split (regex). Tinjau contoh berikut:

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

Keluaran

004
034556

catatan:

Split ini (regex) mengambil regex sebagai argumen. Ingatlah untuk melarikan diri dari regex karakter khusus, seperti titik / titik.

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

Seperti yang disebutkan oleh semua orang, split () adalah opsi terbaik yang dapat digunakan dalam kasus Anda. Metode alternatif dapat menggunakan substring ().

Untuk membagi string, gunakan String.split(regex):

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

Keluaran:

004
034556