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

वोट
219

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

13/10/2008 को 07:10
का स्रोत उपयोगकर्ता
अन्य भाषाओं में...                            


14 जवाब

वोट
243

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

String s = "...stuff...";

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

यही कारण है कि मैं क्या कर सकता है। यह मेरे लिए सबसे आसान लगता है।

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

13/10/2008 को 07:13
का स्रोत उपयोगकर्ता

वोट
3

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

जावाडोक का कहना है:

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

13/10/2008 को 07:26
का स्रोत उपयोगकर्ता

वोट
0

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

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

में लंबाई रखो int lenऔर प्रयोग forपाश।

13/10/2008 को 07:34
का स्रोत उपयोगकर्ता

वोट
16

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

import java.text.*;

final CharacterIterator it = new StringCharacterIterator(s);
for(char c = it.first(); c != CharacterIterator.DONE; c = it.next()) {
   // process c
   ...
}
13/10/2008 को 07:38
का स्रोत उपयोगकर्ता

वोट
157

दो विकल्प

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

या

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

पहले शायद तेजी से है, तो 2 शायद अधिक पठनीय है।

13/10/2008 को 09:06
का स्रोत उपयोगकर्ता

वोट
0

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

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

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

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

हालांकि, मैं केवल उन्हें नकारने के प्रयोजन के लिए इन विकल्पों का उल्लेख है। दोनों तकनीकों चार पुरातन के बजाय एक चरित्र स्ट्रिंग में मूल स्ट्रिंग को तोड़ने, और दोनों ऑब्जेक्ट निर्माण और स्ट्रिंग परिवर्तन के रूप में भूमि के ऊपर के एक महान सौदा शामिल है। तुलना करें कि जो वास्तव में कोई भूमि के ऊपर पड़ता है पाश के लिए एक में बुला charAt (), करने के लिए।

13/10/2008 को 13:24
का स्रोत उपयोगकर्ता

वोट
22

मैं मानता हूँ कि StringTokenizer overkill यहाँ है। असल में मैं उपरोक्त सुझावों बाहर की कोशिश की और समय लगा।

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

मेरी 2.6 GHz Powerbook (जो एक मैक :-)) और JDK 1.5 पर परिणाम:

  • टेस्ट 1: charAt + स्ट्रिंग -> 3138msec
  • टेस्ट 2: स्ट्रिंग सरणी में बदला -> 9568msec
  • टेस्ट 3: StringBuilder charAt -> 3536msec
  • टेस्ट 4: CharacterIterator और स्ट्रिंग -> 12151msec

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

BTW मैं CharacterIterator उपयोग करने के लिए के रूप में मैं "यात्रा के अंत" एक बहुत भयानक हैक के रूप में '\ 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");
11/12/2008 को 22:08
का स्रोत उपयोगकर्ता

वोट
78

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

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

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

12/12/2008 को 00:04
का स्रोत उपयोगकर्ता

वोट
16

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

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

अद्यतन: @Alex के रूप में, ध्यान दिया जावा 8 के साथ वहाँ भी है CharSequence#charsउपयोग करने के लिए। यहां तक कि प्रकार IntStream है, इसलिए ऐसा लगता है कि वर्ण मैप किया जा सकता:

yourString.chars()
        .mapToObj(c -> Character.valueOf((char) c))
        .forEach(c -> System.out.println(c)); // Or whatever you want
08/03/2011 को 15:30
का स्रोत उपयोगकर्ता

वोट
9

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

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

या स्ट्रीम के बजाय सीधे एक के पाश के लिए उपयोग कर:

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

भी नहीं है CharSequence#charsअगर तुम (हालांकि यह एक है, वर्णों की एक धारा चाहते हैं IntStream, वहाँ कोई है के बाद से CharStream)।

06/01/2015 को 10:38
का स्रोत उपयोगकर्ता

वोट
0

पर विस्तार से चर्चा करते क्या यह उत्तर और इस जवाब

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

    String supplementary = "Some Supplementary: ";
    supplementary.codePoints().forEach(cp -> 
            System.out.print(new String(Character.toChars(cp))));
05/11/2016 को 23:59
का स्रोत उपयोगकर्ता

वोट
0

इस उदाहरण कोड आप बाहर मदद करेगा!

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);
    }
}
15/03/2017 को 09:39
का स्रोत उपयोगकर्ता

वोट
4

में जावा 8 हम इसे के रूप में हल कर सकते हैं:

String str = "xyz";
str.chars().forEachOrdered(i -> System.out.print((char)i));
str.codePoints().forEachOrdered(i -> System.out.print((char)i));

विधि वर्ण () एक रिटर्न IntStreamके रूप में में बताया गया डॉक :

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

विधि codePoints()भी एक रिटर्न IntStreamप्रति दस्तावेज़ के रूप में:

इस क्रम से कोड अंक मान की एक धारा देता है। अनुक्रम में आई किसी भी सरोगेट जोड़े के रूप में Character.toCodePoint द्वारा अगर जोड़ दिया जाता है और परिणाम धारा में भेजा जाता है। साधारण बीएमपी वर्ण, अयुगल सरोगेट्स और अपरिभाषित कोड इकाइयों सहित किसी भी अन्य कोड इकाइयों,, मूल्यों जो तब धारा को पास किया जाता int करने के लिए शून्य विस्तारित कर रहे हैं।

कैसे चार और कोड बिंदु अलग है? में उल्लेख किया है इस लेख:

यूनिकोड 3.1 अनुपूरक वर्ण जोड़ा, अधिक से अधिक 216 अक्षर है कि एक भी 16 बिट से प्रतिष्ठित किया जा सकता करने के लिए वर्णों की कुल संख्या लाने char। इसलिए, एक charमूल्य नहीं रह गया है यूनिकोड में मौलिक अर्थ इकाई के लिए एक एक-से-एक मानचित्रण है। JDK 5 चरित्र मूल्यों के बड़े सेट का समर्थन करने के अद्यतन किया गया था। की परिभाषा को बदलने के बजाय charप्रकार, नई अनुपूरक पा