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





string (25)


ऐसा करने का एक तरीका स्ट्रिंग के माध्यम से प्रत्येक लूप में भागना और आवश्यक विभाजन चरित्र का उपयोग करना है।

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

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

string1=004
string2=034556

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




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

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



जावा 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




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.split (regex) का उपयोग करता है। निम्नलिखित उदाहरणों की समीक्षा करें:

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

उत्पादन

004
034556

नोट यह विभाजन (regex) एक तर्क के रूप में एक regex लेता है, रेगेक्स विशेष पात्रों, जैसे अवधि / बिंदु से बचने के लिए याद रखें।




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

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




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

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




कृपया 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 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;
}



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

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

आउटपुट:

004
034556



आप स्प्लिट () का उपयोग कर सकते हैं:

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



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



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



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

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




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

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



बस उपयुक्त विधि का उपयोग करें: String#split()

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

ध्यान दें कि यह एक नियमित अभिव्यक्ति लेता है, इसलिए यदि आवश्यक हो तो विशेष पात्रों से बचने के लिए याद रखें।

विशेष अर्थ वाले 12 वर्ण हैं: बैकस्लैश \ , कैरेट ^ , डॉलर साइन $ , अवधि या बिंदु . , लंबवत बार या पाइप प्रतीक | सवाल चिह्न ? , तारांकन या स्टार * , प्लस साइन + , उद्घाटन कोष्ठक ( , समापन कोष्ठक ) , और उद्घाटन स्क्वायर ब्रैकेट [ , उद्घाटन घुंघराले ब्रेस { , इन विशेष पात्रों को अक्सर "मेटाएक्टैक्टर्स" कहा जाता है।

इसलिए, यदि आप अवधि / बिंदु पर विभाजित करना चाहते हैं . जिसका अर्थ है रेगेक्स में " कोई भी चरित्र ", अलग-अलग विशेष चरित्र से बचने के लिए बैकस्लैश \ का उपयोग करें, जैसे कि split("\\.") , या वर्ण वर्ग [] का उपयोग करें ताकि शाब्दिक चरित्र (ओं) का प्रतिनिधित्व किया जा सके split("[.]") , या पूरे स्ट्रिंग से बचने के लिए Pattern#quote() का उपयोग करें split(Pattern.quote("."))

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

स्ट्रिंग में कुछ वर्ण होने पर पहले से परीक्षण करने के लिए, बस String#contains() उपयोग करें String#contains()

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

ध्यान दें, यह नियमित अभिव्यक्ति नहीं लेता है। इसके लिए, इसके बजाय String#matches() उपयोग करें।

यदि आप परिणामी भागों में विभाजित चरित्र को बनाए रखना चाहते हैं, तो सकारात्मक लुकराउंड का उपयोग करें। यदि आप विभाजित चरित्र को बाएं हाथ में समाप्त करना चाहते हैं, तो उपसर्ग द्वारा सकारात्मक दिखने का उपयोग करें ?<= पैटर्न पर समूह।

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

यदि आप विभाजित चरित्र को दाएं हाथ में समाप्त करना चाहते हैं, तो पैटर्न पर prefixing ?= समूह द्वारा सकारात्मक लुकहेड का उपयोग करें।

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

यदि आप परिणामी भागों की संख्या को सीमित करना चाहते हैं, तो आप वांछित संख्या को split() विधि के दूसरे तर्क के रूप में आपूर्ति कर सकते हैं।

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



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.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



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

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



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

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



आप स्ट्रिंगटोकनाइज़र का उपयोग केवल दो या अधिक हिस्सों में एक स्ट्रिंग को विभाजित करने के लिए कर सकते हैं चाहे किसी भी प्रकार के डिलीमीटर हैं:

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



ईएस 6 में , हमारे पास कुछ कॉल शामिल हैं जो वास्तव में आप जो चाहते हैं: तो आप बस ऐसा ही कर सकते हैं:

'str1'.includes('str2');

ईएस 5 में भी, यदि आप इसका व्यापक रूप से उपयोग करते हैं, तो आप इसे आसानी से जोड़ सकते हैं:

String.prototype.includes = String.prototype.includes || function(str) {
  return this.indexOf(str) > -1;
}




java string