Rotacion de caracteres

En este problema lo que se quiere es rotar los caracteres de una determinada palabra o frase , el cual se ingresara por consola , por ejemplo :
Se ingresa JAVA , entonces la salida tiene que ser :
JAVA
AJAV
VAJA
AVAJ
JAVA
Es decir la palabra rotara hasta que vuelva a quedar ordenada. Aquí se hizo uso de dos métodos ampliamente usados de la clase String , como son charAt() y substring( inicio  ,  fin ) .

He aquí el código :
================================================================

import java.io.*;

public class Rotacion {

    public static void main(String[]args)throws IOException{

        int i;
        String entrada;
        String salida;


        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Ingrese la frase a rotar :");
        entrada=br.readLine();

        for(i=0;i<=entrada.length()-1;i++){

            entrada=entrada.charAt(entrada.length()-1)+ entrada.substring(0,entrada.length()-1);
            System.out.println(entrada);
        }
      
    }
}

================================================================

He aquí la simulación :

Métodos Estáticos

Generalmente los metodos y los campos usados en una clase estan asociados a los objetos , sin embargo no siempre es así , ya que puede haber métodos genéricos cuya finalidad no dependa del objeto a tratar, a estos métodos se les suele llamar métodos estáticos.  Puesto que el método estático no depende de un objeto en particular podemos invocarlo sin tener que crear un objeto  , la sintaxis en esta caso seria :         Nombre_De_La_Clase . método();  aunque si se le llama desde el interior de la misma clase solo bastaria escribir el nombre del metodo .

Por ejemplo en la clase Motocicleta :

       class Motocicleta  {
      
             String color;
             String marca;
             int placa;
         static  int ruedas=2;
          static int  numRuedas () {
                   return  ruedas;
                                          }
                                  
                   }
 Solo he colocado un método que nos da el numero de  ruedas de la motocicleta , pero como todas las motocicletas tienen dos ruedas , entonces podemos decir que el numero de ruedas no depende de ningún objeto en particular de la clase Motocicleta y por lo tanto lo podemos considerar un método estático.

Ordenar numeros de menor a mayor

En este ejemplo , se preguntara primero cuantos números se van a ingresar para luego introducir los mismos y finalmente se mostraran los números de menor a mayor . Observe que se usa un array llamado datos   para guardar los números y luego compararlos entre si , para obtener los números ordenados.
Código :

===============================================================

import java.io.*;

public class Ordenar {

    public static void main(String[]args)throws IOException{

               int i,n;
               BufferedReader br;
               br=new BufferedReader(new InputStreamReader(System.in));

          System.out.println("Cuantos numeros va  a ingresar :");
          n=Integer.parseInt(br.readLine());
          System.out.println("Usted ingresara " + n + " numeros");
          int datos[]= new int[n];
          System.out.println("Ingrese los numeros :"  );
          for(i=0;i<n;i++){
               datos[i]=Integer.parseInt(br.readLine()); }

          for(i=0;i<n-1;i++)                                             {

              int min=i;
                   for(int j=i+1;j<n;j++)     {
                       if(datos[j]<datos[min])      {
                       min=j;}
                                              }
                  if(i!=min){
                       int aux =datos[i];
                       datos[i]=datos[min];
                       datos[min] = aux;}



                                                                          }
          System.out.println("Los numeros de menor a manor son :");
          for(int k=0; k<n;k++)

            System.out.print(datos[k] + "  ");
    }

   }

===============================================================

Simulacion : 

Ejemplo sobre promedios

En este ejemplo se mostrara un pequeño codigo sobre promedio de notas, en el cual primero se  preguntara cuantas notas va a ingresar para luego introducir las mismas y como resultado nos dira el promedio de estas y a parte nos dira cuales de estas notas fueron superiores al promedio :
Codigo :
==============================================================

import java.io.*;

public class Promedio {

  
    public Promedio(){
        super();
    }

    public static void main(String[]args)throws IOException{

        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

        System.out.println("Cuantas notas va a ingresar: ");
        int numNotas=Integer.parseInt(br.readLine());
        int []notas=new int[numNotas];
        double promedio=0;
       double acumulado=0;
        for(int i=0;i<=numNotas-1;i++){
            System.out.println("Ingrese la nota numero " +i );
            notas[i]=Integer.parseInt(br.readLine());
            acumulado=acumulado + notas[i];
                                      }
         promedio=acumulado/numNotas;
        System.out.println("el promedio es :" + promedio);
        System.out.println("===========================");
        System.out.println("LAS NOTAS MAYORES AL PROMEDIO SON: ");
       for(int j=0;j<=numNotas-1;j++){
           if(notas[j]>promedio){
            
               System.out.println(notas[j]);
           }
          }
      }
}
===============================================================

Simulacion :

Raiz Digital de un numero en Java

