Foros aprenderaprogramar.com
Didáctica y divulgación de la programación

Hola.

Si te fijas, cada String del arreglo auxiliar contiene 4 datos. Están juntos en el mismo String, pero separados por un ;

Bien, la clase String tiene un método llamado split() al cuál podemos pedirle que separe un String a partir de un carácter o una cadena.
Entonces, si le pedimos que haga split(";") , dividirá cada uno de esos String en 4 String separados y los devolverá en un arreglo de 4 posiciones.

Si tenemos 10 String, y de cada uno de ellos podemos obtener 10 arreglos de 4 posiciones, pues ya podemos construir la matriz de [10,4].

Entonces, la mecánica a seguir es usar un bucle para recorrer las 10 posiciones del arreglo auxiliar.
Por cada String que contiene, usamos split(";") y obtenemos un arreglo de 4 posiciones, con los 4 datos ya separados.
Este arreglo de 4 posiciones, lo insertamos en la matriz, en la misma posición que hemos usados para leer el arreglo auxiliar.
Y el bucle se repite hasta completar las 10 posiciones.

Este podría ser un código que cumpliera con esto.
Luego al final se muestra en pantalla los datos de la matriz para comprobar que se han obtenido los datos.
Pruébalo, asegúrate de que lo comprendes y no dudes en preguntar y repreguntar lo que sea.
Un saludo.

public class Main {

public static void main(String[] args) {

String[] auxiliar = new String[10];

        auxiliar[0] = "16.125.690-0;CLAUDIO ANTONIO HONORATO DE LA FUENTE;240000;PJE. ESTERO AZUL N 1742";
        auxiliar[1] = "16.107.855-7;BARBARA FABIOLA DELGADO SANCHEZ;216800;PJE. SCHEAT 8587 - VILLA ESTRELLA SUR";
        auxiliar[2] = "16.082.439-5;PABLO ANDRES HENRIQUEZ LEON;353657;AURORA 8964";
        auxiliar[3] = "16.030.010-8;JORGE ARIEL CARTES JARA;478604;AMUNATEGUI N 630 BARRIO STA ANA";
        auxiliar[4] = "15.822.860-2;CESAR ALEJANDRO LIGUENO ROJAS;901209;CATEDRAL 1450 DPTO 108";
        auxiliar[5] = "15.798.385-7;JUAN PABLO ESCANILLA CORREA;525000;HERALDICA 8861";
        auxiliar[6] = "15.797.263-4;DOMINGO HERNAN DIAZ MORALES;380000;AV. FRESIA 2375";
        auxiliar[7] = "15.775.088-7;NICOLAS BENJAMIN ANDAUR MOREIRA;240000;SAN IGNACIO 268 PJE. INTERIOR 2 - CASA 191";
        auxiliar[8] = "15.767.949-K;BEATRIZ IDAMIA ORTIZ CESPEDES;1250000;PSJE SAN MARTIN 958";
        auxiliar[9] = "15.754.871-9;CHRISTOPHER JONATHAN OLGUIN ALVARADO;755000;LA LLARETA 9073";
       
        String[][] matriz = new String[10][4];
       
        /*
         * Cada String del arreglo auxiliar contiene 4 datos separados por ;
         * Estos String se pueden descomponer en un arreglo de 4 String donde
         * almacenar esos 4 datos por separado.
         * Para ello, podemos usar el método split() de la clase String, indicándole
         * que separe el String original allá donde encuentre un ;
         * Este método nos dará un arreglo String con los 4 datos ya separados,
         * con los cuáles construiremos la matriz 10,4
         */
        for (int i = 0; i < auxiliar.length; i++) {
        //Con split(), dividimos cada String en un arreglo de 4 String
        String[] datos = auxiliar[i].split(";");
        //Este arreglo de 4 datos, lo insertamos en la matriz
        matriz[i] = datos;
        }
       
        //Mostramos la matriz con el resultado final
        for (int i = 0; i < matriz.length; i++)
        System.out.println(Arrays.toString(matriz[i]));

}

}

