এন অক্ষর দিয়ে একটি স্ট্রিং তৈরি করুন

144

জাভাতে কোনও নির্দিষ্ট বর্ণের একটি নির্দিষ্ট সংখ্যার সাথে একটি স্ট্রিং তৈরির উপায় আছে? আমার ক্ষেত্রে, আমার 10 টি স্পেস সহ একটি স্ট্রিং তৈরি করতে হবে। আমার বর্তমান কোডটি হ'ল:

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

একই জিনিস সম্পাদন করার আরও ভাল উপায় আছে কি? বিশেষত আমি দ্রুত এমন কিছু চাই (মৃত্যুদন্ড কার্যকর করার ক্ষেত্রে)।

java  string  stringbuffer 
— সি রস
সূত্র
1
যদি আপনি নিজেকে এটি অনেক কিছু করে দেখছেন তবে কেবল একটি ফাংশন লিখুন: স্ট্রিং চরিত্রের পুনরাবৃত্তি (চর সি, ইন্ট দৈর্ঘ্য) {...} যা কোনও চরিত্র এবং কোনও দৈর্ঘ্যের জন্য আপনি সেখানে যা করেন তা করে। তারপরে আপনার যখন প্রয়োজন হবে তখনই এটি কল করুন।
— অস্টিন ফিটজপ্যাট্রিক
12
আপনি স্ট্রিংবুফারের পরিবর্তে স্ট্রিংবিল্ডার ব্যবহার করতে চান
বাফারের আকারটি ভিক্ষা করতে যোগ করুন, মেমরি পরিচালকের সুবিধামতো জিনিস গণনা করা সহজ !. স্ট্রিংবিল্ডার আউটপুটফার = নতুন স্ট্রিংবিল্ডার (পুনরাবৃত্তি * বেস.লেন্থ ());
— ভিক্টর
1
— ডেভ জারভিস
যদি আপনি একটি একক স্থান যুক্ত করতে চান তবে append(' ')পরিবর্তে ব্যবহার করুন ... এতে সামান্য কম কম্পিউটিং জড়িত ...
— এরক

উত্তর:

36

সংকলক দ্বারা লুপ জন্য অনুকূলিত করা হবে। আপনার মতো ক্ষেত্রে আপনার নিজেরাই অপ্টিমাইজেশন সম্পর্কে যত্ন নেওয়ার প্রয়োজন নেই। সংকলককে বিশ্বাস করুন।

বিটিডাব্লু, যদি এন স্পেস অক্ষরগুলির সাথে একটি স্ট্রিং তৈরি করার উপায় থাকে তবে এটি আপনার যেমন ঠিক তেমন কোড করে থাকে।

— kalkin
সূত্র
1
এমনকি এটি অপ্টিমাইজড না হলেও - আপনার প্রোগ্রামে এটি কতবার তৈরি হয় - যদি প্রায়শই কোনও স্ট্যাটিক ভেরিয়েবল বা অন্যান্য ক্যাশে সংরক্ষণ করা হয়
— মিমি মিমি
বিটিডব্লিউ অ্যারে.ফিল () কেবল অ্যারের মধ্য দিয়ে লুপ করে। / আমার অন্যের পোস্টগুলিতে মন্তব্য করার জন্য অবশ্যই আরও বেশি পয়েন্ট প্রয়োজন :)
— কলকিন
@ মার্ক দৈর্ঘ্য পরিবর্তনশীল, সুতরাং এটি সংরক্ষণ করা নির্বোধ বলে মনে হয়। আমি কি করব, একটি আছে static Dictionary<int, String>?
— সি রস
1
আপনি যে স্ট্রিংটি চান তার চেয়ে দীর্ঘতম স্টোর করুন, তারপরে এই জাতীয় কিছু ব্যবহার করুন: " ".substring(0, 10);
— মজাগার্ড
169

সম্ভবত 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 ) );
— polygenelubricants
সূত্র
4
যদিও আমি ওয়ান-লাইনারটি পছন্দ করি, তবুও আমি মনে করি ফ্রস্ট্রেটড উইথফর্মসডেসের সমাধান কার্যকর করা যখন আরও কার্যকর হয় যেহেতু এটি প্রতিটি \ 0 এর জন্য পরীক্ষা করা এড়িয়ে যায় এবং কেবল স্থান বরাদ্দ করে।
— বাউনার
1
পরীক্ষিত, এটি লুপের তুলনায় সর্বদা দ্রুত, বেশ ধারাবাহিকভাবে 50000-100000 ন্যানো সেকেন্ড দ্রুত যা খুব তাৎপর্যপূর্ণ হতে পারে (0.1 মিলিসেকেন্ড) লুপটি পুনরুক্তির সংখ্যা বাড়ায় যদিও মোট সময় এখনও বেশি। এটি বিভিন্ন আকারের স্পেস স্ট্রিং তৈরি করার ক্ষেত্রে সত্য।
— kmecpp
বেশ সুন্দর সমাধান জন্য আপ থাপ্পড়, আমি এখানে আমার উত্তর এটা ব্যবহার করেছেন stackoverflow.com/questions/852665/...
— maytham-ɯɐɥʇʎɐɯ
66

