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


Answers

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

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 मैचों और एकल दशमलव अंक, और + का मतलब है "पिछली अभिव्यक्ति में से एक या अधिक से मेल खाता है) - इसका कोई विशेष अर्थ नहीं है, इसलिए इनपुट में उस वर्ण से मेल खाता है। ध्यान दें कि आपको बैकस्लैश को दोबारा से बचने की आवश्यकता है जावा स्ट्रिंग के रूप में इसे लिखते समय। कुछ अन्य उदाहरण:

([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
Question

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

string1=004
string2=034556

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




संक्षेप में: जावा में स्ट्रिंग को विभाजित करने के कम से कम पांच तरीके हैं:

  1. String.split ():

    String[] parts ="10,20".split(",");
    
  2. Pattern.compile (regexp) .splitAsStream (इनपुट):

    List<String> strings = Pattern.compile("\\|")
          .splitAsStream("010|020202")
          .collect(Collectors.toList());
    
  3. स्ट्रिंगटोकनाइज़र (विरासत वर्ग):

    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. अपाचे कॉमन्स स्ट्रिंगउट्स:

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

इसलिए आप जो चाहते हैं उसके आधार पर आप के लिए सबसे अच्छा विकल्प चुन सकते हैं, उदाहरण के लिए वापसी प्रकार (सरणी, सूची, या पुन: प्रयोज्य)।

Here इन तरीकों का एक बड़ा अवलोकन है और सबसे आम उदाहरण (डॉट, स्लैश, प्रश्न चिह्न इत्यादि द्वारा विभाजित कैसे करें)




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

 String concatenated_String="hi^Hello";

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



कृपया 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 जांच करें।




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

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.split(regex) उपयोग करें:

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

आउटपुट:

004
034556



जावा 8 के साथ:

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

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



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

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



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

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

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

String textStr[] = yourString.split("-");



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



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

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



यहां दो तरीके हैं जो इसे प्राप्त करते हैं।

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



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



Related



Tags

java java   string