Java数组排序（我做错了什么）

编辑3：这是问题的原因：

对于removeArrayElement（第一个版本），它返回toArray（新项[0]），它在末尾执行null元素，但是使用新方法，它返回toArray（arr），它不执行null，但是您可以；t创建t的泛型类型数组，即新的t[0]，那么什么是替换？而不是“再次传递数组”以消除末尾的null元素

老问题：

我最近更新了我是如何通过创建一个主方法（通过实现泛型类型）来处理数组排序的。只有余波方法给了我数组越界错误

有什么我错过的吗

旧方法：

private static Item[] insertTabItem(Item[] a, int pos, Item item) {
    Item[] result = new Item[a.length + 1];
    for(int i = 0; i < pos; i++)
        result[i] = a[i];
    result[pos] = item;
    for(int i = pos + 1; i < a.length + 1; i++)
        result[i] = a[i - 1];
    return result;
}

private static Item[] removeArrayItem(Item[] arr, Item item) {
   List<Item> list = new ArrayList<Item>(Arrays.asList(arr));
      for (int i = 0; i < list.size(); i++) {
          if (list.get(i) == item) {
              list.remove(i);
          }
      }
     return list.toArray(new Item[0]);
}

当newBankVarient=bankContents[bankSlots[0]][1]并将其删除时，系统将在is之后脱离阵列：

"[var, var, var, null]

---

如果不运行代码，则可能是

removeArrayElement

导致了异常

使用

列表是不好的做法。从迭代相同循环的
for
循环中删除（i）

或者，您需要

中断直接在<代码>删除（i）< /代码>调用之后，或者您可以考虑使用迭代器代替，这是“在迭代时安全删除”。
例如：

最后，如果
T
具有可比性，那么您应该能够通过
列表从列表中删除。删除（项）
-如果不需要，您不需要乱动索引。
正如@vikingsteve所提到的，不要在循环中使用删除方法，因为您最有可能跳到可能的索引之前

但是，您可以保持循环并从后面而不是从前面开始循环

这样做可以：

public static <T> T[] removeArrayElement(T[] arr, T item) {
   List<T> list = new ArrayList<T>(Arrays.asList(arr));
      for (int i = list.size()-1; i >= 0; i--) {
          if (list.get(i) == item) {
              list.remove(i);
          }
      }
     return list.toArray(arr);
}

publicstatict[]removeArrayElement（T[]arr，T项）{
List List=newarraylist（Arrays.asList（arr））；
对于（int i=list.size（）-1；i>=0；i--）{
if（list.get（i）=项）{
列表。删除（i）；
}
}
返回列表。toArray（arr）；
}
在循环中删除是问题所在。删除项时，或使用基于迭代器的循环并调用迭代器。删除对于编辑3，这是javadoc中描述的正确行为

如果列表适合指定的阵列，且有空闲空间（即阵列
数组中的元素比列表中的元素多），数组中的元素立即
列表末尾的后面设置为null。（这有助于确定
仅当调用方知道列表不存在时，列表的长度
包含任何空元素。）

使用数组的空副本保留类型

private static Item[] removeArrayItem(Item[] arr, Item item) {
    Item[] emptyArray = Arrays.copyOf(arr, 0);
    List<Item> list = new ArrayList<Item>(Arrays.asList(arr));
    for (Iterator<Item> iter = list.iterator(); iter.hasNext();) {
      Item current = iter.next();
      if (item.equals(current)) {
        iter.remove();
        break;
      }
    }
    return list.toArray(emptyArray);
}

私有静态项[]removeArrayItem（项[]arr，项项）{
Item[]emptyArray=Arrays.copyOf（arr，0）；
List List=newarraylist（Arrays.asList（arr））；
for（迭代器iter=list.Iterator（）；iter.hasNext（）；）{
项目当前=iter.next（）；
如果（项目等于（当前））{
iter.remove（）；
打破
}
}
返回列表。toArray（空数组）；
}

顺便说一句，ref上的相等性测试是一种糟糕的做法，如果可以，请选择相等。
如果您的项目具有可比性，您也可以使用Arrays.binarySearch获取要删除的项目的索引，避免使用迭代器而直接使用列表上的删除（index）。
不要使用
list。删除（i）
在for循环中。旧方法中也使用了该方法，但由于某些原因，新方法会出错，这是为什么，顺便说一句，它删除了循环的主题“i”，而不是再次删除相同的元素，并再次详细说明@vikingsteve在说什么；您可以使用另一个整数列表来存储
i
的值，其中
list.get（i）=item
为true，然后在新列表上迭代并删除列表中的所有
i
，请显示完整的堆栈跟踪以及测试代码。该方法仍然会给java.lang.ArrayIndexOutofBoundsException我一秒钟，我将使用Debugger检查此特定方法是否出于某种原因没有删除元素，而是使元素=null，这将导致数组超出边界，因为同时，我在外部减少编辑主数组大小的变量。您可以向我提供传递到方法中的参数，如果可能的话，完整的代码请该方法正确地对数组排序，但不-1大小，因此最后一个元素为=null，导致数组超出边界
"[var, var, var, null]

public static <T> T[] removeArrayElement(T[] arr, T item) {
   List<T> list = new ArrayList<T>(Arrays.asList(arr));
      for (int i = list.size()-1; i >= 0; i--) {
          if (list.get(i) == item) {
              list.remove(i);
          }
      }
     return list.toArray(arr);
}

private static Item[] removeArrayItem(Item[] arr, Item item) {
    Item[] emptyArray = Arrays.copyOf(arr, 0);
    List<Item> list = new ArrayList<Item>(Arrays.asList(arr));
    for (Iterator<Item> iter = list.iterator(); iter.hasNext();) {
      Item current = iter.next();
      if (item.equals(current)) {
        iter.remove();
        break;
      }
    }
    return list.toArray(emptyArray);
}