Java'da bir dize nasıl bölünür

"004-034556"İki dizeye bölmek istiyorum, bir dize var :

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

Bu, ilk dizenin önceki karakterleri içereceği '-'ve ikinci dizenin sonraki karakterleri içereceği anlamına gelir '-'. Ben de dize '-'içinde olup olmadığını kontrol etmek istiyorum . Değilse, bir istisna atarım. Bunu nasıl yapabilirim?

Sadece uygun yöntemi kullanın: String#split().

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

Bunun normal bir ifade aldığını unutmayın, bu nedenle gerekirse özel karakterlerden kaçmayı unutmayın .

Orada ters eğik çizgi: özel anlamlarla 12 karakter \, şapka ^, dolar işareti $, nokta veya nokta ., dikey çubuk veya boru sembol |, soru işareti ?, yıldız veya yıldız *, artı işareti +, açılış parantezi (kapatma parantezi ), ve açılış köşeli ayraç [, açılış kıvırcık ayraç {, Bu özel karakterlere genellikle "metakarakterler" denir.

Yani, regex'te ." herhangi bir karakter " anlamına gelen nokta / noktaya bölmek istiyorsanız, özel karakterden kaçmak için ters eğik çizgiyi\ kullanın split("\\.")veya böyle değişmez karakterleri temsil etmek için karakter sınıfını[]split("[.]") kullanın Pattern#quote()veya tüm dize gibi kaçmak split(Pattern.quote(".")).

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

Dizenin belirli karakter (ler) içerip içermediğini önceden test etmek için kullanın String#contains().

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

Bu normal bir ifade almaz. Bunun için String#matches()kullanın.

Bölünmüş karakteri sonuçta kalan bölümlerde tutmak istiyorsanız, olumlu bakış açısını kullanın . Bölünmüş karakterin sol tarafta görünmesini istiyorsanız ?<=, desene grubun ön ekini ekleyerek pozitif görüş arkası kullanın .

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

Bölünmüş karakterin sağ tarafta olmasını istiyorsanız ?=, desende grubun önüne ön ek koyarak pozitif ileriye bakın .

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

Ortaya çıkan parçaların sayısını sınırlamak isterseniz, istediğiniz sayıyı split()yöntemin 2. bağımsız değişkeni olarak sağlayabilirsiniz .

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

Dizeyi doğrudan işlemenin bir alternatifi, yakalama gruplarıyla normal bir ifade kullanmak olacaktır. Bunun avantajı, girdi üzerinde daha karmaşık kısıtlamalar getirmeyi kolaylaştırmasıdır. Örneğin, aşağıdakiler dizeyi iki parçaya ayırır ve her ikisinin de yalnızca rakamlardan oluşmasını sağlar:

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

Desen bu örnekte sabitlendiğinden, önceden derlenebilir ve statik bir üye olarak saklanabilir (örnekte sınıf yükleme zamanında başlatılabilir). Normal ifade:

(\d+)-(\d+)

Parantezler yakalama gruplarını gösterir; regexp'nin bu bölümüyle eşleşen dize, gösterildiği gibi Match.group () yöntemiyle erişilebilir. \ D ve tek ondalık basamak ile eşleşir ve +, "önceki ifadenin bir veya daha fazlasıyla eşleşir" anlamına gelir. - özel bir anlama sahip değildir, bu nedenle yalnızca girişteki bu karakterle eşleşir. Java dizesi olarak yazarken, diğer bazı örnekler:

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

Bu, dizenizi 2 parçaya böler. Dizideki ilk öğe, öğesinden önceki öğeleri içeren bölüm olur ve dizideki -2. öğe dizeden sonraki dizeyi içerir -.

Dizi uzunluğu 2 değilse, o zaman dize biçiminde değildi: string-string.

Sınıftaki split()yöntemi kontrol edin String.

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

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

İstediğin şeyi yapmalısın. String sınıfı, string ile çalışmak için birçok yönteme sahiptir.

// 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 ile:

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

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

Gereksinimler yorum için yer bıraktı. Bir yöntem yazmanızı öneririm,

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

ki bu işlevi de kapsar. Tabii ki uygulama için diğer cevaplarda belirtildiği gibi String.split (..) kullanabilirsiniz.

Giriş dizeleri ve istenen sonuçlar ve davranışlar için bazı birim testleri yazmalısınız.

İyi sınav adayları şunları içermelidir:

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

Uygun test sonuçlarını tanımlayarak davranışı belirtebilirsiniz.

Örneğin, "-333"geri dönmeli [,333]veya bir hata ise. Can "333-333-33"ayrılabilirler [333,333-33] or [333-333,33]ya da bir hatadır? Ve bunun gibi.

Bunu da deneyebilirsin

 String concatenated_String="hi^Hello";

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

Varsaymak, bu

• bölmeniz için gerçekten düzenli ifadelere ihtiyacınız yok
• uygulamanızda zaten apache commons lang kullanıyorsunuz

En kolay yol StringUtils # split (java.lang.String, char) kullanmaktır . Düzenli ifadelere ihtiyacınız yoksa, Java tarafından kutunun dışında sağlanandan daha uygundur. El kitabının dediği gibi, şu şekilde çalışır:

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

Genellikle kullanılabilir bir sürü şey içerdiğinden, commong-lang kullanmanızı öneririm. Ancak, bölünme yapmaktan başka bir şeye ihtiyacınız yoksa, kendinizi uygulamak veya normal ifadeden kaçmak daha iyi bir seçenektir.

Dizeleri bölmek istediğiniz karakter veya dizeye göre ayırabilen org.apache.commons.lang.StringUtils ' bölme yöntemini kullanın .

Yöntem imzası:

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

Sizin durumunuzda, "-" olduğunda bir dizeyi bölmek istersiniz.

Basitçe aşağıdaki gibi yapabilirsiniz:

String str = "004-034556";

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

Çıktı:

004
034556

Dizenizde -yoksa, verilen dizeyi döndürdüğünü ve herhangi bir istisna alamayacağınızı varsayın .

Özetlemek gerekirse: Java'da bir dizeyi bölmenin en az beş yolu vardır:

1. String.split ():

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

2. Pattern.compile (düzenli ifadesi) .splitAsStream (giriş):

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

3. StringTokenizer (eski sınıf):

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

4. Google Guava Ayırıcı:

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

5. Apache Commons Dizesi

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

İhtiyacınız olan şeye bağlı olarak sizin için en iyi seçeneği seçebilirsiniz, örneğin dönüş türü (dizi, liste veya yinelenebilir).

İşte bu yöntemlere ve en yaygın örneklere büyük bir genel bakış (nokta, eğik çizgi, soru işareti vb.

En az kaynağı tüketen en hızlı yol şu olabilir:

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

Regex kullanarak birden çok karakterle String Split

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

Çıktı:

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

Ancak tüm JDK sürümlerinde aynı çıktıyı beklemeyin. İlk boş dizenin yoksayıldığı bazı JDK sürümlerinde var olan bir hata gördüm . Bu hata en son JDK sürümünde mevcut değildir, ancak JDK 1.7 geç sürümleri ve 1.8 erken sürümleri arasında bazı sürümlerde bulunur.

Basit kullanım için durumlarda String.split()iş yapmalısınız. Guava kullanıyorsanız , farklı dize işlemlerinin zincirlenmesine izin veren ve CharMatcher'ı destekleyen bir Splitter sınıfı da vardır :

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

Aşağıdaki ifadeyi kullanarak bir dizeyi satır sonu ile bölebilirsiniz:

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

Aşağıdaki ifadeyi kullanarak bir dizeyi tire / karaktere bölebilirsiniz:

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 () işlevini kullanabilirsiniz:

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

Aksi takdirde, StringTokenizer kullanabilirsiniz:

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

Gerçekten dikkate almanız gereken iki yöntem var.

Tek karakterli bir sınırlayıcı için String.split komutunu kullanın, aksi takdirde performansı önemsemiyorsunuz

Performans bir sorun değilse veya sınırlayıcı, normal ifade özel karakteri olmayan tek bir karakter ise (örneğin, biri değil .$|()[{^?*+\) kullanabilirsiniz String.split.

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

Bölme yöntemi, sınırlayıcı yukarıdaki listede değilse, tek bir karakterse normal bir ifade kullanmaktan kaçınmak için bir optimizasyona sahiptir. Aksi takdirde, düzenli bir ifade derlemesi gerekir ve bu ideal değildir.

Pattern.split kullanın ve karmaşık bir sınırlayıcı kullanıyorsanız ve performansı önemsiyorsanız deseni önceden derleyin.

Performans bir sorunsa ve sınırlayıcınız yukarıdakilerden biri değilse, daha sonra yeniden kullanabileceğiniz normal bir ifade deseni derlemelisiniz.

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

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

Bu son seçenek hala yeni bir Matchernesne oluşturur . Ayrıca, maksimum performans için bu nesneyi önbelleğe alabilir ve her giriş için sıfırlayabilirsiniz, ancak bu biraz daha karmaşıktır ve iş parçacığı için güvenli değildir.

Bunu yapmanın bir yolu, her biri için bir döngüde Dize boyunca koşmak ve gerekli bölünmüş karakteri kullanmaktır.

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

Çıktı:

The split parts of the String are:
004
034556

Lütfen StringTokenizer sınıfını, uyumluluk nedeniyle saklanan eski bir sınıf olduğu için kullanmayın ve kullanımı yeni kodda önerilmez. Ve diğerlerinin önerdiği şekilde split yöntemini kullanabiliriz.

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

Ve beklendiği gibi yazdıracak:

[004, 034556]

Bu cevapta ayrıca Java 8'de yöntem için yapılan bir değişikliğe dikkatsplit çekmek istiyorum . Dize # bölünmüş () metodu markaları kullanımı Pattern.splitve şimdi result dizisinin başında boş dizeleri kaldıracak. Java 8 belgelerindeki bu değişikliğe dikkat edin :

Giriş dizisinin başında pozitif genişlikli bir eşleşme olduğunda, sonuçta oluşan dizinin başına boş bir ön alt dize eklenir. Başlangıçta sıfır genişlikteki bir eşleşme asla böyle boş ön alt dize üretmez.

Aşağıdaki örnek için şu anlama gelir:

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

üç dize alacağız: [0, 0, 4]Java 7'de ve daha önce olduğu gibi dört değil. Benzer soruyu da kontrol edin .

İşte ikisinin bunu başarmasının iki yolu.

YOLLU 1: İki sayıyı özel bir karakterle ayırmanız gerektiğinden normal ifadeyi kullanabilirsiniz

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

YOL 2: String split yöntemini kullanma

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

Herhangi bir sınırlayıcı türü olsun, bir dizeyi iki veya daha fazla parçaya bölmek için StringTokenizer'ı kullanabilirsiniz:

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

Javadoc sınıfta split()yöntemi kontrol edin 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++;
}

Burada bölünmüş dize için pek çok örnek ama ben az kod optimize.

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

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

Sadece Java yerleşik işlevleri kullanmak yerine bir algoritma yazmak istedim:

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

Yöntemi kullanabilirsiniz 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 \"-\".");
        }
    }
}

Bir dizeyi bölmek için String.split (regex) öğesini kullanır. Aşağıdaki örnekleri inceleyin:

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

Çıktı

004
034556

Not:

Bu bölünme (normal ifade) bir normal ifadeyi argüman olarak alır. Nokta / nokta gibi normal ifade özel karakterlerinden kaçmayı unutmayın.

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

Herkes tarafından belirtildiği gibi, split () sizin durumunuzda kullanılabilecek en iyi seçenektir. Alternatif bir yöntem substring () kullanmak olabilir.

Bir dizeyi bölmek için şunu kullanın String.split(regex):

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

Çıktı:

004
034556