Comparte el código que quieras, el foro está a tu disposición.
Un saludo.

Bienvenido.
Siéntete libre de preguntar, responder y aportar lo que quieras.

En la web tienes cursos disponibles para aprender o reafirmar conocimientos.

Un saludo.

Hola.
Algo importante es conseguir que el método main(), el principal, tenga el menor código posible. Que de una lectura rápida, uno se haga fácilmente una idea de lo que hace el programa y que lógica sigue.

Para ello puede resultar útil declarar variables fuera del main, no necesariamente todas, pero al menos sí las más importantes.
Además, al estar fuera del main, estas variables pasan a formar parte del ámbito global de la clase, lo cuál amplia su visibilidad y nos facilita poder usar métodos para así separar el código en fragmentos menores.
Estos  métodos al estar fuera del main, no podrían tener acceso a las variables que estuvieran dentro del main, ya que su visibilidad se limitaría al interior del main.

Pero si las declaramos fuera, tienen visibilidad absoluta y los métodos pueden interactuar con ellas fácilmente.

Con esto, conseguimos que el main se quede más reducido y legible.
Por ejemplo, la parte donde declaras los arrays ArticuloLitro, ValorArticulo, CodeAlfaNumChar y les das valores.
Son muchas líneas de código que podemos extraer del main y ponerlas en un método separado.


Otra cosa que me he fijado que se puede optimizar, es que cuando pides elegir articulo entre 1 y 3, haces un switch, y en los 3 cases tienes exactamente el mismo código escrito tres veces.
Solo cambia el indice para elegir artículo.
Si el usuario elige 1, tu accedes al 0
Si elige 2, acceder al 1 y si elige 3, accedes al 2....

Si te fijas, no necesitas repetir tres veces el código, solo necesitas restarle -1 a la opción del usuario y así accederías al artículo correcto.

Otra cosa, para el bucle principal usas un while() que se repite 6 veces. Esto es correcto y funciona de maravilla.
Pero si tienes claro que quieres que se repita 6 veces, es mejor usar un bucle for().
Más que nada, porque al leer el código, si un programador ve que has usado un for(), ya tiene la certeza de que el programa está pensado para repetirse un número determinado de veces.
Pero si ve un while(), la tendencia es pensar que se va a ejecutar un número INdeterminado de veces. Luego verá que no es así, pero la primera impresión que se llevará el lector puede ser errónea.

Más cosas. En Java, por convención, los métodos, nombres de variables (incluidos arrays), de objetos... siempre empiezan en minúscula.
Solo los nombres de las clases empiezan con mayúscula.
Por ejemplo Scanner, String, Integer, Object, MiFactura, Programa_empresa....

Por cierto, tampoco es costumbre usar línea de subrayado para separa nombres. En otros lenguajes sí, pero en Java la convención es usar el sistema CamelCase, es decir, cada palabra compuesta hacer que comience con mayúscula.
Así, Programa_empresa sería --> ProgramaEmpresa

Puedes escribirlo como te de la gana, y a Java le va a dar igual. El programa no va a funcionar ni mejor ni peor.
Pero es una de las normas que todos los programadores Java suelen cumplir, entonces, de nuevo, alguien que lea tu código puede confundir el nombre de una variable, con el de una clase, si ambas las escribes con la primera letra en mayúsculas.
Por eso conviene cumplir estas convenciones, por temas de legibilidad.

Dicho esto, así es como podría quedar tu clase aplicando estos cambios (excepto el de las mayúsculas, eso lo dejo a tu criterio).

