• Metodes, kā konvertēt Java virkni uz dubultā
  • #1) Double.parseDouble() metode
  • #2) Double.valueOf() metode
  • #3) DecimalFormat Parse () metode
  • #4) Jauna Double() konstruktors
  • Biežāk uzdotie jautājumi
• Secinājums

Šajā pamācībā mēs uzzināsim, kā konvertēt Java virknes uz divkāršu datu tipu:

Mēs iemācīsimies izmantot šādas metodes, lai pārvērstu virkni divkāršā vērtībā Java:

• Double.parseDouble(String)
• Double.valueOf(virkne)
• DecimalFormat parse()
• jauns Double(Virkne s)

Metodes, kā konvertēt Java virkni uz dubultā

Ir daži scenāriji, kad mūsu Java programmā mums ir jāveic kādas aritmētiskas darbības ar skaitlisku vērtību, piemēram, rēķina aprēķināšana, noguldījuma summas procentu aprēķināšana u. c. Taču šīs programmas ievades dati ir pieejami teksta formātā, t. i. Java virknes datu tips .

Piemēram, pārtikas produktu rēķinu aprēķināšanai - produkta cena un nopirkto vienību skaits tiek ievadīti no tīmekļa lapas teksta lauka vai teksta apgabala teksta formātā, t. i., Java String datu tipa. Šādos scenārijos mums vispirms ir jākonvertē šī string, lai iegūtu skaitļus, kas ir Java primitīvais datu tips double .

Aplūkosim detalizēti dažādas metodes vienu pēc otras.

#1) Double.parseDouble() metode

Double klase nodrošina metodi parseDouble(). Double klasi sauc par Wrapper klasi, jo tā ietver primitīvā tipa double vērtību objektā.

Aplūkosim metodes parakstu turpmāk:

public static double parseDouble(String str) throws NumberFormatException

Šī ir klases Double statiskā metode, kas atgriež divkāršo datu tipu, ko pārstāv norādītā virkne String.

Šajā gadījumā 'str' parametrs ir virkne, kas satur analizējamo divkāršās vērtības atveidojumu, un atgriež argumenta atveidoto divkāršo vērtību.

Šī metode izmet izņēmumu NumberFormatException ja virkne nesatur analizējamu divkāršu.

Piemēram, aplūkosim scenāriju, kad vēlamies aprēķināt cenu pēc atlaides saņemšanas no preču sākotnējās cenas.

Šim nolūkam ievades vērtības, piemēram, preces sākotnējā cena un atlaide, tiek saņemtas no jūsu norēķinu sistēmas kā teksts, un mēs vēlamies veikt aritmētisku darbību ar šīm vērtībām, lai aprēķinātu jauno cenu pēc atlaides atskaitīšanas no sākotnējās cenas.

