වම්පස ඇති ශුන්‍යයන් සමඟ පූර්ණ සංඛ්‍යාවක් පෑඩ් කරන්නේ කෙසේද?

ජාවා හි inta බවට පරිවර්තනය කිරීමේදී ඔබ ශුන්‍යයන් සමඟ පෑඩ් Stringතබන්නේ කෙසේද?

මම මූලික වශයෙන් බලන්නේ 9999ප්‍රමුඛ ශුන්‍යයන් (උදා. 1 = 0001) සමඟ පූර්ණ සංඛ්‍යා ඉවත් කිරීමට ය .

මේ ආකාරයට භාවිතා කරන්න java.lang.String.format(String,Object...):

String.format("%05d", yournumber);

ෂඩ් දශම ප්රතිදානය සඳහා 5. දිග ශුන්ය-පුරවන සඳහා වෙනුවට dසමග xමෙන් "%05x".

සම්පූර්ණ ආකෘතිකරණ විකල්පයන් කොටසක් ලෙස ලේඛනගත කර ඇත java.util.Formatter.

ගේ ඔබ මුද්රණය කිරීමට අවශ්ය බවත් කියන්න මට ඉඩ දෙන්න 11ලෙස011

ඔබට ආකෘති පත්‍රයක් භාවිතා කළ හැකිය : "%03d".

ඔබට මෙම ආකෘතිය භාවිතා කළ හැකිය:

int a = 11;
String with3digits = String.format("%03d", a);
System.out.println(with3digits);

විකල්පයක් ලෙස, සමහර ජාවා ක්‍රම මෙම ආකෘතිකරුවන්ට සෘජුවම සහය දක්වයි:

System.out.printf("%03d", a);

ඔබ කිසියම් හේතුවක් නිසා පෙර 1.5 ජාවා භාවිතා කරන්නේ නම් Apache Commons Lang ක්‍රමය සමඟ උත්සාහ කළ හැකිය

org.apache.commons.lang.StringUtils.leftPad(String str, int size, '0')

මෙම උදාහරණය හමු විය ... පරීක්ෂා කරනු ඇත ...

import java.text.DecimalFormat;
class TestingAndQualityAssuranceDepartment
{
    public static void main(String [] args)
    {
        int x=1;
        DecimalFormat df = new DecimalFormat("00");
        System.out.println(df.format(x));
    }
}

මෙය පරීක්ෂා කර:

String.format("%05d",number);

දෙකම වැඩ කරයි, මගේ අරමුණු සඳහා මම සිතන්නේ String.Format වඩා හොඳ හා වඩා සංක්ෂිප්ත ය.

ඔබගේ නඩුවේ කාර්ය සාධනය වැදගත් නම්, String.formatශ්‍රිතයට සාපේක්ෂව අඩු පිරිවැයකින් ඔබට එය කළ හැකිය :

/**
 * @param in The integer value
 * @param fill The number of digits to fill
 * @return The given value left padded with the given number of digits
 */
public static String lPadZero(int in, int fill){

    boolean negative = false;
    int value, len = 0;

    if(in >= 0){
        value = in;
    } else {
        negative = true;
        value = - in;
        in = - in;
        len ++;
    }

    if(value == 0){
        len = 1;
    } else{         
        for(; value != 0; len ++){
            value /= 10;
        }
    }

    StringBuilder sb = new StringBuilder();

    if(negative){
        sb.append('-');
    }

    for(int i = fill; i > len; i--){
        sb.append('0');
    }

    sb.append(in);

    return sb.toString();       
}

කාර්ය සාධනය

