Ejemplo: Uso de arreglos o array como estructura de datos

Aquel que pregunta una vez es tonto una vez, aquel que no pregunta nunca es tonto siempre.

Comparto un ejemplo del uso de arreglos, como una estructura de datos, proporcionando solución a un problema planteado.
Si la explicación aun no te queda clara puedes consultar la anterior publicación la cual es un instructivo como manual de bolsillo indispensable, con el cual puedes aprender rápidamente el uso de los mismos.

Fundamentos de Arreglos o Array
Apuntadores en java.

Ejemplo 1 parte 1

 

Código fuente

//Librerias importantes

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.logging.Level;
import java.util.logging.Logger;

public class ArregloSimple {
    
      //Tipos Simples
  private  String mensaje;
  private  String linea;
  private boolean asignado;
  
     //forma#1
//  String [] Nombres;
//  String [] Clasificaciones={"Disponible","Espacio no Disponible","Error de formato","Sistema iniciado"};
  //forma#2
   private  String [] Nombres, Clasificacion={"Disponible","Espacio no Disponible","Error de formato","Sistema iniciado"};
  
   
   InputStreamReader Flujo_bytes= new InputStreamReader (System.in);
   BufferedReader entrada= new BufferedReader (Flujo_bytes); 
 public void iniciarSistema(){
      System.out.println("Para Iniciar el sistema debe ingresar el numero de datos a registrar:");
      try {
          linea= entrada.readLine();
         
      } catch (IOException ex) {
         System.out.println("Error ");

      }
      
      
      try{
      int numPersona= Integer.parseInt(linea);
      Nombres= new String[numPersona];
      System.out.println( Clasificacion[3]);
      }catch(NumberFormatException e){
         System.out.println("Error ");

      }
       
 }
 
 public void registrarUsuario(){
  boolean respuesta= true;
  while(respuesta){
  System.out.println("Ingrese el nombre de usuario");  
      try {
          linea= entrada.readLine();
          listarSimple(linea);
         
      } catch (IOException ex) {
         System.out.println("Error ");

      }
      
      try{
      System.out.println("Desea registrar otro usuario? SI o NO");   
      linea= entrada.readLine();
      System.out.flush();
      
       if( linea.equalsIgnoreCase("si")){
              continue;
              }else if( linea.equalsIgnoreCase("no")){
              break;
              }
      
      }catch (IOException ex) {
             System.out.println("Error ");

          }
  
  }
     
 
 }
  
public void listarSimple (String nombre){
asignado= false;
if(Nombres!=null){//analizar si existe
        
                for (int i = 0; i < Nombres.length; i++) {

                if(Nombres[i]== null){
                System.out.println("Casilla \t"+i+Clasificacion[0]);
                Nombres[i]=nombre;
                
                asignado=true;
                break;
                }
                    
                
            }
            
        }

if(asignado){
            mensaje="Asignado Exitosamente";
            System.out.println(mensaje); 
        }else{
              mensaje="No existe Espacio suficiente";
            System.out.println(mensaje); 
        }


}

public void listarDatos(){
 for (int i = 0; i < Nombres.length; i++) {

               
                System.out.println("Usuario \t"+Nombres[i]);
               
         }


}

    
}

//clase con el metodo principal (main)

public class Ejemplo2 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
      ArregloSimple objeto= new ArregloSimple();
      objeto.iniciarSistema();
      objeto.registrarUsuario();
      objeto.listarDatos();
      
      
    }
}

Ejemplo 1 Entrada y salida de datos en java

El código fuente:

Clase principal:

public class Ejemplo1 {
    
   public static void main(String[] a3d) {
        Datos objeto  = new Datos();
     objeto.obtenerCaracter();
     objeto.mostrarDato();
//   objeto.obtenerFlujo();
//   objeto.mostrarDatos();
    }
}

Clase Datos:

public class Datos {
 
    // atributos globales
      private static char flujo;//variable temporal que recibe el dato
      private String linea = null; 
    
       
       //metodo para obtener Un caracter.
       public void obtenerCaracter(){
       System.out.println("Ingresar un dato");
           try {
               flujo=(char) System.in.read();// se castea para pertenecer al mismo tipo de variable
           } catch (IOException ex) {
               Logger.getLogger(Datos.class.getName()).log(Level.SEVERE, null, ex);
           }
       
       }
    //metodo para obtner flujo
    public void obtenerFlujo(){
         
   
    InputStreamReader Flujo_bytes= new InputStreamReader (System.in);
    BufferedReader entrada= new BufferedReader (Flujo_bytes);
    System.out.println("Ingresar un flujo de datos");  
      // System.out.flush();
           try {
             
               //       
                           linea= entrada.readLine();
           } catch (IOException ex) {
               Logger.getLogger(Datos.class.getName()).log(Level.SEVERE, null, ex);
           }
       
        
        
    }
    public void mostrarDatos(){
    System.out.println("Dato ingresado: "+linea);   
    }
    
