दिलचस्प पोस्ट
जीएनयू में पुनरावर्ती वाइल्डकार्ड बनाते हैं? C # कंसोल अनुप्रयोग के त्वरित संपादन मोड को प्रोग्रामैटिक अक्षम कैसे करें? किसी सूची में सभी तत्वों को कैसे प्राप्त करें? MYSQL में बल्क INSERT वसंत नियंत्रक के साथ त्रुटि 404 संभाल ट्विटर बूटस्ट्रैप – पंक्तियों के बीच शीर्ष स्थान जोड़ें सादी अंग्रेजी में योकोनें का प्रत्यय पेड़ एल्गोरिदम स्थिर फ़ाइलों को सेवा देने के लिए ASP.NET रूटिंग का उपयोग करना टी-एसक्यूएल में एसक्यूएल सर्वर रेगुलर एक्सप्रेशंस मैं एक पायथन कार्यक्रम के निष्पादन का समय कैसे प्राप्त करूं? FBSDKCoreKit के लिए फेसबुक आईओएसओ एसडीके बिल्ड मॉड्यूल त्रुटि रेगुलर एक्सप्रेशन के लिए वैरिएबल-लिक्विड लिक्विड-डिसर्सशन ऑप्शंस थोड़े से स्वैप () के उदाहरण जब एक बुरा विचार है? दशमलव संख्या में टेक्स्ट प्रतिनिधित्व में हेक्स कन्वर्ट करें मॉकिटो के साथ कॉलबैक कॉल करना

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

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

 string1=004 string2=034556 

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

वेब के समाधान से एकत्रित समाधान "जावा में एक स्ट्रिंग को कैसे विभाजित किया जाए"

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

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

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

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

इसलिए, यदि आप विभाजन करना चाहते हैं जैसे अवधि / डॉट जिसका अर्थ है "regex" में " कोई भी अक्षर ", तो अलग-अलग स्पेशल कैरेक्टर जैसे कि split("\\.") से बचने के लिए बैकस्लैश का उपयोग करें, या वर्चुअल क्लास का इस्तेमाल करें [] ताकि split("[.]") जैसे split("[.]") , या split(Pattern.quote(".")) करने के लिए Pattern#quote() का उपयोग करें ताकि 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 

यदि आप अलग-अलग चरित्र को दाहिनी ओर से समाप्त करना चाहते हैं, तो पूर्वप्रिक्सिंग द्वारा सकारात्मक lookahead का उपयोग करें ?= पैटर्न पर समूह

 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 

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

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

 ([AZ]+)-([AZ]+) // Each part consists of only capital letters ([^-]+)-([^-]+) // Each part consists of characters other than - ([AZ]{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"); 

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

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

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

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

 // 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]); } 
 String[] out = string.split("-"); 

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

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

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

जो इस समारोह को समझाता है। बेशक आप स्ट्रिंग.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 concatenated_String="hi^Hello"; String split_string_array[]=concatenated_String.split("\\^"); 

ऐसा मानते हुए

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

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

 A null input String returns null. StringUtils.split(null, *) = null StringUtils.split("", *) = [] StringUtils.split("abc", '.') = ["a", "b", "c"] StringUtils.split("a..bc", '.') = ["a", "b", "c"] StringUtils.split("a:b:c", '.') = ["a:b:c"] StringUtils.split("abc", ' ') = ["a", "b", "c"] 

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

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

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

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

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

आप बस निम्नानुसार कर सकते हैं:

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

आउटपुट:

 004 034556 

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

जावा 8 के साथ:

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

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

 Splitter.on('-') .trimResults() .omitEmptyStrings() .split(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 

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

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

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

 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 

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

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

और जैसा कि यह अपेक्षित होगा प्रिंट होगा:

 [004, 034556] 

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

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

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

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

हमें तीन स्ट्रिंग मिलेंगी: [0, 0, 4] और नहीं, जैसा कि जावा 7 और इससे पहले के मामले में था। इसके समान सवाल भी देखें ।

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

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

आशा करता हूँ की ये काम करेगा.. 🙂

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

मार्ग 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); } } } 

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

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

जवाडॉक पर 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 str="004-034556" String[] sTemp=str.split("-");// '-' is a delimiter string1=004 // sTemp[0]; string2=034556//sTemp[1]; 
 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)); } } 

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

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

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

उत्पादन:

004
034,556

प्रलेखन से:

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 string = "004^034556-34"; String[] parts = string.split(Pattern.quote("^")); 

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

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

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

कभी-कभी यदि आप string containing + को विभाजित करना चाहते हैं तो यह विभाजन नहीं होगा; इसके बजाय आपको एक runtime error मिलेगी। उस स्थिति में, पहले replace + to _ और फिर विभाजित करें:

  this.text=text.replace("/", "_"); String temp[]=text.split("_");