Kk

Bom Dia.

Eu faria desse modo:

Faria um programa que receberia a mensagem e transformaria ela em um array de char, criaria um for para percorrer esse array, em toda posição to array chamaria um método para fazer a mudança.

O método que faz a mudança seria um método que receberia um char e retornaria um char, ele pegaria o char que recebeu transformaria no seu numero ASCII correspondente,somaria 1 e transformaria novamente em char e retornaria o char mudado.

Caso você não saiba transformar em ASCII tem essa pergunta no grupo que tem bastantes exemplos.

Esta é uma possibilidade:

import java.util.stream.Collectors;

class Main {
    public static void main(String[] args) {
        String texto = "casa";

        String inverso = texto.chars()
                .mapToObj(i ->  Character.toString((char) (i + 1)))
                .collect(Collectors.joining(""));

        System.out.println(inverso);
    }
}

Muito obrigado!!

Não entendi oq vc disse! sou um pouco noob, esou começando java agora! me ajude

O código funciona pra qualquer palavra.

Usei uma String comum no exemplo porque achei que seu problema fosse apenas com a inversão.

Em Java, pra poder permitir que o usuário entre com a String, vc vai ter que usar a classe Scanner.

Ficaria algo mais ou menos assim:

/* ... */
String texto = new Scanner(System.in).nextLine();
/* ... */

Mestre deu certinho agora vou estudar oq vc usou aq!
muito foda vc!
poderia me explicar seu codigo? tipo tem algumas coisas ali q numca vir!
como falei estou começando agora!

Olha o jeito q ficou

String texto = new Scanner(System.in).nextLine();
    String inverso = texto.chars()
            .mapToObj(i ->  Character.toString((char) (i + 1)))
            .collect(Collectors.joining(""));
      System.out.println("A palavra cripitografada e " +inverso);

Explica cada linha please

String inverso = texto.chars() ->EXPLICA?
.mapToObj(i -> Character.toString((char) (i + 1)))->EXPLICA?
.collect(Collectors.joining(""))->EXPLICA?

Para este código eu usei um recurso disponível a partir da versão 8 do Java que são as Streams e o método chars() que está disponível a partir da versão 9.

Primeiro eu usei o código abaixo para transformar a String em uma Stream de inteiros.

texto.chars()

Uma stream é uma sequencia de valores, é quase como um array se vc for pensar que as duas estruturas organizam seus elementos sequencialmente.

Contudo, Streams são mais versáteis e permitem que nós as manipulemos de formas que não é possível ou que seria mais trabalhso usando arrays comuns.

Por exemplo: O próximo passo, destacado no trecho abaixo, eu transformei a sequencia/stream de inteiros em uma sequencia de Strings.

