Métodos para Manipular Arrays en Java: Ejemplos Prácticos

En este documento, exploraremos diversos métodos para la manipulación de arrays en Java. Se incluyen ejemplos de código para ilustrar cada operación.

Creación de Arrays

Crear un array de enteros solicitando la longitud al usuario

public static int crear(int [] a) {
    int n,i;
    i = 0;
    System.out.println("Introduce cuantos elementos quieres ocupar: ");
    n = InputData.readInt();
    while (i <= n-1) {
        System.out.println("Introduce el elemento " + i);
        a[i] = InputData.readInt();
        i++;
    }
    return n;
}

Crear un array de enteros con una longitud predefinida

public static void crear (int [] a, int n) {
    int i = 0;
    while (i <= n-1) {
        System.out.println("Introduce el elemento " + i);
        a[i] = InputData.readInt();
        i++;
    }
}

Crear un array de Strings con una longitud predefinida

public static void crear (String [] a, int n) {
    int i = 0;
    while(i <= n-1) {
        System.out.println("Introduce el elemento " + i);
        a[i] = InputData.readString();
        i++;
    }
}

Crear un array de enteros de tamaño 25 y llenarlo con datos del usuario

public static int [] crear (int n) {
    int i = 0;
    int [] a = new int [25];
    while (i <= n-1) {
        System.out.println("Introduce el elemento " + i);
        a[i] = InputData.readInt();
        i++;
    }
    return a;
}

Visualización de Arrays

public static void visualizar (int [] a, int n) {
    int i = 0;
    while (i <= n-1) {
        System.out.println(a[i]);
        i++;
    }
}

Inserción de Elementos

Insertar un elemento al principio del array

public static int insertarPorElPrincipio (int [] a, int n, int dato) {
    int i = n-1;
    while (i >= 0) {
        a[i+1] = a[i];
        i--;
    }
    a[0] = dato;
    n++;
    return n;
}

Insertar un elemento en una posición específica del array

public static int insertarPorPosicion (int [] a, int n, int k, int dato)  {
    int i = n-1;
    while (i >= k) {
        a[i+1] = a[i];
        i--;
    }
    a[k] = dato;
    n++;
    return n;
}

Insertar un elemento al final del array

public static int insertarPorElFinal (int [] a, int n, int dato) {
    a[n] = dato;
    n++;
    return n;
}

Eliminación de Elementos

public static int eliminar (int [] a, int n, int k) {
    int i = k;
    while (i <= n-2) {
        a[i] = a[i+1];
        i++;
    }
    n--;
    return n;
}

Búsqueda de Elementos

Búsqueda secuencial en un array de enteros

public static int busquedaSecuencial (int [] a, int n, int dato) {
    int i = 0;
    int pos = -1;
    while (i <= n-1 && pos == -1) {
        if (dato == a[i]) {
            pos = i;
        }
        i++;
    }
    return pos;
}

Búsqueda secuencial en un array de Strings (usando equals)

public static int busquedaSecuencialString1(String [] a, int n, String dato) {
    int i = 0;
    int pos = -1;
    boolean resultado; 
    while (i <= n-1 && pos == -1) {
        resultado = dato.equals(a[i]);
        if (resultado == true) {
            pos = i; 
        }
        i++;
    }
    return pos;
}

Búsqueda secuencial en un array de Strings (usando compareTo)

public static int busquedaSecuencialString2(String [] a, int n, String dato) {
    int i = 0;
    int pos = -1;
    int res;
    while(i <= n-1 && pos == -1) {
        res = dato.compareTo(a[i]);
        if(res == 0) {
            pos = i;
        }
        i++;
    }
    return pos;
}

Búsqueda con centinela en un array de enteros

public static int busquedaCentinela(int [] a, int n, int dato) {
    int i = 0;
    int pos = -1;
    a[n] = dato;
    while (a[i] != dato) {
        i++;
    }
    if (i == n) {
        pos = -1;
    }else {
        pos = i;
    }
    return pos;
}

Búsqueda con centinela en un array de Strings

public static int busquedaCentinela(String [] a, int n, String dato) {
    int i = 0;
    int pos = -1;
    a[n] = dato;
    while(a[i] != dato) {
        i++;
    }
    if(i == n) {
        pos = -1;
    }else {
        pos = i;
    }
    return pos;
}

Búsqueda binaria en un array de enteros

public static int busquedaBinaria(int [] a, int n, int dato) {
    int p = 0;
    int f = n-1;
    int medio = (p+f)/2;
    int pos;
    while (p <= f && a[medio] != dato) {
        if (dato < a[medio]) {
            f = medio-1;
        }else {
            p = medio+1;
        }
        medio = (p+f)/2;
    }
    if (a[medio] == dato) {
        pos = medio;
    }else {
        pos = -1;
    }
    return pos;
}

Búsqueda binaria en un array de Strings

public static int busquedaBinaria(String [] a, int n, String dato) {
    int p = 0;
    int f = n-1;
    int medio = (p+f)/2;
    int pos;
    int resComparacion;
    while(p <= f && a[medio] != dato) {
        resComparacion = dato.compareTo(a[medio]);
        if(resComparacion < 0) {
            f = medio-1;
        }else {
            p = medio+1; 
        }
        medio = (p+f)/2;
    }
    if(a[medio] == dato) {
        pos = medio;
    }else {
        pos = -1;
    }
    return pos;
}

Ordenación de Arrays

Ordenación por selección directa en un array de enteros