public static void main(String[] args) {
    Random rdm;
    long start; 

    // Using own function
    rdm = new Random(0);
    start = System.nanoTime();

    for(int i = 10000000; i != 0; i--){
        lPadZero(rdm.nextInt(20000) - 10000, 4);
    }
    System.out.println("Own function: " + ((System.nanoTime() - start) / 1000000) + "ms");

    // Using String.format
    rdm = new Random(0);        
    start = System.nanoTime();

    for(int i = 10000000; i != 0; i--){
        String.format("%04d", rdm.nextInt(20000) - 10000);
    }
    System.out.println("String.format: " + ((System.nanoTime() - start) / 1000000) + "ms");
}

ප්‍රති ult ලය

තමන්ගේම කාර්යය: 1697ms

String.format: 38134ms

ඔබට ගූගල් ගුවා භාවිතා කළ හැකිය :

මේවන්:

<dependency>
     <artifactId>guava</artifactId>
     <groupId>com.google.guava</groupId>
     <version>14.0.1</version>
</dependency>

නියැදි කේතය:

String paddedString1 = Strings.padStart("7", 3, '0'); //"007"
String paddedString2 = Strings.padStart("2020", 3, '0'); //"2020"

සටහන:

Guavaඑය ද අදාළ වන කාරණා ගොඩක් සපයයි, ඉතා ප්රයෝජනවත් පුස්තකාලය Collections, Caches, Functional idioms, Concurrency, Strings, Primitives, Ranges, IO, Hashing, EventBus, ආදිය

Ref: GuavaExplained

මෙය උත්සාහ කරන්න:

import java.text.DecimalFormat; 

DecimalFormat df = new DecimalFormat("0000");

String c = df.format(9);   // Output: 0009

String a = df.format(99);  // Output: 0099

String b = df.format(999); // Output: 0999

ඉහත ප්‍රවේශයන් බොහොමයක් හොඳ වුවත්, සමහර විට අපට පූර්ණ සංඛ්‍යා මෙන්ම පාවෙන ද සංයුති කළ යුතුය. අපට මෙය භාවිතා කළ හැකිය, විශේෂයෙන් අපට නිශ්චිත ශුන්‍ය සංඛ්‍යාවක් වම් පසින් මෙන්ම දශම සංඛ්‍යා වල දකුණට ඇලවීමට අවශ්‍ය වූ විට.

import java.text.NumberFormat;  
public class NumberFormatMain {  

public static void main(String[] args) {  
    int intNumber = 25;  
    float floatNumber = 25.546f;  
    NumberFormat format=NumberFormat.getInstance();  
    format.setMaximumIntegerDigits(6);  
    format.setMaximumFractionDigits(6);  
    format.setMinimumFractionDigits(6);  
    format.setMinimumIntegerDigits(6);  

    System.out.println("Formatted Integer : "+format.format(intNumber).replace(",",""));  
    System.out.println("Formatted Float   : "+format.format(floatNumber).replace(",",""));  
 }    
}  

int x = 1;
System.out.format("%05d",x);

ඔබට ආකෘතිගත කළ පෙළ කෙලින්ම තිරය මත මුද්‍රණය කිරීමට අවශ්‍ය නම්.

ඔබට ෆෝමැටරයක් භාවිතා කිරීමට අවශ්‍යය , පහත කේතය අංක ෆෝමැට් භාවිතා කරයි

    int inputNo = 1;
    NumberFormat nf = NumberFormat.getInstance();
    nf.setMaximumIntegerDigits(4);
    nf.setMinimumIntegerDigits(4);
    nf.setGroupingUsed(false);

    System.out.println("Formatted Integer : " + nf.format(inputNo));

නිමැවුම්: 0001

පංති DecimalFormat භාවිතා කරන්න, එසේ:

NumberFormat formatter = new DecimalFormat("0000"); //i use 4 Zero but you can also another number
System.out.println("OUTPUT : "+formatter.format(811)); 

පිටත : 0000811

මෙන්න ඔබට භාවිතා නොකර ඔබේ නූල් සංයුති කළ හැකි ආකාරය DecimalFormat.

String.format("%02d", 9)

09

String.format("%03d", 19)

019

String.format("%04d", 119)

0119

