दिलचस्प पोस्ट
पायथन पर कीबोर्ड और माउस अनुकरण करने का सबसे आसान तरीका कौन सा है? आधा उपलब्ध स्क्रीन चौड़ाई की घोषणा चौड़ाई के लिए चौड़ाई निर्दिष्ट करें SSL प्रमाणपत्र विश्वसनीय नहीं है – केवल मोबाइल पर संदर्भ – PHP में यह त्रुटि क्या है? मानचित्र जो मूल्यों के क्रम में दोहराया जा सकता है रेजर MVC3 का उपयोग करके सशर्त HTML गुण यूआई-राउटर में पथ एलियास को कार्यान्वित कैसे करें जावा: एक पाठ फ़ाइल कैसे पढ़ा जाए सी # में एक अस्थायी और अपरिवर्तनीय स्ट्रिंग के बीच क्या अंतर है? अनुक्रमिक गिनती जेनरेटर एंड्रॉइड में कोड से स्टाइल सेट करना इतना जटिल क्यों है Jquery शर्त जांच (': होवर') काम नहीं कर रहा है सी # एचटीटीपी क्लाइंट 4.5 मल्टीपार्ट / फॉर्म-डेटा अपलोड चहचहाना बूटस्ट्रैप संकुचित प्लगइन दिशा-क्षैतिज के बजाय कार्यक्षेत्र MySQL डेटाबेस में एक्सेल फ़ाइल कन्वर्ट करने के लिए कैसे?

जावा में एक स्ट्रिंग के वर्णों के माध्यम से पुनरावृति करने के लिए सबसे आसान / सबसे अच्छा / सबसे सही तरीका क्या है?

StringTokenizer ? String को एक char[] परिवर्तित करें और उस पर पुनरावृत्त करें? कुछ और?

Solutions Collecting From Web of "जावा में एक स्ट्रिंग के वर्णों के माध्यम से पुनरावृति करने के लिए सबसे आसान / सबसे अच्छा / सबसे सही तरीका क्या है?"

