N वर्णों के साथ एक स्ट्रिंग बनाएँ

Question

क्या जावा में एक निर्दिष्ट चरित्र की एक निर्दिष्ट संख्या के साथ एक स्ट्रिंग बनाने का एक तरीका है? मेरे मामले में, मुझे 10 स्थानों के साथ एक स्ट्रिंग बनाने की आवश्यकता होगी। मेरा वर्तमान कोड है:

StringBuffer outputBuffer = new StringBuffer(length);
for (int i = 0; i < length; i++){
   outputBuffer.append(" ");
}
return outputBuffer.toString();

क्या एक ही चीज़ को पूरा करने का एक बेहतर तरीका है। विशेष रूप से मुझे कुछ ऐसा चाहिए जो तेज़ हो (निष्पादन के मामले में)।

Comments

यदि आप खुद को ऐसा करते हुए पाते हैं, तो एक फंक्शन लिखें: स्ट्रिंग कैरेक्टररिपेट (चार सी, इंट लेंथ) {...} जो आप किसी भी कैरेक्टर और किसी भी लेंथ के लिए करते हैं। फिर जरूरत पड़ने पर ही फोन करें।

— ऑस्टिन फिट्जपैट्रिक

आप StringBuer के बजाय StringBuilder का उपयोग करना चाहते हैं

बफ़र के आकार को भीख में जोड़ें, स्मृति प्रबंधन में चीजों की सुविधा की गणना करना आसान है! StringBuilder आउटपुट Buffer = नया StringBuilder (दोहराएँ * base.length ());

— विक्टर

इसे भी देखें: stackoverflow.com/questions/1235179/…

— डेव जार्विस

यदि आप किसी एकल स्थान को जोड़ना चाहते हैं, तो append(' ')इसके स्थान पर उपयोग करें ... इसमें थोड़ा कम कंप्यूटिंग शामिल है ...

— Erk

Answer 1

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

BTW, अगर वहाँ n अंतरिक्ष वर्णों के साथ एक स्ट्रिंग बनाने का एक तरीका है, तो यह उसी तरह कोडित है जैसे आपने अभी किया था।

Comments

भले ही यह अनुकूलित नहीं था - आपके कार्यक्रम में यह कितनी बार बनाया गया है - यदि अक्सर एक स्थिर चर या अन्य कैश में सहेजा जाता है

— mmmmmm

btw Array.fill () केवल सरणी के माध्यम से लूप करता है। / मुझे दूसरों के पदों पर टिप्पणी करने के लिए निश्चित रूप से अधिक बिंदुओं की आवश्यकता है :)

— कलकिन

@ मर्क लेंथ परिवर्तनशील है, इसलिए इसे सहेजना मूर्खतापूर्ण लगता है। मैं क्या करूँगा, क्या है static Dictionary<int, String>?

— सी। रोस

सबसे लंबे समय तक स्टोर करें जिसे आप कभी भी स्ट्रिंग चाहते हैं, तो कुछ इस तरह का उपयोग करें: " ".substring(0, 10);

— mjaggard

Answer 2

Stringविशेष रूप से एपीआई का उपयोग करते हुए सबसे छोटा कोड :

String space10 = new String(new char[10]).replace('\0', ' ');

System.out.println("[" + space10 + "]");
// prints "[          ]"

---

एक विधि के रूप में, बिना सीधे तात्कालिकता के char:

import java.nio.CharBuffer;

/**
 * Creates a string of spaces that is 'spaces' spaces long.
 *
 * @param spaces The number of spaces to add to the string.
 */
public String spaces( int spaces ) {
  return CharBuffer.allocate( spaces ).toString().replace( '\0', ' ' );
}

उपयोग करें:

System.out.printf( "[%s]%n", spaces( 10 ) );

Comments

भले ही मुझे वन-लाइनर पसंद है, मुझे लगता है कि FrustratedWithFormsDes का समाधान तब बेहतर होता है जब इसे क्रियान्वित करने की बारी आती है क्योंकि यह प्रत्येक 0 के लिए जाँच से बचता है और बस स्थान असाइन करता है।