නිඛිල සහ නූල් සඳහා වැඩ කරන මගේ කේතය පරීක්ෂා කරන්න.

අපගේ පළමු අංකය 2 යැයි උපකල්පනය කරන්න. තවද අපට එයට ශුන්‍ය එකතු කිරීමට අවශ්‍ය වන අතර අවසාන නූලෙහි දිග 4 වනු ඇත. ඒ සඳහා ඔබට පහත කේතය භාවිතා කළ හැකිය

    int number=2;
    int requiredLengthAfterPadding=4;
    String resultString=Integer.toString(number);
    int inputStringLengh=resultString.length();
    int diff=requiredLengthAfterPadding-inputStringLengh;
    if(inputStringLengh<requiredLengthAfterPadding)
    {
        resultString=new String(new char[diff]).replace("\0", "0")+number;
    }        
    System.out.println(resultString);

වම් පසින් ශුන්‍යයන් සහිත පූර්ණ සංඛ්‍යාවක් පෑඩ් කිරීමට තවත් ක්‍රමයක් මෙන්න. ඔබේ පහසුව අනුව ඔබට ශුන්‍ය ගණන වැඩි කළ හැකිය. Negative ණ සංඛ්‍යාවක් හෝ අගයකට වඩා වැඩි හෝ වින්‍යාස කර ඇති ශුන්‍යයන්ට සමාන අගයක් ලබා දීමට චෙක්පතක් එකතු කර තිබේ. ඔබේ අවශ්‍යතාවය අනුව ඔබට තවදුරටත් වෙනස් කළ හැකිය.

/**
 * 
 * @author Dinesh.Lomte
 *
 */
public class AddLeadingZerosToNum {
    
    /**
     * 
     * @param args
     */
    public static void main(String[] args) {
        
        System.out.println(getLeadingZerosToNum(0));
        System.out.println(getLeadingZerosToNum(7));
        System.out.println(getLeadingZerosToNum(13));
        System.out.println(getLeadingZerosToNum(713));
        System.out.println(getLeadingZerosToNum(7013));
        System.out.println(getLeadingZerosToNum(9999));
    }
    /**
     * 
     * @param num
     * @return
     */
    private static String getLeadingZerosToNum(int num) {
        // Initializing the string of zeros with required size
        String zeros = new String("0000");
        // Validating if num value is less then zero or if the length of number 
        // is greater then zeros configured to return the num value as is
        if (num < 0 || String.valueOf(num).length() >= zeros.length()) {
            return String.valueOf(num);
        }
        // Returning zeros in case if value is zero.
        if (num == 0) {
            return zeros;
        }
        return new StringBuilder(zeros.substring(0, zeros.length() - 
                String.valueOf(num).length())).append(
                        String.valueOf(num)).toString();
    }
}

ආදානය

0

7

13

713

7013

9999

ප්‍රතිදානය

0000

0007

0013

7013

9999

public static String zeroPad(long number, int width) {
   long wrapAt = (long)Math.pow(10, width);
   return String.valueOf(number % wrapAt + wrapAt).substring(1);
}

මෙම ප්‍රවේශයේ ඇති එකම ගැටළුව නම්, එය ක්‍රියා කරන ආකාරය හඳුනා ගැනීමට ඔබේ සිතීමේ තොප්පිය පැළඳීමයි.

පැකේජ අවශ්‍ය නොවේ:

String paddedString = i < 100 ? i < 10 ? "00" + i : "0" + i : "" + i;

මෙය අක්ෂර තුනකට නූල් පටවන අතර හතරක් හෝ පහක් සඳහා තවත් කොටසක් එකතු කිරීම පහසුය. මෙය කිසිම ආකාරයකින් පරිපූර්ණ විසඳුමක් නොවන බව මම දනිමි (විශේෂයෙන් ඔබට විශාල පෑඩ් නූල් අවශ්‍ය නම්), නමුත් මම එයට කැමතියි.