public class Programa_empresa{

//Variables y objetos de ámbito global
static Random CodeAlfaNumRand = new Random();
static Scanner Input = new Scanner(System.in);
static int ArticuloLitro[] = new int[3];
static int ValorArticulo[] = new int[3];
static int CodeAlfaNumArray = 0, Amplifiart = 0;
static int OPc_1 = 0, FacturasMayores = 0;
static char CodeAlfaNumChar[] = new char[12];
static char CodeAlfaNum[] = new char[6]; //cantidad de elementos del codigo alfanumerico

//Programa principal
public static void main(String args[]){

inicializarArrays(); //Método que inicializa con valores los arrays

for (int j = 0; j <= 5; j++){

declararCodigoAlfa(); //declarar el codigo alfanumerico

do {
System.out.println("\t--- FARMACIA ---\nCual producto desea llevar:");
System.out.println("1: Desinfectante " + ArticuloLitro[0] + "L | Valor: " + ValorArticulo[0]);
System.out.println("2: Desinfectante " + ArticuloLitro[1] + "L | Valor: " + ValorArticulo[1]);
System.out.println("3: Desinfectante " + ArticuloLitro[2] + "L | Valor: " + ValorArticulo[2]);
OPc_1 = Input.nextInt();

if (OPc_1 < 1 || OPc_1 > 3)
System.out.println("No ha selecciona de manera correcta...\n");
else {
System.out.print("Cuantos desea llevar: ");
Amplifiart = Input.nextInt();           
ValorArticulo[OPc_1 - 1] *= Amplifiart; //multiplicar el preico del producto
ArticuloLitro[OPc_1 - 1] *= Amplifiart; //multiplicar cuantos litros hay en total
System.out.println("\t--- FACTURA ---");
System.out.print("Codigo del articulo: ");
for(int i = 0; i < CodeAlfaNum.length; i++){
System.out.print(CodeAlfaNum[i]);
}
System.out.println("\nPrecio total: " + ValorArticulo[OPc_1 - 1]);
System.out.println("Cantidad de litros comprados: " + ArticuloLitro[OPc_1 - 1]);
if (ValorArticulo[0] > 600){
FacturasMayores++;               
}
}

}while(OPc_1 < 1 || OPc_1 > 3);

} //Fin del bucle for

if (FacturasMayores > 1){
System.out.println("Hay " + FacturasMayores + " facturas que pasan de los $600");
}else{
System.out.println("Hay " + FacturasMayores + " factura que pasa de los $600");
}
}

//Métodos de la clase

private static void inicializarArrays() {
ArticuloLitro[0] = 5; //5 Litros
ArticuloLitro[1] = 15; //15 Litros
ArticuloLitro[2] = 25; //25 Litros
ValorArticulo[0] = 150; //valor articulos
ValorArticulo[1] = 300;
ValorArticulo[2] = 425;
//caracteres para el codigo del articulo
CodeAlfaNumChar[0] = 'A';
CodeAlfaNumChar[1] = 'B';
CodeAlfaNumChar[2] = 'C';
CodeAlfaNumChar[3] = 'D';
CodeAlfaNumChar[4] = 'E';
CodeAlfaNumChar[5] = 'F';
CodeAlfaNumChar[6] = 'G';
CodeAlfaNumChar[7] = '0';
CodeAlfaNumChar[8] = '1';
CodeAlfaNumChar[9] = '2';
CodeAlfaNumChar[10] = '3';
CodeAlfaNumChar[11] = '4';
}

private static void declararCodigoAlfa() {
for(int i = 0; i < CodeAlfaNum.length; i++){
CodeAlfaNumArray = CodeAlfaNumRand.nextInt(12);
CodeAlfaNum[i] = CodeAlfaNumChar[CodeAlfaNumArray];
}
}
}
Como puedes ver, el main se ha quedado mucho más reducido. Y el código es casi el mismo. Solo se ha reducido el código del switch, que ya no es necesario repetirlo.
El resto sigue estando ahí, solo que fuera del método main.

Bien, revisada la estética del programa, ahora quiero hacerte notar una cosa sobre la lógica, que me parece que no es correcta.
Cuando se selecciona un artículo y su cantidad, para calcular el precio y la cantidad que se lleva, estás modificando los valores en los arrays de artículos, porque haces la multiplicación directamente sobre ellos.
Lo marco en rojo.

               System.out.print("Cuantos desea llevar: ");
               Amplifiart = Input.nextInt();           
               ValorArticulo[OPc_1 - 1] *= Amplifiart; //multiplicar el preico del producto
               ArticuloLitro[OPc_1 - 1] *= Amplifiart; //multiplicar cuantos litros hay en total

