ජාවා හි නූලක් int එකක් බවට පරිවර්තනය කරන්නේ කෙසේද?

කොහොමද මම පරිවර්තනය කළ හැකි Stringවන කිරීමටint ජාවා?

මගේ සංගීතයේ අඩංගු වන්නේ සංඛ්‍යා පමණි, එය නියෝජනය කරන අංකය ආපසු ලබා දීමට මට අවශ්‍යය.

උදාහරණයක් ලෙස, නූලට අනුව ප්‍රති "1234"result ලය අංකය විය යුතුය 1234.

String myString = "1234";
int foo = Integer.parseInt(myString);

ඔබ ජාවා ප්‍රලේඛනය දෙස බැලුවහොත් ඔබට පෙනෙනුයේ “ඇල්ලීම” යනු මෙම ශ්‍රිතයට විසි කළ හැකි බවය NumberFormatException, ඇත්ත වශයෙන්ම ඔබ හැසිරවිය යුත්තේ:

int foo;
try {
   foo = Integer.parseInt(myString);
}
catch (NumberFormatException e)
{
   foo = 0;
}

(මෙම ප්‍රතිකාරය අක්‍රමික අංකයකට පෙරනිමිය 0 , නමුත් ඔබ කැමති නම් ඔබට වෙනත් දෙයක් කළ හැකිය.)

විකල්පයක් ලෙස, ඔබට Intsගුවා පුස්තකාලයෙන් ක්‍රමයක් භාවිතා කළ හැකිය , එය ජාවා 8 සමඟ ඒකාබද්ධව Optional, නූලක් int බවට පරිවර්තනය කිරීම සඳහා ප්‍රබල හා සංක්ෂිප්ත ක්‍රමයක් නිර්මාණය කරයි:

import com.google.common.primitives.Ints;

int foo = Optional.ofNullable(myString)
 .map(Ints::tryParse)
 .orElse(0)

උදාහරණයක් ලෙස, මෙන්න ක්‍රම දෙකක්:

Integer x = Integer.valueOf(str);
// or
int y = Integer.parseInt(str);

මෙම ක්‍රම අතර සුළු වෙනසක් ඇත:

• valueOf නව හෝ හැඹිලි උදාහරණයක් ලබා දෙයි java.lang.Integer
• parseInt ප්‍රාථමික ප්‍රතිලාභ ලබා දෙයි int .

සෑම අවස්ථාවකටම සමාන වේ: Short.valueOf/ parseShort, Long.valueOf/ parseLong, ආදිය.

හොඳයි, සලකා බැලීම සඳහා ඉතා වැදගත් කරුණක් සඳහන් ලෙස පූර්ණ සංඛ්යාව ව්යාකරණ විග්රහ NumberFormatException අවුලට බව ය Javadoc .

int foo;
String StringThatCouldBeANumberOrNot = "26263Hello"; //will throw exception
String StringThatCouldBeANumberOrNot2 = "26263"; //will not throw exception
try {
      foo = Integer.parseInt(StringThatCouldBeANumberOrNot);
} catch (NumberFormatException e) {
      //Will Throw exception!
      //do something! anything to handle the exception.
}

try {
      foo = Integer.parseInt(StringThatCouldBeANumberOrNot2);
} catch (NumberFormatException e) {
      //No problem this time, but still it is good practice to care about exceptions.
      //Never trust user input :)
      //Do something! Anything to handle the exception.
}

බෙදීම් තර්ක වලින් පූර්ණ සංඛ්‍යා ලබා ගැනීමට උත්සාහ කරන විට හෝ යමක් ගතිකව විග්‍රහ කිරීමේදී මෙම ව්‍යතිරේකය හැසිරවීම වැදගත් වේ.

එය අතින් කරන්න:

