Modificar Tamaño Arreglo en Java

Encuentra en el sitio

Algunas veces nos encontraremos con una interrogante: ¿Debemos Modificar el Tamaño de un Arreglo en Java?, siendo afirmativa la respuesta nos encontramos con una nueva interrogante: ¿Como lo hacemos?. A esta ultima nos hace dudar de la modificacion del tamaño de un arreglo por la definicion de este, recordando que un arreglo es una variable especial que tiene un tamaño fijo, si tiene un tamaño fijo, como es posible modificar su tamaño?
 

Realizando un trabajo de la Universidad me encontre con este dilema y la solucion a este, mas que un “atajo” es la agrupacion de los conceptos vistos en los anteriores post’s, ademas de algo de ingenio y algo de tiempo antes de encontrar la solucion 🙂 Lo primero que debemos de realizar (sin duda alguna) es el algoritmo, lo expresamos mediante Pseudocodigo para tener idea de lo que deseamos y los pasos de como lo vamos a realizar, un ejemplo de esto se muestra en la siguiente imagen:

Pseudocodigo para el desarrollo del problema


 
Una vez realizado esto empezamos a escribir código, en el camino veremos dos posibles casos al momento de ingresar los elementos al arreglo creado para xi, esto es cuando el arreglo esta vacío, y cuando este ya tiene elementos. Ahora el código en el cual va el enunciado del problema y el código debidamente comentareado para que lo estudien y analicen 😉

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
import javax.swing.JOptionPane;
 
/**
 * 
 * la alcaldia de irak desea saber cuantas personas habitan en las viviendas del barrio Campo Santo. Se encuesta y se obtiene los
 * siguientes datos preliminares: 3 1 4 2 1     4 2 2 3 2
 * media aritmetica = ((1*2) + (2*4) + (3*2) + (4*2)) / 10
 * media aritmetica = 2.4
 * 
 */
public class ModEsta {
 
    int personas[], com[];
    int k=0;    
 
    public static void main(String[] args) {
 
       ModEsta x = new ModEsta();
 
       x.menu();
       System.exit(0);
    }
 
    void menu(){
        int op=0;
 
        do{
           op = Integer.parseInt(JOptionPane.showInputDialog("1. Modelo estadistico. n"
 
                                                           + "2. Salir"));
           switch(op){
               case 1:{
                   modEsta();
                   break;
               }              
               case 2:{
                   JOptionPane.showMessageDialog(null, "Ha decidido salir :)");
               }
 
           }
 
        }while(op!=2);
    }
 
    void modEsta(){
        int c, cont=0;
        float trin=0, resul;         
        c= Integer.parseInt(JOptionPane.showInputDialog(null, "Cuantos datos desea ingresar: "));
        personas= new int[c];         
 
        for(int i=0; i<c; i++){
            personas[i]=Integer.parseInt(JOptionPane.showInputDialog(null, "Cuantas personas viven en el hogar "+(i+1)));            
        }
 
        for(int i=0; i<c; i++){//primer ciclo            
 
            if(com==null){ //iniciando la comparacion
                arreDin(personas[i]);//agregando el valor inicial al arreglo de comparacion
                for(int j=0; j<c; j++){//el primer ciclo para comparar valores
                    if(personas[i]==personas[j]){
                        cont++;
                    }
                }
                trin+=personas[i]*cont;
                cont=0;//se inicializa el contador
            }
            else{ //cuando ya se ha iniciado la comparacion
                if(!verArre(personas[i])){ //si el valor NO ESTA en el arreglo de comparacion se continua con la operacion
                    arreDin(personas[i]); //se agrega el nuevo valor al arreglo de comparacion
 
                    for(int j=0; j<c; j++){//ciclo para saber cuantas veces se repite el valor
                        if(personas[i]==personas[j]){
                            cont++;
                        }
                    }
                    trin+=personas[i]*cont;
                    cont=0;
                }
            }
        }//final ciclo principal
 
        resul =(trin/c); //operacion de la media
        JOptionPane.showMessageDialog(null,"La media de los resultados ingresados es: "+resul);//mostrando resultado.             
    }
 
    public void arreDin(int e){ //metodo para ingresar numeros a cierto arreglo para comparar si los valores se repiten        
        int tem[]; //arreglo temporal
 
        if(com==null){//cuando el arreglo a comparar esta vacio            
            com = new int[1];
            for(int i=0; i<com.length; i++)
            com[i]=e;            
        }
        else{//cuando el arreglo no esta vacio
            tem = new int[com.length];
            for(int i=0; i<com.length; i++){
                tem[i]=com[i];
            }
            com=null;//eliminacion de todos los datos del arreglo de comparacion
            com = new int[tem.length+1];//creando el nuevo arreglo con un campo adicional
 
            for(int i=0; i<com.length; i++){
                if(i<tem.length){//reacomodando datos desde el arreglo temporal al arreglo de comparacion
                    com[i]=tem[i];
                }
                else
                    com[i]=e;//agregando el nuevo dato en el espacio que no habia
            }            
        }
        tem=null;
    }
 
    public boolean verArre(int e){//metodo para saber si un valor del arreglo original ya esta en el arreglo a comparar
        int c=0;
 
        for(int i=0; i<com.length; i++){
            if(com[i]==e)
                c++;
        }
        if(c!=0)
            return true;//si existen valores iguales
        else 
            return false;
    }    
 
}

 
En la linea 13 vemos la declaración de dos arreglos, uno es para almacenar los valores, el otro va a ser el que almacene los datos de xi, a este ultimo lo llame com. En las lineas del 86 al 111 creé un metodo para ingresar los elementos al arreglo com, en las lineas 113 a la 124 creé un método para verificar que un elemento ya existe en un arreglo que también esta en otro o.0 No es necesario crear una tabla para fi ya que estos numeros los tenemos en cuenta con un contador, la operación del numerador la realice con una variable que acumula el proceso matemático, esta variable la llame trin 🙂 El resto de lineas es solo logica y tener buenas bases conceptuales.

 
En conclusión, lo que se ha hecho es usar un arreglo temporal el cual almacena los valores del arreglo original, luego se elimina las propiedades (tamaño) del arreglo original y luego se vuelve a crear con un nuevo tamaño, agregando los valores que tenia y el nuevo valor. Si pensamos en almacenar grandes cantidades de datos esta operación resulta tediosa por el procedimiento, pero para esto podemos usar los hilos, claro que este tema va mucho mas adelante 😉 Espero que este post haya sido de gran utilidad, cualquier duda, apunte, o agradecimiento lo pueden dejar en un comentario o compartiendo el post 🙂

Si te ha gustado el post, compártelo, regala un like ó comenta 😉

  1. Avatar for belial9826 hackshirama dice:

    Increible algoritmo.

  2. Avatar for belial9826 Rey Josías Hernandez Hernández dice:

    Gracias me sirvió de mucho tu lógica del final :).

Deja un comentario