হুম এখন যে আমি এটি সম্পর্কে চিন্তা করি, সম্ভবত Arrays.fill:

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

অবশ্যই, আমি ধরে নিই যে fillপদ্ধতিটি আপনার কোড হিসাবে একই কাজ করে, সুতরাং এটি সম্ভবত এটির সম্পর্কে সম্পাদন করবে, তবে কমপক্ষে এটি কম লাইন।

— FrustratedWithFormsDesigner
সূত্র
2
উত্সটি যাচাই করার পরে, মনে হয় এটি কার্যত
— পোপ
2
@ লর্ড টর্গামাস কি ওপির প্রশ্নটি সম্পাদিত হয়েছিল? কারণ আমি যে সংস্করণটি দেখছি তাতে সে স্ট্রিংবফার.এপেন্ড () এ লুপিং করছে এবং ফ্রাস্ট্রেটেড সংস্করণটি একটি ফিল করছে (অবশ্যই অ্যারেগুলিতে চর অ্যাসাইনমেন্টগুলি করে কোনটি লুপ)। মোটেও একই জিনিস নয়।
— সিপারকিনস
@ সিগার্কিনস, যথেষ্ট ন্যায্য, আমি পরিষ্কার ছিলাম না। আমার বক্তব্যটি হ'ল উভয়ই লুপের ভিতরে অক্ষর দ্বারা অক্ষর সন্নিবেশ করান।
— পোপস
1
@ লর্ড টর্গামাস - এতে একমত হয়েছেন। করুণা jvm একটি স্মৃতিচারণ করতে পারবেন না। মূল্য আমরা প্রশস্ত অক্ষরের জন্য প্রদান করি।
— সিপারকিন্স
2
@ পোপস এটি লক্ষ্য করার মতো যে যদি Arrays.fill()ফাংশনটি আপনার কোড এবং (স্ট্যান্ডার্ড এবং বাহ্যিক) লাইব্রেরি কোড জুড়ে এই কাজটি করার জন্য ধারাবাহিকভাবে ব্যবহৃত হয় তবে এটি হটস্পট সংকলনের জন্য একটি ভাল প্রার্থী করে তোলে এবং আপনার সিপিইউ ক্যাশে পাওয়া যাওয়ার আরও ভাল সুযোগ দাঁড়িয়েছে। ভবিষ্যতের জেভিএমগুলি এটিকে একটি অভ্যন্তরীণ ফাংশন হিসাবে নির্ধারণ করতে পারে । নিজের ঘূর্ণায়মান আপনাকে এই সমস্ত পারফরম্যান্স সদ্ব্যবহার থেকে দূরে সরিয়ে দেয় ...
— সুসানডাব্লু
65

আমি হাত থেকে লুপটি না লেখার জন্য অত্যন্ত পরামর্শ দিচ্ছি। আপনার প্রোগ্রামিং ক্যারিয়ারের সময় আপনি বার বার তা করবেন। লোকেরা আপনার কোড পড়ছে - এতে আপনার অন্তর্ভুক্ত রয়েছে - লুপটির অর্থ হজম করার জন্য সর্বদা সময় ব্যয় করতে হবে, এটি কেবল কয়েক সেকেন্ডের হলেও।

পরিবর্তে পুনঃব্যবহারের যে শুধু করে কোড প্রদানের প্রাপ্তিসাধ্য লাইব্রেরি এক যে মত StringUtils.repeatথেকে অ্যাপাচি কমন্স ল্যাঙ :

StringUtils.repeat(' ', length);

এইভাবে আপনাকে পারফরম্যান্স নিয়েও মাথা ঘামাতে হবে না, এইভাবে সমস্ত বিব্রত বিবরণ StringBuilder ঘামাতে , সংকলক অপটিমাইজেশন ইত্যাদি গোপন রয়েছে। যদি ফাংশনটি ধীর হয়ে যায় তবে এটি লাইব্রেরির একটি বাগ হবে g