Esto produce un efecto indeseado. Y es que la primera vez que se muestran en pantalla las opciones, salen bien. Garrafas de 5L, de 15L y de 25L
Pero al hacer una compra, la siguiente vez que se muestran, estos valores han sido modificados por la compra anterior.
Mira:

   --- FARMACIA ---
Cual producto desea llevar:
1: Desinfectante 5L | Valor: 150 //Valor correcto
2: Desinfectante 15L | Valor: 300
3: Desinfectante 25L | Valor: 425
1
Cuantos desea llevar: 1000
   --- FACTURA ---
Codigo del articulo: C0D4AC
Precio total: 150000
Cantidad de litros comprados: 5000
   --- FARMACIA ---
Cual producto desea llevar:
1: Desinfectante 5000L | Valor: 150000 //WTF!! :0
2: Desinfectante 15L | Valor: 300
3: Desinfectante 25L | Valor: 425

Habría que cambiar esa lógica. El cálculo del importe y guardado de este no debería hacerse en los arrays de artículos. Estos arrays deberían ser intocables.

Dale un par de vueltas a ver que se te ocurre.

Un saludo y muchas gracias por participar en el foro

Hola.
Muevo tu mensaje a otra sección más acorde. Donde publicaste inicialemente es para presentaciones y sugerencias.

Esto que preguntas, me ha recordado un práctica que hice algún tiempo (que no llegué a terminar, como casi todo lo que hago xD) donde simulaba una cartelera de cine, y guardaba información de películas, incluida una imagen con la portada de la película.
Estos objetos los serializaba para guardarlos en disco y recuperarlos al iniciar el programa.

No se si podría ser aplicable en tu caso, es cuestión de probralo.
La imagen, la guardaba en un array de bytes.

Mira, estos eran los atributos de la clase. Marco en negrita donde se guardaba la imagen.

public final class Pelicula implements Serializable{
   
   private String titulo;
   private String director;
   private String anio;
   private String sinopsis;
   private String genero;
   private Integer entradasVendidas;
   private Double recaudacion;
   private byte[] portada;

Para convertir la imagen en un array de bytes, usaba el siguiente método, que recibe un objeto File que apunta al fichero de la imagen.