public static int strToInt( String str ){
    int i = 0;
    int num = 0;
    boolean isNeg = false;

    //Check for negative sign; if it's there, set the isNeg flag
    if (str.charAt(0) == '-') {
        isNeg = true;
        i = 1;
    }

    //Process each character of the string;
    while( i < str.length()) {
        num *= 10;
        num += str.charAt(i++) - '0'; //Minus the ASCII code of '0' to get the value of the charAt(i++).
    }

    if (isNeg)
        num = -num;
    return num;
}

විකල්ප විසඳුමක් වන්නේ Apache Commons ' NumberUtils භාවිතා කිරීමයි:

int num = NumberUtils.toInt("1234");

Apache උපයෝගීතාව හොඳයි, මන්ද එම නූල අවලංගු සංඛ්‍යා ආකෘතියක් නම් 0 සෑම විටම ආපසු ලබා දෙනු ඇත. එබැවින් ඔබ උත්සාහක ඇල්ලීමේ කොටස ඉතිරි කරයි.

Apache NumberUtils API අනුවාදය 3.4

දැනට මම විද්‍යාලය සඳහා පැවරුමක් කරමින් සිටිමි, එහිදී මට ඉහත වැනි සමහර ප්‍රකාශන භාවිතා කළ නොහැකි අතර ASCII වගුව දෙස බැලීමෙන් මට එය කිරීමට හැකි විය. එය වඩා සංකීර්ණ කේතයකි, නමුත් එය මා මෙන් සීමා කර ඇති අනෙක් අයට උපකාර කළ හැකිය.

කළ යුතු පළමු දෙය නම් ආදානය ලැබීම, මේ අවස්ථාවේ දී, ඉලක්කම් මාලාවක්; මම එය අමතන්නම් String number, මේ අවස්ථාවේ දී, මම එය අංක 12 භාවිතා කර නිදර්ශනය කරමිString number = "12";

තවත් සීමාවක් නම් මට පුනරාවර්තන චක්‍ර භාවිතා කළ නොහැකි වීමයි, එබැවින් forචක්‍රයක් (පරිපූර්ණ වනු ඇත) ද භාවිතා කළ නොහැක. මෙය අපට ටිකක් සීමා කරයි, නමුත් නැවතත්, ඉලක්කය එයයි. මට අවශ්‍ය වූයේ ඉලක්කම් දෙකක් පමණි (අවසාන ඉලක්කම් දෙක ගනිමින්), සරල එකක් charAtඑය විසඳීය:

 // Obtaining the integer values of the char 1 and 2 in ASCII
 int semilastdigitASCII = number.charAt(number.length()-2);
 int lastdigitASCII = number.charAt(number.length()-1);

කේත තිබීම, අපට අවශ්‍ය වන්නේ මේසය දෙස බලා අවශ්‍ය වෙනස්කම් කිරීමයි:

 double semilastdigit = semilastdigitASCII - 48;  //A quick look, and -48 is the key
 double lastdigit = lastdigitASCII - 48;

දැන්, ඇයි දෙගුණයක්? හොඳයි, ඇත්තටම "අමුතු" පියවරක් නිසා. දැනට අපට ද්විත්ව යුගල දෙකක් ඇත, 1 සහ 2, නමුත් අපි එය 12 බවට පත් කළ යුතුයි, අපට කළ හැකි ගණිතමය මෙහෙයුමක් නොමැත.

අපි දෙවැන්න (lastdigit) විලාසිතාවෙන් 10 න් බෙදන්නෙමු 2/10 = 0.2(එබැවින් ඇයි දෙගුණයක්):

 lastdigit = lastdigit/10;

මෙය හුදෙක් සංඛ්‍යා සමඟ සෙල්ලම් කිරීමකි. අපි අන්තිම ඉලක්කම් දශමයකට හරවනවා. නමුත් දැන්, සිදුවන්නේ කුමක්දැයි බලන්න:

 double jointdigits = semilastdigit + lastdigit; // 1.0 + 0.2 = 1.2