সঙ্গে জাভা 11 এটা এমনকি সহজ হয়ে:

" ".repeat(length);
— mfuchs
সূত্র
5
অন্যদিকে, যদি স্ট্রিংটিলগুলি ইতিমধ্যে প্রকল্পে ব্যবহার না করা হয় তবে এ জাতীয় সাধারণ কাজের জন্য আরও একটি নির্ভরতা যুক্ত করা ওভারকিল হতে পারে।
— এরিচ কিটজমুয়েলার
1
যদি এটি আস্তে আস্তে পরিণত হয় তবে আপনি কার্যটির জন্য নিজের ফিক্সও জমা দিতে পারেন।
— হবে
13

আপনি যদি কেবল ফাঁকা জায়গা চান তবে কীভাবে:

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

যার ফলশ্রুতিতে অ্যাবস (এন) স্পেস দেখা দেবে;

— BryceCicada
সূত্র
6
যদিও গতি জন্য এটি? আমি ছাপ ফর্ম্যাট অধীনে তুলনামূলকভাবে ধীর। এটি স্ট্রিংটি সর্বোপরি তৈরি করার আগে পার্স করতে হবে।
— সি রস
11

যেহেতু জাভা 11 :

" ".repeat(10);

যেহেতু জাভা 8 :

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

কোথায়:

import static java.util.stream.Collectors.joining;
import static java.util.stream.Stream.generate;
— epox
সূত্র
9

জাভা 11 যেহেতু String.repeat(count)আপনি সহজেই আপনার সমস্যা সমাধানের জন্য ব্যবহার করতে পারেন ।

একটি স্ট্রিং ফেরত দেয় যার মান এই স্ট্রিংটির পুনরাবৃত্তি countবারের সংমিশ্রণ ।

যদি এই স্ট্রিংটি খালি থাকে বা countশূন্য হয় তবে খালি স্ট্রিংটি ফিরে আসবে।

সুতরাং একটি লুপের পরিবর্তে আপনার কোডটি ঠিক এর মতো দেখায়:

" ".repeat(length);
— স্যামুয়েল ফিলিপ
সূত্র
8

আমি মনে করি এটি যত কম কোড এটি সম্ভব, এটি পেয়ারা যোগদানকারী শ্রেণি ব্যবহার করে:

যোজক .on ( "") (যোগদান করুন। Collections.nCopies ") (10)";

— meilechh
সূত্র
সংক্ষিপ্ততম কোডের লাইন তবে কেবলমাত্র সেই সাধারণ কাজের জন্য একটি বৃহত লাইব্রেরি যুক্ত করা কোনও অর্থবোধ করে না। আমি নিজেই একটি একক পদ্ধতিতে একটি ছোট জেআর তৈরি করতে পারি pubic String n(int n) { ... }যা "কম" কোডটিকেও অনুমতি দেবে: n(10)তবে আবার কোনও অর্থবোধ হয় না।
— ইস্পির
@ আইসাপির যারা ইতিমধ্যে পেয়ারা ব্যবহার করছেন তাদের পক্ষে এটি দুর্দান্ত উত্তর
— nasch
1
@ ন্যাশ গুয়ারা এই প্রশ্নের অংশ ছিল না। কিন্তু যাই হোক, 2018 সালে সত্যিই পেয়ারা এর যোজক ব্যবহার করতে যখন আপনি String.join () যা জাভা 8. দেখুন যোগ করা হয়েছিল ব্যবহার করতে পারেন কোনো কারণ নেই stackoverflow.com/a/43011939/968244
— isapir
@ আইসাপির না, পেয়ারা একটি উত্তর ছিল। প্রশ্ন জিজ্ঞাসা করা ব্যক্তির চেয়ে স্ট্যাকওভারফ্লো-তে উত্তরগুলি একটি বিস্তৃত শ্রোতা রয়েছে, সুতরাং কিছু উত্তর যদি জিজ্ঞাসা করা ব্যক্তির পক্ষে সেরা না হয় তবে তা ঠিক আছে। এবং স্ট্রিং.জোঁইন () সম্পর্কে মন্তব্যটি দুর্দান্ত। তবে যদিও এটি নিশ্চিত নয় যে এটি অ্যান্ড্রয়েডের সমস্ত সংস্করণে পাওয়া যাচ্ছে যা জাভার বিশিষ্ট ব্যবহার।
— নাস্তা
7

আপনি 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));

আউটপুট:

#######
— আলেক্সি গুসেভ
সূত্র
6