Aplūkosim, kā izmantot Double.parseDouble() metodi, lai atveidotu virknes vērtību dubultā, izmantojot šādu koda paraugu:

 package com.softwaretestinghelp; /** * Šī klase demonstrē parauga kodu, lai pārvērstu virknes uz dubultā java programmā * izmantojot Double.parseDouble() metodi * * * @autor * * */ public class StringToDoubleDemo1 { public static void main(String[] args) { // Piešķirt "500.00" string mainīgajam originalPriceStr String originalPriceStr = "50.00D"; // Piešķirt "30" string mainīgajam originalPriceStr StringdiscountStr = "+30.0005d"; System.out.println("originalPriceStr : "+originalPriceStr); System.out.println("discountStr : "+discountStr); // Nodod originalPriceStr, t.i., virkni "50.005d" kā parametru parseDouble() // lai pārvērstu virknes 'originalPriceStr' vērtību dubultā // un piešķirtu to dubultajam mainīgajam originalPrice double originalPrice = Double.parseDouble(originalPriceStr); // Nodod discountStrt.i., virkne "30.005d" kā parametrs parseDouble() // lai pārvērstu virknes 'discountStr' vērtību divkāršā // un piešķirtu to divkāršajam mainīgajam discount double discount = Double.parseDouble(discountStr); System.out.println("Laipni lūdzam, mūsu sākotnējā cena ir : $"+originalPrice+""); System.out.println("Mēs piedāvājam atlaidi : "+discount+"%"); //Calculate new price after discount dual newPrice =Sākotnējā cena - ((sākotnējā cena*atlaide)/100); //Na konsoles ekrānā izdrukāt jauno cenu pēc atlaides saņemšanas System.out.println("Izbaudiet jauno pievilcīgo cenu pēc atlaides: $"+Jaunā cena+""); } } } 

Šeit ir programmas izeja:

originalPriceStr :50.00D

discountStr :+30.0005d

Laipni lūdzam, mūsu sākotnējā cena ir : $50.0

Mēs piedāvājam atlaidi :30.0005%

Izbaudiet jaunu pievilcīgu cenu pēc atlaides : $34.99975

Šeit virkne ir "50.00D", kurā D norāda virkni kā divkāršu vērtību.

 String originalPriceStr = "50.00D"; 

Šis originalPriceStr, t. i., "50.00D", tiek nodots kā parametrs metodei parseDouble(), un šī vērtība tiek piešķirta dubultajam mainīgajam originalPrice.

 double originalPrice = Double.  parseDouble  (originalPriceStr); 

metode parseDouble() pārvērš virknes vērtību divkāršā un noņem "+" vai "-" un 'D','d'.

Tādējādi, kad mēs izdrukājam originalPrice uz konsoles:

 Sistēma.  ārā  .println("Laipni lūdzam, mūsu sākotnējā cena ir : $"+oriģinālcena+"")."); 

Konsole parādīs šādu izvades signālu:

Laipni lūdzam, mūsu sākotnējā cena ir : $50.0

Līdzīgi, lai virkne discountStr = "+30.0005d"; Virkni "+30.0005d" var pārvērst divkāršā, izmantojot parseDouble() metodi kā:

 double discount = Double.  parseDouble  (discountStr); 

Tādējādi, kad mēs izdrukājam atlaidi konsoles ekrānā.

 System.out.println("Mēs piedāvājam atlaidi : "+discount+"%"); 

Konsole parādīs šādu izvades signālu:

 Mēs piedāvājam atlaidi :30.0005% 

Turklāt ar šīm skaitliskām vērtībām programmā tiek veiktas aritmētiskās darbības.

#2) Double.valueOf() metode

metodi valueOf() nodrošina apvalka klase Double.

Aplūkosim metodes parakstu turpmāk:

public static Double valueOf(String str) throws NumberFormatException

Šī statiskā metode atgriež datu tipa Double objektu, kam ir dubultā vērtība, ko attēlo norādītā virkne string str.

Šajā gadījumā parametrs 'str' ir virkne, kas satur analizējamo divkāršo attēlojumu, un tiek atgriezta divkāršā vērtība, ko arguments pārstāv decimālskaitļos.

Šī metode izmet izņēmumu NumberFormatException ja virknē nav analizējamas skaitliskas vērtības.

Mēģināsim saprast, kā izmantot šo Double.valueOf() metodi, izmantojot šādu paraugprogrammu:

 package com.softwaretestinghelp; /** * Šī klase demonstrē parauga kodu, lai pārvērstu virknes uz dubultā java programmā * izmantojot Double.valueOf() metodi * * * @autor * * */ public class StringToDoubleDemo2 { public static void main(String[] args) { // Piešķirt "1000.0000d" virknes mainīgajam depositAmountStr String depositAmountStr = "1000.0000d"; // Piešķirt "5.00D" virknes mainīgajam interestRate StringinterestRateStr = "+5.00D"; // Piešķirt "2" virknes mainīgajam yearsStr String yearsStr = "2"; System.out.println("depositAmountStr : "+depositAmountStr); System.out.println("interestRateStr : "+interestRateStr); System.out.println("yearsStr : "+yearsStr); // Nodot depositAmountStr t.i., virkni "1000.0000d" kā parametru valueOf() // lai pārvērstu virknes 'depositAmountStr' vērtību divkāršā // un piešķirtuto uz divkāršo mainīgo depositAmount Double depositAmount = Double.valueOf(depositAmountStr); // InterestRateStr, t.i., virkne "5.00D", kā parametru nodot valueOf() // lai pārvērstu virknes 'interestRateStr' vērtību divkāršā // un piešķirtu to divkāršajam mainīgajam discount Double interestRate = Double.valueOf(interestRateStr); // YearsStr, t.i., virkne "2", kā parametru nodot valueOf() // lai pārvērstu virkni'yearsStr' vērtību dubultā // un piešķir to dubultam mainīgajam discount Double years = Double.valueOf(yearsStr); System.out.println("Laipni lūdzam ABC bankā. Paldies, ka mūsu bankā noguldījāt : $"+ noguldījuma summa+"); System.out.println("Mūsu banka piedāvā pievilcīgu procentu likmi uz 1 gadu : "+procentu likme+"%"); /Saprēķināt procentus pēc 2 gadiem no noguldījuma summas Double interestEarned =((noguldījuma summa*procentu likme*gadiem)/100); System.out.println("Jūs saņemsiet kopējos procentus pēc "+gadiem+" ir $"+iegūtie procenti+""); } } } 

Šeit ir programmas izeja:

depositAmountStr :1000.0000d

interestRateStr :+5.00D

yearsStr :2

Laipni lūdzam ABC Bankā. Paldies par noguldījumu: $1000,0 mūsu bankā.

Mūsu banka piedāvā pievilcīgu procentu likmi uz 1 gadu :5,0%

Pēc 2,0 likmes saņemat procentus, kuru kopsumma ir $100,0.

Šeit mēs piešķiram vērtības virknes mainīgajiem:

 String depositAmountStr = "1000.0000d"; String interestRateStr = "+5.00D"; String yearsStr = "2"; 

Izmantojiet metodi valueOf(), lai konvertētu šīs vērtības uz Double, kā parādīts tālāk.

 Double depositAmount = Double.  valueOf  (depositAmountStr); 

Turpmākajos aritmētiskajos aprēķinos izmantojam tās pašas vērtības kā:

 Double interestEarned = ((depositAmount*interestRate*years)/100); 

#3) DecimalFormat Parse () metode

Šim nolūkam vispirms iegūstam klases NumberFormat gadījumu un izmantojam klases NumberFormat metodi parse().

Aplūkosim metodes parakstu turpmāk:

public Number parse(String str) throws ParseException

Šī metode analizē norādīto tekstu. Tā izmanto virkni no sākuma pozīcijas un atdod skaitli.

Šī metode izmet izņēmumu ParseException ja virknes sākums neatrodas analizējamā rakstā.

Aplūkosim tālāk redzamo programmas paraugu. Šis parauga kods analizē formatētu teksta virkni, kas satur divkāršu vērtību, izmantojot metodi parse():

 package com.softwaretestinghelp; import java.text.DecimalFormat; import java.text.NumberFormat; import java.text.ParseException; /** * Šī klase demonstrē parauga kodu, lai pārvērstu virknes uz dubultā java programmā * izmantojot DecimalFormat parse () metodi * * * @autor * */ public class StringToDoubleDemo3 { public static void main(String [] args) throws ParseException { // Piešķirt "5,000,00.00" uz Stringmainīgais pointsString String pointsString = "5,000,00.00.00"; System.out.println("pointsString : "+pointsString); // Nodod pointsString, t.i., virkni "+5,000,00.00.00" kā parametru // DecimalFormat.getNumberInstance(). parse() metodei // lai pārvērstu virknes pointsString vērtību dubultā // un piešķirtu to dubultam mainīgajam points NumberFormat num = DecimalFormat.getNumberInstance(); Number pointsNum =num.parse(pointsString); double points = pointsNum.doubleValue(); System.out.println("Apsveicam! Jūs esat nopelnījis : "+punkti+" punkti!"); } } } 

Šeit ir programmas izeja:

punktiString :5,000,00.00

Apsveicam ! Jūs esat nopelnījis :500000.0 punktu!

Šeit formatētais teksts tiek piešķirts virknes mainīgajam šādi:

 Virkne pointsString = "5,000,00.00.00"; 

Šis formatētais teksts "5,000,00.00.00" tiek nodots kā arguments num.parse() metodei.

Pirms tam klases NumberFormat instance tiek izveidota, izmantojot DecimalFormat. getNumberInstance () metode.

 DecimalFormat.getNumberInstance() metode. NumberFormat num = DecimalFormat.getNumberInstance(); Number pointsNum = num.parse(pointsString); 

Tādējādi dubultā vērtība tiek iegūta, izsaucot metodi doubleValue (), kā parādīts tālāk.

 double points = pointsNum.doubleValue(); 

#4) Jauna Double() konstruktors

Vēl viens veids, kā pārvērst Java virkni dubultā, ir izmantot Double klases konstruktoru(String str).

public Double(String str) throws NumberFormatException

Šis konstruktors konstruē un atgriež Double objektu, kura vērtība ir double tipa vērtība, ko pārstāv norādītā String.

str ir virkne, ko paredzēts konvertēt uz Double

Šī metode izmet izņēmumu ar nosaukumu NumberFormatException ja virknei nav analizējamas skaitliskās vērtības.

Mēģināsim saprast, kā izmantot šo Double (String str) konstruktoru, izmantojot šādu paraugprogrammu, kas aprēķina apļa laukumu, vispirms konvertējot rādiuss no String uz double.

 package com.softwaretestinghelp; /** * Šī klase demonstrē parauga kodu, lai pārvērstu virkni dubultā java programmā * izmantojot jauno Double(String str) konstruktoru * * * @autors * * */ public class StringToDoubleDemo4 { public static void main(String[] args) { // Piešķirt "+15.0005d" virknes mainīgajam radiusStr String radiusStr = "+15.0005d"; System.out.println("radiusStr : "+radiusStr); // Pass radiusStrt.i., virkne "+15.0005d" kā parametrs new Double() // lai pārvērstu virknes radiusStr vērtību dubultā // un piešķirtu to dubultam mainīgajam radius double radius =  jauns  Dubultā  (radiusStr)  .doubleValue(); System.out.println("Apļa rādiuss : "+radius+" cm"); //aprēķina apļa laukumu double area = (3,14*(rādiuss*radius)); System.out.println("Apļa laukums : "+area+" cm"); } } } 

Šeit ir programmas izeja:

radiusStr :+15.0005d

Apļa rādiuss :15,0005 cm

Apļa laukums :706,546,5471007850001 cm

Iepriekš minētajā programmā apļa rādiusa vērtība ir piešķirta mainīgajam String:

 Virkne radiusStr = "+15.0005d"; 

Lai aprēķinātu apļa laukumu, rādiuss tiek pārvērsts divkāršā vērtībā, izmantojot Double() konstruktoru, kas atgriež Double datu tipa vērtību. Pēc tam tiek izsaukta metode doubleValue(), lai iegūtu primitīvā datu tipa double vērtību, kā parādīts turpmāk.

 dubultais rādiuss =  jauns  Double (radiusStr).doubleValue(); 

Piezīme: Double(String str) konstruktors ir novecojis kopš Java 9.0. Tas ir iemesls, kāpēc Double ir pārsvītrots.

Tāpēc šis veids tagad ir mazāk vēlams. Tādējādi esam aplūkojuši visas metodes, kā konvertēt Java virkni uz dubultā Java primitīvo datu tipu.

Apskatīsim dažus no biežāk uzdotajiem jautājumiem par virknes uz divkāršu konversijas metodi.

Biežāk uzdotie jautājumi

Q #1) Vai mēs varam pārvērst virkni dubultā programmā Java?

Atbilde: Jā , programmā Java virknes konvertēšanu no virknes uz divkāršu var veikt, izmantojot šādas Java klases metodes:

• Double.parseDouble(String)
• Double.valueOf(virkne)
• DecimalFormat parse()
• jauns Double(Virkne s)

2. jautājums) Kā virkni pārvērst dubultā?

Atbilde: Java piedāvā dažādas metodes, kā virkni pārvērst divkāršā.

Tālāk ir dotas Java klases metodes:

• Double.parseDouble(String)
• Double.valueOf(virkne)
• DecimalFormat parse()
• jauns Double(Virkne s)

Q #3) Vai dubultnieks ir Java?

Atbilde: Jā . Java piedāvā dažādus primitīvos datu tipus skaitlisko vērtību glabāšanai, piemēram, short, int, double u. c. Double ir Java primitīvais datu tips, kas paredzēts skaitļa ar peldošo komatspunktu attēlošanai. Šis datu tips glabāšanai aizņem 8 baitus, un tam ir 64 bitu precizitāte ar peldošo komatu. Šis datu tips ir izplatīta izvēle decimālskaitļu vērtību attēlošanai.

Q #4) Kas ir Java skeneris?

Atbilde: Java nodrošina java.util.Scanner klasi, lai iegūtu ievaddatus no lietotāja. Tai ir dažādas metodes, lai iegūtu ievaddatus dažādos datu tipos. Piemēram, NextLine() tiek izmantota, lai nolasītu virknes datu tipa vērtību. Lai nolasītu divkāršu datu vērtību, tiek izmantota metode nextDouble().

Secinājums

Šajā pamācībā mēs redzējām, kā konvertēt virknes datu tipu uz primitīvo datu tipu double Java, izmantojot šādas klases metodes kopā ar vienkāršiem piemēriem.

• Double.parseDouble(String)
• Double.valueOf(virkne)
• DecimalFormat parse()
• jauns Double(Virkne s)