— बाउंसर

परीक्षण किया गया, यह लूप की तुलना में हमेशा तेज होता है, लगातार 50000-100000 नैनो सेकंड तेजी से, जो कि काफी महत्वपूर्ण हो सकता है (0.1 मिलीसेकंड) लूप तेज हो जाता है क्योंकि पुनरावृत्तियों की संख्या बढ़ जाती है, हालांकि कुल समय अभी भी अधिक है। यह अंतरिक्ष के विभिन्न आकारों के निर्माण के लिए सही है।

— किमीकैप

बहुत अच्छे समाधान के लिए प्रहार करें, मैंने अपने उत्तर में इसका इस्तेमाल किया है stackoverflow.com/questions/852665/…

— maytham-ɯɐɥʇʎɐɯ

Answer 3

हम्म कि अब मैं इसके बारे में सोचते हैं, शायद Arrays.fill:

char[] charArray = new char[length];
Arrays.fill(charArray, ' ');
String str = new String(charArray);

बेशक, मैं मानता हूं कि fillविधि आपके कोड के समान काम करती है, इसलिए यह संभवतः उसी के बारे में प्रदर्शन करेगी, लेकिन कम से कम यह कम लाइनें है।

Comments

स्रोत की जाँच करने के बाद, ऐसा लगता है कि यह वास्तव में वही करता है जो ओपी ने पोस्ट किया था: रेखा 806 of docjar.com/html/api/java/util/Arrays.java.html

— पोप्स

@ लॉर्ड टोर्गामस ओपी के प्रश्न को संपादित किया गया था? क्योंकि जिस संस्करण में मैं देख रहा हूं, वह StringBuffer.append () पर लूपिंग कर रहा है, और Frustrated का संस्करण एक फिल कर रहा है (जो निश्चित रूप से सरणी में चार असाइनमेंट कर रहा है)। बिलकुल एक ही बात नहीं।

— CPerkins

@CPerkins, काफी साफ है, मैं स्पष्ट नहीं था। मेरा कहना यह है कि दोनों एक लूप के अंदर कैरेक्टर-बाय-कैरेक्टर इंसर्शन करते हैं।

— पॉप

@ लॉर्ड तोर्गामस - उस पर सहमत हुए। अफ़सोस की बात है कि jvm सिर्फ एक मेमसेट नहीं कर सकता है। मूल्य हम व्यापक पात्रों के लिए भुगतान करते हैं।

— CPerkins

@Pops यह ध्यान देने योग्य है कि यदि Arrays.fill()फ़ंक्शन आपके कोड और (मानक और बाहरी) लाइब्रेरी कोड में इस काम को करने के लिए लगातार उपयोग किया जाता है , तो यह हॉटस्पॉट संकलन के लिए एक अच्छा उम्मीदवार बनाता है, और आपके CPU कैश पाए जाने का एक बेहतर मौका खड़ा करता है। भविष्य के JVM इसे एक आंतरिक कार्य के रूप में निर्दिष्ट कर सकते हैं । इस सभी प्रदर्शन अच्छाई से अलग होने पर आपकी खुद की

— कटिंग को रोल करना

Answer 4

मैं अत्यधिक सुझाव देता हूं कि लूप को हाथ से न लिखें। आप अपने प्रोग्रामिंग कैरियर के दौरान बार-बार ऐसा करेंगे। आपके कोड को पढ़ने वाले लोग - जिसमें आप शामिल हैं - हमेशा समय का निवेश करना पड़ता है, भले ही यह केवल कुछ सेकंड हो, लूप के अर्थ को पचाने के लिए।

इसके बजाय पुन: उपयोग है कि बस करता कोड उपलब्ध कराने उपलब्ध पुस्तकालयों में से एक इस तरह StringUtils.repeatसे अपाचे कॉमन्स लैंग :

StringUtils.repeat(' ', length);

इस तरह आपको प्रदर्शन के बारे में परेशान करने की ज़रूरत नहीं है, इस प्रकार StringBuilder, कंपाइलर ऑप्टिमाइज़ेशन इत्यादि के सभी गैरी विवरण छिपे हुए हैं। यदि फ़ंक्शन धीमा हो जाता है तो यह लाइब्रेरी का बग होगा।

