दिलचस्प पोस्ट
मैं एक .so फ़ाइल में प्रतीकों की सूची कैसे करूं? कैसे HTML में शब्द को लपेटें टेक्स्ट? तत्व की आईडी प्राप्त करना जो एक घटना को निकाल दिया विन्डोज़ विस्टा यूएसी उन्नयन का अनुरोध करें यदि पथ सुरक्षित है? कैसे एक प्रतिबद्ध में सभी फाइलों की सूची है? चर और विधियों के साथ अंडरस्कोर बनाम डबल अंडरस्कोर एक बहु-फ़ाइल जाने वाली परियोजना को व्यवस्थित करना विशिष्ट वस्तुओं के लिए LINQ के साथ काम नहीं कर रहा है सीमा सीएसएस के भीतर सीमा सेलेनियम का उपयोग करने वाले प्रमाण पत्रों से कैसे निपटें? जावा: सूचित करें () बनाम सूचित करें (सभी) फिर से कैसे उपनिर्देशों और समय के साथ निर्देशिका में नवीनतम संशोधित फाइलों को लगातार मिल जाए और सूचीबद्ध करें? जावा प्रोग्रामिंग: जावा से एक एक्सई कॉल करें और मापदंडों को पारित करें सेलेनियम प्रतीक्षाफ़र एलेमेंट रूबी में @@ चर का क्या अर्थ है?

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

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

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

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

अपाचे स्ट्रिंग यूटिल के पास कई तरीके हैं: बाएंपाड, राइटपैड, केंद्र और दोहराएं

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

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

 public static String padRight(String s, int n) { return String.format("%1$-" + n + "s", s); } public static String padLeft(String s, int n) { return String.format("%1$" + n + "s", s); } ... public static void main(String args[]) throws Exception { System.out.println(padRight("Howto", 20) + "*"); System.out.println(padLeft("Howto", 20) + "*"); } /* output : Howto * Howto* */ 

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 ********* 

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

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

कुछ सरल:

मान एक स्ट्रिंग होना चाहिए। इसे स्ट्रिंग में परिवर्तित करें, अगर ऐसा नहीं है। "" + 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" 

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

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

 public static String LPad(String str, Integer length, char car) { return str + String.format("%" + (length - str.length()) + "s", "") .replace(" ", String.valueOf(car)); } public static String RPad(String str, Integer length, char car) { return String.format("%" + (length - str.length()) + "s", "") .replace(" ", String.valueOf(car)) + str; } LPad("Hi", 10, 'R') //gives "RRRRRRRRHi" RPad("Hi", 10, 'R') //gives "HiRRRRRRRR" RPad("Hi", 10, ' ') //gives "Hi " //etc... 

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

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

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

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

एसबी के आंतरिक बफर को बढ़ने से रोकता है

यहां दाईं ओर पैड का दूसरा तरीका है:

 // 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-------"; 

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

 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(...) विधि के लिए एक पैरामीटर बना सकते हैं उस स्थिति में कन्स्ट्रक्टर के बजाय उस विधि में छिपे हुए पैडिंग का समायोजन करना

(सुझाव: अतिरिक्त क्रेडिट के लिए, यह धागा-सुरक्षित बनाएँ! 😉

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

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

यह काम:

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

यह आपकी स्ट्रिंग XXX को एक श्वेत स्थान के साथ 9 वर्ण तक भर देगी। उसके बाद सभी व्हाइटस्पेस को एक 0 से बदल दिया जाएगा। आप जो कुछ भी चाहते हैं वह व्हाटस्पेस और 0 को बदल सकते हैं …

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

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

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

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

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

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

java.util.Formatter छोड़ दिया और सही पैडिंग करेंगे अजीब तीसरी पार्टी निर्भरताओं की आवश्यकता नहीं है (क्या आप उन्हें कुछ इतना तुच्छ के लिए जोड़ना चाहते हैं)

[मैंने विवरण छोड़ दिया है और इस पोस्ट को 'सामुदायिक विकी' बना दिया है क्योंकि यह मेरे लिए कुछ नहीं है।]

@ के और @ मार्लोन तारक के उत्तर केवल उन 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 

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

 public static String padRight(String s, int n, char padding){ String pad = ""; for(int i = 0; i < n; i++){ pad += padding; } return s + pad; } public static String padLeft(String s, int n, char padding) { String pad = ""; for(int i = 0; i < n; i++){ pad += padding; } return pad + s; } public static String pad(String s, int n, char padding){ return padLeft(padRight(s,n, padding),n,padding); } 

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

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

जावा इनलाइनर, कोई फैंसी पुस्तकालय नहीं।

 // 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" 

सभी स्ट्रिंग ऑपरेशन को बहुत कुशल होना चाहिए – खासकर यदि आप बड़े डेटा सेट के साथ काम कर रहे हों मुझे वह चीज चाहिए जो तेजी से और लचीली हो, जैसा कि आप 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; } } 
  • ध्यान दें कि इसे स्ट्रिंग.toचरराअरे () के साथ कहा जाता है और परिणाम को स्ट्रिंग में नया स्ट्रिंग (([चार [] परिणाम के साथ परिवर्तित किया जा सकता है)। इसका कारण यह है कि यदि आप कई आपरेशनों को लागू करते हैं तो आप उन्हें चार [चार] पर कर सकते हैं और स्वरूपों के बीच परिवर्तित नहीं रख सकते – परिदृश्य के पीछे, स्ट्रिंग को चार [चारों के रूप में संग्रहीत किया जाता है] अगर ये संचालन स्ट्रिंग कक्षा में ही शामिल थे, तो यह दो बार कुशल – गति और स्मृति के आधार पर होता।

यह डोजोन पर मिला

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

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

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

 private String leftPadding(String value, int length, String ch) { if (length-- > value.length()) return leftPadding(ch + value, length, ch); return value; } 

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

 leftPadding(month, 2, "0"); 

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

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

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

यह कैसा है

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

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