Galera como eu consigo arredondar um numero nos decimais?
Se uma conta resulta o valor de 2,07 como fazer pra ela retornar 2.1?
Se for um 2,04 o round vai jogar pra baixo, e isso não pode acontecer nesta equação, manualmente eu teria que escolher 2.05. O ceil jogaria para o próximo valor inteiro, então não é uma opção também.
Estou guardando este valor em uma variável double.
o 2.07 ficaria 2,1 porque você arrendou os valor maior 0,5 para o seu inteiro imediato, e se for 2,04 qual seria o valor?
Cite vários exemplos e os valores que deverão ficar?
Então, estou dimensionando uma estrutura certo? O valor mínimo de um elemento será de 2,07, ou 2,04 metros, porém eu não vou falar com o cara pra fazer uma forma de 2,07 ou 2,04. O ideal seria arredondar para 2,10. E como estou calculando a dimensão mínima, eu não poderia arredondar esse valor para baixo. Se a conta desse 2,04 eu não poderia por exemplo usar o round que arredondaria para 2. Porque o valor mínimo é 2,04. E se eu utilizar o ceil esse valor iria para 3, mas ai gastaria mais material.
Cara!
Cite valores?
se tem um valor 2.04 é para arredondar para 2.1
Entendeu?
É exatamente isso!
Então se for:
2,15 é para arredondar pra quanto?
0,15 é para arredondar pra quanto?
2,05 é para arredondar pra quanto?
2,04 é para arredondar pra quanto?
0,04 é para arredondar pra quanto?
2,15 = 2,2
0,15 = 0,2
2,05 = 2,1
2,04 = 2,1
0,04 = 0,1
Entendeu?
Seria legal quando for perguntar algo de contas especificar as saídas, sim eu já tinha entendido, mas, não tinha ficado muito claro.
/* package whatever; // don't place package name! */
import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;
/* Name of the class has to be "Main" only if the class is public. */
class Ideone
{
public static void main (String[] args) throws java.lang.Exception
{
/*
2,15 = 2,2
0,15 = 0,2
2,05 = 2,1
2,04 = 2,1
0,04 = 0,1*/
double v0 = 2.15;
double v1 = 0.15;
double v2 = 2.05;
double v3 = 2.04;
double v4 = 0.19;
double v5 = 0.9;
System.out.println(prepareValue(v0));
System.out.println(prepareValue(v1));
System.out.println(prepareValue(v2));
System.out.println(prepareValue(v3));
System.out.println(prepareValue(v4));
System.out.println(prepareValue(v5));
}
public static Object prepareValue(double value)
{
int r = 10;
String[] str = String.valueOf(value).split("\\.");
if (str.length > 0)
{
str[1] = str[1].length() == 1 ? (str[1]+"0") : str[1];
int s1 = Integer.parseInt(str[1]);
if (s1 < 10) r = 10; else
if (s1 >= 10 && s1 <20) r = 20; else
if (s1 >= 20 && s1 <30) r = 30; else
if (s1 >= 30 && s1 <40) r = 40; else
if (s1 >= 40 && s1 <50) r = 50; else
if (s1 >= 50 && s1 <60) r = 60; else
if (s1 >= 60 && s1 <70) r = 70; else
if (s1 >= 70 && s1 <80) r = 80; else
if (s1 >= 80 && s1 <90) r = 90; else
if (s1 >= 90) r = 100;
}
BigDecimal re =
new BigDecimal(Math.abs(((value - (int)value)*100)-r)/100)
.setScale(2, RoundingMode.HALF_EVEN);
return re.add(new BigDecimal(value)
.setScale(2, RoundingMode.HALF_EVEN))
.doubleValue();
}
}
Possa ser que além dessa lógica existe mais alguma regra para impor, isso tudo vai depender do seu modelo de negócio. De um modo geral isso funciona perfeitamente.
Se queres apenas mostrar o valor e não queres reinventar a roda:
NumberFormat nf = new DecimalFormat("0.0");
nf.setRoundingMode(RoundingMode.CEILING);
System.out.println(nf.format(2.15));
System.out.println(nf.format(0.15));
System.out.println(nf.format(2.05));
System.out.println(nf.format(2.04));
System.out.println(nf.format(0.04));
2,2
0,2
2,1
2,1
0,1
Se precisas de usar o valor arrondado:
double d = Math.ceil(2.15 * 10) / 10; // d fica = a 2,2
// o numero a multiplicar e dividir terá tantos 0 como o número de casas decimais pretendido
1 curtida
Testa com valores maiores com 0,5? a idéia dele é outra! o arrendodamento é diferente (nem sei se isso é arrendodamento, é um regra de negócio) se for 0,5 é 1 ou, se for 0,1 é 1 também.!
Apesar que nada ficou muito claro.
Arredonda sempre “para cima” daí o nf.setRoundingMode(RoundingMode.CEILING) ou Math.ceil
Fiz da seguinte forma:
a = 2.07
double aa;
int arredA = (int) a;
aa = (Math.ceil((a - arredA)*10)/10) + arredA;
Resultado: 2.1
Isolei a parte fracionária e arredondei ela apenas…
Galera, obrigado pela força ai. Sou novo por aqui, da próxima vez tentarei ser mais claro. Mas muito obrigado!
Mesmo assim teste com 2.19 não dá certo! olha no meu exemplo! porque eu fiz com esses ajustes
double d = Math.ceil(2.19 * 10) / 10;
System.out.println(d);
2.2
Como não dá certo?
Não precisas de isolar e voltar a somar:
double aa = 2.07;
aa = Math.ceil(aa * 10) / 10;
System.out.println(aa);
2.1
Então tá, cuidado com dados double!
Cuidados com arredondamento porque uma hora vai aparecer um monte de 999999 depois da virgula.
Só é um dica.
sem mais