जावा 11 के साथ यह और भी आसान हो जाता है:

" ".repeat(length);

Comments

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

— एरिच किट्ज़म्यूलर

यदि यह धीमा हो गया है तो आप फ़ंक्शन के लिए अपना फिक्स भी जमा कर सकते हैं।

— होगा

Answer 5

जावा 8 में आप उपयोग कर सकते हैं String.join:

String.join("", Collections.nCopies(n, s));

Answer 6

यदि आप केवल स्थान चाहते हैं, तो कैसे के बारे में:

String spaces = (n==0)?"":String.format("%"+n+"s", "");

जिसके परिणामस्वरूप एब्स (एन) रिक्त स्थान होंगे;

Comments

हालांकि यह गति के लिए कैसा है? मैं इंप्रेशन फॉर्मेट के अंतर्गत हूं, अपेक्षाकृत धीमी है। इससे पहले कि इसे बनाने के बाद इसे स्ट्रिंग को पार्स करना पड़े।

— सी। रॉस

Answer 7

जावा 11 के बाद से :

" ".repeat(10);

---

के बाद से जावा 8 :

generate(() -> " ").limit(10).collect(joining());

कहाँ पे:

import static java.util.stream.Collectors.joining;
import static java.util.stream.Stream.generate;

Answer 8

जावा 11 के बाद से आप बस String.repeat(count)अपनी समस्या को हल करने के लिए उपयोग कर सकते हैं ।

एक स्ट्रिंग लौटाता है, जिसका मान इस स्ट्रिंग का बार- countबार समाप्‍त होता है ।

यदि यह स्ट्रिंग खाली है या countशून्य है तो खाली स्ट्रिंग लौटा दी जाती है।

एक लूप के बजाय आपका कोड इस तरह दिखेगा:

" ".repeat(length);

Answer 9

मुझे लगता है कि यह कम संभव कोड है, यह अमरूद जॉइनर वर्ग का उपयोग करता है:

जॉइनर .on ("")। Join ( कलेक्शंस .nCopies ( 10, ""));

Comments

कोड की सबसे छोटी पंक्ति लेकिन उस सरल कार्य के लिए एक बड़ी लाइब्रेरी जोड़ने से कोई मतलब नहीं है। मैं एक एकल JAR को एक एकल विधि से बना सकता हूं pubic String n(int n) { ... }जो "कम" कोड को भी अनुमति देगा: n(10)लेकिन फिर से, कोई मतलब नहीं है।

— इपिर

@isapir यह उन लोगों के लिए बहुत अच्छा जवाब है जो पहले से ही अमरूद

— नास

@ ज्ञानचंद अमरूद सवाल का हिस्सा नहीं था। लेकिन वैसे भी, 2018 में वास्तव में अमरूद के जॉइनर का उपयोग करने का कोई कारण नहीं है जब आप String.join () का उपयोग कर सकते हैं जो कि जावा 8 में जोड़ा गया था। देखें stackoverflow.com/a/43011939/968244

— isapir

@isapir नहीं, अमरूद एक जवाब था। StackOverflow के उत्तर में व्यापक सवाल पूछने वाले व्यक्ति की तुलना में व्यापक दर्शक होते हैं, इसलिए यह ठीक है यदि कुछ उत्तर पूछने वाले के लिए सर्वश्रेष्ठ नहीं हैं। और String.join () के बारे में टिप्पणी एक महान है, हालांकि मुझे यकीन नहीं है कि यह एंड्रॉइड के सभी संस्करणों पर उपलब्ध है, जो जावा का एक प्रमुख उपयोग है।

— नास

Answer 10

आप String.formatएन रिक्त स्थान उत्पन्न करने के लिए मानक फ़ंक्शन का उपयोग कर सकते हैं । उदाहरण के लिए:

String.format("%5c", ' ');

5 स्थानों के साथ एक स्ट्रिंग बनाता है।

या

int count = 15;
String fifteenSpacebars = String.format("%" + count + "c", ' ');

