java - जावा में एक स्ट्रिंग कैसे विभाजित करें




string (20)

आप इसे भी आजमा सकते हैं

 String concatenated_String="hi^Hello";

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

मेरे पास एक स्ट्रिंग है, "004-034556" , कि मैं दो तारों में विभाजित करना चाहता हूं:

string1=004
string2=034556

इसका मतलब है कि पहली स्ट्रिंग में '-' से पहले वर्ण होंगे, और दूसरी स्ट्रिंग में '-' बाद वर्ण होंगे। मैं यह भी जांचना चाहता हूं कि स्ट्रिंग में '-' है या नहीं। यदि नहीं, तो मैं एक अपवाद फेंक दूंगा। मैं यह कैसे कर सकता हूँ?


आप निम्न कथन का उपयोग करके एक स्ट्रिंग को एक लाइन ब्रेक से विभाजित कर सकते हैं:

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

आप निम्न कथन का उपयोग करके एक स्ट्रिंग को एक हाइफ़न / वर्ण द्वारा विभाजित कर सकते हैं:

String textStr[] = yourString.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];
    }
}

अन्यथा, आप स्ट्रिंगटोकनाइज़र का उपयोग कर सकते हैं:

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

आवश्यकताओं के लिए कमरे छोड़ दिया आवश्यकताओं। मैं एक विधि लिखने की सलाह देते हैं,

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] में अलग किया जा सकता है या यह एक त्रुटि है? और इसी तरह।


ऐसा मानते हुए

  • आपको वास्तव में अपने विभाजन के लिए नियमित अभिव्यक्ति की आवश्यकता नहीं है
  • आप पहले से ही अपने ऐप में अपाचे कॉमन्स लैंग का उपयोग कर रहे हैं

StringUtils # विभाजन (java.lang.String, char) का उपयोग करने का सबसे आसान तरीका है। अगर आपको नियमित अभिव्यक्ति की आवश्यकता नहीं है तो जावा द्वारा बॉक्स द्वारा प्रदान किए गए एक से अधिक सुविधाजनक है। अपने मैनुअल की तरह कहते हैं, यह इस तरह काम करता है:

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

मैं कमोंग-लैंग का उपयोग करने की अनुशंसा करता हूं, क्योंकि आम तौर पर इसमें बहुत सारी चीज़ें होती हैं जो प्रयोग योग्य होती हैं। हालांकि, अगर आपको विभाजन करने के अलावा किसी और चीज की आवश्यकता नहीं है, तो अपने आप को लागू करना या रेगेक्स से बचना बेहतर विकल्प है।


कृपया StringTokenizer क्लास का उपयोग न करें क्योंकि यह एक विरासत वर्ग है जिसे संगतता कारणों के लिए बनाए रखा गया है, और इसका उपयोग नए कोड में निराश है। और हम दूसरों द्वारा सुझाए गए स्प्लिट विधि का भी उपयोग कर सकते हैं।

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

और उम्मीद के अनुसार यह प्रिंट करेगा:

[004, 034556]

इस जवाब में मैं जावा 8 में split विधि के लिए एक बदलाव को इंगित करना चाहता हूं। String#split() विधि Pattern.split उपयोग Pattern.split , और अब यह परिणाम सरणी की शुरुआत में खाली तारों को हटा देगा। जावा 8 के लिए प्रलेखन में इस change ध्यान दें:

जब इनपुट अनुक्रम की शुरुआत में सकारात्मक-चौड़ाई वाला मिलान होता है तो परिणामस्वरूप सरणी की शुरुआत में एक खाली अग्रणी सबस्ट्रिंग शामिल होती है। शुरुआत में शून्य-चौड़ाई वाला मैच हालांकि कभी खाली खाली सबस्ट्रिंग का उत्पादन नहीं करता है।

इसका मतलब निम्नलिखित उदाहरण के लिए है:

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

हमें तीन तार मिलेंगे: [0, 0, 4] और जावा 7 और इससे पहले के मामले में चार नहीं थे। यह भी इसी तरह की question जांच करें।


जावाडोक पर 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++;
}

स्प्लिट स्ट्रिंग के लिए यहां कई उदाहरण हैं लेकिन मैं थोड़ा कोड अनुकूलित करता हूं।