मैं स्ट्रिंग को पुनरावृति करने के लिए लूप का उपयोग करता हूं और प्रत्येक चरित्र को जांचने के लिए charAt() का उपयोग करता हूं। चूंकि स्ट्रिंग को एक सरणी के साथ कार्यान्वित किया जाता है, charAt() विधि एक निरंतर समय संचालन है।

 String s = "...stuff..."; for (int i = 0; i < s.length(); i++){ char c = s.charAt(i); //Process char } 

यही मैं क्या करूँगा यह मेरे लिए आसान लगता है

जहां तक ​​शुद्धता होती है, मुझे विश्वास नहीं होता कि यहां मौजूद है। यह आपकी व्यक्तिगत शैली पर आधारित है

दो विकल्प

 for(int i = 0, n = s.length() ; i < n ; i++) { char c = s.charAt(i); } 

या

 for(char c : s.toCharArray()) { // process c } 

सबसे पहले संभवतः तेज है, फिर दूसरा शायद अधिक पठनीय है।

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

उस स्थिति में आपका कोड होगा:

 String str = "...."; int offset = 0, strLen = str.length(); while (offset < strLen) { int curChar = str.codePointAt(offset); offset += Character.charCount(curChar); // do something with curChar } 

Character.charCount(int) विधि में जावा 5+ की आवश्यकता होती है

स्रोत: http://mindprod.com/jgloss/codepoint.html

मैं मानता हूं कि स्ट्रिंगटोकनाइज़र यहां ओवरकिल है। दरअसल मैंने उपरोक्त सुझावों का प्रयास किया और समय लिया।

मेरा परीक्षण काफी सरल था: एक स्ट्रिंगबिलर बनाने के बारे में करीब दस लाख अक्षर हैं, इसे एक स्ट्रिंग में परिवर्तित करें, और चार एट () के साथ / चार अक्षरों में कनवर्ट करने के बाद / एक चरित्र के साथ एक हजार बार (निश्चित रूप से सुनिश्चित करने के लिए) स्ट्रिंग पर कुछ करें ताकि कम्पाइलर पूरे लूप को दूर नहीं कर सकें :-))।

मेरे 2.6 GHz पावरबुक पर नतीजा (जो मैक 🙂 है) और जेडीके 1.5:

  • टेस्ट 1: चारएट + स्ट्रिंग -> 3138msec
  • टेस्ट 2: स्ट्रिंग को सरणी में रूपांतरित किया गया -> 9568 मिसेक
  • टेस्ट 3: स्ट्रिंगबिल्ल्डर चारएट -> 3536 मिसेक
  • टेस्ट 4: कैरेक्टर इटरेटर और स्ट्रिंग -> 12151 मिसे

जैसा कि परिणाम बहुत अलग हैं, सबसे सीधा रास्ता भी सबसे तेज़ लगता है दिलचस्प बात यह है कि स्ट्रिंगबिइल्डर के चारएट (स्ट्रेटबिल्टर) स्ट्रिंग की तुलना में थोड़ी धीमी लगती हैं।

बीटीडब्लूडब्लू (WTF) मैं 'चरित्र का उपयोग नहीं करने का सुझाव देता हूं क्योंकि मैं इसे' \ uFFFF 'चरित्र के दुरुपयोग पर विचार करता हूं "वास्तव में भयानक हैक" "अंतराल के अंत" के रूप में। बड़ी परियोजनाओं में हमेशा दो लोग हैं जो दो अलग-अलग उद्देश्यों के लिए एक ही तरह के हैक का उपयोग करते हैं और कोड वास्तव में रहस्यमय ढंग से क्रैश करता है

यहां एक परीक्षण है:

  int count = 1000; ... System.out.println("Test 1: charAt + String"); long t = System.currentTimeMillis(); int sum=0; for (int i=0; i<count; i++) { int len = str.length(); for (int j=0; j<len; j++) { if (str.charAt(j) == 'b') sum = sum + 1; } } t = System.currentTimeMillis()-t; System.out.println("result: "+ sum + " after " + t + "msec"); 

इसके लिए कुछ समर्पित कक्षाएं हैं:

 import java.text.*; final CharacterIterator it = new StringCharacterIterator(s); for(char c = it.first(); c != CharacterIterator.DONE; c = it.next()) { // process c ... } 

यदि आप अपने क्लासपाथ पर अमरूद हैं , तो निम्नलिखित एक सुंदर पठनीय विकल्प है। अमरूद के इस मामले में अमरूद भी काफी सुसंगत कस्टम सूची क्रियान्वयन है, इसलिए इसे अक्षम नहीं होना चाहिए।

 for(char c : Lists.charactersOf(yourString)) { // Do whatever you want } 

अद्यतनः जैसा @ एलेक्स ने लिखा, जावा 8 के साथ ही उपयोग करने के लिए CharSequence#chars Chars भी है यहां तक ​​कि टाइप भी इंटस्ट्रीम है, इसलिए इसे वर्णों की तरह मैप किया जा सकता है:

 yourString.chars() .mapToObj(c -> Character.valueOf((char) c)) .forEach(c -> System.out.println(c)); // Or whatever you want 

यदि आपको String के कोड बिंदुओं के माध्यम से पुनरावृत्त करने की आवश्यकता है (यह उत्तर देखें) एक छोटे / अधिक पठनीय तरीका है कि जावा 8 में जोड़ा गया CharSequence#codePoints विधि का उपयोग करना है:

 for(int c : string.codePoints().toArray()){ ... } 

या सीधे लूप के लिए स्ट्रीम का उपयोग करते हुए:

 string.codePoints().forEach(c -> ...); 

अगर आप पात्रों की एक धारा चाहते हैं तो CharSequence#chars भी है (हालांकि यह एक IntStream , चूंकि कोई CharStream नहीं है)।

मैं स्ट्रिंगटोकनाइज़र का उपयोग नहीं करूंगा क्योंकि यह StringTokenizer की कक्षाओं में से एक है जो विरासत है

जवाडॉक कहता है:

StringTokenizer एक लीगेसी क्लास है जिसे संगतता के कारणों के लिए रखा गया है, हालांकि इसके उपयोग को नए कोड में हतोत्साहित किया गया है। यह अनुशंसा की जाती है कि इस कार्यक्षमता की तलाश करने वाले कोई भी String या java.util.regex पैकेज के विभाजन विधि का उपयोग करें।

जावा ट्यूटोरियल देखें : स्ट्रिंग्स

 public class StringDemo { public static void main(String[] args) { String palindrome = "Dot saw I was Tod"; int len = palindrome.length(); char[] tempCharArray = new char[len]; char[] charArray = new char[len]; // put original string in an array of chars for (int i = 0; i < len; i++) { tempCharArray[i] = palindrome.charAt(i); } // reverse array of chars for (int j = 0; j < len; j++) { charArray[j] = tempCharArray[len - 1 - j]; } String reversePalindrome = new String(charArray); System.out.println(reversePalindrome); } } 

लेंस में लम्बा और लंबाई का प्रयोग करें।

StringTokenizer पूरी तरह से अपने व्यक्तिगत वर्णों में एक स्ट्रिंग को तोड़ने के कार्य के लिए अनुपयुक्त है। String#split() आप आसानी से एक regex का उपयोग करके ऐसा कर सकते हैं जो कुछ भी मेल न हो, जैसे:

 String[] theChars = str.split("|"); 

लेकिन StringTokenizer regexes का उपयोग नहीं करता है, और कोई सीमांकक स्ट्रिंग नहीं है जो आप निर्दिष्ट कर सकते हैं कि वर्णों के बीच कुछ भी मेल नहीं खाएगा। एक प्यारा सा हैक का उपयोग आप एक ही चीज़ को पूरा करने के लिए कर सकते हैं: स्ट्रिंग का उपयोग सीमांकक स्ट्रिंग के रूप में करें (प्रत्येक चरित्र को सीमांकक बनाकर) और इसे सीमांकक वापस लौटाएं:

 StringTokenizer st = new StringTokenizer(str, str, true); 

हालांकि, मैं इन विकल्पों को केवल उनको खारिज करने के लिए बताता हूं दोनों तकनीकों को मूल स्ट्रिंग को मूल रूप से वर्णों के बजाय एक अक्षर के तारों में तोड़ते हैं, और दोनों में वस्तु निर्माण और स्ट्रिंग हेरफेर के रूप में बहुत अधिक उपरि शामिल होता है। इसकी तुलना लूप के लिए चारएट () को कॉल करने के लिए करें, जो वस्तुतः कोई ओवरहेड नहीं है।

इस उत्तर पर विस्तार और यह उत्तर ।

उपरोक्त उत्तर यहां कई समाधानों की समस्या को इंगित करते हैं जो कोड बिंदु मूल्य से दोबारा नहीं करते – उन्हें किसी भी किराए के वर्णों के साथ परेशानी पड़ेगी। जावा डॉक्स भी इस मुद्दे को रूपरेखा देते हैं ("यूनिकोड कैरेक्टर रिप्रेजेंटेशन" देखें) किसी भी तरह, यहाँ कुछ कोड है जो पूरक यूनिकोड सेट से कुछ वास्तविक सरोगेट वर्ण का उपयोग करता है, और उन्हें वापस स्ट्रिंग में रूपांतरित करता है। ध्यान दें कि। ToChars () वर्णों की एक सरणी देता है: यदि आप सरोगेट्स के साथ काम कर रहे हैं, तो आपके पास दो वर्ण होंगे यह कोड किसी भी यूनिकोड वर्ण के लिए काम करना चाहिए।

  String supplementary = "Some Supplementary: 𠜎𠜱𠝹𠱓"; supplementary.codePoints().forEach(cp -> System.out.print(new String(Character.toChars(cp)))); 

यह उदाहरण कोड आपकी सहायता करेगा!

 import java.util.Comparator; import java.util.HashMap; import java.util.Map; import java.util.TreeMap; public class Solution { public static void main(String[] args) { HashMap<String, Integer> map = new HashMap<String, Integer>(); map.put("a", 10); map.put("b", 30); map.put("c", 50); map.put("d", 40); map.put("e", 20); System.out.println(map); Map sortedMap = sortByValue(map); System.out.println(sortedMap); } public static Map sortByValue(Map unsortedMap) { Map sortedMap = new TreeMap(new ValueComparator(unsortedMap)); sortedMap.putAll(unsortedMap); return sortedMap; } } class ValueComparator implements Comparator { Map map; public ValueComparator(Map map) { this.map = map; } public int compare(Object keyA, Object keyB) { Comparable valueA = (Comparable) map.get(keyA); Comparable valueB = (Comparable) map.get(keyB); return valueB.compareTo(valueA); } }