15 स्पेसबार की एक स्ट्रिंग बनाता है।

यदि आप दूसरा प्रतीक दोहराना चाहते हैं, तो आपको अपने इच्छित प्रतीक के साथ रिक्त स्थान को बदलना होगा:

int count = 7;
char mySymbol = '#';
System.out.println(String.format("%" + count + "c", ' ').replaceAll("\\ ", "\\" + mySymbol));

आउटपुट:

#######

Answer 11

तेजी से घातांक के लिए एल्गोरिथ्म पर आधारित मेरा योगदान।

/**
 * Repeats the given {@link String} n times.
 * 
 * @param str
 *            the {@link String} to repeat.
 * @param n
 *            the repetition count.
 * @throws IllegalArgumentException
 *             when the given repetition count is smaller than zero.
 * @return the given {@link String} repeated n times.
 */
public static String repeat(String str, int n) {
    if (n < 0)
        throw new IllegalArgumentException(
                "the given repetition count is smaller than zero!");
    else if (n == 0)
        return "";
    else if (n == 1)
        return str;
    else if (n % 2 == 0) {
        String s = repeat(str, n / 2);
        return s.concat(s);
    } else
        return str.concat(repeat(str, n - 1));
}

मैंने एल्गोरिथ्म का परीक्षण दो अन्य तरीकों के खिलाफ किया:

• लूप के लिए नियमित रूप String.concat()से स्ट्रिंग स्ट्रिंग का उपयोग करना
• एक का उपयोग कर लूप के लिए नियमित StringBuilder

टेस्ट कोड (एक लूप के लिए उपयोग करना और String.concat()बड़े के लिए धीमा हो जाता है n, इसलिए मैंने इसे 5 वें पुनरावृत्ति के बाद छोड़ दिया)।

/**
 * Test the string concatenation operation.
 * 
 * @param args
 */
public static void main(String[] args) {
    long startTime;
    String str = " ";

    int n = 1;
    for (int j = 0; j < 9; ++j) {
        n *= 10;
        System.out.format("Performing test with n=%d\n", n);

        startTime = System.currentTimeMillis();
        StringUtil.repeat(str, n);
        System.out
                .format("\tStringUtil.repeat() concatenation performed in    %d milliseconds\n",
                        System.currentTimeMillis() - startTime);

        if (j <5) {
            startTime = System.currentTimeMillis();
            String string = "";
            for (int i = 0; i < n; ++i)
                string = string.concat(str);
            System.out
                    .format("\tString.concat() concatenation performed in        %d milliseconds\n",
                            System.currentTimeMillis() - startTime);
        } else
            System.out
                    .format("\tString.concat() concatenation performed in        x milliseconds\n");
        startTime = System.currentTimeMillis();
        StringBuilder b = new StringBuilder();
        for (int i = 0; i < n; ++i)
            b.append(str);
        b.toString();
        System.out
                .format("\tStringBuilder.append() concatenation performed in %d milliseconds\n",
                        System.currentTimeMillis() - startTime);
    }
}

परिणाम:

Performing test with n=10
    StringUtil.repeat() concatenation performed in    0 milliseconds
    String.concat() concatenation performed in        0 milliseconds
    StringBuilder.append() concatenation performed in 0 milliseconds
Performing test with n=100
    StringUtil.repeat() concatenation performed in    0 milliseconds
    String.concat() concatenation performed in        1 milliseconds
    StringBuilder.append() concatenation performed in 0 milliseconds
Performing test with n=1000
    StringUtil.repeat() concatenation performed in    0 milliseconds
    String.concat() concatenation performed in        1 milliseconds
    StringBuilder.append() concatenation performed in 1 milliseconds
Performing test with n=10000
    StringUtil.repeat() concatenation performed in    0 milliseconds
    String.concat() concatenation performed in        43 milliseconds
    StringBuilder.append() concatenation performed in 5 milliseconds
Performing test with n=100000
    StringUtil.repeat() concatenation performed in    0 milliseconds
    String.concat() concatenation performed in        1579 milliseconds
    StringBuilder.append() concatenation performed in 1 milliseconds
