¿Cómo establecer la precisión para valores dobles en Java?

Los dígitos significativos se refieren a todos los dígitos, incluidos los de izquierda y derecha, al lugar decimal. Mantener una nota que agrega 0 a la izquierda de cualquier número no se cuenta como dígitos significativos, mientras que los dígitos precisos se refieren a los dígitos que solo se encuentran en el lado derecho o en breve después del lugar decimal en matemáticas. En Java, hay números de más de 16 números solo para la precisión, pero pueden ir más. Aquí se nos da un valor doble, la tarea es establecer su valor de precisión en lugares decimales específicos. Se ilustra debajo de las ilustraciones de la siguiente manera:

Ilustraciones: 

Input  : val = 1 
Output : 1.0000
Upto 4 decimal places

Input  : 12.5
Output : 12.500000
Upto 6 decimal places

Diferentes métodos para establecer la precisión en valores dobles

1. Usando el método format() de la clase String
2. Usando el método round() de la clase Math

Método 1: Usar el método format() de la clase String

Podemos usar el método format() de la clase String para formatear el número decimal en algún formato específico.

Sintaxis:

String.format("%.Df", decimalValue);
// Where D is the number required number of Decimal places

Ejemplo 1:

// Java Program to Illustrate format() Method
// of String class
 
// Importing required classes
import java.io.*;
import java.lang.*;
 
// Class
class GFG {
   
  // Main driver method
  public static void main(String[] args) {
 
     // Declaring and initializing
     // double value
    double a = 0.9;
 
    // Setting the precision
    // to 20 places
    System.out.println(
      String.format("%.20f", a));
 
    double b = 1;
 
    // Setting the precision
    // to 5 places
    System.out.println(
      String.format("%.5f", b));
  }
}

0.90000000000000000000
1.00000

De la salida anterior, está claro que la precisión de 20 dígitos se lleva a cabo para la primera entrada, mientras que la precisión de 5 dígitos se lleva a cabo en el valor doble de entrada. 

Ejemplo-2:

// Demonstrating the precision modifier
 
import java.util.*;
 
class GFG {
    public static void main (String[] args) {
      Formatter fm=new Formatter();
       
      // Format 4 decimal places
      fm.format("%.4f", 123.1234567);
      System.out.println(fm);
      fm.close();
       
      //Format 2 decimal places in a 16 charcater field
      fm=new Formatter();
      fm.format("%16.2e",123.1234567);
      System.out.println("GFG!");
      fm.close();
       
      //Display atmost 15 characters in a string
      fm=new Formatter();
      fm.format("%.15s", "Learning with Gfg is easy quick");
      System.out.println(fm);
      fm.close();
    }
}

123.1235
GFG!
Learning with G

Método 2: Usando el método round() de Math Class

Ejemplo:

// Java Program to Illustrate Precision Setting In Double
// Using round() Method of Math Class
 
// Importing required classes
import java.util.*;
 
// Class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Declaring and initializing double variable
        double num = 3.141414141414;
 
        // Rounding off above double number
        // to 7 precision
        double ans
            = Math.round(num * 10000000) / 10000000.0;
 
        // Printing the above precised value
        // of double value
        System.out.println(ans);
    }
}

3.1414141

El número doble anterior tiene una precisión de 7 dígitos que se puede ver fácilmente a partir de la salida generada.