दस्तावेज़ीकरण से:

public String[] split(String regex,int limit) दी गई नियमित अभिव्यक्ति के मैचों के आसपास इस स्ट्रिंग को public String[] split(String regex,int limit) । इस विधि द्वारा लौटाई गई सरणी में इस स्ट्रिंग के प्रत्येक सबस्ट्रिंग शामिल है जिसे किसी अन्य सबस्ट्रिंग द्वारा समाप्त किया जाता है जो दिए गए अभिव्यक्ति से मेल खाता है या स्ट्रिंग के अंत तक समाप्त होता है। सरणी में सबस्ट्रिंग क्रम में हैं जिसमें वे इस स्ट्रिंग में होते हैं। अगर अभिव्यक्ति इनपुट के किसी भी हिस्से से मेल नहीं खाती है तो परिणामस्वरूप सरणी में केवल एक तत्व होता है , अर्थात् यह स्ट्रिंग।

असल में आप ऐसा कुछ कर सकते हैं:

String s = "123-456-789-123"; // The String to be split
String[] array = s.split("-"); // Split according to the hyphen and put them in an array
for(String subString : array){ // Cycle through the array
   System.out.println(subString);
}

आउटपुट:

123
456
789
123

मैं बस जावा अंतर्निहित कार्यों का उपयोग करने के बजाय एक एल्गोरिदम लिखना चाहता था:

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 वैसे: जैसा कि आपको एक विशेष चरित्र द्वारा दो संख्याओं को विभाजित करना है, आप रेगेक्स का उपयोग कर सकते हैं

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

सबसे तेज़ तरीका, जो कम से कम संसाधन का उपभोग भी कर सकता है:

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() को नौकरी करना चाहिए। यदि आप अमरूद का उपयोग करते हैं, तो एक Splitter क्लास भी है जो विभिन्न स्ट्रिंग ऑपरेशंस की श्रृंखला को अनुमति देता है और CharMatcher का समर्थन करता है:

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

स्ट्रिंग को विभाजित करने के लिए, String.split(regex) उपयोग करें:

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

आउटपुट:

004
034556

स्ट्रिंग को विभाजित करने के लिए, 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 का उपयोग कर कई वर्णों के साथ स्ट्रिंग स्प्लिट

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

लेकिन सभी जेडीके संस्करणों में एक ही आउटपुट की अपेक्षा न करें। मैंने एक बग देखा है जो कुछ जेडीके संस्करणों में मौजूद है जहां पहली नल स्ट्रिंग को अनदेखा कर दिया गया है। यह बग नवीनतम जेडीके संस्करण में मौजूद नहीं है, लेकिन यह जेडीके 1.7 देर के संस्करणों और 1.8 प्रारंभिक संस्करणों के बीच कुछ संस्करणों में मौजूद है।


 String string = "004^034556-34";
 String[] parts = string.split(Pattern.quote("^"));

यदि आपके पास एक विशेष चरित्र है तो आप Patter.quote का उपयोग कर सकते हैं। यदि आपके पास बस डैश (-) है तो आप कोड को छोटा कर सकते हैं:

 String string = "004-34";
 String[] parts = string.split("-");

यदि आप डैश (^) के स्थान पर अन्य विशेष चरित्र जोड़ने का प्रयास करते हैं तो त्रुटि ArrayIndexOutOfBoundsException उत्पन्न करेगी । इसके लिए आपको Pattern.quote का उपयोग Pattern.quote


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

जैसा कि सभी ने उल्लेख किया है, विभाजन () सबसे अच्छा विकल्प है जिसका उपयोग आपके मामले में किया जा सकता है। एक वैकल्पिक विधि substring () का उपयोग कर सकते हैं।


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

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

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

यह आपकी स्ट्रिंग को 2 भागों में विभाजित करेगा। सरणी में पहला तत्व भाग से पहले सामान होगा - और सरणी में दूसरे तत्व में आपकी स्ट्रिंग का हिस्सा होगा -

यदि सरणी लंबाई 2 नहीं है, तो स्ट्रिंग प्रारूप में नहीं थी: string-string

String क्लास में split() विधि देखें।

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


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




string