[RESOLVIDO] Invertendo número inteiro

Seguindo seu exercício abaixo:

primeiramente vc precisa converter isso para um String e depois um for
regressivo pode ser usado conforme o código abaixo :

public class TesteGeral {

	public static void main(String[] args) {
		Integer a = new Integer(7631);
		String b = a.toString();
		String c = "";
		
		for (int i=b.length(); i > 0; i--) {
			c += b.substring(i - 1, i);
		}
		
		System.out.println("numero invertido:" + c);
	}
}

Falow

Utilizando matemática:

int i0 = 7631;
int i = 0;

while (i0 > 0) {

i *= 10;

i += (i0 % 10);

i0 /= 10;

}

(Não testei, mas a idéia deve ser clara :])

Gente, muito obrigado pelas respostas.
Realmente ajudaram muito!

adolfo_eloy, eu vou guardar o script feito por você para estudá-lo mais para frente. Eu ainda não estudei até agora a conversão, nem os métodos toString e subString. Mas mais para frente será útil sem dúvida alguma! Muito obrigado.

Aldrin Leal, você captou exatamente o que eu precisava. Cara, eu nunca ia chegar nesse algoritmo só pelo que o DEITEL ensinou no livro. Eu acho que ele pecou um pouquinho em não dar um exemplo dessa ‘inversão’, afinal essa lógica é um tanto quanto adversa em relação às demais.

Eu vou postar o código para quem se interessar pelo assunto ou para os fãs do google que futuramente chegarão através do mesmo aqui ao GUJ!

O código FUNCIONA.

import java.util.Scanner;

	public class Exercicio626 {

		private Scanner entrada = new Scanner(System.in);
				
		public void pegaNumero(){
			
			System.out.print("Digite a seguir o número a ser invertido: ");
			int numero = entrada.nextInt();
			
			inverte(numero);
			
		}
		
		
		private void inverte(int numero){
			
		int i = 0;

			 while (numero > 0) {
			 i *= 10;
			 i += (numero % 10);
			 numero /= 10;
			 } 
			 
			 System.out.printf("O número invertido é: %d.\n", i);
			
		}
	
	
	}

public class Exercicio626Teste {


	public static void main(String[] args) {
		Exercicio626 objeto = new Exercicio626();
		
		objeto.pegaNumero();

	}

}

E por fim, olhe a saída do código tendo digitado no input o número dado no enunciado:

Digite a seguir o número a ser invertido: 7631
O número invertido é: 1367.

Abraços e obrigado novamente pela ajuda,
Giancarlo.

Boa tarde, estou estudando java tb… e estou tentando entender a lógica utilizada

Utilizando matemática:

int i0 = 7631; 
int i = 0; 

while (i0 > 0) { 
i *= 10; 
i += (i0 % 10); 
i0 /= 10; 
}

eu realizei o meu baseando nisto:

class AulaInverter {

    public static void main(String args[]) {
        int numeroInverte = 123456789;
        int numeroInvertido = 0;

        while (numeroInverte > 0) {
            numeroInvertido = numeroInvertido *10;
            numeroInvertido = numeroInvertido + (numeroInverte % 10);
            numeroInverte = numeroInverte / 10;
		}
		System.out.println(numeroInvertido);
    }
}

