मैं जावा में एक स्ट्रिंग को कैसे पैड कर सकता हूं?

Question

क्या जावा में स्ट्रिंग्स को पैड करने का कुछ आसान तरीका है?

कुछ ऐसा लगता है जो कुछ स्ट्रिंग-यूटील जैसे एपीआई में होना चाहिए, लेकिन मुझे ऐसा कुछ भी नहीं मिल रहा है जो ऐसा करता है।

Comments

अपाचे फ़ंक्शन बनाम स्ट्रिंग फॉर्मेटर के मुद्दे पर थोड़ा संदेह है कि अपाचे फ़ंक्शन अधिक स्पष्ट और पढ़ने में आसान है। फ़ंक्शन नामों में फ़ॉर्मैटर को लपेटना आदर्श नहीं है।

— टेरा कैनस

Answer 1

अपाचे StringUtilsकई तरीके होते हैं: leftPad, rightPad, centerऔर repeat।

लेकिन कृपया ध्यान दें कि - जैसा कि दूसरों ने इस उत्तर में उल्लेख किया है और प्रदर्शित किया है - String.format()और Formatterजेडीके में कक्षाएं बेहतर विकल्प हैं। कॉमन्स कोड पर उनका उपयोग करें।

Comments

java.util.Formatter (और String.format ()) ऐसा करता है। हमेशा JDK को किसी बाहरी लाइब्रेरी में पसंद करें अगर JDK संस्करण काम करता है (जो यह करता है)।

— cletus

कई कारणों से, मैं अब अपाचे कॉमन्स के लिए अमरूद पसंद करूंगा; इस जवाब से पता चलता है कि यह अमरूद में कैसे किया जाता है ।

— जोनीक

@ जेनिक क्या आप अपने कुछ कारणों को सूचीबद्ध करना चाहेंगे? API बहुत सुंदर दिखते हैं।

— glen3b

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

— जोनिक

@ glen3b: इस सवाल पर कुछ और अच्छा पढ़ने के लिए ।

— जोनिक

Answer 2

जावा 1.5 के बाद से, String.format()किसी दिए गए स्ट्रिंग को बाएँ / दाएँ पैड के लिए उपयोग किया जा सकता है।

public static String padRight(String s, int n) {
     return String.format("%-" + n + "s", s);  
}

public static String padLeft(String s, int n) {
    return String.format("%" + n + "s", s);  
}

...

public static void main(String args[]) throws Exception {
 System.out.println(padRight("Howto", 20) + "*");
 System.out.println(padLeft("Howto", 20) + "*");
}

और आउटपुट है:

Howto               *
               Howto*

Comments

क्या होगा यदि आपको अन्य वर्णों के साथ लैपड करने की आवश्यकता है (रिक्त स्थान नहीं)? क्या यह अभी भी String.format के साथ संभव है? मैं यह काम करने में सक्षम नहीं हूं ...

— Guido

AFAIK String.format () ऐसा नहीं कर सकता है, लेकिन इसे कोड करना बहुत मुश्किल नहीं है, rgagnon.com/javadetails/java-0448.html (दूसरा उदाहरण) देखें

— RealHowTo

@ Nullw0rm, अगर आप rgagnon.com का जिक्र कर रहे हैं, तो ध्यान रखें कि RealHowTo rgagnon.com का लेखक भी है, इसलिए वह खुद को श्रेय देगा ...

— कॉलिन पिकार्ड

