Eliminar un elemento en un índice específico de una array en Java

Dada una array de longitud fija. La tarea es eliminar un elemento en un índice específico de la array.

Ejemplos: 

Input: arr[] = { 1, 2, 3, 4, 5 }, index = 2
Output: arr[] = { 1, 2, 4, 5 }

Input: arr[] = { 4, 5, 9, 8, 1 }, index = 3
Output: arr[] = { 4, 5, 9, 1 }

Una array es una estructura de datos que contiene un grupo de elementos. Por lo general, estos elementos son todos del mismo tipo de datos, como un número entero o una string. Las arrays se usan comúnmente en programas de computadora para organizar datos de modo que un conjunto relacionado de valores pueda ordenarse o buscarse rápidamente. Todos los elementos de la array se almacenan en ubicaciones de memoria contiguas. 

Enfoques

Existen numerosos enfoques para verificar si un elemento específico está presente en esta array o no en Java. Estos son – 

• Usando otra array
• Uso de flujos de Java 8
• Usando ArrayList
• Usando el método System.arraycopy()

1. Uso de otra array (enfoque ingenuo o básico)

El enfoque básico incluye encontrar el elemento en el índice especificado y luego eliminar ese elemento. El resto de los elementos se copian en una nueva array. Esto conduciría a una array de tamaño uno menos que la array original. A continuación se muestra la implementación del enfoque anterior: 

// Java program to remove an element
// from a specific index from an array
 
import java.util.Arrays;
 
class GFG {
 
    // Function to remove the element
    public static int[] removeTheElement(int[] arr, int index)
    {
 
        // If the array is empty
        // or the index is not in array range
        // return the original array
        if (arr == null || index < 0
            || index >= arr.length) {
 
            return arr;
        }
 
        // Create another array of size one less
        int[] anotherArray = new int[arr.length - 1];
 
        // Copy the elements except the index
        // from original array to the other array
        for (int i = 0, k = 0; i < arr.length; i++) {
 
            // if the index is
            // the removal element index
            if (i == index) {
                continue;
            }
 
            // if the index is not
            // the removal element index
            anotherArray[k++] = arr[i];
        }
 
        // return the resultant array
        return anotherArray;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        // Get the array
        int[] arr = { 1, 2, 3, 4, 5 };
 
        // Print the resultant array
        System.out.println("Original Array: "
                           + Arrays.toString(arr));
 
        // Get the specific index
        int index = 2;
 
        // Print the index
        System.out.println("Index to be removed: " + index);
 
        // Remove the element
        arr = removeTheElement(arr, index);
 
        // Print the resultant array
        System.out.println("Resultant Array: "
                           + Arrays.toString(arr));
    }
}

Original Array: [1, 2, 3, 4, 5]
Index to be removed: 2
Resultant Array: [1, 2, 4, 5]

2. Uso de flujos de Java 8

Acercarse: 

• Obtenga la array y el índice.
• Convierta la array en IntStream usando el método IntStream.range().
• Elimina el elemento de índice especificado utilizando el método filter().
• Mapee y forme una nueva array de los elementos filtrados utilizando los métodos map() y toArray().
• Devuelve la array formada.

A continuación se muestra la implementación del enfoque anterior.

// Java program to remove an element
// from a specific index from an array
 
import java.util.Arrays;
import java.util.stream.IntStream;
 
class GFG {
 
    // Function to remove the element
    public static int[] removeTheElement(int[] arr, int index)
    {
 
        // If the array is empty
        // or the index is not in array range
        // return the original array
        if (arr == null
            || index < 0
            || index >= arr.length) {
 
            return arr;
        }
 
        // return the resultant array
        return IntStream.range(0, arr.length)
            .filter(i -> i != index)
            .map(i -> arr[i])
            .toArray();
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        // Get the array
        int[] arr = { 1, 2, 3, 4, 5 };
 
        // Print the resultant array
        System.out.println("Original Array: "
                        + Arrays.toString(arr));
 
        // Get the specific index
        int index = 2;
 
        // Print the index
        System.out.println("Index to be removed: "
                        + index);
 
        // Remove the element
        arr = removeTheElement(arr, index);
 
        // Print the resultant array
        System.out.println("Resultant Array: "
                        + Arrays.toString(arr));
    }
}

