बाइट से स्ट्रिंगबिल्डर बनाएं []

Question

byte[] से StringBuilder बनाने का कोई तरीका है?

मैं StringBuilder का उपयोग कर स्मृति के उपयोग में सुधार करना चाहते हैं, लेकिन क्या मैं पहली बार एक byte[] है, इसलिए मैं byte[] से एक String बनाने और उसके बाद String से StringBuilder बनाने के लिए है और मैं इष्टतम के रूप में इस समस्या का समाधान नहीं दिख रहा है।

धन्यवाद

Answer 1

मूल रूप से, आपका सबसे अच्छा विकल्प सीधे CharsetDecoder का उपयोग किया जा रहा है।

byte[] srcBytes = getYourSrcBytes(); 

//Whatever charset your bytes are endoded in 
Charset charset = Charset.forName("UTF-8"); 
CharsetDecoder decoder = charset.newDecoder(); 

//ByteBuffer.wrap simply wraps the byte array, it does not allocate new memory for it 
ByteBuffer srcBuffer = ByteBuffer.wrap(srcBytes); 
//Now, we decode our srcBuffer into a new CharBuffer (yes, new memory allocated here, no can do) 
CharBuffer resBuffer = decoder.decode(srcBuffer); 

//CharBuffer implements CharSequence interface, which StringBuilder fully support in it's methods 
StringBuilder yourStringBuilder = new StringBuilder(resBuffer); 

जोड़ा:

कुछ परीक्षण करने के बाद ऐसा लगता है कि सरल new String(bytes) तेज हो गया है और ऐसा लगता है वहाँ यह तेजी से है कि तुलना में बनाने के लिए कोई आसान तरीका है

यहाँ कैसे।

import java.io.IOException; 
import java.io.UnsupportedEncodingException; 
import java.nio.ByteBuffer; 
import java.nio.CharBuffer; 
import java.nio.charset.CharacterCodingException; 
import java.nio.charset.Charset; 
import java.nio.charset.CharsetDecoder; 
import java.text.ParseException; 

public class ConsoleMain { 
    public static void main(String[] args) throws IOException, ParseException { 
     StringBuilder sb1 = new StringBuilder("abcdefghijklmnopqrstuvwxyz"); 
     for (int i=0;i<19;i++) { 
      sb1.append(sb1); 
     } 
     System.out.println("Size of buffer: "+sb1.length()); 
     byte[] src = sb1.toString().getBytes("UTF-8"); 
     StringBuilder res; 

     long startTime = System.currentTimeMillis(); 
     res = testStringConvert(src); 
     System.out.println("Conversion using String time (msec): "+(System.currentTimeMillis()-startTime)); 
     if (!res.toString().equals(sb1.toString())) { 
      System.err.println("Conversion error"); 
     } 

     startTime = System.currentTimeMillis(); 
     res = testCBConvert(src); 
     System.out.println("Conversion using CharBuffer time (msec): "+(System.currentTimeMillis()-startTime)); 
     if (!res.toString().equals(sb1.toString())) { 
      System.err.println("Conversion error"); 
     } 
    } 

    private static StringBuilder testStringConvert(byte[] src) throws UnsupportedEncodingException { 
     String s = new String(src, "UTF-8"); 
     StringBuilder b = new StringBuilder(s); 
     return b; 
    } 

    private static StringBuilder testCBConvert(byte[] src) throws CharacterCodingException { 
     Charset charset = Charset.forName("UTF-8"); 
     CharsetDecoder decoder = charset.newDecoder(); 
     ByteBuffer srcBuffer = ByteBuffer.wrap(src); 
     CharBuffer resBuffer = decoder.decode(srcBuffer); 
     StringBuilder b = new StringBuilder(resBuffer); 
     return b; 
    } 
} 

परिणाम::

Size of buffer: 13631488 
Conversion using String time (msec): 91 
Conversion using CharBuffer time (msec): 252 

और एक संशोधित (कम स्मृति लेने वाली) IDEONE संस्करण: Here यहाँ परीक्षण मैं भाग गया है।

Answer 2

यदि यह छोटा कथन है जो आप चाहते हैं, तो स्ट्रिंग चरण के बीच में कोई रास्ता नहीं है। स्ट्रिंग कन्स्ट्रक्टर एक बहुत ही सामान्य मामले में सुविधा के लिए रूपांतरण और ऑब्जेक्ट निर्माण को मिश्रित करता है, लेकिन स्ट्रिंगबिल्डर के लिए ऐसा कोई सुविधा कन्स्ट्रक्टर नहीं है।

यदि यह प्रदर्शन आप में रुचि रखते हैं है, तो आप मध्यवर्ती स्ट्रिंग ऑब्जेक्ट कुछ इस तरह का उपयोग करके न करना चाहें:

new StringBuilder(Charset.forName(charsetName).decode(ByteBuffer.wrap(inBytes))) 

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

CharsetDecoder cd = Charset.forName(charsetName).newDecoder(); 
cd.onMalformedInput(CodingErrorAction.REPLACE); 
cd.onUnmappableCharacter(CodingErrorAction.REPLACE); 
int lengthEstimate = Math.ceil(cd.averageCharsPerByte()*inBytes.length) + 1; 
ByteBuffer inBuf = ByteBuffer.wrap(inBytes); 
CharBuffer outBuf = CharBuffer.allocate(lengthEstimate); 
StringBuilder out = new StringBuilder(lengthEstimate); 
CoderResult cr; 
while (true) { 
    cr = cd.decode(inBuf, outBuf, true); 
    out.append(outBuf); 
    outBuf.clear(); 
    if (cr.isUnderflow()) break; 
    if (!cr.isOverflow()) cr.throwException(); 
} 
cr = cd.flush(outBuf); 
if (!cr.isUnderflow()) cr.throwException(); 
out.append(outBuf); 

मुझे शक है कि इसके बाद के संस्करण कोड, हालांकि ज्यादातर अनुप्रयोगों में प्रयास के लायक हो जाएगा। यदि कोई एप्लिकेशन प्रदर्शन में रूचि रखता है, तो शायद इसे स्ट्रिंगबिल्डर से भी निपटना नहीं चाहिए, लेकिन बफर स्तर पर सब कुछ संभाल लें।