कम से कम मेरे जेवीएम पर, "#" काम नहीं करता है, "-" ठीक है। (बस # हटाएं)। यह फ़ॉर्मेटर डॉक्यूमेंटेशन, I dunno के अनुरूप हो सकता है; यह कहता है "" # '' \ u0023 'आउटपुट को वैकल्पिक रूप का उपयोग करने की आवश्यकता है। फ़ॉर्म की परिभाषा रूपांतरण द्वारा निर्दिष्ट की गई है। "

— गातोतिग्रादो

भयानक जवाब के लिए धन्यवाद। मुझे संदेह है कि हालांकि, इसके लिए क्या है 1$? @ एलो ने एक बहुत ही समान उत्तर दिया है जो उपयोग नहीं करता है 1$और इसका स्पष्ट रूप से एक ही प्रभाव है। क्या इससे कोई फर्क पड़ता है?

— फाबेरिको मटे

Answer 3

10 वर्णों तक पैडिंग:

String.format("%10s", "foo").replace(' ', '*');
String.format("%-10s", "bar").replace(' ', '*');
String.format("%10s", "longer than 10 chars").replace(' ', '*');

उत्पादन:

  *******foo
  bar*******
  longer*than*10*chars

पासवर्ड के पात्रों के लिए '*' प्रदर्शित करें:

String password = "secret123";
String padded = String.format("%"+password.length()+"s", "").replace(' ', '*');

पासवर्ड स्ट्रिंग के समान आउटपुट की लंबाई होती है:

  secret123
  *********

Comments

बस जब तक हम सभी को एक स्ट्रिंग में रिक्त स्थान के साथ नहीं गुजरना याद है ...: D

— leviathanbadger

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

— ब्रायन वारशॉ

अंतरिक्ष मुद्दे को स्वीकार करें। .replace(' ', '*')बल्कि पैडिंग के प्रभाव को दिखाने का इरादा था। पासवर्ड छिपाने की अभिव्यक्ति को वैसे भी यह मुद्दा नहीं है ... मूल जावा सुविधा का उपयोग करके बाएं और दाएं पैडिंग स्ट्रिंग को कस्टमाइज़ करने के बेहतर उत्तर के लिए मेरा अन्य उत्तर देखें।

— leo

यदि स्ट्रिंग में केवल एकल स्थान हैं और आप अलग-अलग वर्णों के साथ पैड करना चाहते हैं, तो आप regex प्रतिस्थापित का उपयोग लुक में पीछे / आगे कर सकते हैं: String.format("%30s", "pad left").replaceAll("(?<=( |^)) ", "*")याString.format("%-30s", "pad right").replaceAll(" (?=( |$))", "*")

— Jaroslaw Pawlak

Answer 4

में अमरूद , इस आसान है:

Strings.padStart("string", 10, ' ');
Strings.padEnd("string", 10, ' ');

Answer 5

कुछ सरल:

मान एक स्ट्रिंग होना चाहिए। इसे स्ट्रिंग में बदलें, यदि यह नहीं है। की तरह "" + 123याInteger.toString(123)

// let's assume value holds the String we want to pad
String value = "123";

गद्देदार के अंत लंबाई तक मूल्य लंबाई चार सूचकांक से शुरू

String padded="00000000".substring(value.length()) + value;

// now padded is "00000123"

ज़्यादा सही

पैड सही:

String padded = value + ("ABCDEFGH".substring(value.length())); 

// now padded is "123DEFGH"

पैड छोड़ दिया:

String padString = "ABCDEFGH";
String padded = (padString.substring(0, padString.length() - value.length())) + value;

// now padded is "ABCDE123"

Answer 6

एक नजर है org.apache.commons.lang.StringUtils#rightPad(String str, int size, char padChar)।

लेकिन एल्गोरिथ्म बहुत सरल है (आकार चार्ट में पैड सही है):

public String pad(String str, int size, char padChar)
{
  StringBuffer padded = new StringBuffer(str);
  while (padded.length() < size)
  {
    padded.append(padChar);
  }
  return padded.toString();
}

Comments

ध्यान दें कि Java 1.5 के रूप में यह StringBuer के बजाय StringBuilder का उपयोग करने के लायक है।

— जॉन स्कीट

Answer 7

अपाचे कॉमन्स के अलावा, यह भी देखें String.formatकि सरल पैडिंग (जैसे रिक्त स्थान के साथ) का ख्याल रखने में सक्षम होना चाहिए।

Answer 8

public static String LPad(String str, Integer length, char car) {
  return (str + String.format("%" + length + "s", "").replace(" ", String.valueOf(car))).substring(0, length);
}

public static String RPad(String str, Integer length, char car) {
  return (String.format("%" + length + "s", "").replace(" ", String.valueOf(car)) + str).substring(str.length(), length + str.length());
}

LPad("Hi", 10, 'R') //gives "RRRRRRRRHi"
RPad("Hi", 10, 'R') //gives "HiRRRRRRRR"
RPad("Hi", 10, ' ') //gives "Hi        "
RPad("Hi", 1, ' ')  //gives "H"
//etc...

Comments

ध्यान दें: आप उल्टे कार्यों के नाम; यदि आप इसे चलाते हैं तो आप देखेंगे।

— नीले

इसके अलावा अगर मूल स्ट्रक में स्पेस है तो यह काम नहीं करता है

— स्टीवन शॉ

@StevenShaw यदि मुझसे गलती नहीं हुई है, तो प्रतिस्थापित मूल को लक्षित नहीं करता है str, इसलिए यह सही है।

— मफू

अधिवेशन द्वारा आपको फ़ंक्शन नामों के लिए एक बड़े अक्षर का उपयोग नहीं करना चाहिए।

— प्रिंसिपल-आदर्श-डोमेन

क्या स्ट्रिंग को वापस करने पर एक लापता स्थिति है जैसा कि (length - str.length())है 0? फ़ॉर्मेटर स्ट्रिंग एक है FormatFlagsConversionMismatchExceptionजब %0sप्रारूप स्ट्रिंग है।

— डेविन वाल्टर्स

Answer 9

यह पता लगाने में मुझे थोड़ा समय लगा। असली कुंजी यह है कि फॉर्मेट प्रलेखन को पढ़ना है।

// Get your data from wherever.
final byte[] data = getData();
// Get the digest engine.
final MessageDigest md5= MessageDigest.getInstance("MD5");
// Send your data through it.
md5.update(data);
// Parse the data as a positive BigInteger.
final BigInteger digest = new BigInteger(1,md5.digest());
// Pad the digest with blanks, 32 wide.
String hex = String.format(
    // See: http://download.oracle.com/javase/1.5.0/docs/api/java/util/Formatter.html
    // Format: %[argument_index$][flags][width]conversion
    // Conversion: 'x', 'X'  integral    The result is formatted as a hexadecimal integer
    "%1$32x",
    digest
);
// Replace the blank padding with 0s.
hex = hex.replace(" ","0");
System.out.println(hex);

Comments

अंत को इतना जटिल क्यों बनाते हैं? आप बस स्ट्रिंग hex = String.format ("% 032x", डाइजेस्ट) कर सकते थे; और सटीक एक ही परिणाम था, बस एक अनावश्यक जगह के बिना () और विशिष्ट चर का उपयोग करने के लिए $ का उपयोग कर (वहाँ केवल एक है, सब के बाद।)

— ArtOfWarfare

@ArtOfWarfare फेयर पॉइंट। किसी ने मूल रूप से एक और प्रश्न में हेक्स मूल्यों को गद्दी देने के लिए कहा, मैंने देखा कि मेरे पास फॉर्मेटर प्रलेखन के लिए एक लिंक था। यह पूर्णता के लिए जटिल है।

— Nthalk

Answer 10

मुझे पता है कि यह धागा पुराना है और मूल प्रश्न एक आसान समाधान के लिए था, लेकिन अगर यह वास्तव में तेज़ होना चाहिए, तो आपको एक चार्ट का उपयोग करना चाहिए।

public static String pad(String str, int size, char padChar)
{
    if (str.length() < size)
    {
        char[] temp = new char[size];
        int i = 0;

        while (i < str.length())
        {
            temp[i] = str.charAt(i);
            i++;
        }

        while (i < size)
        {
            temp[i] = padChar;
            i++;
        }

        str = new String(temp);
    }

    return str;
}

फ़ॉर्मेटर समाधान इष्टतम नहीं है। प्रारूप स्ट्रिंग के निर्माण से 2 नए तार पैदा होते हैं।

एपाचे के समाधान को एसबीबी को लक्ष्य आकार के साथ प्रारंभ करके बेहतर किया जा सकता है ताकि नीचे प्रतिस्थापित किया जा सके

StringBuffer padded = new StringBuffer(str); 

साथ में

StringBuffer padded = new StringBuffer(pad); 
padded.append(value);

sb के आंतरिक बफर को बढ़ने से रोक देगा।

Comments

यदि एक साथ StringBufferकई थ्रेड्स द्वारा एक्सेस नहीं किया जा सकता है (जो इस मामले में सच है), तो आपको StringBuilderसिंक्रनाइज़ेशन के ओवरहेड से बचने के लिए (JDK1.5 + में) का उपयोग करना चाहिए ।

— ग्लेन 3 बी

Answer 11

यहाँ दाईं ओर पैड करने का एक और तरीका है:

// put the number of spaces, or any character you like, in your paddedString

String paddedString = "--------------------";

String myStringToBePadded = "I like donuts";

myStringToBePadded = myStringToBePadded + paddedString.substring(myStringToBePadded.length());

//result:
myStringToBePadded = "I like donuts-------";

Answer 12

जावा 11 के बाद से, String.repeat (int) का उपयोग बाएं / दाएं पैड को दिए गए स्ट्रिंग में किया जा सकता है।

System.out.println("*".repeat(5)+"apple");
System.out.println("apple"+"*".repeat(5));

आउटपुट:

*****apple
apple*****

Comments

जावा 11 के लिए सर्वश्रेष्ठ उत्तर!

— नागी अत्तिला

Answer 13

आप हर बार पुनर्निर्माण के बजाय, पेडिंग डेटा को बनाए रखकर प्रति-कॉल ओवरहेड को कम कर सकते हैं:

public class RightPadder {

    private int length;
    private String padding;

    public RightPadder(int length, String pad) {
        this.length = length;
        StringBuilder sb = new StringBuilder(pad);
        while (sb.length() < length) {
            sb.append(sb);
        }
        padding = sb.toString();
   }

    public String pad(String s) {
        return (s.length() < length ? s + padding : s).substring(0, length);
    }

}

एक विकल्प के रूप में, आप परिणाम लंबाई को pad(...)विधि के लिए एक पैरामीटर बना सकते हैं । उस स्थिति में कंस्ट्रक्टर के बजाय उस विधि में छिपे हुए पैडिंग का समायोजन करें।

(संकेत: अतिरिक्त क्रेडिट के लिए, इसे थ्रेड-सेफ़ करें! ;-)

Comments

असुरक्षित प्रकाशन को छोड़कर यह थ्रेड सुरक्षित है (पाठ्यक्रम के रूप में अपने क्षेत्रों को अंतिम रूप दें)। मुझे लगता है कि प्रदर्शन से पहले एक विकल्प के द्वारा सुधार किया जा सकता है + जिसे कॉनकैट (विचित्र रूप से पर्याप्त) द्वारा प्रतिस्थापित किया जाना चाहिए।

— टॉम हॉल्टिन - 12:24 बजे

Answer 14

यह Dzone पर पाया गया

शून्य के साथ पैड:

String.format("|%020d|", 93); // prints: |00000000000000000093|

Comments

यह उत्तर, सरल और संक्षिप्त होना चाहिए, बाहरी पुस्तकालयों को स्थापित करने की आवश्यकता नहीं है।

— वोंग जिया हौ

Answer 15

आप चर स्ट्रिंग लंबाई के पैडिंग के लिए निर्मित स्ट्रिंग स्ट्रिंग () और इंसर्ट () विधियों का उपयोग कर सकते हैं:

AbstractStringBuilder append(CharSequence s, int start, int end) ;

उदाहरण के लिए:

private static final String  MAX_STRING = "                    "; //20 spaces

    Set<StringBuilder> set= new HashSet<StringBuilder>();
    set.add(new StringBuilder("12345678"));
    set.add(new StringBuilder("123456789"));
    set.add(new StringBuilder("1234567811"));
    set.add(new StringBuilder("12345678123"));
    set.add(new StringBuilder("1234567812234"));
    set.add(new StringBuilder("1234567812222"));
    set.add(new StringBuilder("12345678122334"));

    for(StringBuilder padMe: set)
        padMe.append(MAX_STRING, padMe.length(), MAX_STRING.length());

Answer 16

यह काम:

"".format("%1$-" + 9 + "s", "XXX").replaceAll(" ", "0")

यह आपके स्ट्रिंग XXX को व्हॉट्सएप के साथ 9 चार्ट तक भर देगा। उसके बाद सभी व्हाट्सएप को 0. के साथ बदल दिया जाएगा। आप व्हॉट्सएप और 0 को जो चाहें बदल सकते हैं ...

Comments

आपको खाली स्ट्रिंग का दुरुपयोग करने के बजाय staticविधि को लागू करना चाहिए String.format(…)। स्रोत कोड में चार वर्णों को सहेजना निश्चित रूप से पठनीयता के नुकसान के लायक नहीं है।

— होल्गर

Answer 17

public static String padLeft(String in, int size, char padChar) {                
    if (in.length() <= size) {
        char[] temp = new char[size];
        /* Llenado Array con el padChar*/
        for(int i =0;i<size;i++){
            temp[i]= padChar;
        }
        int posIniTemp = size-in.length();
        for(int i=0;i<in.length();i++){
            temp[posIniTemp]=in.charAt(i);
            posIniTemp++;
        }            
        return new String(temp);
    }
    return "";
}

Answer 18

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

चयनित उत्तर के समान, मैं StringUtilsअपाचे कॉमन्स को पसंद करूंगा लेकिन इस तरह से उपयोग करूंगा :

StringUtils.defaultString(StringUtils.leftPad(myString, 1))

के बारे में बताएं:

• myString: स्ट्रिंग I इनपुट, शून्य हो सकता है
• StringUtils.leftPad(myString, 1): यदि स्ट्रिंग अशक्त है, तो यह कथन भी अशक्त होगा
• फिर defaultStringसमतल नल को रोकने के लिए खाली स्ट्रिंग देने के लिए उपयोग करें

Answer 19

@ck और @Marlon तारक के उत्तर केवल एक का उपयोग करने के लिए हैं char[], जो उन अनुप्रयोगों के लिए हैं जिनके पास प्रति सेकंड पैडिंग विधियों के लिए कई कॉल हैं सबसे अच्छा तरीका है। हालांकि, वे किसी भी सरणी हेरफेर अनुकूलन का लाभ नहीं लेते हैं और मेरे स्वाद के लिए थोड़ा अधिलेखित हैं; यह बिना छोरों के साथ किया जा सकता है ।

public static String pad(String source, char fill, int length, boolean right){
    if(source.length() > length) return source;
    char[] out = new char[length];
    if(right){
        System.arraycopy(source.toCharArray(), 0, out, 0, source.length());
        Arrays.fill(out, source.length(), length, fill);
    }else{
        int sourceOffset = length - source.length();
        System.arraycopy(source.toCharArray(), 0, out, sourceOffset, source.length());
        Arrays.fill(out, 0, sourceOffset, fill);
    }
    return new String(out);
}

सरल परीक्षण विधि:

public static void main(String... args){
    System.out.println("012345678901234567890123456789");
    System.out.println(pad("cats", ' ', 30, true));
    System.out.println(pad("cats", ' ', 30, false));
    System.out.println(pad("cats", ' ', 20, false));
    System.out.println(pad("cats", '$', 30, true));
    System.out.println(pad("too long for your own good, buddy", '#', 30, true));
}

आउटपुट:

012345678901234567890123456789
cats                          
                          cats
                cats
cats$$$$$$$$$$$$$$$$$$$$$$$$$$
too long for your own good, buddy 

Comments

आप इसकी सामग्री को कॉल करने के बजाय सीधे सरणी में कॉपी getCharsकरने के लिए उपयोग कर सकते हैं , उसके बाद । मैं भी कार्यान्वयन को सरल बनाने पर विचार करूंगा ; जबकि ऐसा लगता है कि यह अधिक काम करेगा, यह वास्तव में जेवीएम को डिफ़ॉल्ट शून्य-भरने को समाप्त करने की अनुमति देता है। Stringoutsource.toCharArray()System.arraycopychar[] out = new char[length]; Arrays.fill(out, 0, length, fill); source.getChars(0, source.length(), out, right? 0: length - source.length()); return new String(out);fill

— होल्गर

Answer 20

java.util.Formatterबाएं और दाएं पैडिंग करेंगे। विषम तृतीय पक्ष निर्भरता के लिए कोई ज़रूरत नहीं है (क्या आप उन्हें इतना तुच्छ के लिए जोड़ना चाहते हैं)।

[मैंने विवरण छोड़ दिया है और इस पोस्ट को 'कम्युनिटी विकी' बना दिया है क्योंकि यह ऐसा कुछ नहीं है जिसकी मुझे कोई आवश्यकता है।]

Comments

मैं असहमत हूं। किसी भी बड़े जावा प्रोजेक्ट में आप आमतौर पर स्ट्रिंग हेरफेर का इतना काम करेंगे, कि अपाचे कॉमन्स लैंग का उपयोग करने के लिए बढ़ी हुई पठनीयता और त्रुटियों से बचा जा सके। आप सभी को कुछString.subString (someString.indexOf (startCharacter), someString.lastIndexOf (एंडचेकर)) जैसे कोड पता हैं, जिन्हें आसानी से स्ट्रिंग स्ट्रिंग से बचा जा सकता है।

— Bananeweizen

Answer 21

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

public static char[] lpad(char[] pStringChar, int pTotalLength, char pPad) {
    if (pStringChar.length < pTotalLength) {
        char[] retChar = new char[pTotalLength];
        int padIdx = pTotalLength - pStringChar.length;
        Arrays.fill(retChar, 0, padIdx, pPad);
        System.arraycopy(pStringChar, 0, retChar, padIdx, pStringChar.length);
        return retChar;
    } else {
        return pStringChar;
    }
}

• ध्यान दें कि इसे String.toCharArray () के साथ कहा जाता है और परिणाम को String के साथ नए String ((char []) परिणाम) में परिवर्तित किया जा सकता है। इसका कारण यह है, यदि आप कई ऑपरेशनों को लागू करते हैं, तो आप उन सभी को चार [] पर कर सकते हैं और प्रारूपों के बीच परिवर्तित नहीं कर सकते हैं - पर्दे के पीछे, स्ट्रिंग को [] के रूप में संग्रहीत किया जाता है। यदि इन ऑपरेशनों को स्ट्रिंग क्लास में ही शामिल किया जाता, तो यह दो बार कुशल होता - गति और मेमोरी वार।

Comments

यह वास्तव में सबसे कुशल तरीका लगता है

— डेविड लिलग्रेनगैन

Answer 22

इस फ़ंक्शन का उपयोग करें।

private String leftPadding(String word, int length, char ch) {
   return (length > word.length()) ? leftPadding(ch + word, length, ch) : word;
}

कैसे इस्तेमाल करे?

leftPadding(month, 2, '0');

आउटपुट: 01 02 03 04 .. 11 12

Answer 23

बहुत सारे लोगों के पास कुछ बहुत ही दिलचस्प तकनीकें हैं लेकिन मैं इसे सरल रखना पसंद करता हूं इसलिए मैं इसके साथ जाता हूं:

public static String padRight(String s, int n, char padding){
    StringBuilder builder = new StringBuilder(s.length() + n);
    builder.append(s);
    for(int i = 0; i < n; i++){
        builder.append(padding);
    }
    return builder.toString();
}

public static String padLeft(String s, int n,  char padding) {
    StringBuilder builder = new StringBuilder(s.length() + n);
    for(int i = 0; i < n; i++){
        builder.append(Character.toString(padding));
    }
    return builder.append(s).toString();
}

public static String pad(String s, int n, char padding){
    StringBuilder pad = new StringBuilder(s.length() + n * 2);
    StringBuilder value = new StringBuilder(n);
    for(int i = 0; i < n; i++){
        pad.append(padding);
    }
    return value.append(pad).append(s).append(pad).toString();
}

Comments

यह बहुत ही अयोग्य है, आपको

— बजे

चूंकि आप पहले से ही लंबाई जानते हैं, इसलिए आपको स्ट्रांगबर्ल को उस स्थान को आवंटित करने के लिए कहना चाहिए, जब आप उसे तुरंत भेजते हैं।

— एरियल

@ एरियल दिलचस्प है कि आप इसका उल्लेख करते हैं क्योंकि मैं आज उस लोल के बारे में किसी और से बात कर रहा था।

— अनलफिस

Answer 24

बिना किसी एपीआई के एक सरल समाधान इस प्रकार होगा:

public String pad(String num, int len){
    if(len-num.length() <=0) return num;
    StringBuffer sb = new StringBuffer();
    for(i=0; i<(len-num.length()); i++){
        sb.append("0");
    }
    sb.append(num);
    return sb.toString();
}

Answer 25

जावा ऑनलाइनर, कोई फैंसी लाइब्रेरी नहीं।

// 6 characters padding example
String pad = "******";
// testcases for 0, 4, 8 characters
String input = "" | "abcd" | "abcdefgh"

पैड लेफ्ट, लिमिट नहीं

result = pad.substring(Math.min(input.length(),pad.length())) + input;
results: "******" | "**abcd" | "abcdefgh"

पैड राइट, लिमिट नहीं

result = input + pad.substring(Math.min(input.length(),pad.length()));
results: "******" | "abcd**" | "abcdefgh"

पैड लेफ्ट, पैड की लंबाई तक सीमित है

result = (pad + input).substring(input.length(), input.length() + pad.length());
results: "******" | "**abcd" | "cdefgh"

पैड राइट, पैड की लंबाई तक सीमित है

result = (input + pad).substring(0, pad.length());
results: "******" | "abcd**" | "abcdef"

Answer 26

पुनरावर्तन का उपयोग कैसे करें? नीचे दिए गए समाधान सभी JDK संस्करणों के साथ संगत है और कोई बाहरी पुस्तकालयों की आवश्यकता नहीं है :)