Original Array: [1, 2, 3, 4, 5]
Index to be removed: 2
Resultant Array: [1, 2, 4, 5]

3. Usando ArrayList

Acercarse: 

• Obtenga la array y el índice.
• Forme una ArrayList con los elementos de la array.
• Elimina el elemento de índice especificado usando el método remove().
• Forme una nueva array de ArrayList utilizando los métodos mapToInt() y toArray().
• Devuelve la array formada.

A continuación se muestra la implementación del enfoque anterior.

// Java program to remove an element
// from a specific index from an array
 
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
 
class GFG {
 
    // Function to remove the element
    public static int[] removeTheElement(int[] arr, int index)
    {
 
        // If the array is empty
        // or the index is not in array range
        // return the original array
        if (arr == null
            || index < 0
            || index >= arr.length) {
 
            return arr;
        }
 
        // Create ArrayList from the array
        List<Integer> arrayList = IntStream.of(arr)
                                    .boxed()
                                    .collect(Collectors.toList());
 
        // Remove the specified element
        arrayList.remove(index);
 
        // return the resultant array
        return arrayList.stream()
            .mapToInt(Integer::intValue)
            .toArray();
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        // Get the array
        int[] arr = { 1, 2, 3, 4, 5 };
 
        // Print the resultant array
        System.out.println("Original Array: "
                        + Arrays.toString(arr));
 
        // Get the specific index
        int index = 2;
 
        // Print the index
        System.out.println("Index to be removed: "
                        + index);
 
        // Remove the element
        arr = removeTheElement(arr, index);
 
        // Print the resultant array
        System.out.println("Resultant Array: "
                        + Arrays.toString(arr));
    }
}

Original Array: [1, 2, 3, 4, 5]
Index to be removed: 2
Resultant Array: [1, 2, 4, 5]

4. Usando el método System.arraycopy()

Acercarse:

• Obtenga la array y el índice.
• Cree una nueva array de tamaño uno menos que el tamaño de la array original.
• Copie los elementos desde el inicio hasta el índice de la array original a la otra array usando System.arraycopy().
• Copie los elementos desde el índice + 1 hasta el final de la array original a la otra array usando System.arraycopy().
• Devuelve la array formada.

A continuación se muestra la implementación del enfoque anterior.

// Java program to remove an element
// from a specific index from an array
 
import java.util.Arrays;
 
class GFG {
 
    // Function to remove the element
    public static int[] removeTheElement(int[] arr, int index)
    {
 
        // If the array is empty
        // or the index is not in array range
        // return the original array
        if (arr == null
            || index < 0
            || index >= arr.length) {
 
            return arr;
        }
 
        // Create another array of size one less
        int[] anotherArray = new int[arr.length - 1];
 
        // Copy the elements from starting till index
        // from original array to the other array
        System.arraycopy(arr, 0, anotherArray, 0, index);
 
        // Copy the elements from index + 1 till end
        // from original array to the other array
        System.arraycopy(arr, index + 1,
                        anotherArray, index,
                        arr.length - index - 1);
 
        // return the resultant array
        return anotherArray;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        // Get the array
        int[] arr = { 1, 2, 3, 4, 5 };
 
        // Print the resultant array
        System.out.println("Original Array: "
                        + Arrays.toString(arr));
 
        // Get the specific index
        int index = 2;
 
        // Print the index
        System.out.println("Index to be removed: "
                        + index);
 
        // Remove the element
        arr = removeTheElement(arr, index);
 
        // Print the resultant array
        System.out.println("Resultant Array: "
                        + Arrays.toString(arr));
    }
}

Original Array: [1, 2, 3, 4, 5]
Index to be removed: 2
Resultant Array: [1, 2, 4, 5]