public static void ordenacionSeleccionDirecta(int [] a, int n) {
    int posMenor;
    int aux;
    int j;
    int i = 0;
    while (i <= n-2) {
        posMenor = i;
        j = i+1;
        while (j <= n-1) {
            if (a[j] < a[posMenor]) {
                posMenor = j;
            }
            j++;
        }
        if (posMenor > i) {
            aux = a[i];
            a[i] = a[posMenor];
            a[posMenor] = aux;
        }
        i++;
    }
}

Ordenación por selección directa en un array de Strings

public static void ordenacionSeleccionDirecta(String [] a, int n) {
    int j = 0;
    int k, i;
    int resultadoComparacion;
    String aux;
    while(j <= n-1) {
        k = -1;
        i = 0;
        while(i <= n-1 && k == -1) {
            resultadoComparacion = a[j].compareTo(a[i]);
            if(resultadoComparacion < 0) {
                k = i;
            }
            i++;
        }
        if(k != -1) {
            aux = a[j];
            i = j;
            while(i >= k+1) {
                a[i] = a[i-1];
                i--;
            }
            a[k] = aux;
        }
        j++;
    }
}

Ordenación por inserción directa en un array de enteros (variante 1)

public static void ordenacionInserccionDirectaClase (int [] a, int n) {
    int i = 1;
    int posComp;
    int aux;
    while (i < n) {
        posComp = i;
        while (posComp > 0 && a[posComp-1] > a[posComp]) {
            aux = a[posComp];
            a[posComp] = a[posComp-1];
            a[posComp-1] = aux;
            posComp--;
        }
        i++;
    }
}

Ordenación por inserción directa en un array de enteros (variante 2)

public static void ordenacionInserccionDirecta(int [] a, int n) {
    int j = 1;
    int k, i, aux;
    while (j <= n-1) {
        k = -1;
        i = 0;
        while (i <= j && k == -1) {
            if (a[j] < a[i]) {
                k = i;
            }
            i++;
        }
        if (k != -1) {
            aux = a[j];
            i = j;
            while (i >= k+1) {
                a[i] = a[i-1];
                i--;
            }
            a[k] = aux;
        }
        j++;
    }
}

Ordenación por intercambio en un array de enteros

public static void ordenacionIntercambio(int [] a, int n) {
    int i, j, aux;
    i = 0;
    while(i <= n-2) {
        j = i+1;
        while(j <= n-1) {
            if(a[j] < a[i]) {
                aux = a[j];
                a[j] = a[i];
                a[i] = aux;
            }
            j++;
        }
        i++;
    }
}

Ordenación por intercambio en un array de Strings

public static void ordenacionIntercambio(String [] a, int n) {
    int i = 0;
    int j;
    String aux;
    int resultadoComparacion;
    while(i <= n-2) {
        j = i+1;
        while(j <= n-1) {
            resultadoComparacion = a[j].compareTo(a[i]);
            if(resultadoComparacion < 0) {
                aux = a[j];
                a[j] = a[i];
                a[i] = aux;
            }
            j++;
        }
        i++;
    }
}

Ordenación de burbuja en un array de Strings

public static void ordenacionBurbuja(String [] a, int n) {
    int i = 0;
    int j = 0;
    int k;
    int respuestaComparacion;
    String aux;
    for(k = 0 ; k <= n-2 ; k++) {
        for(i = 0; i <= n-k-2; i++){
            j = i+1;
            respuestaComparacion = a[j].compareTo(a[i]);
            if(respuestaComparacion < 0) {
                aux = a[i];
                a[i] = a[j];
                a[j] = aux;
            }
        }
    }
}

Conversión de Decimal a Binario en Complemento a 2

public static int [] decimalBinariaC2(int decimal, int n) {
    boolean neg = false;
    int bin [] = new int [n];
    if(decimal < 0) {
        neg = true;
        decimal = decimal - (decimal*2);
    }
    for(int i = n-1 ; decimal > 0 ; i--) {
        bin[i] = decimal%2;
        decimal = decimal/2;
    }
    if(neg == true) {
        for(int c = n-1 ; c > 0 ; c--) {
            if (bin[c] > 0) {
                bin[c] = 0;
            }else {
                bin[c] = 1;
            }
        }
        bin[n-1] += 1;
        for(int j = n-1 ; j > 0 ; j--) {
            if(bin[j] == 2) {
                bin[j] = 0;
                bin[j-1] += 1;
            }
        }
    }
    return bin;
}

Comparación de Arrays

public static boolean comparadorDeArrays(int [] a, int [] b, int n, int m) {
    int i = 0;
    int cont = 0;
    boolean resp = false;
    if(n == m) {
        while (i <= n-1) {
            if(a[i] == b[i]) {
                cont++;
            }
            i++;
        }
    }
    if(cont == n) {
        resp = true;
    }else {
        resp = false;
    }
    return resp;
}

Suma de Arrays

public static int[] suma(int [] a, int nA, int [] b, int nB) {
    int i = 0;
    int [] suma = new int [25];
    while(i < nA || i < nB) {
        suma[i] = a[i] + b[i];
        i++;
    }
    return suma;
}

Generación de la Serie de Fibonacci

public static void Fibonacci(int [] fibo, int n) {
    int i;
    fibo[0] = 0;
    fibo[1] = 1;
    i = 2;
    while(i <= n-1) {
        fibo[i] = fibo[i-2] + fibo[i-1];
        i++;
    }
}