private static String addPadding(final String str, final int desiredLength, final String padBy) {
        String result = str;
        if (str.length() >= desiredLength) {
            return result;
        } else {
            result += padBy;
            return addPadding(result, desiredLength, padBy);
        }
    }

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

Answer 27

यहाँ उन लोगों के लिए एक समानांतर संस्करण है जिनके पास बहुत लंबे स्ट्रिंग्स हैं :-)

int width = 100;
String s = "129018";

CharSequence padded = IntStream.range(0,width)
            .parallel()
            .map(i->i-(width-s.length()))
            .map(i->i<0 ? '0' :s.charAt(i))
            .collect(StringBuilder::new, (sb,c)-> sb.append((char)c), (sb1,sb2)->sb1.append(sb2));

Answer 28

गुवा में पैडिंग उदाहरण:

• http://apisonar.com/java-examples/com.google.common.base.Strings.padEnd.html
• http://apisonar.com/java-examples/com.google.common.base.Strings.padStart.html
• http://apisonar.com/java-examples/com.google.common.base.Strings.repeat.html

अपाचे कॉमन्स में पैडिंग उदाहरण:

• http://apisonar.com/java-examples/org.apache.commons.lang.StringUtils.leftPad.html
• http://apisonar.com/java-examples/org.apache.commons.lang.StringUtils.rightPad.html
• http://apisonar.com/java-examples/org.apache.commons.lang.StringUtils.repeat.html

JDK में पैडिंग उदाहरण:

• http://apisonar.com/java-examples/java.util.Formatter.Formatter.html

Answer 29

एक सरल समाधान होगा:

package nl;
public class Padder {
    public static void main(String[] args) {
        String s = "123" ;
        System.out.println("#"+("     " + s).substring(s.length())+"#");
    }
}

Answer 30

यह कैसा है

स्ट्रिंग "हैलो" है और आवश्यक पैडिंग "0" बाएं पैड के साथ 15 है

String ax="Hello";
while(ax.length() < 15) ax="0"+ax;

Comments

यह एक 15 नए तार तक उत्पन्न करता है।

— claj

@ काज हां, लेकिन यह ।

— रफिन