Deu certo, executou o que eu estava precisando, (eu modifiquei (simplifiqueis as operações para tentar entender o que ele estava fazendo) confesso que não entendi, poderiam me explicar por favor…
pq… pelo teste que identifiquei ali… o numeroInverte é maior que zero no primeiro momento, então ele entra no looping, ai… ele pega o numeroInvertido que no momento é zero e multiplica por 10, ou seja … resulta em 0 , ai depois ele armazena nesta váriavel o resto da divisão do numeroInverte, e ai divide o número inverte por 10 ,
sinceramente não to entendendo o que ele esta executando…

Grato.

Espero ter ajudado.

Oi gasmg, bem-vindo ao fórum.
Cuidado ao ressuscitar tópicos muito antigos. Se for faze-lo (como o caso desse, de 1 ano e meio atrás, que estava sem resposta), pelo menos evidencie isso na sua postagem.

Ao postar códigos, use também a tag code, para deixa-lo formatado. Veja como aqui:

Eu não consegui compreender a lógica por trás disto, peço desculpas pela minha ignorancia.

Alguém poderia dizer, fora do código, o que o programa faz?

Obrigado.

Ola pessoal o exercício proposta na apostila que adquiri para estudar é o seguinte :

Desenvolva um programa que solicita ao usuário um número inteiro de no máximo 4 dígitos. Inverta esse número.

o que eu fiz para resolver este problema foi:

import java.util.Scanner;


public class Exercicio9 {
	public static void main(String[] args)
	{
		Scanner entrada = new Scanner(System.in);
		
		int
		numero,
		comparador,
		inverte;
		
		comparador = 0;
		inverte = 0;
		
		while(comparador != 1)
		{
					
			System.out.print("Digite um numero que no máximo contenha 4 digitos: ");
			numero = entrada.nextInt();
			if(numero > 9999)
			{
				System.out.print(numero + " ultrapassou os 4 digitos\n");
			}
			else
			{
				while(numero > 0)
				{
					inverte *= 10;
					inverte += (numero % 10);
					numero /= 10;
				}
				System.out.print("O numero invertido e = " + inverte + "\n");
				comparador = 1;
			}
		}
	}

}

Gostaria que por gentileza alguém me confirma-se se desta forma esta correta ou se na opção para delimitar uma quantidade de valores isso deveria ser feito de uma outra forma.

Senhores,

Sei que o tópico é antigo, mas gostaria se possível de uma ajuda da galera que fez esse exercício ou de quem também procurar por este tópico! Sendo assim, fiz uma solução para esse exercício (um milhão de variáveis, rsrs), entretanto, o mesmo não executa a inversão de valores para centenas e milhares, o programa só inverte os valores em dezenas. Segue abaixo para que, por favor, alguém me dê uma luz de onde eu errei!

import java.util.Scanner;
public class DigitosInvertidos {
	private int num;
	private int numDez;
	private int numCent;
	private int numMil;
	private int dez1;
	private int dez2;
	private int cent1;
	private int cent2;
	private int cent3;
	private int mil1;
	private int mil2;
	private int mil3;
	private int mil4;
	Scanner input = new Scanner(System.in);
	// método para obter o valor e testar seu tamanho para a inversão
	public void obtemValor(){	
		System.out.println("Informe um valor entre (10 e 9999):");
		num = input.nextInt();
		while ( num < 10 || num > 9999 ) {
			System.out.println("Entrada Inválida! Informe um valor entre (10 e 9999):");
			num = input.nextInt();
		}
		if (num >= 10 || num <= 99) {
			numDez = num;
			dez2 = numDez % 10;
			numDez = numDez / 10;
			dez1 = numDez % 10;
			System.out.printf("O valor invertido é: %d%d\n", dez2, dez1);
		} else if (num >= 100 || num <= 999) {
			numCent = num;
			cent3 = numCent % 10;
			numCent = numCent / 10;
			cent2 = numCent % 10;
			numCent = numCent / 10;
			cent1 = numCent % 10;
			System.out.printf("O valor invertido é: %d%d%d\n", cent3, cent2, cent1);
		} else if (num >= 1000 || num <= 9999) {
			numMil = num;
			mil4 = numMil % 10;
			numMil = numMil / 10;
			mil3 = numMil % 10;
			numMil = numMil / 10;
			mil2 = numMil % 10;
			numMil = numMil / 10;
			mil1 = numMil % 10;				
			System.out.printf("O valor invertido é: %d%d%d%d\n", mil4, mil3, mil2, mil1);
		}
	}
}

public class TestaDigitosInvertidos {
	public static void main(String[] args) {
		DigitosInvertidos testa = new DigitosInvertidos();
		testa.obtemValor();
	}
}

brunoeac:

Senhores,

Sei que o tópico é antigo, mas gostaria se possível de uma ajuda da galera que fez esse exercício ou de quem também procurar por este tópico! Sendo assim, fiz uma solução para esse exercício (um milhão de variáveis, rsrs), entretanto, o mesmo não executa a inversão de valores para centenas e milhares, o programa só inverte os valores em dezenas. Segue abaixo para que, por favor, alguém me dê uma luz de onde eu errei!

import java.util.Scanner;
public class DigitosInvertidos {
	private int num;
	private int numDez;
	private int numCent;
	private int numMil;
	private int dez1;
	private int dez2;
	private int cent1;
	private int cent2;
	private int cent3;
	private int mil1;
	private int mil2;
	private int mil3;
	private int mil4;
	Scanner input = new Scanner(System.in);
	// método para obter o valor e testar seu tamanho para a inversão
	public void obtemValor(){	
		System.out.println("Informe um valor entre (10 e 9999):");
		num = input.nextInt();
		while ( num < 10 || num > 9999 ) {
			System.out.println("Entrada Inválida! Informe um valor entre (10 e 9999):");
			num = input.nextInt();
		}
		if (num >= 10 || num <= 99) {
			numDez = num;
			dez2 = numDez % 10;
			numDez = numDez / 10;
			dez1 = numDez % 10;
			System.out.printf("O valor invertido é: %d%d\n", dez2, dez1);
		} else if (num >= 100 || num <= 999) {
			numCent = num;
			cent3 = numCent % 10;
			numCent = numCent / 10;
			cent2 = numCent % 10;
			numCent = numCent / 10;
			cent1 = numCent % 10;
			System.out.printf("O valor invertido é: %d%d%d\n", cent3, cent2, cent1);
		} else if (num >= 1000 || num <= 9999) {
			numMil = num;
			mil4 = numMil % 10;
			numMil = numMil / 10;
			mil3 = numMil % 10;
			numMil = numMil / 10;
			mil2 = numMil % 10;
			numMil = numMil / 10;
			mil1 = numMil % 10;				
			System.out.printf("O valor invertido é: %d%d%d%d\n", mil4, mil3, mil2, mil1);
		}
	}
}

public class TestaDigitosInvertidos { public static void main(String[] args) { DigitosInvertidos testa = new DigitosInvertidos(); testa.obtemValor(); } }

Minha dúvida foi resolvida no tópico em que criei sobre a mesma!

O fórum GUJ é o melhor para Java sem sombra de dúvidas, valeu galera!