Performing test with n=1000000
    StringUtil.repeat() concatenation performed in    0 milliseconds
    String.concat() concatenation performed in        x milliseconds
    StringBuilder.append() concatenation performed in 10 milliseconds
Performing test with n=10000000
    StringUtil.repeat() concatenation performed in    7 milliseconds
    String.concat() concatenation performed in        x milliseconds
    StringBuilder.append() concatenation performed in 112 milliseconds
Performing test with n=100000000
    StringUtil.repeat() concatenation performed in    80 milliseconds
    String.concat() concatenation performed in        x milliseconds
    StringBuilder.append() concatenation performed in 1107 milliseconds
Performing test with n=1000000000
    StringUtil.repeat() concatenation performed in    1372 milliseconds
    String.concat() concatenation performed in        x milliseconds
    StringBuilder.append() concatenation performed in 12125 milliseconds

निष्कर्ष:

• बड़े के लिए n- पुनरावर्ती दृष्टिकोण का उपयोग करें
• छोटे के लिए n- लूप के लिए पर्याप्त गति है

Comments

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

— क्लिटोस काइराकौ

माइक्रो-बेंचमार्किंग के दौरान कुछ सावधानियां बरतने की ज़रूरत होती है, और मुझे नहीं लगता कि आप उनमें से किसी को ले रहे हैं! इस कोड के आसपास के प्रमुख प्रदर्शन के प्रश्न आसानी से हो सकते हैं कि क्या यह हॉटस्पॉट-संकलित है, यह कितना कचरा बनाता है, आदि। मैं शर्त लगाता हूं कि वे सभी ifकथन सीपीयू की शाखा भविष्यवाणी को गड़बड़ाने वाले हैं। यह वास्तव में JMH ( openjdk.java.net/projects/code-tools/jmh ) का उपयोग करके फिर से किया जाना चाहिए , अन्यथा यह थोड़ा व्यर्थ है।

— सुसानडब्लू

ध्यान दें कि इस कार्यान्वयन में O (n * लॉग एन) जटिलता है, जबकि स्ट्रिंगब्रुलेटी O (n) :)

— लियो लिट्टेव

Answer 12

इस बारे में कैसा है?

char[] bytes = new char[length];
Arrays.fill(bytes, ' ');
String str = new String(bytes);

Comments

यह इस मौजूदा जवाब के

— क्रीज

Answer 13

हमारे पास ध्यान में रखते हुए:

String c = "c"; // character to repeat, for empty it would be " ";
int n = 4; // number of times to repeat
String EMPTY_STRING = ""; // empty string (can be put in utility class)

जावा 8 (स्ट्रीम का उपयोग करके)

String resultOne = IntStream.range(0,n)
   .mapToObj(i->c).collect(Collectors.joining(EMPTY_STRING)); // cccc

जावा 8 (nCopies का उपयोग करके)

String resultTwo = String.join(EMPTY_STRING, Collections.nCopies(n, c)); //cccc

Comments

Collectors.joining(EMPTY_STRING)के बराबर हैCollectors.joining()

— PPartisan

Answer 14

RandomStringUtils में दिए गए इनपुट साइज से एक स्ट्रिंग बनाने का प्रावधान है। खिचड़ी भाषा की गति पर टिप्पणी करते हैं, लेकिन इसकी एक लाइनर है।

RandomStringUtils.random(5,"\t");

एक आउटपुट बनाता है

\ T \ t \ t \ t \ t

बेहतर अगर आप अपने कोड में \ 0 देखना नहीं चाहते हैं ।

Answer 15

StringUtils का उपयोग करें: StringUtils.repeat ('', 10)

Answer 16

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

Answer 17

अमरूद के साथ सबसे छोटा घोल:

Strings.repeat(" ", len)

के माध्यम से सरल तरीका जावा में एक स्ट्रिंग को दोहराने के लिए ।

Answer 18

बस अपने StringBuffer को एक StringBuilder से बदलें । उसको हराना मुश्किल।