La llamada raíz digital de un numero no es mas que reducir cualquier numero a un dígito , sumando las cifras de este numero , por ejemplo :  9237456  se reduce primero a 9+2+3+7+4+5+6 =36 , pero como tiene dos dígitos hay que volver a reducirlo sumando nuevamente sus dígitos  3+6=9 , con lo que finaliza la operación .
En el código podemos ver que el método minimizar hará que el numero introducido como parámetro , se reduzca una vez , es decir si se ingresa 9237456 se reducirá a 36 y es lo único que hará ,luego en el método principal se ejecutara este método con la condición lógica que si ese numero es mayor que 9 vuelva a ejecutarse el método minimizar hasta que sea menor o igual a 9 , con lo que se cumple la condición de la raíz digital.

===============================================================


public class RaizDigital {

    static int minimizar(int numero){
        int suma=0;
        int division=numero;
        while(division !=0){
            int resto=division%10;
            division=division/10;
            suma=suma+resto;
        }
            return suma;
    }

    public static void main(String[]args) {
        int salida=minimizar(999989);
        while(salida>9) {

            salida=minimizar(salida);
        }
         System.out.println("La raiz digital  es " + salida);

}
}

==============================================================

En este caso no se uso el ingreso por consola , simplemente se le dio el valor del numero a 

minimizar en el método main , en este caso el numero 999989 . 

Simulación : 

Invertir el orden de las palabras

En este problema , lo que se trata  es de invertir el orden de las palabras en una frase que se ingreso , por ejemplo :
Se ingresa  :   Tengo que estudiar en la tarde para el examen de mañana
Entonces la salida sera :
                     mañana de examen el para tarde la en estudiar que Tengo .

Aqui se hizo uso del metodo split() de la clase String , el cual facilita tremendamente el problema , ya que podemos dividir el string  por cada espacio en blanco que exista lo que nos permite introducir cada  pequeño  string en un array , para luego imprimir este array en forma inversa : 

===============================================================


import java.io.*;

public class Invertir_Palabras {

    public Invertir_Palabras(){
        super();
    }
    public static void main(String [] args)throws IOException {

      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

      System.out.println("Ingrese uns frase : ");
      String frase=br.readLine();
      String []cads=frase.split(" ");

      for(int i=cads.length-1;i>=0;i--){
          System.out.print(cads[i]+" ");
      }

    }

    }

=============================================================

Simulacion :  

Invertir una frase String

En este sencillo programa invertiremos una frase ingresada por consola , el cual es un código muy conocido , pero que nos servirá para aprender a manejar la clase String :

Aquí vemos las tres variables involucradas :
String entrada , para la frase que ingresemos.
String salida, para el resultado.
int i , usado como contador.

La lógica usada aquí es sencilla , recorremos el String desde el final hacia el inicio y recuperamos cada carácter con el método charAt(i) , acumulándolo en la salida . Después lo único que tenemos que hacer es
imprimir el resultado.
==============================================================

import java.io.*;

public class Invertir {

    public static void main(String[]args)throws IOException {
        String entrada="";
        String salida="";
        int i=0;

        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Ingresar una frase : " );

        entrada=br.readLine();

        for(i=entrada.length()-1;i>=0;i--){

            salida= salida + entrada.charAt(i);
        }

        System.out.println("La frase invertida es: " + salida);

    }
}

===============================================================

Aqui la simulacion :

Clase String Ejemplo

En el siguiente ejemplo podemos ver como este programa reemplazara todas las silabas que encuentre en un párrafo por una frase clave (en nuestro ejemplo por "nat") que es una especie de encriptacion sencilla .Hemos importado el paquete io que nos servirá ya que el ingreso de datos es por consola, ademas hemos lanzado la excepción correspondiente.

Vemos las variables tipo string que nos servirán en este simple programa :

     frase = esta string almacenara la frase que vamos a introducir.

     resultado = aquí vamos a almacenar el resultado final , es decir la salida.

     clave= es el string que vamos a reemplazar por cada silaba que encontremos.

También vemos la variable de tipo int i el cual solo nos servirá de contador para recorrer el string frase.  

===============================================================

 import java.io.*;

public class Reemplazar {

    public static void main(String[]args)throws IOException {

        String frase;

        String resultado="";

        String clave="nat";

        int i;

        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

        System.out.println("Ingrese una frase : ");

        frase=br.readLine();

        for(i=0;i<frase.length();i++){

            char xCar=frase.charAt(i);

      if(xCar=='a' || xCar== 'e'|| xCar=='i' || xCar=='o' || xCar=='u') {

            resultado = resultado + "nat";

                                                                        }

        else   {

                resultado =resultado + frase.charAt(i);

        }

             }

        System.out.println("El resultado es : " + resultado);

       }

}

=======================================================

He aquí la simulación :

Si no se ve bien , la entrada es "Yo amo Java" y la salida es : "Ynat natmnat jnatvnat"