Convertir une chaîne en double en Java
Il est couramment utilisé lors de la manipulation d'opérations mathématiques sur une chaîne de nombres doubles. Les données saisies sont reçues sous forme de chaîne chaque fois que nous récupérons des données à partir d'un champ de texte ou d'une zone de texte. Nous devons convertir la chaîne en double si les données d'entrée sont doubles.
Le but est de transformer une String en Double en Java.
Ce tutoriel expliquera comment convertir une chaîne en double en Java. Vous pouvez convertir une chaîne en double de trois manières différentes.
- Utilisation de la méthode Double.parseDouble(String)
- Convertir une chaîne en double en Java à l'aide de Double.valueOf(String)
- Java Convert String to double using the constructor of Double class – Le constructeur Double(String) est obsolète depuis Java version 9
- Analyse du format décimal()
Convertir une chaîne en double en Java eexemples
Input: String = "1532.75" Output: 1532.75 Input: String = "41560.49" Output: 41560.49
Pour atteindre l'objectif, nous pouvons utiliser une variété d'approches :
Utiliser Double.parseDouble()
La méthode Double.parseDouble() est utilisée pour cela. De plus, la fonction statique de la classe Double est parseDouble(). Cette fonction renvoie le double équivalent de l'argument de chaîne fourni. Si la chaîne str fournie est nulle, cette méthode lèvera NullPointerException, et si le format de chaîne n'est pas valide, elle lèvera NumberFormatException. Par exemple, si la chaîne donnée est "6042.80ab", cette méthode lèvera une NumberFormatException.
Voici la signature de la méthode parseDouble() :
La syntaxe est la suivante :
double str1 = Double.parseDouble(str);
ou
public static double parseDouble(str) throws NumberFormatException
Cette procédure lève une exception. Lorsque la chaîne n'inclut pas de double analysable, une exception NumberFormatException est levée.
Regardons un code Java simple pour convertir une chaîne en double.
double d=Double.parseDouble("9805.65"); Exemple 1 :utilisation de Double.parseDouble()
public class StringToDoubleExample{
public static void main(String args[]){
String s="23.6";
double d=Double.parseDouble("23.6");
System.out.println(d);
}
}
Exemple 2 :utilisation de Double.parseDouble()
// program for converting a String to Double in Java
// using parseDouble()
public class Codeunderscored {
// main method
public static void main(String args[])
{
// create a String
String strVar = "2030.50194";
// convert into Double
double strOneVar = Double.parseDouble(strVar);
// print String as Double
System.out.println(strOneVar);
}
} Exemple 3 :Programme de conversion d'une chaîne en double à l'aide de parseDouble(String)
public class JavaParseDouble{
public static void main(String args[]){
String strVal = "5021.1850";
/* Convert String to double using
* parseDouble(String) method of Double
* wrapper class
*/
double dNumber = Double.parseDouble(strVal);
//displaying the value of variable dNumber
System.out.println(dNumber);
}
} Considérez le scénario suivant :nous voulons calculer le prix après avoir reçu une remise sur le prix initial de l'article. Les paramètres d'entrée sont tels que le prix et la remise d'origine de l'article proviennent de votre système de facturation sous forme de texte. Nous voulons effectuer une opération arithmétique sur ces nombres pour déterminer le nouveau prix après avoir soustrait la remise du prix d'origine.
Dans l'exemple de code suivant, nous allons apprendre à utiliser la méthode Double.parseDouble() pour convertir une valeur String en double :
package com.codeunderscored;
/**
* This class is a demonstration of sample code for converting the String to a double in the java program
* using Double.parseDouble() method
*
* @codeunderscored
*
*/
public class StringToDoubleCalculateDiscount {
public static void main(String[] args) {
// Assign "2250.00" to String variable originalPriceStr
String originalPriceStrVar = "150.00D";
// Assigning "50" to String variable originalPriceStrVar
String discountStrVar = "+50.0005d";
System.out.println("originalPriceStrVar :"+originalPriceStrVar);
System.out.println("discountStrVar :"+discountStrVar);
// Pass originalPriceStrVar i.e. String "50.00D" as a parameter to parseDouble()
// to convert string 'originalPriceStrVar' value to double
// and assign it to double variable originalPriceVar
double originalPriceVal = Double.parseDouble(originalPriceStr);
// Pass discountStrVar i.e. String "50.005d" as a parameter to parseDouble()
// to convert string 'discountStrVar' value to double
// and assign it to double variable discount
double discountVal = Double.parseDouble(discountStrVar);
System.out.println("Welcome, the item original price is : $"+originalPriceVal+"");
System.out.println("We are offering the following discount :"+discountVal+"%");
//Calculate new price after discount
double newPriceVal = originalPriceVal - ((originalPriceVal*discountVal)/100);
//Printing of the new price after getting the discount on the console
System.out.println("Enjoy new attractive price after discount: $"+newPriceVal+"");
}
}
Utilisation de Double.valueOf()
La méthode valueOf() de la classe Double wrapper en Java fonctionne de la même manière que la méthode parseDouble() dans l'exemple Java précédent.
La syntaxe est la suivante :
double str1 = Double.valueOf(str);
String strVar = "5021.1850"; double dNumber = Double.valueOf(strVar);
Après conversion, la valeur de dNumber serait 5021.1850.
Regardons un exemple de conversion complet utilisant la fonction Double.valueOf(String).
Exemple 1 :Programme de conversion d'une chaîne en double à l'aide de valueOf(String)
// Program for Converting a String to Double in Java
// using parseDouble()
public class Codeunderscored {
// main method
public static void main(String args[])
{
// create a String
String strVar = "5021.1850";
// convert into Double
double strOneVar = Double.valueOf(strVar);
// print String as Double
System.out.println(strOneVar);
}
} Exemple 2 :Programme de conversion d'une chaîne en double à l'aide de valueOf(String)
public class JavaValueOf{
public static void main(String args[]){
String strVar = "5021.1850";
/* Convert String to double using
* valueOf(String) method of Double
* wrapper class
*/
double dNumber = Double.valueOf(strVar);
//displaying the value of variable dNumber
System.out.println(dNumber);
}
} Exemple 3 :Programme de conversion d'une chaîne en double à l'aide de valueOf(String)
package com.codeunderscored;
/**
* This class has sample code responsible for converting the String to double in Java
* using Double.valueOf() method
*
* @author
*
*/
public class StringToDoubleValueOf
public static void main(String[] args) {
// Assign "1000.0000d" to String variable depositAmountStr
String depositAmountStrVal = "1000.0000d";
// Assign "5.00D" to String variable interestRate
String interestRateStrVal = "+5.00D";
// Assign "2" to String variable yearsStrVal
String yearsStrVal = "2";
System.out.println("The deposit amount string value :"+depositAmountStrVal);
System.out.println("The interest rate string :"+interestRateStrVal);
System.out.println("Number of years string value :"+yearsStrVal);
// Pass depositAmountStrVal i.e.String "1000.0000d" as a parameter to valueOf()
// to convert string 'depositAmountStrVal' value to double
// and assign it to double variable depositAmount
Double depositAmountVal = Double.valueOf(depositAmountStrVal);
// Pass interestRateStrVal i.e.String "5.00D" as a parameter to valueOf()
// to convert string 'interestRateStrVal' value to double
// and assign it to double variable discount
Double interestRateVal = Double.valueOf(interestRateStrVal);
// Pass yearsStrVal i.e.String "2" as a parameter to valueOf()
// to convert string 'yearsStrVal' value to double
// and assign it to double variable discount
Double yearsVal = Double.valueOf(yearsStrVal);
System.out.println("Welcome to Code Sacco. Thanks for depositing : $"+
depositAmountVal+" with our bank");
System.out.println("Our bank is offering attractive interest rate for 1 year :"+interestRateVal+"%");
// interest calculation after two years on the deposit amount
Double interestEarnedVal = ((depositAmountVal*interestRateVal*yearsVal)/100);
System.out.println("You will be receiving total interest after "+yearsVal+" is $"+interestEarnedVal+"");
}
} Utilisation du constructeur de la classe Double
Depuis la version 9 de Java, le constructeur Double(String) est obsolète. Le constructeur de la classe Double analyse l'argument String que nous envoyons et produit une valeur double équivalente.
String strVar = "5021.1850"; double numVar = new Double(strVar);
La syntaxe est la suivante.
Double str1 = new Double(str);
ou
public Double(String s) throws NumberFormatException
Nous pouvons utiliser ce constructeur pour construire un nouvel objet Double en donnant la chaîne que nous voulons convertir.
Exemple 1 :Programme Java pour convertir une chaîne en double à l'aide du constructeur de la classe Double
public class DoubleClassExample{
public static void main(String args[]){
String strVal ="5021.1850";
double numVar = new Double(strVal);
System.out.println(numVar);
}
}
Exemple 2 :Programme Java pour convertir une chaîne en double à l'aide du constructeur de la classe Double
// Program for Converting a String to Double in Java
// using parseDouble()
public class Codeunderscored {
// main method
public static void main(String args[])
{
// create a String
String strVal = "2030.50194";
// convert into Double
Double strOneVar = new Double(strVal);
// print String as Double
System.out.println(strOneVar);
}
} Analyse du format décimal()
Nous pouvons utiliser un DecimalFormat lorsqu'une chaîne exprimant un double a un format plus compliqué. Vous pouvez l'utiliser pour convertir une chaîne formatée en double. Par exemple, si String est "8,11,666.43d", nous pouvons utiliser DecimalFormat pour convertir cette chaîne en :
String strVar = "8,11,666.43d";
try {
double dNumber = DecimalFormat.getNumberInstance().parse(strVar).doubleValue();
System.out.println(dNumber); //811666.48
} catch (ParseException e) {
e.printStackTrace();
} Comme la méthode parse() produit une instance Number, nous devons utiliser doubleValue() pour obtenir le type primitif double. Si la chaîne n'est pas formatée correctement, cette fonction lèvera une ParseException. Nous pouvons convertir une valeur monétaire décimale sans éliminer les symboles non numériques de la manière suivante :
DecimalFormat decimalFormat = new DecimalFormat("\u00A4#,##0.00");
decimalFormat.setParseBigDecimal(true);
BigDecimal decimal = (BigDecimal) decimalFormat.parse("-$9,450.85");
assertEquals(-9450.85, decimal.doubleValue(), 0.000001); La méthode DecimalFormat.parse, comme Double.valueOf, produit un nombre, que nous pouvons convertir en un double de base en utilisant la méthode doubleValue. La méthode setParseBigDecimal est également utilisée pour forcer DecimalFormat.parse à renvoyer un BigDecimal.
Le DecimalFormat est généralement plus compliqué que nécessaire. Par conséquent, nous devrions utiliser le Double à la place. Utilisez plutôt parseDouble ou Double.valueOf. Cette méthode analyse le texte qui lui est transmis. Il renvoie le nombre en utilisant une chaîne à partir de la position de début.
Cette procédure lève une exception. Si le début de String n'est pas dans un format analysable, une ParseException est levée. À l'aide de la méthode parse(), cet exemple de code analyse une chaîne de texte structuré contenant une valeur double :
package com.codeunderscored;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.text.ParseException;
/**
* This class has sample code for the conversion of String to double in Java
* using DecimalFormat parse () method
*
* @author
*
*/
public class StringToDoubleDecimalFormat {
// this is the main method
public static void main(String [] args) throws ParseException {
// Assign "4,380,90.50" to String variable pointsString
String pointsStringVal = "4,380,90.50";
System.out.println("The points string value is:"+pointsStringVal);
// Pass pointsString i.e. String "+4,380,90.50" as a parameter to
// DecimalFormat.getNumberInstance().parse() method
// to convert string pointsString value to double
// and assign it to double variable points
NumberFormat numFormat = DecimalFormat.getNumberInstance();
Number pointsNumber = numFormat.parse(pointsString);
double pointsCount = pointsNumber.doubleValue();
System.out.println("Well Done ! You have earned :"+pointsCount+" points!");
}
} Conversions non valides
Pour les chaînes numériques incorrectes, Java fournit une interface standardisée. Double.parseDouble, Double.valueOf et DecimalFormat en sont quelques exemples. Lorsque nous fournissons null à analyser, nous obtenons une NullPointerException. De même, Double.parseDouble et Double.parseDouble.parseDouble.parseDouble.
Lorsque nous fournissons une chaîne non valide qui ne peut pas être traitée en double, valueOf lève une NumberFormatException (telle que &). Enfin, lorsque nous fournissons une chaîne non valide à DecimalFormat.parse, cela lève une ParseException.
Conclusion
Il existe plusieurs méthodes pour convertir une chaîne Java en double. Aujourd'hui, nous avons examiné certaines des méthodes les plus courantes pour convertir une chaîne Java en un type de données primitif double ou un objet Double. Parce que Java permet l'autoboxing, vous pouvez utiliser indifféremment le type double primitif et le double objet.
Dans l'ensemble, Java nous donne différentes façons de convertir des chaînes en nombres doubles. En général, nous vous conseillons d'utiliser Double. Sauf si un Double encadré est requis, utilisez parseDouble.
