convert - string to double java
كيف أقوم بتحويل سلسلة إلى int في Java؟ (20)
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
فيمكنك استخدام:
الإخراج من العلبة:
int val = Integer.decode("12");
intValue()
:Integer.decode("12").intValue();
كيف يمكنني تحويل String
إلى int
في Java؟
يحتوي My String على أرقام فقط ، وأريد إرجاع الرقم الذي يمثله.
على سبيل المثال ، في ضوء السلسلة "1234"
، يجب أن تكون النتيجة الرقم 1234
.
أسلوب واحد هو parseInt (String) بإرجاع int int
String number = "10";
int result = Integer.parseInt(number);
System.out.println(result);
الأسلوب الثاني هو القيمة (سلسلة) إرجاع كائن عدد صحيح جديد ().
String number = "10";
Integer result = Integer.valueOf(number);
System.out.println(result);
أنا مندهش بعض الشيء أن لا أحد ذكرنا منشئ Integer الذي يأخذ String كمعلمة.
إذن ، ها هو:
String myString = "1234";
int i1 = new Integer(myString);
وبطبيعة الحال ، سيقوم المُنشئ بإرجاع Type Integer
، وتقوم عملية unboxing بتحويل القيمة إلى int
.
من المهم أن أذكر
يستدعي هذا المنشئ أسلوب parseInt
.
public Integer(String var1) throws NumberFormatException {
this.value = parseInt(var1, 10);
}
استخدم 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
افعلها يدويًا:
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 دائمًا. ومن ثم توفير لكم كتلة محاولة الصيد.
بالنسبة إلى السلسلة العادية ، يمكنك استخدام:
int number = Integer.parseInt("1234");
من أجل String builder و String buffer يمكنك استخدام:
Integer.parseInt(myBuilderOrBuffer.toString());
ببساطة يمكنك تجربة هذا:
- استخدم
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 هو أكثر تعقيدًا من مجرد تحويل رقم. لديك التفكير في المشكلات التالية:
- هل تحتوي السلسلة فقط على أرقام من 0 إلى 9 ؟
- ما الأمر مع - / + قبل أو بعد السلسلة؟ هل هذا ممكن (في اشارة الى الارقام المحاسبية)؟
- ما الأمر مع MAX _- / MIN_INFINITY؟ ماذا سيحدث إذا كانت السلسلة 99999999999999999999؟ هل يمكن للجهاز التعامل مع هذه السلسلة كمساهمة؟
حسنًا ، هناك نقطة مهمة يجب وضعها في الاعتبار وهي أن محلل عدد صحيح يلقي 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.
}
من المهم التعامل مع هذا الاستثناء عند محاولة الحصول على قيم عددية من وسيطات مقسمة أو تحليل ديناميكي لشيء ما.
على سبيل المثال ، إليك طريقتان:
Integer x = Integer.valueOf(str);
// or
int y = Integer.parseInt(str);
يوجد اختلاف بسيط بين هذه الطرق:
- إرجاع
valueOf
مثيل جديد أو تخزين مؤقت منjava.lang.Integer
-
parseInt
يعودint
.
وينطبق الشيء نفسه على جميع الحالات: Short.valueOf
/ parseShort
، Long.valueOf
/ parseLong
، إلخ.
في مسابقات البرمجة ، حيث تضمن لك أن الرقم سيكون دائمًا عددًا صحيحًا صحيحًا ، يمكنك كتابة أسلوبك الخاص لتحليل الإدخال. سيؤدي ذلك إلى تخطي جميع التعليمات البرمجية ذات الصلة بالتحقق (بما أنك لست بحاجة إلى أي من ذلك) وستكون أكثر كفاءة.
للحصول على عدد صحيح موجب صحيح:
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; }
لكل من الأعداد الصحيحة الموجبة والسالبة:
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; }
إذا كنت تتوقع مسافة بيضاء قبل أو بعد هذه الأرقام ، فتأكد من إجراء
str = str.trim()
قبل إجراء مزيد من المعالجة.
كما ذكر أباتشي كومنز 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;
لدي حل ، لكني لا أعرف مدى فعالية ذلك. لكنها تعمل بشكل جيد ، وأعتقد أنه يمكنك تحسينها. من ناحية أخرى ، قمت JUnit مع JUnit وهي خطوة بشكل صحيح. أرفقت الوظيفة والاختبار:
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));
}
}
}
ها نحن ذا
String str="1234";
int number = Integer.parseInt(str);
print number;//1234
يمكنك أيضًا البدء بإزالة جميع الأحرف غير العددية ومن ثم تحليل int:
string mystr = mystr.replaceAll( "[^\\d]", "" );
int number= Integer.parseInt(mystr);
لكن كن حذرًا من أن هذا يعمل فقط مع الأرقام غير السالبة.
يمكنك استخدام هذا الرمز أيضًا ، مع بعض الاحتياطات.
الخيار الأول: التعامل مع الاستثناء بشكل صريح ، على سبيل المثال ، إظهار مربع حوار رسالة ثم إيقاف تنفيذ سير العمل الحالي. فمثلا:
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
catch (NumberFormatException ex) { integerValue = 0; }
إن استخدام ثابت سلسلة للمقارنة أو أي نوع من الحوسبة هو دائمًا فكرة جيدة ، لأن ثابتًا لا يعرض قيمة خالية مطلقًا.
يمكننا استخدام الأسلوب parseInt(String str)
لفئة المجمّع Integer
لتحويل قيمة String إلى قيمة عدد صحيح.
فمثلا:
String strValue = "12345";
Integer intValue = Integer.parseInt(strVal);
يوفر فئة Integer
أيضاً القيمة valueOf(String str)
:
String strValue = "12345";
Integer intValue = Integer.valueOf(strValue);
يمكننا أيضًا استخدام toInt(String strValue)
من فئة Utility المساعدة لـ NumberUtils للتحويل:
String strValue = "12345";
Integer intValue = NumberUtils.toInt(strValue);
هذا هو البرنامج الكامل مع جميع الشروط الإيجابية والسلبية دون استخدام المكتبة
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;
}
}
String myString = "1234";
int foo = Integer.parseInt(myString);
انظر وثائق جافا لمزيد من المعلومات.