删除java对象数组中的元素

我正在编写一个程序，在删除对象数组时遇到问题，这是一个逻辑错误，不是编译器请查看函数：

public void deleteMovie(movies []a,String mID,int n) {
    int i;
    boolean check=true;
    for (i=0;i<n;i++) {
        if (a[i].MovieID.equals(mID)) {

            while (i<n-1) {
                a[i]=a[i+1];
                i++;
            }
            n--;
        } else check = false;
    }

    if(check == false)
        System.out.println("unfound Element ");
}

public void deleteMovie（movies[]a，String-mID，int-n）{
int i；
布尔检查=真；
对于（i=0；i因为每个人都已经告诉过你Java集合

，所以我保持它的简单性，并保留数组，以防你可能不喜欢ArrayList

public movies[] deleteMovie(movies[] a, String mID) {
    boolean check = false;
    int j = 0;
    movies[] b = new String[a.length - 1];
    for (int i = 0; i < a.length; i++) {
        if(!a[i].MovieID.equals(mID)) {
            b[j] = a[i];
            j++;
        } else check = true;
    }

    if(check) {
        System.out.println("found Element ");
    }

    return b;
}

公共电影[]删除电影（电影[]a，字符串mID）{
布尔检查=假；
int j=0；
movies[]b=新字符串[a.length-1]；
for（int i=0；i

因为每个人都告诉过你Java集合的事，所以我保持了它的简单性，并保留了数组，以防你可能不喜欢ArrayList

public movies[] deleteMovie(movies[] a, String mID) {
    boolean check = false;
    int j = 0;
    movies[] b = new String[a.length - 1];
    for (int i = 0; i < a.length; i++) {
        if(!a[i].MovieID.equals(mID)) {
            b[j] = a[i];
            j++;
        } else check = true;
    }

    if(check) {
        System.out.println("found Element ");
    }

    return b;
}

公共电影[]删除电影（电影[]a，字符串mID）{
布尔检查=假；
int j=0；
movies[]b=新字符串[a.length-1]；
for（int i=0；i

array

在您计划删除项目时不是数据结构，因为要执行此操作，您必须创建另一个数组

并复制所有其他项目。请检查此项：

static class Movie {

    private final String id;

    public Movie(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }

}

public static Movie[] deleteMovieById(Movie[] movies, String id) {
    int pos = findMovieById(movies, id);

    if (pos == -1)
        return movies;  // not found; retrieve source array

    Movie[] arr = new Movie[movies.length - 1];
    System.arraycopy(movies, 0, arr, 0, pos);
    System.arraycopy(movies, pos + 1, arr, pos, arr.length - pos);
    return arr;
}

private static int findMovieById(Movie[] movies, String id) {
    for (int i = 0; i < movies.length; i++)
        if (movies[i].getId().equals(id))
            return i;

    return -1;
}


使用
恒定时间
元素保持和删除的正确数据结构为
映射
：

public static void deleteMovieById(Map<String, Movie> movies, String id) {
    movies.remove(id);
}

公共静态void deleteMovieById（映射电影，字符串id）{
电影。删除（id）；
}

输出：

Movie[] movies = {
        new Movie("1"),
        new Movie("2"),
        new Movie("3") };
Movie[] res = deleteMovieById(movies, "1");

Map<String, Movie> movies = Map.of(
        "1", new Movie("1"),
        "2", new Movie("2"),
        "3", new Movie("3"));

deleteMovieById(movies, "1");

Map movies=Map.of(
“1”，新电影（“1”），
“2”，新电影（“2”），
“3”，新电影（“3”）；
deleteMovieById（电影，“1”）；

你能看到区别吗？
当你计划删除一个项目时，数组

不是数据结构，因为要这样做，你必须创建另一个数组并复制所有其他项目。检查此项：

static class Movie {

    private final String id;

    public Movie(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }

}

public static Movie[] deleteMovieById(Movie[] movies, String id) {
    int pos = findMovieById(movies, id);

    if (pos == -1)
        return movies;  // not found; retrieve source array

    Movie[] arr = new Movie[movies.length - 1];
    System.arraycopy(movies, 0, arr, 0, pos);
    System.arraycopy(movies, pos + 1, arr, pos, arr.length - pos);
    return arr;
}

private static int findMovieById(Movie[] movies, String id) {
    for (int i = 0; i < movies.length; i++)
        if (movies[i].getId().equals(id))
            return i;

    return -1;
}

---

使用

恒定时间

元素保持和删除的正确数据结构为

映射

：

public static void deleteMovieById(Map<String, Movie> movies, String id) {
    movies.remove(id);
}

公共静态void deleteMovieById（映射电影，字符串id）{
电影。删除（id）；
}

输出：

Movie[] movies = {
        new Movie("1"),
        new Movie("2"),
        new Movie("3") };
Movie[] res = deleteMovieById(movies, "1");

Map<String, Movie> movies = Map.of(
        "1", new Movie("1"),
        "2", new Movie("2"),
        "3", new Movie("3"));

deleteMovieById(movies, "1");

Map movies=Map.of(
“1”，新电影（“1”），
“2”，新电影（“2”），
“3”，新电影（“3”）；
deleteMovieById（电影，“1”）；

---

你能看到区别吗？！

你能用电影类的代码更新你的问题吗？我建议对这类东西使用可变集合，比如

ArrayList

。这样，你就不必处理从数组中删除的麻烦了，因为在使用这些集合时，这个功能是免费提供给你的。改变本地人（如建议）可以找到。至于你的情况，当你说n不递减时，你可能还有另一个问题。你能用电影类的代码更新你的问题吗？我建议对这类东西使用可变集合，比如

ArrayList

。这样，你就不必处理从数组中删除的麻烦了，就像这样在使用这些集合时，功能是免费提供给您的。可以找到备选方案（如建议的）。至于您的情况，当您说n不递减时，您可能还有另一个问题。

movies[]b=新字符串[a.length-1]；

：-）

movies[]b=新字符串[a.length-1]；

：-）