ගණිතයට ඇතුල් නොවී, අපි හුදෙක් සංඛ්‍යාවක ඉලක්කම් හුදකලා කරමු. අප දකින්නේ 0-9 ක් පමණක් බැවින්, 10 න් ගුණ කිරීමෙන් බෙදීම ඔබ එය ගබඩා කරන ස්ථානයක "කොටුවක්" සෑදීම හා සමානයි (ඔබේ පළමු ශ්‍රේණියේ ගුරුවරයා ඔබට ඒකකයක් සහ සියයක් යනු කුමක්දැයි පැහැදිලි කළ විට නැවත සිතන්න). ඒ නිසා:

 int finalnumber = (int) (jointdigits*10); // Be sure to use parentheses "()"

එතනට යන්න. පහත දැක්වෙන සීමාවන් සැලකිල්ලට ගනිමින් ඔබ ඉලක්කම් මාලාවක් (මේ අවස්ථාවේ දී ඉලක්කම් දෙකක්) එම ඉලක්කම් දෙකෙන් සමන්විත පූර්ණ සංඛ්‍යාවක් බවට පත් කළේය:

• පුනරාවර්තන චක්‍ර නොමැත
• ParseInt වැනි "මැජික්" ප්‍රකාශන නොමැත

Integer.decode

ඔබට ද භාවිතා කළ හැකිය public static Integer decode(String nm) throws NumberFormatException.

එය 8 සහ 16 පදනම් සඳහා ද ක්‍රියා කරයි:

// base 10
Integer.parseInt("12");     // 12 - int
Integer.valueOf("12");      // 12 - Integer
Integer.decode("12");       // 12 - Integer
// base 8
// 10 (0,1,...,7,10,11,12)
Integer.parseInt("12", 8);  // 10 - int
Integer.valueOf("12", 8);   // 10 - Integer
Integer.decode("012");      // 10 - Integer
// base 16
// 18 (0,1,...,F,10,11,12)
Integer.parseInt("12",16);  // 18 - int
Integer.valueOf("12",16);   // 18 - Integer
Integer.decode("#12");      // 18 - Integer
Integer.decode("0x12");     // 18 - Integer
Integer.decode("0X12");     // 18 - Integer
// base 2
Integer.parseInt("11",2);   // 3 - int
Integer.valueOf("11",2);    // 3 - Integer

ඔබට intඒ වෙනුවට ලබා ගැනීමට අවශ්‍ය නම් Integerභාවිතා කළ හැකිය:

1. Unboxing:

   int val = Integer.decode("12"); 

2. intValue():

   Integer.decode("12").intValue();

දී ඇති සංගීතයට පූර්ණ සංඛ්‍යාවක් අඩංගු නොවන බවට සුළු හැකියාවක් ඇති විට, ඔබට මෙම විශේෂ අවස්ථාව හැසිරවිය යුතුය. කනගාටුවට කරුණක් නම්, සම්මත ජාවා ක්‍රම Integer::parseIntසහ Integer::valueOfවිසි කිරීම aNumberFormatException මෙම විශේෂ අවස්ථාව සං signal සඳහා කිරීම. මේ අනුව, ඔබ සාමාන්‍යයෙන් නරක කේතීකරණ විලාසය ලෙස සැලකෙන ප්‍රවාහ පාලනය සඳහා ව්‍යතිරේක භාවිතා කළ යුතුය.

මගේ මතය අනුව, මෙම විශේෂ නඩුව හිස්ව ආපසු ලබා දීමෙන් හැසිරවිය යුතුය Optional<Integer>. ජාවා එවැනි ක්‍රමයක් ඉදිරිපත් නොකරන බැවින්, මම පහත සඳහන් ආවරකය භාවිතා කරමි:

private Optional<Integer> tryParseInteger(String string) {
    try {
        return Optional.of(Integer.valueOf(string));
    } catch (NumberFormatException e) {
        return Optional.empty();
    }
}

උදාහරණ භාවිතය:

// prints "12"
System.out.println(tryParseInteger("12").map(i -> i.toString()).orElse("invalid"));
// prints "-1"
System.out.println(tryParseInteger("-1").map(i -> i.toString()).orElse("invalid"));
// prints "invalid"
System.out.println(tryParseInteger("ab").map(i -> i.toString()).orElse("invalid"));

