Det finns flera sätt att ta in ingång i dubbelvärde i Java -programmering, beroende på om du läser från konsolen eller från en fil.
1. Använda `skanner '(för konsolinmatning):
Detta är den vanligaste metoden för att få användarinmatning från konsolen.
`` `Java
import java.util.scanner;
public class DoubleInput {
public static void main (String [] args) {
Skannerskanner =ny skanner (System.in);
System.out.print ("Ange ett dubbelvärde:");
// Använd NextDouble () för att läsa en dubbel
Double DoubleValue =Scanner.NextDouble ();
System.out.println ("Du angav:" + DoubleValue);
skanner.close (); // viktigt:Stäng skannern när den är klar
}
}
`` `
Viktiga överväganden med `skanner`:
* Felhantering: `NextDouble ()` kastar en `InputMismatchException` om användaren kommer in i något som inte är en giltig dubbel (t.ex. text). Du bör hantera detta undantag med ett "Try-Catch" -block för att förhindra att ditt program kraschar:
`` `Java
import java.util.inputmismatchException;
import java.util.scanner;
public class DoubleInputWithExceptionHandling {
public static void main (String [] args) {
Skannerskanner =ny skanner (System.in);
System.out.print ("Ange ett dubbelvärde:");
dubbel dubbelvärde;
försök {
DoubleValue =Scanner.NextDouble ();
} catch (InputMismatchException e) {
System.out.println ("Ogiltig ingång. Ange en giltig dubbel.");
skanner.next (); // Konsumera den ogiltiga ingången
återvända; // eller hantera felet på ett annat sätt
}
System.out.println ("Du angav:" + DoubleValue);
skanner.close ();
}
}
`` `
* `skanner.next ()`: `Scanner.Next ()` samtal inuti "Catch" -blocket är avgörande. Om en "InputMismatchException" inträffar förblir den ogiltiga ingången i "skannerns" buffert. `Scanner.next ()` förbrukar denna ogiltiga ingång, vilket gör att programmet kan uppmana användaren igen utan att fastna i en oändlig slinga.
2. Använda `BufferedReader '(för konsol eller filinmatning):
`BufferedReader 'är effektivare för stora ingångar men kräver mer manuell parsing.
`` `Java
import java.io.bufferedReader;
import java.io.ioException;
import java.io.inputStreamReader;
public class DoubleInputBufferedReader {
public static void main (String [] args) {
BufferedReader Reader =new BufferedReader (ny InputStreamReader (System.in));
System.out.print ("Ange ett dubbelvärde:");
försök {
String Input =Reader.ReadLine ();
Double DoubleValue =Double.ParSedouble (ingång);
System.out.println ("Du angav:" + DoubleValue);
} catch (ioException e) {
System.out.println ("Felläsning Input:" + e.GetMessage ());
} catch (NumberFormateXception e) {
System.out.println ("Ogiltig ingång. Ange en giltig dubbel.");
}
}
}
`` `
Denna metod använder `Double.ParSedouble ()` för att konvertera strängingången till en dubbel. Det inkluderar också felhantering för både `IOException '(ingångs-/utgångsfel) och` NumberFormateXception' (Ogiltigt nummerformat).
3. Kommandoradsargument:
Du kan skicka ett dubbelvärde som ett kommandoradsargument när du kör ditt Java-program.
`` `Java
public class DoubleInputCommandline {
public static void main (String [] args) {
if (args.length> 0) {
försök {
Double DoubleValue =Double.ParSedouble (args [0]);
System.out.println ("Du angav:" + DoubleValue);
} catch (NumberFormateXception e) {
System.out.println ("Ogiltig ingång. Vänligen ange en giltig dubbel som ett kommandoradsargument.");
}
} annat {
System.out.println ("Ge ett dubbelvärde som ett kommandoradsargument.");
}
}
}
`` `
Kom ihåg att kompilera och köra detta från din terminal så här:`Java DoubleInputCommandline 3.14159`
Välj den metod som bäst passar dina behov och kom ihåg att alltid inkludera robust felhantering för att göra ditt program mer motståndskraftigt. "Skanner" -metoden är i allmänhet att föredra för sin enkelhet och inbyggda felhanteringsfunktioner när man tar inmatning från konsolen. `BufferedReader` erbjuder bättre prestanda för stora filer. Kommandoradsargument är användbara för att tillhandahålla input när du kör programmet från terminalen.