यदि आपकी लंबाई एक बड़ी संख्या है, तो आप प्रत्येक पुनरावृत्ति में लंबाई को दोहराते हुए कुछ अधिक कुशल (लेकिन अधिक अनाड़ी) आत्म-परिशिष्ट लागू कर सकते हैं:

 public static String dummyString(char c, int len) {
  if( len < 1 ) return "";
  StringBuilder sb = new StringBuilder(len).append(c);
  int remnant = len - sb.length();
  while(remnant  > 0) {
   if( remnant  >= sb.length() ) sb.append(sb);
   else sb.append(sb.subSequence(0, remnant));
   remnant  = len - sb.length();
  }
  return sb.toString();
 }

इसके अलावा, आप Arrays.fill()aproach ( FrustratedWithFormsDesigner का उत्तर) आज़मा सकते हैं ।

Comments

क्या आप एक से अधिक वर्णों में से कुछ चर नाम दे सकते हैं?

— सी। रॉस

Answer 19

आप बदल सकते हैं StringBufferसाथStringBuilder (उत्तरार्द्ध सिंक्रनाइज़ नहीं है, एक एकल थ्रेड ऐप में तेज़ हो सकता है)

और आप StringBuilderएक बार उदाहरण बना सकते हैं , इसे बनाने के बजाय हर बार जब आपको इसकी आवश्यकता हो।

कुछ इस तरह:

class BuildString {
     private final StringBuilder builder = new StringBuilder();
     public String stringOf( char c , int times ) {

         for( int i = 0 ; i < times ; i++  ) {
             builder.append( c );
         }
         String result = builder.toString();
         builder.delete( 0 , builder.length() -1 );
         return result;
      }

  }

और इसे इस तरह से उपयोग करें:

 BuildString createA = new BuildString();
 String empty = createA.stringOf( ' ', 10 );

यदि आप createAएक उदाहरण चर के रूप में पकड़ते हैं , तो आप समय बनाने के उदाहरणों को बचा सकते हैं।

यह थ्रेड सुरक्षित नहीं है, यदि आपके पास बहु थ्रेड हैं, तो प्रत्येक थ्रेड की अपनी प्रतिलिपि होनी चाहिए।

Answer 20

अच्छे प्रदर्शन के लिए, aznilamir और FrustratedWithFormsDesigner से जवाब मिलाएं

private static final String BLANKS = "                       ";
private static String getBlankLine( int length )
{
    if( length <= BLANKS.length() )
    {
        return BLANKS.substring( 0, length );
    }
    else
    {
        char[] array = new char[ length ];
        Arrays.fill( array, ' ' );
        return new String( array );
    }
}

BLANKSअपनी आवश्यकताओं के आधार पर आकार समायोजित करें। मेरी विशिष्ट BLANKSस्ट्रिंग लगभग 200 वर्णों की लंबाई है।

Answer 21

इस तरह एक विधि है। यह दी गई जगह के अंत में आवश्यक स्पेस देता Stringहै ताकि किसी Stringविशिष्ट लंबाई को लंबाई दी जा सके।

public static String fillSpaces (String str) {

    // the spaces string should contain spaces exceeding the max needed
    String spaces = "                                                   ";
    return str + spaces.substring(str.length());
}

Answer 22

डेटा को सारणीबद्ध करने के लिए स्ट्रिंग को निश्चित आकार का होना चाहिए, ताकि आप या तो पैड या ट्रंकट करें ...

class Playground {
    private static String fixStrSize(String s, int n) {
        return String.format("%-" + n + "s", String.format("%." + n +"s", s));
    }

    public static void main(String[ ] args) {
        System.out.println("|"+fixStrSize("Hell",8)+"|");
        System.out.println("|"+fixStrSize("Hells Bells Java Smells",8)+"|");
    }
}

---

|Hell    |
|Hells Be|

---

यहाँ उत्कृष्ट संदर्भ ।

Answer 23

यह जावा 8 में किसी भी बाहरी पुस्तकालयों का उपयोग किए बिना मेरे लिए काम किया

String sampleText = "test"
int n = 3;
String output = String.join("", Collections.nCopies(n, sampleText));
System.out.println(output);