මෙය තවමත් අභ්‍යන්තරව ප්‍රවාහ පාලනය සඳහා ව්‍යතිරේක භාවිතා කරන අතර, භාවිත කේතය ඉතා පිරිසිදු වේ. එසේම, -1වලංගු අගයක් ලෙස විග්‍රහ කර ඇති නඩුව සහ අවලංගු නූල් විග්‍රහ කිරීමට නොහැකි වූ අවස්ථාව ඔබට පැහැදිලිව හඳුනාගත හැකිය.

අංකයක් පරිවර්තනය කිරීමට වඩා නූල් සංඛ්‍යාවක් int බවට පරිවර්තනය කිරීම වඩාත් සංකීර්ණ වේ. ඔබ පහත සඳහන් කරුණු ගැන සිතා ඇත:

• නූලෙහි අඩංගු වන්නේ 0-9 අංක පමණක්ද?
• මොකද වෙන්නේ - / + පෙර හෝ වැල පසු? එය කළ හැකිද (ගිණුම් අංක සඳහන් කරමින්)?
• MAX _- / MIN_INFINITY සමඟ කුමක් සිදුවේද? නූල 999999999999999999999 නම් කුමක් සිදුවේද? යන්ත්‍රයට මෙම නූල int ලෙස සැලකිය හැකිද?

එය කළ යුතු ක්‍රම:

 1. Integer.parseInt(s)
 2. Integer.parseInt(s, radix)
 3. Integer.parseInt(s, beginIndex, endIndex, radix)
 4. Integer.parseUnsignedInt(s)
 5. Integer.parseUnsignedInt(s, radix)
 6. Integer.parseUnsignedInt(s, beginIndex, endIndex, radix)
 7. Integer.valueOf(s)
 8. Integer.valueOf(s, radix)
 9. Integer.decode(s)
 10. NumberUtils.toInt(s)
 11. NumberUtils.toInt(s, defaultValue)

Integer.valueOf විසින් පූර්ණ සංඛ්‍යා වස්තුව නිෂ්පාදනය කරයි, අනෙක් සියලුම ක්‍රම - ප්‍රාථමික int.

කොමන්ස්-ලැන්ග් 3 හි අවසාන ක්‍රම 2 සහ මෙහි පරිවර්තනය කිරීම පිළිබඳ විශාල ලිපියක් .

අපට parseInt(String str)ක්‍රමවේදය භාවිතා කළ හැකියIntegerසංගීත අගයක් පූර්ණ සංඛ්‍යාවක් බවට පරිවර්තනය කිරීම සඳහා අපට එතීමේ පන්තියේ .

උදාහරණයක් වශයෙන්:

String strValue = "12345";
Integer intValue = Integer.parseInt(strVal);

මෙම Integerද පන්තිය සපයන valueOf(String str)ක්රමය:

String strValue = "12345";
Integer intValue = Integer.valueOf(strValue);

ඒ වගේම අපි භාවිතා කළ හැකි toInt(String strValue)වන NumberUtils උපයෝගිතා පන්තියේ බවට පරිවර්තනය කිරීම සඳහා වූ:

String strValue = "12345";
Integer intValue = NumberUtils.toInt(strValue);

භාවිතා කරන්න Integer.parseInt(yourString).

පහත සඳහන් කරුණු මතක තබා ගන්න:

Integer.parseInt("1"); // හරි

Integer.parseInt("-1"); // හරි

Integer.parseInt("+1"); // හරි

Integer.parseInt(" 1"); // ව්‍යතිරේකය (හිස් ඉඩ)

Integer.parseInt("2147483648");// ව්‍යතිරේකය (පූර්ණ සංඛ්‍යාව 2,147,483,647 ක උපරිම අගයකට සීමා වේ )

Integer.parseInt("1.1");// ව්‍යතිරේකය ( . හෝ , හෝ අවසර නැති ඕනෑම දෙයක්)

