Как я удаляю объекты из массива в Java?
Как будто вы пытаетесь получить доступ к объекту, который является null. Рассмотрим ниже пример:
TypeA objA;
. В это время вы только что объявили этот объект, но не инициализировали или не инициализировали. И всякий раз, когда вы пытаетесь получить доступ к каким-либо свойствам или методам в нем, он будет генерировать NullPointerException, что имеет смысл.
См. Также этот пример:
String a = null;
System.out.println(a.toString()); // NullPointerException will be thrown
8 ответов
[Если Вы хотите некоторый готовый к использованию код, прокрутите к моему "Edit3" (после сокращения). Остальное здесь для потомства.]
Для изложения в деталях идея Мусорщика :
List<String> list = new ArrayList<String>(Arrays.asList(array));
list.removeAll(Arrays.asList("a"));
array = list.toArray(array);
Редактирование: я теперь использую Arrays.asList вместо Collections.singleton: одиночный элемент ограничен одной записью, тогда как эти asList подход позволяет Вам добавлять другие строки для отфильтровывания позже: Arrays.asList("a", "b", "c").
Edit2: вышеупомянутый подход сохраняет тот же массив (таким образом, массив является все еще той же длиной); элемент после последнего устанавливается в NULL. Если Вы хотите новый , массив, измеренный точно как требуется, использует это вместо этого:
array = list.toArray(new String[0]);
Edit3: при использовании этого кода на частой основе в том же классе можно хотеть рассмотреть добавление этого к классу:
private static final String[] EMPTY_STRING_ARRAY = new String[0];
Тогда функция становится:
List<String> list = new ArrayList<>();
Collections.addAll(list, array);
list.removeAll(Arrays.asList("a"));
array = list.toArray(EMPTY_STRING_ARRAY);
Это тогда прекратит замусорить Вашу "кучу" бесполезными массивами пустой строки, которые иначе были бы new редактор каждый раз, когда Ваша функция вызвана.
предложение cynicalman (см. комментарии) также поможет с замусориванием "кучи", и для справедливости я должен упомянуть его:
array = list.toArray(new String[list.size()]);
я предпочитаю свой подход, потому что может быть легче понять явный размер превратно (например, звоня size() в неправильном списке).
Присвойте пустой указатель местоположениям массива.
Arrgh, я не могу заставить код обнаруживаться правильно. Извините, я получил его работа. Извините снова, я не думаю, что считал вопрос правильно.
String foo[] = {"a","cc","a","dd"},
remove = "a";
boolean gaps[] = new boolean[foo.length];
int newlength = 0;
for (int c = 0; c<foo.length; c++)
{
if (foo[c].equals(remove))
{
gaps[c] = true;
newlength++;
}
else
gaps[c] = false;
System.out.println(foo[c]);
}
String newString[] = new String[newlength];
System.out.println("");
for (int c1=0, c2=0; c1<foo.length; c1++)
{
if (!gaps[c1])
{
newString[c2] = foo[c1];
System.out.println(newString[c2]);
c2++;
}
}
Это зависит от того, под чем Вы подразумеваете, "удаляют"? Массив является конструкцией фиксированного размера - Вы не можете изменить число элементов в нем. Таким образом, можно или новое a) создайте новое, короче, выстройте без элементов, которые Вы не хотите или b) присвойте записи, которые Вы не хотите к чему-то, что указывает на их 'пустое' состояние; обычно пустой указатель, если Вы не работаете с примитивами.
В первом случае создают Список из массива, удаляют элементы и создают новый массив из списка. Если производительность важна, выполняют итерации по массиву, присваивающему любые элементы, которые не должны быть удалены к списку, и затем создавать новый массив из списка. Во втором случае просто проходят и присваивают пустой указатель записям массива.
РЕДАКТИРОВАНИЕ:
точка с пустыми указателями в массиве была очищена. Извините за мои комментарии.
Исходный:
Ehm... строка
array = list.toArray(array);
замены все разрывы в массиве, где удаленный элемент был с [1 115] пустой указатель . Это могло бы быть опасно , потому что элементы удалены, но длина массива остается тем же!
, Если Вы хотите избежать этого, используйте новый Массив в качестве параметра для toArray (). Если бы Вы не хотите использовать removeAll, Набор был бы альтернативой:
String[] array = new String[] { "a", "bc" ,"dc" ,"a", "ef" };
System.out.println(Arrays.toString(array));
Set<String> asSet = new HashSet<String>(Arrays.asList(array));
asSet.remove("a");
array = asSet.toArray(new String[] {});
System.out.println(Arrays.toString(array));
Дает:
[a, bc, dc, a, ef]
[dc, ef, bc]
, Где как текущий принятый ответ от выводов Chris Yester Young:
[a, bc, dc, a, ef]
[bc, dc, ef, null, ef]
с кодом
String[] array = new String[] { "a", "bc" ,"dc" ,"a", "ef" };
System.out.println(Arrays.toString(array));
List<String> list = new ArrayList<String>(Arrays.asList(array));
list.removeAll(Arrays.asList("a"));
array = list.toArray(array);
System.out.println(Arrays.toString(array));
без любых нулевых значений оставлен позади.
Что-то о вхождении в список его тогда удаляет затем обратно к массиву, кажется мне неправильно. Не протестировали, но я думаю, что следующее будет работать лучше. Да я, вероятно, незаконно предварительно оптимизирую.
boolean [] deleteItem = new boolean[arr.length];
int size=0;
for(int i=0;i<arr.length;i==){
if(arr[i].equals("a")){
deleteItem[i]=true;
}
else{
deleteItem[i]=false;
size++;
}
}
String[] newArr=new String[size];
int index=0;
for(int i=0;i<arr.length;i++){
if(!deleteItem[i]){
newArr[index++]=arr[i];
}
}
Можно всегда делать:
int i, j;
for (i = j = 0; j < foo.length; ++j)
if (!"a".equals(foo[j])) foo[i++] = foo[j];
foo = Arrays.copyOf(foo, i);
Сделайте List из массива с Arrays.asList(), и вызов remove() на всех соответствующих элементах. Тогда звоните toArray() в 'Списке' для превращения назад в массив снова.
Не ужасно производительный, но если Вы инкапсулируете его правильно, можно всегда делать что-то более быстрое позже.