谁能告诉我如何在java中同时删除两个元素？

Question

例如：

int[] nums = {11,12,13,14,15,16};
int[] position = {1,2};

所以，在这里我想删除多个元素，例如，我想同时删除索引 1 和 2：当我调用 delete 方法时。

public int[] delete(int[] source, int[] position) {
    // How do I implement this?
}

//Main Class
public static void main(String[] args){

    int[] newArray = delete(nums, position);

}

那么，我该如何解决这个问题？？？？？？我已经尝试了很多次，但我无法映射位置和数组值。所以，删除两个值真的很难。

Answer 1

也许使用 ArrayList 并将数组转换为 Integer 而不是原始 int 会更容易。

---

1. 这里的第一个问题是在position[] 函数的delete 参数中：你可以得到一个IndexOutOfBoundsException，因为任何调用这个函数的人都可以传递一个数组num[] 中不能有的位置列表

例如：

num[] 数组的大小为 4，有人传递了一个位置{1,6}，在这种情况下，第 6 个索引在 num[] 中不存在）

---

1. 第二个问题是确保删除正确的索引。

例如，如果 num{34, 53, 33, 64} 和 position{0, 1} 代表要删除的索引，您会希望删除数字 34 和 53，但因为 0 索引被删除, 53 成为 0 索引，而不是像以前那样的索引 1。

所以这里的解决方法是反转排序位置，所以它可以防止这个问题。

---

这里是一个示例代码，只是为了说明删除功能：

Integer num[]... //Using Integer instead of int will be use to remove items using ArrayList

public void delete(Integer[] position){   //position[] being Integer instead of int will be easier to rever sorting
    //
    //Reversing order of position[] to prevent problem 2
    Arrays.sort(position, Collections.reverseOrder());
    //
    ArrayList<Integer> objArrayListMyNumbers = Array.asList(num);
    //
    // Iterate through every element of position
    for(Integer i : position){
        //
        //It's better surround by try and catch, because of the problem 1 (IndexOutOfBoundsException)
        try{
            objArrayListMyNumbers.remove(i);
        }
        catch(IndexOutOfBoundsException e){
            e.printStack();
        }
    }
//
    //Gets a new Array with items removed
    num = new Integer(objArrayListMyNumbers.size());
    num = objArrayListMyNumbers.toArray(); 
}

Answer 2

您是否正在寻找这样的方法？ Java 数组无法调整大小，您必须创建一个新数组。

public static int[] delete(int[] source, int[] position) {
    Arrays.sort(position);
    int positionIdx = 0;
    int[] newArray = new int[source.length - position.length];
    for (int i = 0; i < source.length; i++) {
        if (positionIdx < position.length && i == position[positionIdx]) {
            positionIdx++;
        } else {
            newArray[i - positionIdx] = source[i];
        }
    }
    return newArray;
}

用法：

public static void main(String[] args) {
    int[] nums = {11, 12, 13, 14, 15, 16};
    int[] position = {1, 2};
    System.out.println(Arrays.toString(delete(nums, position)));
}

Answer 3

可能有一个基于过滤流的解决方案：

static int[] deleteAtPositions(int[] nums, int[] positions) {
    Set<Integer> idx = Arrays.stream(positions).boxed().collect(Collectors.toSet());

    return IntStream.range(0, nums.length)
                    .filter(i -> !idx.contains(i)) // no need to check for bounds
                    .map(i -> nums[i])
                    .toArray();
}

int[] nums = {11,12,13,14,15,16};
int[] positions = {1,2};

System.out.println(Arrays.toString(deleteAtPositions(nums, positions)));

输出：

[11, 14, 15, 16]