Eu peguei cada item da sequencia (representado pela variável i e somei com + 1 para avançar a letra (‘a’ vira ‘b’, ‘b’ vira ‘c’ e assim por diante).

E com a ajuda do método Character.toString() eu transformei a letra resultante em string.

.mapToObj(i ->  Character.toString((char) (i + 1)))

Por último eu usei o trecho abaixo para pegar/coletar cada item da sequencia e juntar tudo numa String só.

.collect(Collectors.joining(""));

Se eu quisesse juntar tudo, mas inserindo uma virgula entre cada letra, eu poderia fazer assim:

.collect(Collectors.joining(", "));

Um exemplo de outra coisa legal que é possível de fazer é o seguinte: digamos que a gente queira excluir as vogais antes de fazer a criptografia, ficaria assim:

String inverso = texto.chars()
	.filter(i -> "AEIOUaeiou".indexOf(i) == -1)
        .mapToObj(i ->  Character.toString((char) (i + 1)))
        .collect(Collectors.joining(""));

Uma forma mais simples de fazer, sem Streams, seria assim:

class Main {
    public static void main(String[] args) {
        String texto = "casa";

        char[] array = texto.toCharArray();
        String inverso = "";

        for(int i = 0; i < texto.length(); i++) {
            inverso += (char) (array[i] + 1);
        }

        System.out.println(inverso);
    }
}

O problema da forma acima é que ela cria uma nova String a cada iteração do loop. O mais correto (e não tão simples) seria usar o StringBuilder.

class Main {
    public static void main(String[] args) {
        String texto = "casa";

        char[] array = texto.toCharArray();
        StringBuilder builder = new StringBuilder();

        for(int i = 0; i < texto.length(); i++) {
            builder.append((char) (array[i] + 1));
        }

        String inverso = builder.toString();

        System.out.println(inverso);
    }
}

A idéia é que em Java, String são imutáveis e, por isso, quando vc soma uma String com outra String, vc não está modificando-a, vc está criando uma String completamente nova com o valor somado das outras.

O StringBuilder nos ajuda a compor String de forma mais performática. Ele tem mecanismos que evitam a criação de tantas Strings desnecessárias.

sensacional sua explicação valeu!! qualquer duvida te chamo!

Voçê sabe outro jeito de fazer usando um (for) e criando um (vetor) com o alfabeto?

Eu mostrei como é possível fazer com o for, só não sei onde esse vetor com o alfabeto se encaixa na história.

Pois e acho q estou pensando errado!

vir aq com o for!!

e como descriptografar? deixando do mesmo jeito q o usuário digitou?

Do mesmo jeito, só que fazendo -1 ao invés de +1. Exemplo:

Com Streams:

inverso.chars()
       .mapToObj(i ->  Character.toString((char) (i - 1)))
       .collect(Collectors.joining(""));

valeu

Mestre !pra quem ta começando agora o ideal seria estudar bastante vetor e matriz e saber bem como usar? Se eu souber usar bem consigo resolver muitos algoritmos?

Vetores (ou arrays) são bastante úteis em várias situações e vc tem sim que entender bem.

O ideal seria vc escolher um curso ou um livro ou algum tutorial, que apresenta uma estrutura de aprendizado, e fosse seguindo no seu tempo, aprendendo progressivamente.

Mas que parte do uso dos arrays vc não entende?

Posso fazer um Array de qualquer coisa? tipo int e String?
E como faço pra chamar ele tipo deixando ele livre para o usuario digitar!
Um livro bom que voçê pode me indicar, para pro seguir passo a passo.

Vc pode criar arrays de qualquer coisa, desde os tipos primitivos até os tipos referência (que são os tipos representados pelas classes).

A sintaxe para criar um array é a mesma pra qualquer tipo.

int[] arrayDeInteiros;
char[] arrayDeCaracteres;

// Digamos que vc esteja criando um jogo com naves inimigas
Nave[] navesInimigas;

Uma coisa pra ficar atento é que há diferença entre declarar um array e criar um array.

No trecho acima eu apenas declarei aqueles arrays. Para criar de verdade eu preciso user o new, assim:

int[] arrayDeInteiros = new int[10];
char[] arrayDeCaracteres = new char[10];
Nave[] navesInimigas = new Nave[10];

Notou o 10 entre colchetes? Ele especifica qual a capacidade do array, ou seja, a quantidade de elementos máxima que o array pode conter.

No exemplo eu criei arrays com capacidade para 10 elementos.

Depois da criação dos arrays vc precisa adicionar os elementos. Adicionamos elementos da seguinte forma:

arrayDeInteiros[0] = 1;
arrayDeInteiros[1] = 2;
arrayDeInteiros[2] = 3;
arrayDeInteiros[3] = 4;
arrayDeInteiros[4] = 5;
arrayDeInteiros[5] = 6;
arrayDeInteiros[6] = 7;
arrayDeInteiros[7] = 8;
arrayDeInteiros[8] = 9;
arrayDeInteiros[9] = 10;

navesInimigas[0] = new Nave();
navesInimigas[1] = new Nave();
navesInimigas[2] = new Nave();
/* e assim por diante... */

Os indices (os números entre colchetes) sempre começam em 0, o 0 representa a posição do primeiro elemento do array. No caso do meu array com capacidade para 10 elementos, a última posição é representada pelo indice 9.

Dependendo do caso, pode ser útil usar um loop pra fazer a inicialização.

for(int i = 0; i < navesInimigas.length; i++) {
    navesInimigas[i] = new Nave();
}

Pra encher o array com dados vindos do usuário, vc faria algo como:

Scanner scan = new Scanner(System.in);
int[] numerosDaSorte = new int[3];

System.out.println("Entre com o primeiro número da sorte: ");
numerosDaSorte[0] = Integer.parseInt(scan.nextLine());

System.out.println("Entre com o segundo número da sorte: ");
numerosDaSorte[0] = Integer.parseInt(scan.nextLine());

System.out.println("Entre com o terceiro número da sorte: ");
numerosDaSorte[0] = Integer.parseInt(scan.nextLine());

Ou pra facilitar:

Scanner scan = new Scanner(System.in);
int[] numerosDaSorte = new int[3];

for(int i = 0; i < numerosDaSorte.length; i++) {
    System.out.println("Entre com o " + (i + 1) + "° número da sorte: ");
    numerosDaSorte[i] = Integer.parseInt(scan.nextLine());
}

System.out.println("Seus números são: ");
for (int i = 0; i < numerosDaSorte.length; i++) {
    System.out.print(numerosDaSorte[i] + " ");
}

Arrays em Java tem tamanho fixo e isso quer dizer que se vc declara um array com capacidade para 10 elementos, vc nunca vai conseguir acrescentar mais elementos do que isso e, se tentar, uma exceção será lançada.

Se tentar algo como:

numerosDaSorte[3] = 123;

A exceção IndexOutOfBoundsException será lançada. É bom ficar atento com isso porque já vi gente no fórum perguntando o que é esse “erro do Java”.

Este tipo de erro não é do Java, mas sim do próprio programador e significa puramente que vc informou que queria um array de tamanho x, mas está usando como se tive tamanho x + 1.

Fique atento às mensagens no console.

Acho que é isso o básico.

Não conheço livros pra indicar.

Exemplo:

import java.util.Scanner;

public class Exemplo {

    public static void main(String[] args) {
        Exemplo programa = new Exemplo();
        programa.executar();
    }

    private static final Scanner entrada = new Scanner(System.in);

    public void executar() {
        System.out.print("Digite uma palavra: ");
        String palavra = entrada.nextLine();
        System.out.print("A palavra encriptada é: ");
        char[] letras = palavra.toCharArray();
        for (char letra : letras) {
            letra++;
            System.out.print(letra);
        }
    }
}

Valeu mestre!!