вопрос в списке java удалить

Нет, это не то, что он делает. Элемент удаляется, а все индексы, следующие за ним, уменьшаются на единицу. Что заставляет вас думать, что он действует по-другому?

Согласно Java API здесь говорится, что функция удаления списка ДЕЙСТВИТЕЛЬНО сдвигает

Удаляет элемент в указанной позиции в этом списке (дополнительная операция). Сдвигает любые последующие элементы влево (вычитает единицу из их индексов). Возвращает элемент, который был удален из списка.

РЕДАКТИРОВАТЬ:

Основной класс:

import java.util.ArrayList;
import java.util.Iterator;


public class Main {


    public static void main(String[] args) {


        ArrayList<A> x = new ArrayList<A>();
        A one = new A("one");
        A two = new A("two");
        A three = new A("three");
        A four = new A("four");
        A five = new A("five");
        A six = new A("six");
        A seven = new A("seven");
        A eight = new A("eight");
        A nine = new A("nine");
        A ten = new A("ten");

        x.add(one);
        x.add(two);
        x.add(three);
        x.add(four);
        x.add(five);
        x.add(six);
        x.add(seven);
        x.add(eight);
        x.add(nine);
        x.add(ten);

        for(A item:x){
            System.out.println(item.getStr());
        }

        x.remove(four);

        Iterator<A> i = x.iterator();
        while(i.hasNext()){
            A item = i.next();
            System.out.println(item.getStr());
        }
    }
}

Класс А:

public class A {
    private String str;

    public A(String x){
        this.str = x;
    }

    public String getStr(){
        return this.str;
    }

}

работает отлично! нет исключения нулевого указателя. Вот как это должно быть сделано. первый цикл For — это альтернативный синтаксис того, что я сделал с объектом Iterator. На самом деле Java автоматически переводит первый цикл for во что-то похожее на цикл while.

Если вы посмотрите на Реализация удаления ArrayList, он использует локальный метод fastRemove(index) следующим образом:

/* * Частный метод удаления, который пропускает проверку границ и * не возвращает удаленное значение. */

private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // Let gc do its work
}

Он использует arraycopy, что является доказательством того, что вы получаете целый новый список свежих объектов, а не нуль, заполненный между ними. Это доказательство?

Контракт для java.util.List подразумевает, что вызов remove приведет к уменьшению size(). Если вы говорите конкретно о java.util.ArrayList, то вы можете быть правы в том, что внутренний массив не сдвигает свои элементы, но это деталь реализации, которая не должна иметь для вас значения в 99% всех случаев. Если это все еще имеет значение, то вы пытаетесь оптимизировать для конкретной ситуации и вам, вероятно, следует реализовать свой собственный List или использовать что-то вроде java.util.LinkedList.

Либо ваше наблюдение неверно, либо вы используете какую-то другую реализацию List (а не ArrayList), которая не сдвигает элементы справа от удаляемого элемента. Можете ли вы опубликовать свой код?

Если вы посмотрите на исходный код java.util.ArrayList в JDK8, вы увидите, что метод remove(Object o) эффективно копирует элементы справа от удаляемого элемента в тот же массив, начиная с индекса элемента удаляются. Посмотрите на ArrayList исходный код для получения дополнительной информации:

Если вам нужен только массив данных, просто вызовите toArray().