Integer.parseInt(""); // ව්‍යතිරේකය (0 හෝ වෙනත් දෙයක් නොවේ)

එක් ව්‍යතිරේකයක් පමණක් ඇත: NumberFormatException

මට විසඳුමක් ඇත, නමුත් එය කෙතරම් effective ලදායීදැයි මම නොදනිමි. නමුත් එය හොඳින් ක්‍රියාත්මක වන අතර ඔබට එය වැඩිදියුණු කළ හැකි යැයි මම සිතමි. අනෙක් අතට, මම නිවැරදිව පියවර තබන ජුනිට් සමඟ පරීක්ෂණ කිහිපයක් කළා . මම ශ්‍රිතය හා පරීක්ෂාව අමුණා ඇත:

static public Integer str2Int(String str) {
    Integer result = null;
    if (null == str || 0 == str.length()) {
        return null;
    }
    try {
        result = Integer.parseInt(str);
    } 
    catch (NumberFormatException e) {
        String negativeMode = "";
        if(str.indexOf('-') != -1)
            negativeMode = "-";
        str = str.replaceAll("-", "" );
        if (str.indexOf('.') != -1) {
            str = str.substring(0, str.indexOf('.'));
            if (str.length() == 0) {
                return (Integer)0;
            }
        }
        String strNum = str.replaceAll("[^\\d]", "" );
        if (0 == strNum.length()) {
            return null;
        }
        result = Integer.parseInt(negativeMode + strNum);
    }
    return result;
}

JUnit සමඟ පරීක්ෂා කිරීම:

@Test
public void testStr2Int() {
    assertEquals("is numeric", (Integer)(-5), Helper.str2Int("-5"));
    assertEquals("is numeric", (Integer)50, Helper.str2Int("50.00"));
    assertEquals("is numeric", (Integer)20, Helper.str2Int("$ 20.90"));
    assertEquals("is numeric", (Integer)5, Helper.str2Int(" 5.321"));
    assertEquals("is numeric", (Integer)1000, Helper.str2Int("1,000.50"));
    assertEquals("is numeric", (Integer)0, Helper.str2Int("0.50"));
    assertEquals("is numeric", (Integer)0, Helper.str2Int(".50"));
    assertEquals("is numeric", (Integer)0, Helper.str2Int("-.10"));
    assertEquals("is numeric", (Integer)Integer.MAX_VALUE, Helper.str2Int(""+Integer.MAX_VALUE));
    assertEquals("is numeric", (Integer)Integer.MIN_VALUE, Helper.str2Int(""+Integer.MIN_VALUE));
    assertEquals("Not
     is numeric", null, Helper.str2Int("czv.,xcvsa"));
    /**
     * Dynamic test
     */
    for(Integer num = 0; num < 1000; num++) {
        for(int spaces = 1; spaces < 6; spaces++) {
            String numStr = String.format("%0"+spaces+"d", num);
            Integer numNeg = num * -1;
            assertEquals(numStr + ": is numeric", num, Helper.str2Int(numStr));
            assertEquals(numNeg + ": is numeric", numNeg, Helper.str2Int("- " + numStr));
        }
    }
}

ගූගල් පේර ඇත tryParse (සංගීත) වන ප්රතිලාභ, nullවැල උදාහරණයක් ලෙස, කියවූ නම් කල නො හැකි විය:

Integer fooInt = Ints.tryParse(fooString);
if (fooInt != null) {
  ...
}

සංඛ්‍යාත්මක නොවන සියලුම අක්ෂර ඉවත් කර පූර්ණ සංඛ්‍යා විග්‍රහ කිරීමෙන් ඔබට ආරම්භ කළ හැකිය:

String mystr = mystr.replaceAll("[^\\d]", "");
int number = Integer.parseInt(mystr);

නමුත් මෙය ක්‍රියාත්මක වන්නේ negative ණ නොවන සංඛ්‍යා සඳහා පමණක් බව අනතුරු අඟවන්න.

පෙර පිළිතුරු වලට අමතරව, මම කාර්යයන් කිහිපයක් එකතු කිරීමට කැමැත්තෙමි. ඔබ ඒවා භාවිතා කරන අතරතුර මේවා ප්‍රති results ල වේ:

public static void main(String[] args) {
  System.out.println(parseIntOrDefault("123", 0)); // 123
  System.out.println(parseIntOrDefault("aaa", 0)); // 0
  System.out.println(parseIntOrDefault("aaa456", 3, 0)); // 456
  System.out.println(parseIntOrDefault("aaa789bbb", 3, 6, 0)); // 789
}

ක්‍රියාත්මක කිරීම:

public static int parseIntOrDefault(String value, int defaultValue) {
  int result = defaultValue;
  try {
    result = Integer.parseInt(value);
  }
  catch (Exception e) {
  }
  return result;
}

public static int parseIntOrDefault(String value, int beginIndex, int defaultValue) {
  int result = defaultValue;
  try {
    String stringValue = value.substring(beginIndex);
    result = Integer.parseInt(stringValue);
  }
  catch (Exception e) {
  }
  return result;
}

public static int parseIntOrDefault(String value, int beginIndex, int endIndex, int defaultValue) {
  int result = defaultValue;
  try {
    String stringValue = value.substring(beginIndex, endIndex);
    result = Integer.parseInt(stringValue);
  }
  catch (Exception e) {
  }
  return result;
}

සඳහන් කළ පරිදි, Apache Commons NumberUtilsහට එය කළ හැකිය. එය නැවත පැමිණේ0 නූලක් int බවට පරිවර්තනය කළ නොහැකි නම් .

ඔබට ඔබේ පෙරනිමි අගය අර්ථ දැක්විය හැකිය:

NumberUtils.toInt(String str, int defaultValue)

උදාහරණයක්:

NumberUtils.toInt("3244", 1) = 3244
NumberUtils.toInt("", 1)     = 1
NumberUtils.toInt(null, 5)   = 5
NumberUtils.toInt("Hi", 6)   = 6
NumberUtils.toInt(" 32 ", 1) = 1 // Space in numbers are not allowed
NumberUtils.toInt(StringUtils.trimToEmpty("  32 ", 1)) = 32;

සමහර පූර්වාරක්ෂාවන් සමඟ ඔබට මෙම කේතය භාවිතා කළ හැකිය.

• විකල්ප # 1: ව්‍යතිරේකය පැහැදිලිව හසුරුවන්න, උදාහරණයක් ලෙස පණිවිඩ සංවාදයක් පෙන්වීම සහ වත්මන් කාර්ය ප්‍රවාහය ක්‍රියාත්මක කිරීම නවත්වන්න. උදාහරණයක් වශයෙන්:

  try
      {
          String stringValue = "1234";
  
          // From String to Integer
          int integerValue = Integer.valueOf(stringValue);
  
          // Or
          int integerValue = Integer.ParseInt(stringValue);
  
          // Now from integer to back into string
          stringValue = String.valueOf(integerValue);
      }
  catch (NumberFormatException ex) {
      //JOptionPane.showMessageDialog(frame, "Invalid input string!");
      System.out.println("Invalid input string!");
      return;
  }

• විකල්ප # 2: ව්‍යතිරේකයකදී ක්‍රියාත්මක කිරීමේ ප්‍රවාහය දිගටම පැවතිය හැකි නම් බලපෑමට ලක්වූ විචල්‍යය නැවත සකසන්න. උදාහරණයක් ලෙස, ඇල්ලීමේ කොටසෙහි සමහර වෙනස් කිරීම් සමඟ

  catch (NumberFormatException ex) {
      integerValue = 0;
  }

සංසන්දනය කිරීම සඳහා හෝ ඕනෑම ආකාරයක පරිගණකයක් සඳහා නියත නියතයක් භාවිතා කිරීම සැමවිටම හොඳ අදහසකි, මන්ද නියතයක් කිසි විටෙකත් ශුන්‍ය අගයක් ලබා නොදේ.

ඔබට භාවිතා කළ හැකිය new Scanner("1244").nextInt(). හෝ int එකක් පවා තිබේදැයි විමසන්න:new Scanner("1244").hasNextInt()

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

1. වලංගු ධනාත්මක පූර්ණ සංඛ්‍යාවක් සඳහා:

   private static int parseInt(String str) {
       int i, n = 0;
   
       for (i = 0; i < str.length(); i++) {
           n *= 10;
           n += str.charAt(i) - 48;
       }
       return n;
   }

2. ධනාත්මක හා negative ණ පූර්ණ සංඛ්‍යා සඳහා:

   private static int parseInt(String str) {
       int i=0, n=0, sign=1;
       if (str.charAt(0) == '-') {
           i = 1;
           sign = -1;
       }
       for(; i<str.length(); i++) {
           n* = 10;
           n += str.charAt(i) - 48;
       }
       return sign*n;
   }

3. මෙම සංඛ්‍යා වලට පෙර හෝ පසුව ඔබ හිස් අවකාශයක් අපේක්ෂා කරන්නේ නම්, str = str.trim()තවදුරටත් සැකසීමට පෙර එය කිරීමට වග බලා ගන්න .

ඔබට මෙය උත්සාහ කළ හැකිය:

• භාවිතය Integer.parseInt(your_string);සඳහා පරිවර්තනය කිරීමට Stringකිරීමටint
• භාවිතය Double.parseDouble(your_string);සඳහා පරිවර්තනය කිරීමට Stringකිරීමටdouble

උදාහරණයක්

String str = "8955";
int q = Integer.parseInt(str);
System.out.println("Output>>> " + q); // Output: 8955

String str = "89.55";
double q = Double.parseDouble(str);
System.out.println("Output>>> " + q); // Output: 89.55

සාමාන්‍ය නූලක් සඳහා ඔබට භාවිතා කළ හැකිය:

int number = Integer.parseInt("1234");

නූල් සාදන්නෙකු සහ සංගීත බෆරයක් සඳහා ඔබට භාවිතා කළ හැකිය:

Integer.parseInt(myBuilderOrBuffer.toString());

int foo=Integer.parseInt("1234");

නූලෙහි සංඛ්‍යාත්මක නොවන දත්ත නොමැති බවට වග බලා ගන්න.

ස්ට්‍රිං පරාමිතියක් ලෙස ගන්නා ඉන්ටර්ජර් කන්ස්ට්‍රක්ටර් ගැන කිසිවෙකු සඳහන් නොකිරීම ගැන මම ටිකක් පුදුම වෙමි.

ඉතින්, මෙන්න එයයි:

String myString = "1234";
int i1 = new Integer(myString);

ජාවා 8 - පූර්ණ සංඛ්‍යා (නූල්) .

ඇත්ත වශයෙන්ම, ඉදිකිරීම්කරු නැවත වර්ගය ලබා දෙන අතර Integer, නොබැඳි මෙහෙයුමක් මඟින් අගය පරිවර්තනය කරයි int.

සඳහන් කිරීම වැදගත් ය : මෙම ඉදිකිරීම්කරු parseIntක්‍රමය හඳුන්වයි .

public Integer(String var1) throws NumberFormatException {
    this.value = parseInt(var1, 10);
}

try...catchසංඛ්‍යාත්මක නොවන අක්ෂරයක් ඇතුළත් කළ විට ඕනෑම දෝෂයක් හැසිරවීම සඳහා Integer.parseInt () භාවිතා කර එය බ්ලොක් එකක් තුළට දමන්න .

private void ConvertToInt(){
    String string = txtString.getText();
    try{
        int integerValue=Integer.parseInt(string);
        System.out.println(integerValue);
    }
    catch(Exception e){
       JOptionPane.showMessageDialog(
         "Error converting string to integer\n" + e.toString,
         "Error",
         JOptionPane.ERROR_MESSAGE);
    }
 }

මෙන්න අපි යනවා

String str="1234";
int number = Integer.parseInt(str);
print number;//1234

එය ක්‍රම හතකින් කළ හැකිය:

import com.google.common.primitives.Ints;
import org.apache.commons.lang.math.NumberUtils;

String number = "999";

1) භාවිතා කිරීම Ints.tryParse:

int result = Ints.tryParse(number);

2) භාවිතා කිරීම NumberUtils.createInteger:

Integer result = NumberUtils.createInteger(number);

3) භාවිතා කිරීම NumberUtils.toInt:

int result = NumberUtils.toInt(number);

4) භාවිතා කිරීම Integer.valueOf:

Integer result = Integer.valueOf(number);

5) භාවිතා කිරීම Integer.parseInt:

int result = Integer.parseInt(number);

6) භාවිතා කිරීම Integer.decode:

int result = Integer.decode(number);

7) භාවිතා කිරීම Integer.parseUnsignedInt:

int result = Integer.parseUnsignedInt(number);

එක් ක්‍රමයක් වන්නේ parseInt (String) ය. එය ප්‍රාථමික int එකක් ලබා දෙයි:

String number = "10";
int result = Integer.parseInt(number);
System.out.println(result);

දෙවන ක්‍රමය valueOf (String) වන අතර එය නව පූර්ණ () වස්තුවක් ලබා දෙයි:

String number = "10";
Integer result = Integer.valueOf(number);
System.out.println(result);

ඔබට පහත සඳහන් ඕනෑම දෙයක් භාවිතා කළ හැකිය:

1. Integer.parseInt(s)
2. Integer.parseInt(s, radix)
3. Integer.parseInt(s, beginIndex, endIndex, radix)
4. Integer.parseUnsignedInt(s)
5. Integer.parseUnsignedInt(s, radix)
6. Integer.parseUnsignedInt(s, beginIndex, endIndex, radix)
7. Integer.valueOf(s)
8. Integer.valueOf(s, radix)
9. Integer.decode(s)
10. NumberUtils.toInt(s)
11. NumberUtils.toInt(s, defaultValue)

