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

Question

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

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

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

Answer 1

बस उपयुक्त विधि का उपयोग करें: 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()।

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

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

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

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

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

Comments

स्ट्रिंग के तरीकों का परिसीमन करने के लिए आप हैश प्रतीकों का उपयोग क्यों करते हैं?

— क्राउन

@Crowie: javadoc- शैली।

— बालुसक

कॉर्नर केस: यदि यह नहीं मिल सकता है तो यह reugalr expressionपूरे स्ट्रिंग के साथ एक तत्व सरणी देता है।

— klimat

विश्वास नहीं किया जा सकता है कि सबसे अधिक मतदान संस्करण इस तरह है। 1) part2 वह नहीं है जो पोस्टर चाहता है यदि मूल स्ट्रिंग में दो हैं "-" 2) प्रश्न में उल्लिखित कोई त्रुटि हैंडलिंग नहीं है। 3) कम कुशल। एक एकल चरित्र खोज को नियमित अभिव्यक्ति निर्माण और मिलान की आवश्यकता होती है। अतिरिक्त सरणी बनाई गई, आदि

— डेविड

@ डेविड: 1) यह सवाल में शामिल नहीं है। 2) यह अपवाद नहीं है। 3) ओपी पूछता है कि विभाजन कैसे किया जाए, प्रतिस्थापन कैसे नहीं। 4) एक ब्रेक लें, गहरी सांस लें और अपने सिर की सारी नकारात्मकता को दूर करें :)

— BalusC

Answer 2

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

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 के उस भाग से मेल खाता है, मैच.ग्रुप () विधि द्वारा एक्सेस की जा सकती है, जैसा कि दिखाया गया है। \ 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

Comments

यह एक महान समाधान है, हालांकि पहला भाग होना चाहिए m.group(1), दूसरा भाग m.group(2), क्योंकि m.group(0)वास्तव में पूर्ण मिलान पैटर्न लौटाता है। मुझे लगता है कि मुझे यह भी याद group(0)है कि फुल पैटर्न के बजाय पहला मैच हुआ करता था, हो सकता है कि हालिया जावा संस्करण अपडेट में यह बदल गया हो।

— ptstone

धन्यवाद। Docs.oracle.com/javase/7/docs/api/java/util/regex/… को देखते हुए , आप सही कह रहे हैं - अधिकांश अन्य regexp पुस्तकालयों के साथ, समूह 0 पूर्ण मैच है, और कैप्चर किया गया प्रारंभ 1. जैसा कि आप कहते हैं, मुझे संदेह है कि यह तब से बदल गया है जब मैंने मूल रूप से उत्तर लिखा था, लेकिन किसी भी मामले में मैं इसे वर्तमान व्यवहार को प्रतिबिंबित करने के लिए अपडेट करूंगा।

— रॉब हेग

Answer 3

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

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

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

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

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

Comments

यह "-555" को इनपुट और रिटर्न [, 555] के रूप में स्वीकार करेगा। आवश्यकताओं को स्पष्ट नहीं किया गया है, अगर यह स्वीकार करने के लिए मान्य होगा। मैं वांछित व्यवहार को परिभाषित करने के लिए कुछ यूनिट-परीक्षण लिखने की सलाह देता हूं।

— माइकल कोनित्ज़का

बदलने के लिए संभवत: सबसे सुरक्षित (result.length! = 2) to (

— result.length

Answer 4

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

आप चाहते हैं बात करनी चाहिए स्ट्रिंग के साथ संचालित करने के लिए स्ट्रिंग क्लास में कई विधि हैं।

Answer 5

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

Comments

JavaDoc स्पष्ट रूप से बताता है: " StringTokenizerएक विरासत वर्ग है जिसे संगतता कारणों से बरकरार रखा जाता है, हालांकि इसका उपयोग नए कोड में हतोत्साहित किया जाता है। यह अनुशंसा की जाती है कि इस कार्यक्षमता की मांग करने वाला कोई भी व्यक्ति इसके बजाय पैकेज या splitपद्धति का उपयोग करे ।" Stringjava.util.regex

— bvdb

Answer 6

जावा 8 के साथ:

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

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

Comments

जोड़ने के खाली स्थान के आप निकालना चाहते हैं .map(String::trim)के बादsplit

— रोलाण्ड

Answer 7

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

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]या यह एक त्रुटि है? और इसी तरह।

Comments

उपयोगी सलाह, लेकिन वास्तव में सवाल का जवाब नहीं। यदि आप किसी अन्य उत्तर का विस्तार से समर्थन कर रहे हैं तो टिप्पणी पसंद की जाती है।

— क्रिस माउंटफोर्ड

उपयोग करें: संदर्भ विज़िट के लिए geeksforgeeks.org/split-string-java-examples

— रयान ऑगस्टाइन

Answer 8

आप इस तरह की कोशिश भी कर सकते हैं

 String concatenated_String="hi^Hello";

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

Answer 9

ऐसा मानते हुए

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

सबसे आसान तरीका है 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"]

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

Answer 10

Org.apache.commons.lang.StringUtils ' स्प्लिट विधि का प्रयोग करें जो आप जिस चरित्र या स्ट्रिंग को विभाजित करना चाहते हैं उसके आधार पर स्ट्रिंग्स को विभाजित कर सकते हैं।