और आउटपुट है

testtesttest

Answer 24

int c = 10; स्ट्रिंग रिक्त स्थान = String.format ("%" + c + "c", ''); इससे आपकी समस्या दूर हो जाएगी।

Answer 25

नीचे की तरह एक सरल विधि का भी उपयोग किया जा सकता है

public static String padString(String str, int leng,char chr) {
        for (int i = str.length(); i <= leng; i++)
            str += chr;
        return str;
    }

Comments

यह निर्विवाद रूप से धीमा है।

— एसएलके

यदि आप जिस स्ट्रिंग के साथ काम कर रहे हैं वह बड़े आकार के हैं, तो स्ट्रिंग स्ट्रिंग के बजाय आप स्ट्रिंग स्ट्रिंग का उपयोग कर सकते हैं। यह गति को काफी प्रभावित करेगा

— यशपाल सिंगला

Answer 26

इस बारे में कैसा है?

public String fillSpaces(int len) {
    /* the spaces string should contain spaces exceeding the max needed */  
    String spaces = "                                                   ";
    return spaces.substring(0,len);
}

संपादित करें: मैंने अवधारणा का परीक्षण करने के लिए एक सरल कोड लिखा है और यहाँ जो मैंने पाया है।

विधि 1: एक लूप में एकल स्थान जोड़ रहा है:

  public String execLoopSingleSpace(int len){
    StringBuilder sb = new StringBuilder();

    for(int i=0; i < len; i++) {
        sb.append(' ');
    }

    return sb.toString();
  }

विधि 2: 100 रिक्त स्थान और लूप संलग्न करें, फिर प्रतिस्थापित करें:

  public String execLoopHundredSpaces(int len){
    StringBuilder sb = new StringBuilder("          ")
            .append("          ").append("          ").append("          ")
            .append("          ").append("          ").append("          ")
            .append("          ").append("          ").append("          ");

    for (int i=0; i < len/100 ; i++) {
        sb.append("          ")
            .append("          ").append("          ").append("          ")
            .append("          ").append("          ").append("          ")
            .append("          ").append("          ").append("          ");
    }

    return sb.toString().substring(0,len);
  }

परिणाम मैं 12,345,678 रिक्त स्थान प्राप्त कर रहा हूं:

C:\docs\Projects> java FillSpace 12345678
method 1: append single spaces for 12345678 times. Time taken is **234ms**. Length of String is 12345678
method 2: append 100 spaces for 123456 times. Time taken is **141ms**. Length of String is 12345678
Process java exited with code 0

और 10,000,000 रिक्त स्थान के लिए:

C:\docs\Projects> java FillSpace 10000000
method 1: append single spaces for 10000000 times. Time taken is **157ms**. Length of String is 10000000
method 2: append 100 spaces for 100000 times. Time taken is **109ms**. Length of String is 10000000
Process java exited with code 0

प्रत्यक्ष आवंटन और पुनरावृत्ति का संयोजन हमेशा कम समय लेता है, विशाल स्थान बनाते समय औसतन 60ms कम। छोटे आकार के लिए, दोनों परिणाम नगण्य हैं।

लेकिन कृपया टिप्पणी जारी रखें :-)

Comments

@ aznilamir: हम्म, आप 10k रिक्त स्थान के लिए कैसे करेंगे?

— जयन

यह विचार 100 स्थानों के लूप और प्रत्यक्ष आवंटन को संयोजित करने का है। यहाँ कोड स्निपेट है:

— aznilamir

आप 100 अक्षरों को जोड़ने के लिए कई ऐप्प का उपयोग क्यों करते हैं? क्यों नहीं एक 100 आकर्षण?

— निकाइनिक

Answer 27

मुझे पता है कि आप किस बारे में पूछ रहे हैं, इसके लिए कोई अंतर्निहित पद्धति नहीं है। हालांकि, 10 जैसी छोटी निश्चित लंबाई के लिए, आपकी विधि काफी तेज होनी चाहिए।

Comments

यदि केवल यह 10 की तरह एक छोटे से तय लंबाई था

— सी रॉस