මෙය පුස්තකාලයක් භාවිතා නොකර සියලු කොන්දේසි ධනාත්මක හා negative ණාත්මක වන සම්පූර්ණ වැඩසටහනකි

import java.util.Scanner;


public class StringToInt {

    public static void main(String args[]) {
        String inputString;
        Scanner s = new Scanner(System.in);
        inputString = s.nextLine();

        if (!inputString.matches("([+-]?([0-9]*[.])?[0-9]+)")) {
            System.out.println("Not a Number");
        }
        else {
            Double result2 = getNumber(inputString);
            System.out.println("result = " + result2);
        }
    }


    public static Double getNumber(String number) {
        Double result = 0.0;
        Double beforeDecimal = 0.0;
        Double afterDecimal = 0.0;
        Double afterDecimalCount = 0.0;
        int signBit = 1;
        boolean flag = false;

        int count = number.length();
        if (number.charAt(0) == '-') {
            signBit = -1;
            flag = true;
        }
        else if (number.charAt(0) == '+') {
            flag = true;
        }
        for (int i = 0; i < count; i++) {
            if (flag && i == 0) {
                continue;
            }
            if (afterDecimalCount == 0.0) {
                if (number.charAt(i) - '.' == 0) {
                    afterDecimalCount++;
                }
                else {
                    beforeDecimal = beforeDecimal * 10 + (number.charAt(i) - '0');
                }
            }
            else {
                afterDecimal = afterDecimal * 10 + number.charAt(i) - ('0');
                afterDecimalCount = afterDecimalCount * 10;
            }
        }
        if (afterDecimalCount != 0.0) {
            afterDecimal = afterDecimal / afterDecimalCount;
            result = beforeDecimal + afterDecimal;
        }
        else {
            result = beforeDecimal;
        }
        return result * signBit;
    }
}