     public void mostrarDato(){
    System.out.println("Dato ingresado: "+flujo);   
    }

}

Flujo de datos en java

 Para introducirnos en el amplio mundo  de la programación   hablaremos de la importancia del manejo de los datos entrada y salida de los mismos, ya que esto es solo una muestra de lo que veremos el resto  de nuestras próximas publicaciones, el uso adecuado de los datos.
Es decir,  con la finalidad de comprender las funciones, mostrare código fuente  para que puedan analizar y usar en sus proyectos.
Por supuesto que se dará una breve explicación del funcionamiento y su implementacion.

Entrada y salida de datos en java ( Teclado y pantalla)

Lo que debemos saber de entrada de datos.

En la mayoría de casos la fuente de entrada de datos es el teclado  y la fuente de salida de datos es la pantalla.

La entrada y salida estándar son flujos de datos que actúan como canales de comunicación permitiendo la interacción entre un programa y su entorno en el sistema. En Java podemos tener acceso a estos flujos de datos desde la clase

java.lang.System.

La clase System define un objeto de la clase BufferedIputStream, cuya referencia viene dada  por in. El objeto esta asociado al flujo estándar de entrada, que por defecto  es el teclado. Los elementos  básicos de este flujo  son caracteres individuales , no cadenas como ocurre con el objeto out. Entre los métodos de las clase se encuentra  read(), que devuelve el carácter actual en el  buffer de  entrada (solamente 1 carácter).

Los Buffer son Espacios de memoria principal que se reservan para el almacenamiento intermedio de datos procedentes o con destino a los periféricos. Los dos esquemas más usuales de reserva de zonas que incorporan los Sistemas Operativos para mejorar su rendimiento son el buffer simple y el buffer doble.

Lo que debemos saber de salida de datos.

El objeto out definido en la clase System esta asociado con el flujo de salida, que dirige los datos a consola y permite visualizar en la pantalla de su equipo.

System.out  es una referencia a un objeto de la clase PrintStream, el cual contiene los métodos esenciales para mostrar la salida de datos por pantalla a través de un  buffer. Entre ellos tenemos:

print(); Transfiere una cadena de caracteres al buffer de la pantalla.

println(); Transfiere una cadena de caracteres y el caracter de fin de linea al buffer de la pantalla.

flus();  El buffer con las cadenas almacenadas se vuelcan en pantalla.

Ejemplo 1:
El código siguiente es un ejemplo simple de entrada de datos desde la consola.
Pero hacemos énfasis en el concepto anterior, donde explica que con el metodo  read(), solamente obtendremos un solo carácter.

import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;

public class EDDSimples {
    private static char flujo;//variable temporal que recibe el dato

    public static void main(String[] args) {
        System.out.println("Ingresar un dato");
        try {
            flujo=(char) System.in.read();// se castea para pertenecer al mismo tipo de variable
        } catch (IOException ex) {
            Logger.getLogger(EDDSimples.class.getName()).log(Level.SEVERE, null, ex);
        }
        
           System.out.println("El dato ingresado: "+flujo);
    }
}

Resultado del primer ejemplo

Ejemplo 2:
El código siguiente es un ejemplo simple de entrada de datos desde la consola.
Ahora no  recaudaremos un solo carácter  sino que  obtendremos todos los datos encontrados en una linea. Usando InputStreamReader se obtiene el flujos de bytes y es trasladado a flujos de caracteres.

BufferedReader Crea un flujo de caracteres de entrada de búfer que utiliza una memoria intermedia de entrada de tamaño predeterminado.

La variable linea solo obtiene la conversión de bytes a cadenas de caracteres.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.logging.Level;
import java.util.logging.Logger;

public class EDDSimples {
    

   public static void main(String[] args) {
        
    String linea = null;   
    InputStreamReader Flujo_bytes= new InputStreamReader (System.in);
    BufferedReader entrada= new BufferedReader (Flujo_bytes);
    System.out.println("Ingresar un flujo de datos");    
    System.out.flush();
        try {
            linea= entrada.readLine();
        } catch (IOException ex) {
            Logger.getLogger(EDDSimples.class.getName()).log(Level.SEVERE, null, ex);
        }
        
        System.out.println("Dato ingresado: "+linea);   
    }
}

Salida del ejemplo 2