Bom dia a todos.
Alguém poderia me dizer, por favor, se existe algum método ou função, e como posso usá-lo caso exista, que pegue um valor decimal com vários números depois da vírgula, e que o arredonde para um número específico de casas decimais. Exemplo: o número 2522,1223507 ser arredondado para 2522,1224.
Desde já agradeço pela possível ajuda de vocês.
Abraço a todos.
Olá, Ricardo,
DÊ uma olhada nessa classe.
E, pro favor, seja mais claro no título do tópico, tem mais chances de ser visualizado assim.
[]s
O que vc quer é a linha abaixo:
Math.round(X * Math.pow(10, n)) / Math.pow(10, n);onde, X é o seu valor inicial e n é o número de casas desejadas.
public class Teste {
public static void main(String[] args) {
double X = 2522.1223507;
int n = 4;
double i = Math.round(X * Math.pow(10, n)) / Math.pow(10, n);
System.out.println(i);
}
}pcalcado, eu não tinha visto sua resposta … (desculpe)
Vc tem razão, se o Ricardo deseja imprimir um valor com uma certa quantidade de casas decimais é melhor usar o numberFormat.
Obrigado pela ajuda pessoal. Mas o caso é que eu preciso arredondar o número. Por exemplo, tinham professores que quando se deparavam com uma nota 8,42 arredondavam para baixo e o aluno ganhava apenas um 8. E quando viam um 8,78 davam 9 para o aluno. O meu caso é que eu preciso pegar um número com muitas casas decimais e arredondá-lo para um número com quatro casas decimais. Não simplesmente sumindo ou andando com a vírgula pelo número.
pcalcado, obrigado pela dica do título do tópico. Prometo que serei mais claro quando tiver alguma dúvida. E rodrigousp, valeu pela força também.
Espero que vocês possam continuar me ajudando.
Um abraço.
Olá
Anulei minha mensagem por não tempo de pensar direito.
[]s
Luca
É isso?
BigDecimal bd = new BigDecimal(1.234567);
int decimalPlaces = 4;
bd = bd.setScale(decimalPlaces, BigDecimal.ROUND_HALF_EVEN);
System.out.println(bd);Dá uma olhada na API para entender os modos de arredondamento.
Vc já testou o método que eu tinha te enviado !?
public class Teste {
public static void main(String[] args) {
double X = 2522.1223507;
int n = 4;
double i = Math.round(X * Math.pow(10, n)) / Math.pow(10, n);
System.out.println(i);
}
} Ele não some com os números, ele arredonda meu caro !
2522.1224Caros amigos,
obrigado pela ajuda de todos vocês. Valeu mesmo. Voltei agora do horário de almoço e vou tentar usar as dicas de vocês.
Mas acho que com essa dica do om meu problema vai se resolver. Dei uma olhada na API e acho que é isso mesmo. Só preciso decidir se uso o ROUND_HALF_EVEN, ROUND_HALF_UP ou o ROUND_HALF_DOWN, e também como vou implementá-lo numa página JSP. O camarada que trabalha comigo e eu não sabemos direito como fazer isso. Alguém sabe como nós poderíamos estar fazendo isso? Nós não sabemos se criamos uma função, ou um javaScript, ou um bean… sei lá. Eu ainda não tenho muitos conhecimentos técnicos pra pensar em qual seria a melhor forma de estar utilizando esse método.
Quem ainda estiver disposto a me ajudar, por favor, me dê só mais essa dica. Belê?! 
Brigadão pessoal.
Abraço a todos.
Grande rodrigousp!!!
Me perdoe, mas eu não havia testado seu código. Pra falar a verdade eu não havia testado nenhum. Tive que parar de trabalhar pra almoçar com o pessoal. Eu só tinha tido tempo pra dar uma olhada no API, o que não me ajudou muito. Pois quando o li, ficou essa impressão de que o método não arredondava, só movia a vírgula ou a fazia sumir. Agora sim pude testar e ver que funciona.
Brigadão cara, e mais uma vez, me desculpe.
Brigadão a todos também. Não deixem de ler a mensagem que postei a cima. Tenho uma pequena dúvida a respeito de como utilizar esse método em uma página JSP. Quem puder, por favor, me ajude.
Abraço a todos e obrigado.
Que interessante… Será que isto faz o que eu estou pensando?
ROUND_HALF_DOWN: arredonda para baixo
ROUND_HALF_UP: arredonda para cima
ROUND_HALF_EVEN: arredonda (ou trunca) de modo que o próximo algarismo seja sempre par.
Se fizer, ficarei muito feliz, pois são justamente os critérios de arredondamento que eu uso nas minhas disciplinas de Física Experimental…
Cara, é bem capaz. Mas vai ter que arrumar o código que tem aí acima, pois o mesmo está com uns probleminhas.
Tomara que te ajude.
Para tentar entender os modos de arredondamento, fiz uma classezinha pra testar todos. Pode ser útil pra mais alguém, portanto aí vai:
import java.math.BigDecimal;
/*
* Created on 22/06/2004
*/
/**
* @author omarques
*
* 22/06/2004
*/
public class TestRound
{
public static void main(String[] args)
{
BigDecimal bd;
int decimalPlaces = 4;
double valor;
valor = -1.12345000;
/*
ROUND_CEILING
Arredonda em direção ao positivo.
*/
roundCeiling(decimalPlaces, valor);
/*
ROUND_DOWN
Arredonda em direção a zero
*/
roundDown(decimalPlaces, valor);
/*
ROUND_FLOOR
Arredonda em direção ao negativo
*/
rounFloor(decimalPlaces, valor);
/*
ROUND_HALF_DOWN
Arredonda em direção ao "vizinho" mais próximo.
Caso a distância entre os dois seja a mesma, arredonda pra baixo
*/
roundHalfDown(decimalPlaces, valor);
/*
ROUND_HALF_EVEN
Arredonda em direção ao "vizinho" mais próximo.
Caso a distância entre os dois seja a mesma, arredonda para valor PAR
*/
roundHalfEven(decimalPlaces, valor);
/*
ROUND_HALF_UP
Arredonda em direção ao "vizinho" mais próximo.
Caso a distância entre os dois seja a mesma, arredonda pra cima
*/
roundHalfUp(decimalPlaces, valor);
/*
ROUND_UP
Arredonda para o valor mais distante de zero
*/
roundUp(decimalPlaces, valor);
/*
ROUND_UNNECESSARY
Modo utilizado para verificar que o resultado é exato, sem necessidade de arredondamento.
Caso esta condição não seja atendida, é lançada uma ArithmeticException
*/
roundUnnecessary(decimalPlaces, valor);
}
private static void roundUnnecessary(int decimalPlaces, double valor)
{
BigDecimal bd;
bd = new BigDecimal(valor);
try
{
bd = bd.setScale(decimalPlaces, BigDecimal.ROUND_UNNECESSARY);
System.out.println(valor + " ROUND_UNNECESSARY -> " + bd);
}
catch (ArithmeticException e)
{
System.out.println(valor + " ROUND_UNNECESSARY -> impossivel");
}
}
private static void roundUp(int decimalPlaces, double valor)
{
BigDecimal bd;
bd = new BigDecimal(valor);
bd = bd.setScale(decimalPlaces, BigDecimal.ROUND_UP);
System.out.println(valor + " ROUND_UP -> " + bd);
}
private static void roundHalfUp(int decimalPlaces, double valor)
{
BigDecimal bd;
bd = new BigDecimal(valor);
bd = bd.setScale(decimalPlaces, BigDecimal.ROUND_HALF_UP);
System.out.println(valor + " ROUND_HALF_UP -> " + bd);
}
private static void roundHalfEven(int decimalPlaces, double valor)
{
BigDecimal bd;
bd = new BigDecimal(valor);
bd = bd.setScale(decimalPlaces, BigDecimal.ROUND_HALF_EVEN);
System.out.println(valor + " ROUND_HALF_EVEN -> " + bd);
}
private static void roundHalfDown(int decimalPlaces, double valor)
{
BigDecimal bd;
bd = new BigDecimal(valor);
bd = bd.setScale(decimalPlaces, BigDecimal.ROUND_HALF_DOWN);
System.out.println(valor + " ROUND_HALF_DOWN -> " + bd);
}
private static void rounFloor(int decimalPlaces, double valor)
{
BigDecimal bd;
bd = new BigDecimal(valor);
bd = bd.setScale(decimalPlaces, BigDecimal.ROUND_FLOOR);
System.out.println(valor + " ROUND_FLOOR -> " + bd);
}
private static void roundDown(int decimalPlaces, double valor)
{
BigDecimal bd;
bd = new BigDecimal(valor);
bd = bd.setScale(decimalPlaces, BigDecimal.ROUND_DOWN);
System.out.println(valor + " ROUND_DOWN -> " + bd);
}
private static void roundCeiling(int decimalPlaces, double valor)
{
BigDecimal bd;
bd = new BigDecimal(valor);
bd = bd.setScale(decimalPlaces, BigDecimal.ROUND_CEILING);
System.out.println(valor + " ROUND_CEILING -> " + bd);
}
}