विधि हस्ताक्षर:

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

आपके मामले में, आप "-" होने पर एक स्ट्रिंग को विभाजित करना चाहते हैं।

आप बस इस प्रकार कर सकते हैं:

String str = "004-034556";

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

आउटपुट:

004
034556

मान लें कि यदि -आपकी स्ट्रिंग में मौजूद नहीं है, तो यह दिए गए स्ट्रिंग को लौटाता है, और आपको कोई अपवाद नहीं मिलेगा।

Answer 11

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

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. अपाचे कॉमन्स StringUtils:

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

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

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

Answer 12

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

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

Comments

सबसे दुर्लभ संसाधन अक्सर प्रोग्रामर का समय और ध्यान होता है। यह कोड विकल्प से अधिक उस संसाधन का उपभोग करता है।

— क्रिस माउंटफोर्ड

आपके पास बहुत सारे अंतर्निर्मित संसाधन हैं जिनका आप उपयोग कर सकते हैं, जहाँ प्रदर्शन पर वास्तव में विचार किया जाता है, इस समाधान में निष्पादन निष्पादन समय का अभाव है

— J Sanchez

किसी एकल वर्ण पर त्रुटि विभाजन के साथ एक साधारण विभाजन करने के लिए, यह रेगेक्स संस्करण से अधिक जटिल नहीं है।

— टेकहेड

वाहवाही! अंत में इस सवाल का एक जवाब जो रेगेक्स का उपयोग नहीं करता है! इस सरल कार्य के लिए एक regex का उपयोग करना बल्कि एक हेडस्क्रैकर है। अच्छा देखने के लिए इस धरती पर अभी भी समझदार प्रोग्रामर हैं :-)

— गेब्रियल मैगाना

केवल एक "-" है, एक अपवाद चाहता है और परिणाम string1 और string2 पर जाना चाहिए। इससे string1 = s.substring(0, s.indexOf("-")); string2 = s.substring(s.indexOf("-") + 1);बाहर करो। आप StringIndexOutOfBoundsExceptionस्वचालित रूप से प्राप्त करेंगे यदि कोई "-" नहीं था।

— कपलान

Answer 13

Regex का उपयोग करके कई वर्णों के साथ String भाजित

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

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

Answer 14

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

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

Answer 15

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

Answer 16

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

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

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

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

Answer 17

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

Comments

यदि मैं सलाह साझा कर सकता हूं, तो आपका जवाब पहले से ही स्वीकृत समाधान से अधिक मूल्य कैसे लाता है? stackoverflow.com/a/3481842/420096 ऐसी स्थितियों पर आप मौजूदा समाधान पर वोट डाल सकते हैं, खासकर यदि यह उस तरह का एक स्पष्ट तुच्छ मामला है।

— सोमब्रीक

Answer 18

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

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

इसके अलावा, आप 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("-");
    }
}

Answer 19

केवल दो विधियाँ हैं जिन पर आपको वास्तव में विचार करने की आवश्यकता है।

एक-चरित्र सीमांकक के लिए String.split का उपयोग करें या आप प्रदर्शन के बारे में परवाह नहीं करते हैं

यदि प्रदर्शन कोई समस्या नहीं है, या यदि सीमांकक एक एकल वर्ण है जो एक नियमित अभिव्यक्ति विशेष वर्ण नहीं है (यानी, एक नहीं .$|()[{^?*+\) तो आप उपयोग कर सकते हैं String.split।

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

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

एक जटिल सीमांकक का उपयोग करते हुए पैटर्न का उपयोग करें।

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

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

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

यह अंतिम विकल्प अभी भी एक नई Matcherवस्तु बनाता है । आप इस ऑब्जेक्ट को कैश भी कर सकते हैं और इसे अधिकतम प्रदर्शन के लिए प्रत्येक इनपुट के लिए रीसेट कर सकते हैं, लेकिन यह कुछ अधिक जटिल है और थ्रेड-सुरक्षित नहीं है।

Answer 20

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

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

Answer 21

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

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

और उम्मीद के मुताबिक यह छपेगा:

[004, 034556]

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

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

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

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

हमें तीन तार मिलेंगे: [0, 0, 4]और चार नहीं जैसा कि जावा 7 और उससे पहले हुआ था। इसी तरह के प्रश्न की भी जाँच करें ।

Answer 22

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

WAY 1: जैसा कि आपको एक विशेष वर्ण द्वारा दो संख्याओं को विभाजित करना होगा आप 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());
        }
    }
}

रास्ता 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);
        }
    }
}

Answer 23

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

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

Answer 24

जावदोक पर कक्षा split()में विधि देखें 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++;
}

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

Comments

इसके -साथ बदलें |और देखें कि क्या होता है :)

— R Sun

उस स्थिति में, stackoverflow.com/questions/10796160/…

— R Sun

Answer 25

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

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

Answer 26

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

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

Answer 27

आप विधि का उपयोग कर सकते हैं 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 \"-\".");
        }
    }
}

Answer 28

एक स्ट्रिंग को विभाजित करने के लिए, 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 लेता है। रेगेक्स विशेष वर्णों से बचने के लिए याद रखें, जैसे अवधि / बिंदी।

Answer 29

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

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

Answer 30

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

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

आउटपुट:

004
034556