দ্রুত বর্ধনের জন্য অ্যালগরিদমের ভিত্তিতে আমার অবদান।

/**
 * 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জন্য - লুপ জন্য যথেষ্ট গতি আছে
— নীলস বিলেন
সূত্র
4
এটি একটি আকর্ষণীয় বাস্তবায়ন। দুর্ভাগ্যক্রমে, আপনার সিদ্ধান্তগুলির বিপরীতে, এটি বড় এন এর পক্ষে খুব অদক্ষ। আমি সন্দেহ করি এটি প্রতিবার যখন আপনি স্ট্রিংকে যুক্ত করে চলে তখন প্রচুর মেমরির বরাদ্দ রয়েছে। এটিকে পুনরাবৃত্ত পদ্ধতির চারপাশে মোড়ক হিসাবে লেখার চেষ্টা করুন যা স্ট্রিংয়ের পরিবর্তে স্ট্রিংবিল্ডার নেয়। আমি বাজি ধরছি আপনি ফলাফলগুলি আরও ভাল পাবেন।
— ক্লিটোস কিরিয়াকু
3
এই জাতীয় কিছু মাইক্রো-বেঞ্চমার্ক করার সময় আপনার প্রচুর সতর্কতা অবলম্বন করা উচিত এবং আমি মনে করি না যে আপনি সেগুলির কোনও গ্রহণ করছেন! এই কোড চারপাশের প্রভাবশালী কর্মক্ষমতা এমন প্রশ্ন যা সহজেই হতে পারে কিনা তা হটস্পট-কম্পাইল করা হয়, এটা কত আবর্জনা সৃষ্টি, ইত্যাদি আমি বাজি ধরতে পারি ঐ সমস্ত ifবিবৃতি আপ CPU- এর শাখা ভবিষ্যদ্বাণী জগাখিচুড়ি করতে যাচ্ছি। এটি সত্যিই জেএমএইচ ( ওপেনজেডক.জ্যাভা.ট. / প্রজেক্টস / কোড / টোলস / জেএমএইচ ) ব্যবহার করে পুনরায় করা উচিত , অন্যথায় এটি কিছুটা অর্থহীন।
— সুসানডাব্লু
নোট করুন যে এই বাস্তবায়নের ও (এন * লগ এন) জটিলতা রয়েছে, যখন স্ট্রিংবিল্ডার ও (এন) :)
— লিও লিওন্তেভ
4

আমাদের আছে বিবেচনা:

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 (এনকপি ব্যবহার করে)

String resultTwo = String.join(EMPTY_STRING, Collections.nCopies(n, c)); //cccc
— akhil_mittal
সূত্র
1
Collectors.joining(EMPTY_STRING)সমতুল্যCollectors.joining()
— পিপার্টিসান
2

প্রদত্ত ইনপুট আকার থেকে একটি স্ট্রিং তৈরি করার র্যান্ডম স্ট্রিং ইউটিলেসের একটি বিধান রয়েছে। গতি সম্পর্কে মন্তব্য করতে পারবেন না, তবে এটি একটি ওয়ান লাইনার।

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

একটি আউটপুট তৈরি করে

\ T \ T \ T \ T \ টি

আপনি যদি আপনার কোডটিতে \ 0 দেখতে না চান তবে পছন্দনীয় ।

— মুলকি
সূত্র
2

স্ট্রিংটিলগুলি ব্যবহার করুন: স্ট্রিংটিল.ট্রিপেট ('', 10)

— Icegras
সূত্র
1

বেশিরভাগ ক্ষেত্রে আপনার কেবলমাত্র নির্দিষ্ট দৈর্ঘ্য পর্যন্ত স্ট্রিংগুলির প্রয়োজন, 100 টি স্পেস বলুন। আপনি স্ট্রিংয়ের একটি অ্যারে প্রস্তুত করতে পারেন যেখানে সূচক সংখ্যাটি স্থান-পূর্ণ স্ট্রিংয়ের আকারের সমান এবং স্ট্রিংটিকে সন্ধান করতে পারে, যদি প্রয়োজনীয় দৈর্ঘ্য সীমাতে থাকে বা এটি সীমানার বাইরে থাকে তবে চাহিদা অনুযায়ী তৈরি করতে পারে।

— আন্ড্রেয়াস ডলক
সূত্র
0

আপনার স্ট্রিংবফারটিকে কেবল একটি স্ট্রিংবুডার দিয়ে প্রতিস্থাপন করুন । মারতে কষ্ট হয়।

আপনার দৈর্ঘ্য যদি একটি বড় সংখ্যা হয় তবে আপনি প্রতিটি পুনরাবৃত্তির দৈর্ঘ্যের সদৃশ করে কিছু বেশি দক্ষ (তবে আরও আনাড়ি) স্ব-সংযোজন প্রয়োগ করতে পারেন:

 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()এপ্রোচ চেষ্টা করতে পারেন ( হতাশাগ্রস্থ উইথফোর্ডস ডিজাইনারের উত্তর)।

— leonbloy
সূত্র
আপনি কিছু ভেরিয়েবলের একাধিক চরিত্রের নাম রাখতে পারেন?
— সি। রস
0

আপনি প্রতিস্থাপন করতে পারেন 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 উদাহরণটি পরিবর্তনশীল হিসাবে দৃষ্টান্ত তৈরির সময় সাশ্রয় করতে পারেন।

এটি থ্রেড নিরাপদ নয়, যদি আপনার একাধিক থ্রেড থাকে তবে প্রতিটি থ্রেডের নিজস্ব অনুলিপি থাকা উচিত।

— OscarRyz
সূত্র
0

ভাল পারফরম্যান্সের জন্য, আজ্নিলিমির এবং হতাশাগ্রস্থ উইথফোর্ডস ডিজাইনার থেকে উত্তরগুলি একত্রিত করুন

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 টি অক্ষরের দৈর্ঘ্য।

— olibre
সূত্র
0

এই মত একটি পদ্ধতি আছে। নির্দিষ্ট দৈর্ঘ্যের দৈর্ঘ্যে 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());
}
— নীলের চারা
সূত্র
0

স্ট্রিং স্থির আকারের হতে চান, যাতে আপনি টেবিলেটিং ডেটার জন্য প্যাড বা ছাঁটাই করুন ...

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|

এখানে দুর্দান্ত রেফারেন্স ।

— JGFMK
সূত্র
0

এটি জাভা 8-তে কোনও বাহ্যিক লাইব্রেরি ব্যবহার না করে আমার জন্য কাজ করেছে

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

এবং আউটপুট হয়

testtesttest
— সজন জন
সূত্র
0

int সি = 10; স্ট্রিং স্পেসস = স্ট্রিং.ফর্ম্যাট ("%" + সি + "সি", ''); এই আপনার সমস্যার সমাধান হবে.

— Mr.Geeky
সূত্র
-1

নীচের মতো একটি সাধারণ পদ্ধতিও ব্যবহার করা যেতে পারে

public static String padString(String str, int leng,char chr) {
        for (int i = str.length(); i <= leng; i++)
            str += chr;
        return str;
    }
— যশপাল সিঙ্গলা
সূত্র
এটি নিম্নতর ধীর।
— স্ল্যাक्स
স্ট্রিং কনফারেন্সের পরিবর্তে আপনি স্ট্রিংবাফার ব্যবহার করতে পারেন, যদি আপনি যে স্ট্রিংগুলি ব্যবহার করছেন তার আকার বড় আকারের হয়। এটি গতিতে যথেষ্ট প্রভাব ফেলবে
— যশপাল সিঙ্গলা
-2

এ কেমন? 

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

প্রত্যক্ষ বরাদ্দ এবং পুনরাবৃত্তির সংমিশ্রণে সর্বদা বিশাল স্থান তৈরি করার সময় কমপক্ষে 60 মিমি কম সময় লাগে। ছোট আকারের জন্য, উভয় ফলাফলই নগণ্য।

তবে দয়া করে মন্তব্য করা চালিয়ে যান :-)

— aznilamir
সূত্র
3
@ আজনিলেমির: এইচএম, আপনি কীভাবে 10 কে স্পেস করবেন?
— জয়ন
লুপটি এবং 100 টি স্পেসের সরাসরি বরাদ্দ একত্রিত করার ধারণাটি। কোড স্নিপেটগুলি এখানে:
— আজনিলেমির
আপনি কেন 100 টি অক্ষর যুক্ত করতে একাধিক সংযোজন ব্যবহার করেন? এক শ চর সংযোজন কেন?
— nycynik
-3

আপনি যা জিজ্ঞাসা করছেন তার কোনও বিল্ট-ইন পদ্ধতি আমি জানি না। তবে, 10 এর মতো ছোট স্থির দৈর্ঘ্যের জন্য, আপনার পদ্ধতিটি প্রচুর দ্রুত হওয়া উচিত।

— পপ
সূত্র
কেবলমাত্র এটি যদি 10 এর মতো একটি ছোট স্থির দৈর্ঘ্য ছিল
— সি রস
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.