   public void setPortada(File imagen) {
      portada = new byte[(int)imagen.length()];
      try {
         FileInputStream fis = new FileInputStream(imagen);
         fis.read(portada);
         fis.close();
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }

Para el proceso inverso, es decir, ese array de bytes volver a construir una imagen, usaba este otro método que devolvía un objeto Image.
En este método la devuelvo reescalada a un determinado tamaño para que me coincida con un JPanel que usaré para mostrarla, pero no es necesario, eso ya depende de tu caso.

   public Image getPortada() {
      Image imagen = null;
      ByteArrayInputStream bis = new ByteArrayInputStream(portada); //portada es el array de bytes
      try {
         imagen = ImageIO.read(bis);
      } catch (IOException e) {
         JOptionPane.showMessageDialog(null, "Error recuperando portada desde el array de bytes",
               "Pelicula.getPortada()", JOptionPane.ERROR_MESSAGE);
         e.printStackTrace();
      }
      return imagen.getScaledInstance(250, 382, Image.SCALE_SMOOTH);
   }

De este modo, con ObjectOutputStream lo guardaba en disco, y con ObjectInputStream lo recuperaba al iniciar el programa.


Este objeto Image que devuelve este último método, yo luego lo "pintaba" en una clase que hereda de Jpanel, y así se mostraba la imagen en pantalla.

   private class PanelImagen extends JPanel {
      private Image imagen;

      public PanelImagen() {
         setBackground(Color.DARK_GRAY);
         setPreferredSize(new Dimension(250, 382));
         setMaximumSize(new Dimension(250, 382));
      }

      public void setImagen(Image img) {
         imagen = img;
         repaint();
      }

      public void reset() {
         imagen = null;
         repaint();
      }

      @Override
      public void paintComponent(Graphics g) {
         super.paintComponent(g);
         g.drawImage(imagen, 0, 0, 250, 382, this);
      }
   }

No se darte más detalles al respecto, porque es algo que hice hace mucho tiempo, algo que de hecho no sabía hacer y tras investigar por la red di con esta solución.
Ya te digo que ni recordaba que había empezado esta práctica, la tenía olvidada y tu consulta me la ha hecho recordar.

Mira a ver si puedes implementarlo en tu código y nos cuentas.

Un saludo.

Muevo el tema a otra sección, ya que donde se había publicado es una sección para presentaciones y sugerencias.

Para calcular la mediana tienes que ordenar aritméticamente los números que tengas. La mediana será el valor que esté en la posición central.

Por ejemplo, tenemos estos 5 números: 1.3, 6.2, 8.0, 5.3 y 5.1
Si los ordenamos, el valor que queda en el centro, es la mediana:
1.3, 5.1, 5.3, 6.2, 8.0

¿Y si tenemos una cantidad par de números? Entonces no habrá un número que quede exactamente en el centro:
1.3, 5.1, 6.2, 8.0

En ese caso, se cogen los dos centrales, y se calcula su media aritmética

1.3, 5.1, 6.2, 8.0

5.1 + 6.2 / 2= 5.65


Bien, esa es la teoría. Si quieres hacerlo mediante un código de programación, comienza tú un programa y te ayudamos a completarlo.
Ve por partes, comienza por un programa que sea capaz de ordenar un array de números.

Cuando eso funcione, ya se irá pensando como hacer el resto.

¿Aquí querías poner meses + 30, o más bien sería meses * 30?

if (Year_2 > Year || Year > Year_2){
    DateMinus = (Day - Day_2) - ((Month - Month_2) + 30) - (((Year - Year_2) * 365));

A ver, tenemos una clase Cliente, con sus atributos, getters y setters.

public class Cliente {

private String dni;
private String nombre;
private String especialidad;

public Cliente(String dni, String nombre, String especialidad) {
this.dni = dni;
this.nombre = nombre;
this.especialidad = especialidad;
}

public String getDni() {
return dni;
}

public void setDni(String dni) {
this.dni = dni;
}

public String getNombre() {
return nombre;
}

public void setNombre(String nombre) {
this.nombre = nombre;
}

public String getEspecialidad() {
return especialidad;
}

public void setEspecialidad(String especialidad) {
this.especialidad = especialidad;
}

}
Bien, luego en una clase main declaramos un array de clase Cliente con 10 elementos.

Al inicializar este array, sus 10 elementos tienen valor null.
Entonces, en esa opción 1 de crear nuevo Cliente, lo que hay que hacer es:
- Pedir datos para crear Cliente: dni, nombre y especialidad
- Con esos datos, creamos un nuevo objeto Cliente.
- Buscar un hueco libre en el array. ¿Cómo?
Pues con un bucle lo recorremos y buscamos una posición que tenga valor null.
Si encontramos dicha posición, guardamos su indice y luego lo usamos para meter ahí el nuevo Cliente que hemos creado.
Si no se encuentra ninguna posición null, es que el array ya está lleno, así que no se puede guardar el nuevo Cliente.

El código podría ser como este. Pruébalo y verás que cada nuevo Cliente se va guardando en la posición 0, luego, 1, 2, 3... hasta la posición 9.

A partir de ahí, el array está lleno y ya no se pueden guardar más Clientes.

public class TestCliente {

private static Scanner teclado = new Scanner(System.in);
private static Cliente[] clientes = new Cliente[10];

public static void main(String[] args) {

int opc = 0;
do {
System.out.println("\n\t\tMENU OPCIONES");
System.out.println("[1] -- Nuevo Cliente");
System.out.println("[9] -- SALIR");
System.out.print("Elija opcion: ");
opc = Integer.parseInt(teclado.nextLine());

switch(opc) {
case 1:
nuevoCliente();
break;
case 9:
System.out.println("\nFIN DE PROGRAMA");
break;
default:
System.out.println("\nOpción inválida.");
}

}while(opc != 9);

}

private static void nuevoCliente() {
//Pedimos datos para crear un CLiente
System.out.print("\nDNI: ");
String dni = teclado.nextLine();
System.out.print("Nombre: ");
String nombre = teclado.nextLine();
System.out.print("Especialidad: ");
String especi = teclado.nextLine();
//Creamos Cliente
Cliente nuevoCliente = new Cliente(dni, nombre, especi);
//Buscamos posicion libre en el array
int huecoLibre = -1;
for (int i = 0; i < clientes.length && huecoLibre == -1; i++) {
if (clientes[i] == null) //Hemos encontrado hueco libre
huecoLibre = i; //Guardamos posicion libre, esto ademas pone fin al bucle
}
//Comprobamos si hemos encontrado hueco libre
if (huecoLibre == -1)
System.out.println("No hay espacio disponible para guardar el nuevo Cliente.");
else {
clientes[huecoLibre] = nuevoCliente;
System.out.println("Nuevo Cliente se ha guardado en la posición: " + huecoLibre);
}
}

}

El operador módulo te da el resto final.
Por ejemplo, mira la división de esta imagen:




Si en el código hacemos un 243 % 5, el resultado que nos dará sera 3

Un ejemplo muy habitual en programación para practicar el operador módulo es un programa que reciba un número y diga si es par o impar.
La forma de saber si un número es par, es dividir entre 2 y comprobar si el resto es 0.
Es decir, si tenemos el número guardado en una variable llamada num, pues preguntaríamos esto:

if (num % 2 == 0)
    System.out.println("Es par");
else
    System.out.println("Es impar);
De este ejemplo, podemos deducir que también podemos usarlo para saber si un número es múltiplo de otro.
De nuevo, imagina que tenemos num1 y num2. Si al dividir num1 entre num2, el resto es cero, significa que num1 es múltiplo de num2.

Mayormente, el resto es útil en aplicaciones matemáticas como por ejemplo una técnica para dividir polinomios (Teorema del residuo/resto).


Pero hay también algún que otro uso curioso.

Por ejemplo en España, los DNI/NIF para identificar a cada ciudadano consta de una cadena con un número de 8 cifras y una letra.
Esa letra no es al azar, depende del resto de ese número al dividir entre 23.

En el curso de Java se propone resolver este ejercicio en Java.
Esta más pensado para aprender a  usar arrays, pero bueno, puedes intentarlo.

Deberías intentar hacerlo usando String y no int.

Tenemos la tendencia a que cuando trabajamos con números, pensamos que lo correcto es escoger un tipo de dato numérico como int.
Pero solo deberíamos hacerlo cuando necesitemos hacer operaciones aritméticas con esos números: sumar, restar, dividir, contar, acumular, potenciar,...

Para casos como números de teléfono, números DNI/cédula, códigos postales, placas de vehículos..., números de lotería..., etc...
Es mejor usar String.
Sobre todo si vamos a necesitar comparar los caracteres que componen ese número por separado, sustituirlos, añadirlos... y cosas así, va a resultar mucho más fácil con la clase String que no con int/Integer.


Si no quieres usar String, otra opción es usar un array de 4 int, aunque esto te obligaría a pedir los 4 números de apuesta por separado.

Trabajar directamente con un int te va a obligar a usar mucho código y romperte la cabeza.
Y además NUNCA vas a conseguir que por ejemplo 45 te lo transforme en 0045... porque son exactamente el mismo número y aritméticamente los 0 a la izquierda no tienen ningún valor.
Un int no guarda caracteres, guarda un valor aritmético.
Si quieres que un 45 tenga 4 caracteres complementando con ceros a la izquierda, tendrás que usa un String o un array.

Inténtalo, si necesitas más ayuda porque no conoces bien la clase String y sus numerosos métodos, dilo y te ayudamos en lo que sea.