blocks|key|363993|text|使用Arrays.asList()对数组进行List，并在所有适当的元素上调用remove()。然后调用“列表”上的toArray()，再次返回到一个数组中。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|363994|性能不是很好，但是如果你正确地封装它，你可以在以后做一些更快的事情。|363995|entityMap^0|2|F|M|4|13|8|1M|9|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|I|$]]

Make a <code>List</code> out of the array with <code>Arrays.asList()</code>, and call <code>remove()</code> on all the appropriate elements. Then call <code>toArray()</code> on the 'List' to make back into an array again.

Not terribly performant, but if you encapsulate it properly, you can always do something quicker later on.

blocks|key|3368810|text|将null赋值给数组位置。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3368811|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Assign null to the array locations.

blocks|key|364084|text|如果你想要一些现成的代码，请滚动到我的"Edit3“(在剪切之后)。剩下的将留给子孙后代。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|364085|充实Dustman's+idea|offset|length|364086|List<String>+list+=+new+ArrayList<String>(Arrays.asList(array));
list.removeAll(Arrays.asList("a"));
array+=+list.toArray(array);|code-block|syntax|javascript|364087|编辑:我现在使用Arrays.asList而不是Collections.singleton：singleton被限制为一个条目，而asList方法允许您添加其他字符串以便稍后过滤掉：Arrays.asList("a",+"b",+"c")。|style|CODE|364088|Edit2:上面的方法保留相同的数组(因此数组的长度仍然相同)；最后一个数组之后的元素被设置为null。如果您想要一个大小完全符合要求的新数组，请改用以下代码：|364089|array+=+list.toArray(new+String[0]);|364090|364091|Edit3:如果您经常在同一个类中使用此代码，您可能会考虑将此代码添加到您的类中：|364092|private+static+final+String[]+EMPTY_STRING_ARRAY+=+new+String[0];|364093|然后，该函数变为：|364094|List<String>+list+=+new+ArrayList<>();
Collections.addAll(list,+array);
list.removeAll(Arrays.asList("a"));
array+=+list.toArray(EMPTY_STRING_ARRAY);|364095|这样就不会在堆中堆满无用的空字符串数组，否则这些数组在每次调用函数时都会被new。|364096|cynicalman的建议(参见评论)也将有助于垃圾堆放，为了公平起见，我应该提一下：|364097|array+=+list.toArray(new+String[list.size()]);|364098|我更喜欢我的方法，因为它可能更容易得到错误的显式大小(例如，在错误的列表上调用size()+)。|364099|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/112507/13^0|0|2|E|0|0|0|8|D|O|L|1T|6|2J|S|0|0|0|0|0|0|0|0|11|3|0|0|0|13|6|0^^$0|@$1|2|3|4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1I|8|@]|9|@$D|1J|E|1K|1|1L]]|A|$]]|$1|F|3|G|5|H|7|1M|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1N|8|@$D|1O|E|1P|M|N]|$D|1Q|E|1R|M|N]|$D|1S|E|1T|M|N]|$D|1U|E|1V|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1W|8|@]|9|@]|A|$]]|$1|Q|3|R|5|H|7|1X|8|@]|9|@]|A|$I|J]]|$1|S|3|-4|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|V|3|W|5|H|7|20|8|@]|9|@]|A|$I|J]]|$1|X|3|Y|5|6|7|21|8|@]|9|@]|A|$]]|$1|Z|3|10|5|H|7|22|8|@]|9|@]|A|$I|J]]|$1|11|3|12|5|6|7|23|8|@$D|24|E|25|M|N]]|9|@]|A|$]]|$1|13|3|14|5|6|7|26|8|@]|9|@]|A|$]]|$1|15|3|16|5|H|7|27|8|@]|9|@]|A|$I|J]]|$1|17|3|18|5|6|7|28|8|@$D|29|E|2A|M|N]]|9|@]|A|$]]|$1|19|3|-4|5|6|7|2B|8|@]|9|@]|A|$]]]|1A|$1B|$5|1C|1D|1E|A|$1F|1G]]]]

[If you want some ready-to-use code, please scroll to my "Edit3" (after the cut). The rest is here for posterity.]

To flesh out <a href="https://stackoverflow.com/a/112507/13">Dustman's idea</a>:

<pre><code>List&lt;String&gt; list = new ArrayList&lt;String&gt;(Arrays.asList(array));
list.removeAll(Arrays.asList("a"));
array = list.toArray(array);
</code></pre>

Edit: I'm now using <code>Arrays.asList</code> instead of <code>Collections.singleton</code>: singleton is limited to one entry, whereas the <code>asList</code> approach allows you to add other strings to filter out later: <code>Arrays.asList("a", "b", "c")</code>.

Edit2: The above approach retains the same array (so the array is still the same length); the element after the last is set to null. If you want a new array sized exactly as required, use this instead:

<pre><code>array = list.toArray(new String[0]);
</code></pre>

<hr>

Edit3: If you use this code on a frequent basis in the same class, you may wish to consider adding this to your class:

<pre><code>private static final String[] EMPTY_STRING_ARRAY = new String[0];
</code></pre>

Then the function becomes:

<pre><code>List&lt;String&gt; list = new ArrayList&lt;&gt;();
Collections.addAll(list, array);
list.removeAll(Arrays.asList("a"));
array = list.toArray(EMPTY_STRING_ARRAY);
</code></pre>

This will then stop littering your heap with useless empty string arrays that would otherwise be <code>new</code>ed each time your function is called.

cynicalman's suggestion (see comments) will also help with the heap littering, and for fairness I should mention it:

<pre><code>array = list.toArray(new String[list.size()]);
</code></pre>

I prefer my approach, because it may be easier to get the explicit size wrong (e.g., calling <code>size()</code> on the wrong list).

blocks|key|3156205|text|关于创建一个列表，然后删除，然后返回到一个数组，我觉得这是错误的。还没有测试过，但我认为下面的代码会表现得更好。是的，我可能是过度预优化了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3156206|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%2B%2B;
+++}
}
String[]+newArr=new+String[size];
int+index=0;
for(int+i=0;i<arr.length;i%2B%2B){
+++if(!deleteItem[i]){
++++++newArr[index%2B%2B]=arr[i];
+++}
}|code-block|syntax|javascript|3156207|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Something about the make a list of it then remove then back to an array strikes me as wrong. Haven't tested, but I think the following will perform better. Yes I'm probably unduly pre-optimizing.

<pre><code>boolean [] deleteItem = new boolean[arr.length];
int size=0;
for(int i=0;i&lt;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&lt;arr.length;i++){
 if(!deleteItem[i]){
 newArr[index++]=arr[i];
 }
}
</code></pre>

blocks|key|367051|text|啊，我不能让代码正确显示。抱歉，我把它修好了。再次抱歉，我认为我没有正确阅读问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|367052|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%2B%2B)
{
++++if+(foo[c].equals(remove))
++++{
++++++++gaps[c]+=+true;
++++++++newlength%2B%2B;
++++}
++++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%2B%2B)
{
++++if+(!gaps[c1])
++++{
++++++++newString[c2]+=+foo[c1];
++++++++System.out.println(newString[c2]);
++++++++c2%2B%2B;
++++}
}|code-block|syntax|javascript|367053|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Arrgh, I can't get the code to show up correctly. Sorry, I got it working. Sorry again, I don't think I read the question properly.

<pre><code>String foo[] = {"a","cc","a","dd"},
remove = "a";
boolean gaps[] = new boolean[foo.length];
int newlength = 0;

for (int c = 0; c&lt;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&lt;foo.length; c1++)
{
 if (!gaps[c1])
 {
 newString[c2] = foo[c1];
 System.out.println(newString[c2]);
 c2++;
 }
}
</code></pre>

blocks|key|3156247|text|编辑：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3156248|数组中具有空值的点已被清除。很抱歉我的评论。|3156249|原件：|3156250|嗯..。这条线|3156251|array+=+list.toArray(array);|code-block|syntax|javascript|3156252|用空替换已移除元素所在的数组中的所有间隙。这可能是危险的，因为元素被移除了，但是数组的长度保持不变！|offset|length|style|BOLD|3156253|如果要避免这种情况，请使用新的数组作为toArray()的参数。如果您不想使用removeAll，则可以选择Set：|3156254|++++++++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));|3156255|提供：|3156256|[a,+bc,+dc,+a,+ef]
[dc,+ef,+bc]|3156257|克里斯·耶斯特·杨目前接受的答案是：|3156258|[a,+bc,+dc,+a,+ef]
[bc,+dc,+ef,+null,+ef]|3156259|使用代码|3156260|++++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));|3156261|而不会留下任何空值。|3156262|entityMap^0|0|0|0|0|0|1|1|P|3|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1D|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1E|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1F|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|1G|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1H|8|@$O|1I|P|1J|Q|R]|$O|1K|P|1L|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1M|8|@]|9|@]|A|$]]|$1|U|3|V|5|J|7|1N|8|@]|9|@]|A|$K|L]]|$1|W|3|X|5|6|7|1O|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|J|7|1P|8|@]|9|@]|A|$K|L]]|$1|10|3|11|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|12|3|13|5|J|7|1R|8|@]|9|@]|A|$K|L]]|$1|14|3|15|5|6|7|1S|8|@]|9|@]|A|$]]|$1|16|3|17|5|J|7|1T|8|@]|9|@]|A|$K|L]]|$1|18|3|19|5|6|7|1U|8|@]|9|@]|A|$]]|$1|1A|3|-4|5|6|7|1V|8|@]|9|@]|A|$]]]|1B|$]]

EDIT:

The point with the nulls in the array has been cleared. Sorry for my comments. 

Original:

Ehm... the line

<pre><code>array = list.toArray(array);
</code></pre>

replaces all gaps in the array where the removed element has been with null. This might be dangerous, because the elements are removed, but the length of the array remains the same!

If you want to avoid this, use a new Array as parameter for toArray(). If you don`t want to use removeAll, a Set would be an alternative:

<pre><code> String[] array = new String[] { "a", "bc" ,"dc" ,"a", "ef" };

 System.out.println(Arrays.toString(array));

 Set&lt;String&gt; asSet = new HashSet&lt;String&gt;(Arrays.asList(array));
 asSet.remove("a");
 array = asSet.toArray(new String[] {});

 System.out.println(Arrays.toString(array));
</code></pre>

Gives:

<pre><code>[a, bc, dc, a, ef]
[dc, ef, bc]
</code></pre>

Where as the current accepted answer from Chris Yester Young outputs:

<pre><code>[a, bc, dc, a, ef]
[bc, dc, ef, null, ef]
</code></pre>

with the code

<pre><code> String[] array = new String[] { "a", "bc" ,"dc" ,"a", "ef" };

 System.out.println(Arrays.toString(array));

 List&lt;String&gt; list = new ArrayList&lt;String&gt;(Arrays.asList(array));
 list.removeAll(Arrays.asList("a"));
 array = list.toArray(array); 

 System.out.println(Arrays.toString(array));
</code></pre>

without any null values left behind.

blocks|key|367062|text|您可以随时执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|367063|int+i,+j;
for+(i+=+j+=+0;+j+<+foo.length;+%2B%2Bj)
++if+(!"a".equals(foo[j]))+foo[i%2B%2B]+=+foo[j];
foo+=+Arrays.copyOf(foo,+i);|code-block|syntax|javascript|367064|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can always do:

<pre><code>int i, j;
for (i = j = 0; j &lt; foo.length; ++j)
 if (!"a".equals(foo[j])) foo[i++] = foo[j];
foo = Arrays.copyOf(foo, i);
</code></pre>

blocks|key|364154|text|这取决于你所说的“删除”是什么意思？数组是一个固定大小的结构--你不能改变其中元素的数量。因此，你可以a)创建一个新的，更短的，不包含你不想要的元素的数组，或者b)将你不想要的条目赋值给某个表示其“空”状态的东西；如果你不使用基元，通常为null。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|364155|在第一种情况下，从数组中创建一个列表，删除元素，然后从列表中创建一个新的数组。如果性能很重要，则迭代数组，将不应该删除的元素分配给列表，然后从列表中创建一个新的数组。在第二种情况下，只需遍历并将null赋值给数组条目。|364156|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

It depends on what you mean by "remove"? An array is a fixed size construct - you can't change the number of elements in it. So you can either a) create a new, shorter, array without the elements you don't want or b) assign the entries you don't want to something that indicates their 'empty' status; usually null if you are not working with primitives.

In the first case create a List from the array, remove the elements, and create a new array from the list. If performance is important iterate over the array assigning any elements that shouldn't be removed to a list, and then create a new array from the list. In the second case simply go through and assign null to the array entries.

blocks|key|3369149|text|您可以使用外部库：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3369150|org.apache.commons.lang.ArrayUtils.remove(java.lang.Object[]+array,+int+index)|code-block|syntax|javascript|3369151|它在Apache+Commons+Lang+http://commons.apache.org/lang/项目中。|offset|length|3369152|entityMap|0|LINK|mutability|MUTABLE|url|http://commons.apache.org/lang/^0|0|0|M|V|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

You can use external library:

<pre><code>org.apache.commons.lang.ArrayUtils.remove(java.lang.Object[] array, int index)
</code></pre>

It is in project Apache Commons Lang <a href="http://commons.apache.org/lang/" rel="nofollow noreferrer">http://commons.apache.org/lang/</a>

blocks|key|3156312|text|我意识到这是一个非常古老的帖子，但这里的一些答案对我有帮助，所以这是我的两便士‘哈’便士价值！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3156313|在写回的数组需要调整大小之前，我挣扎了很长一段时间，除非对ArrayList所做的更改保持列表大小不变。|offset|length|style|CODE|3156314|如果要修改的ArrayList的元素比开始时多或少，List.toArray()行将导致异常，因此您需要List.toArray(new+String[]+{})或List.toArray(new+String[0])之类的内容才能创建具有新(正确)大小的数组。|3156315|现在我知道了，这听起来很明显。这对于一个Android/Java新手来说并不是那么明显，因为他正在处理新的和不熟悉的代码结构，并且在这里的一些早期帖子中也不是很明显，所以我只想让其他像我一样抓了几个小时头的人真正明白这一点！|3156316|entityMap^0|0|T|9|0|6|9|Q|E|1G|T|2A|R|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@$D|S|E|T|F|G]|$D|U|E|V|F|G]|$D|W|E|X|F|G]|$D|Y|E|Z|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|10|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|M|$]]

I realise this is a very old post, but some of the answers here helped me out, so here's my tuppence' ha'penny's worth!

I struggled getting this to work for quite a while before before twigging that the array that I'm writing back into needed to be resized, unless the changes made to the <code>ArrayList</code> leave the list size unchanged.

If the <code>ArrayList</code> that you're modifying ends up with greater or fewer elements than it started with, the line <code>List.toArray()</code> will cause an exception, so you need something like <code>List.toArray(new String[] {})</code> or <code>List.toArray(new String[0])</code> in order to create an array with the new (correct) size.

Sounds obvious now that I know it. Not so obvious to an Android/Java newbie who's getting to grips with new and unfamiliar code constructs and not obvious from some of the earlier posts here, so just wanted to make this point really clear for anybody else scratching their heads for hours like I was!

blocks|key|364167|text|我对这个问题的一点贡献。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|364168|public+class+DeleteElementFromArray+{
public+static+String+foo[]+=+{"a","cc","a","dd"};
public+static+String+search+=+"a";


public+static+void+main(String[]+args)+{
++++long+stop+=+0;
++++long+time+=+0;
++++long+start+=+0;
++++System.out.println("Searched+value+in+Array+is:+"%2Bsearch);
++++System.out.println("foo+length+before+is:+"%2Bfoo.length);
++++for(int+i=0;i<foo.length;i%2B%2B){+System.out.println("foo["%2Bi%2B"]+=+"%2Bfoo[i]);}
++++System.out.println("==============================================================");
++++start+=+System.nanoTime();
++++foo+=+removeElementfromArray(search,+foo);
++++stop+=+System.nanoTime();
++++time+=+stop+-+start;
++++System.out.println("Equal+search+took+in+nano+seconds+=+"%2Btime);
++++System.out.println("==========================================================");
++++for(int+i=0;i<foo.length;i%2B%2B){+System.out.println("foo["%2Bi%2B"]+=+"%2Bfoo[i]);}
}
public+static+String[]+removeElementfromArray(+String+toSearchfor,+String+arr[]+){
+++++int+i+=+0;
+++++int+t+=+0;
+++++String+tmp1[]+=+new+String[arr.length];+++++
+++++++++for(;i<arr.length;i%2B%2B){
++++++++++++++if(arr[i]+==+toSearchfor){+++++
++++++++++++++i%2B%2B;
++++++++++++++}
+++++++++++++tmp1[t]+=+arr[i];
+++++++++++++t%2B%2B;
+++++}+++
+++++String+tmp2[]+=+new+String[arr.length-t];+++
+++++System.arraycopy(tmp1,+0,+tmp2,+0,+tmp2.length);
+++++arr+=+tmp2;+tmp1+=+null;+tmp2+=+null;
++++return+arr;
}|code-block|syntax|javascript|364169|}|364170|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

My little contribution to this problem.

<pre><code>public class DeleteElementFromArray {
public static String foo[] = {"a","cc","a","dd"};
public static String search = "a";


public static void main(String[] args) {
 long stop = 0;
 long time = 0;
 long start = 0;
 System.out.println("Searched value in Array is: "+search);
 System.out.println("foo length before is: "+foo.length);
 for(int i=0;i&lt;foo.length;i++){ System.out.println("foo["+i+"] = "+foo[i]);}
 System.out.println("==============================================================");
 start = System.nanoTime();
 foo = removeElementfromArray(search, foo);
 stop = System.nanoTime();
 time = stop - start;
 System.out.println("Equal search took in nano seconds = "+time);
 System.out.println("==========================================================");
 for(int i=0;i&lt;foo.length;i++){ System.out.println("foo["+i+"] = "+foo[i]);}
}
public static String[] removeElementfromArray( String toSearchfor, String arr[] ){
 int i = 0;
 int t = 0;
 String tmp1[] = new String[arr.length]; 
 for(;i&lt;arr.length;i++){
 if(arr[i] == toSearchfor){ 
 i++;
 }
 tmp1[t] = arr[i];
 t++;
 } 
 String tmp2[] = new String[arr.length-t]; 
 System.arraycopy(tmp1, 0, tmp2, 0, tmp2.length);
 arr = tmp2; tmp1 = null; tmp2 = null;
 return arr;
}
</code></pre>

}

blocks|key|367091|text|请参阅下面的代码|type|unstyled|depth|inlineStyleRanges|entityRanges|data|367092|ArrayList<String>+a+=+new+ArrayList<>(Arrays.asList(strings));
a.remove(i);
strings+=+new+String[a.size()];
a.toArray(strings);|code-block|syntax|javascript|367093|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

See code below

<pre><code>ArrayList&lt;String&gt; a = new ArrayList&lt;&gt;(Arrays.asList(strings));
a.remove(i);
strings = new String[a.size()];
a.toArray(strings);
</code></pre>

blocks|key|363720|text|Java+8中的另一种选择：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|363721|String[]+filteredArray+=+Arrays.stream(array)
++++.filter(e+->+!e.equals(foo)).toArray(String[]::new);|code-block|syntax|javascript|363722|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

An alternative in Java 8: 

<pre><code>String[] filteredArray = Arrays.stream(array)
 .filter(e -&gt; !e.equals(foo)).toArray(String[]::new);
</code></pre>

blocks|key|362335|text|如果您需要从数组中删除多个元素，而不将其转换为List，也不需要创建额外的数组，则可以在O(n)中执行此操作，而不依赖于要删除的项数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|362336|这里，a是初始数组，int...+r是要删除的元素的不同排序索引(位置)：|362337|public+int+removeItems(Object[]+a,+int...+r)+{
++++int+shift+=+0;+++++++++++++++++++++++++++++
++++for+(int+i+=+0;+i+<+a.length;+i%2B%2B)+{+++++++
++++++++if+(shift+<+r.length+&&+i+==+r[shift])++//+i-th+item+needs+to+be+removed
++++++++++++shift%2B%2B;++++++++++++++++++++++++++++//+increment+`shift`
++++++++else+
++++++++++++a[i+-+shift]+=+a[i];++++++++++++++++//+move+i-th+item+`shift`+positions+left
++++}
++++for+(int+i+=+a.length+-+shift;+i+<+a.length;+i%2B%2B)
++++++++a[i]+=+null;++++++++++++++++++++++++++++//+replace+remaining+items+by+nulls

++++return+a.length+-+shift;++++++++++++++++++++//+return+new+"length"
}++|code-block|syntax|javascript|362338|小测试：|362339|String[]+a+=+{"0",+"1",+"2",+"3",+"4"};
removeItems(a,+0,+3,+4);+++++++++++++++++++++//+remove+0-th,+3-rd+and+4-th+items
System.out.println(Arrays.asList(a));++++++++//+[1,+2,+null,+null,+null]|362340|在您的任务中，您可以首先扫描数组来收集"a“的位置，然后调用removeItems()。|362341|entityMap^0|N|4|0|3|1|A|8|0|0|0|0|U|D|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|13|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|14|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|T|$]]

If you need to remove multiple elements from array without converting it to <code>List</code> nor creating additional array, you may do it in O(n) not dependent on count of items to remove.

Here, <code>a</code> is initial array, <code>int... r</code> are distinct ordered indices (positions) of elements to remove:

<pre><code>public int removeItems(Object[] a, int... r) {
 int shift = 0; 
 for (int i = 0; i &lt; a.length; i++) { 
 if (shift &lt; r.length &amp;&amp; i == r[shift]) // i-th item needs to be removed
 shift++; // increment `shift`
 else 
 a[i - shift] = a[i]; // move i-th item `shift` positions left
 }
 for (int i = a.length - shift; i &lt; a.length; i++)
 a[i] = null; // replace remaining items by nulls

 return a.length - shift; // return new "length"
} 
</code></pre>

Small testing:

<pre><code>String[] a = {"0", "1", "2", "3", "4"};
removeItems(a, 0, 3, 4); // remove 0-th, 3-rd and 4-th items
System.out.println(Arrays.asList(a)); // [1, 2, null, null, null]
</code></pre>

In your task, you can first scan array to collect positions of "a", then call <code>removeItems()</code>.

blocks|key|362343|text|将复制除索引为i的元素以外的所有元素：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|362344|if(i+==+0){
++++++++++++++++System.arraycopy(edges,+1,+copyEdge,+0,+edges.length+-1+);
++++++++++++}else{
++++++++++++++++System.arraycopy(edges,+0,+copyEdge,+0,+i+);
++++++++++++++++System.arraycopy(edges,+i%2B1,+copyEdge,+i,+edges.length+-+(i%2B1)+);
++++++++++++}|code-block|syntax|javascript|362345|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Will copy all elements except the one with index i:

<pre><code>if(i == 0){
 System.arraycopy(edges, 1, copyEdge, 0, edges.length -1 );
 }else{
 System.arraycopy(edges, 0, copyEdge, 0, i );
 System.arraycopy(edges, i+1, copyEdge, i, edges.length - (i+1) );
 }
</code></pre>

blocks|key|362347|text|初始数组|type|unstyled|depth|inlineStyleRanges|entityRanges|data|362348|+++int[]+array+=+{5,6,51,4,3,2};|code-block|syntax|javascript|362349|如果要删除索引为2+51，请使用以下命令|362350|+for(int+i+=+2;+i+<+array.length+-1;+i%2B%2B){
++++array[i]+=+array[i+%2B+1];
++}|362351|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Initial array 

<pre><code> int[] array = {5,6,51,4,3,2};
</code></pre>

if you want remove 51 that is index 2, use following

<pre><code> for(int i = 2; i &lt; array.length -1; i++){
 array[i] = array[i + 1];
 }
</code></pre>

blocks|key|362353|text|在像这样的字符串数组中|type|unstyled|depth|inlineStyleRanges|entityRanges|data|362354|String+name+=+'a+b+c+d+e+a+f+b+d+e‘//可以类似于String+name+=+'aa+bb+c+d+e+aa+f+bb+d+e’|362355|我构建了以下类|362356|class+clearname{
def+parts
def+tv
public+def+str+=+''
String+name
clearname(String+name){
++++this.name+=+name
++++this.parts+=+this.name.split("+")
++++this.tv+=+this.parts.size()
}
public+String+cleared(){

++++++++int+i
++++++++int+k
++++++++int+j=0++++++++
++++for(i=0;i<tv;i%2B%2B){
++++++++for(k=0;k<tv;k%2B%2B){
++++++++++++if(this.parts[k]+==+this.parts[i]+&&+k!=i){
+++++++++++++++this.parts[k]+=+'';
++++++++++++++++j%2B%2B
++++++++++++}
++++++++}
++++}
++++def+str+=+''
++++for(i=0;i<tv;i%2B%2B){
++++++++if(this.parts[i]!='')

+++++++++++this.str+%2B=+this.parts[i].trim()%2B'+'
++++}+
++++return+this.str++++
}}



return+new+clearname(name).cleared()|code-block|syntax|javascript|362357|得到这个结果|362358|A、B、C、D、F|362359|希望这段代码对任何人有帮助|362360|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|V|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

In an array of Strings like

String name = 'a b c d e a f b d e' // could be like String name = 'aa bb c d e aa f bb d e'

I build the following class

<pre><code>class clearname{
def parts
def tv
public def str = ''
String name
clearname(String name){
 this.name = name
 this.parts = this.name.split(" ")
 this.tv = this.parts.size()
}
public String cleared(){

 int i
 int k
 int j=0 
 for(i=0;i&lt;tv;i++){
 for(k=0;k&lt;tv;k++){
 if(this.parts[k] == this.parts[i] &amp;&amp; k!=i){
 this.parts[k] = '';
 j++
 }
 }
 }
 def str = ''
 for(i=0;i&lt;tv;i++){
 if(this.parts[i]!='')

 this.str += this.parts[i].trim()+' '
 } 
 return this.str 
}}



return new clearname(name).cleared()
</code></pre>

getting this result

a b c d e f

hope this code help anyone 
Regards

blocks|key|362362|text|如果元素的顺序无关紧要。您可以在元素foox和foo之间交换，然后调用foo.drop(1)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|362363|foo.drop(n)从数组中删除前(n)个元素。|offset|length|style|CODE|362364|我想这是最简单和最节省资源的方法。|362365|PS：indexOf可以通过多种方式实现，这是我的版本。|BOLD|362366|Integer+indexOf(String[]+arr,+String+value){
++++for(Integer+i+=+0+;+i+<+arr.length;+i%2B%2B+)
++++++++if(arr[i]+==+value)
++++++++++++return+i;+++++++++//+return+the+index+of+the+element
++++return+-1+++++++++++++++++//+otherwise+-1
}

while+(true)+{
+++Integer+i;
+++i+=+indexOf(foo,"a")
+++if+(i+==+-1)+break;
+++foo[i]+=+foo[0];+++++++++++//+preserve+foo[0]
+++foo.drop(1);
}|code-block|syntax|javascript|362367|entityMap^0|0|0|B|0|0|0|2|3|7|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@$D|V|E|W|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|Y|8|@$D|Z|E|10|F|L]|$D|11|E|12|F|G]]|9|@]|A|$]]|$1|M|3|N|5|O|7|13|8|@]|9|@]|A|$P|Q]]|$1|R|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|S|$]]

If it doesn't matter the order of the elements. you can swap between the elements foo[x] and foo[0], then call foo.drop(1). 

<code>foo.drop(n)</code> removes (n) first elements from the array.

I guess this is the simplest and resource efficient way to do.

PS: <code>indexOf</code> can be implemented in many ways, this is my version.

<pre class="lang-java prettyprint-override"><code>Integer indexOf(String[] arr, String value){
 for(Integer i = 0 ; i &lt; arr.length; i++ )
 if(arr[i] == value)
 return i; // return the index of the element
 return -1 // otherwise -1
}

while (true) {
 Integer i;
 i = indexOf(foo,"a")
 if (i == -1) break;
 foo[i] = foo[0]; // preserve foo[0]
 foo.drop(1);
}
</code></pre>

blocks|key|3156396|text|只删除几个相等条目中的第一个条目|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3156397|使用lambda|3156398|boolean[]+done+=+{false};
String[]+arr+=+Arrays.stream(+foo+).filter(+e+->
++!+(!+done[0]+&&+Objects.equals(+e,+item+)+&&+(done[0]+=+true)+))
++++.toArray(String[]::new);|code-block|syntax|javascript|3156399|可以删除null条目|offset|length|style|CODE|3156400|entityMap^0|0|0|0|4|4|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

to remove  only the first  of several equal entries 
with a lambda
<pre><code>boolean[] done = {false};
String[] arr = Arrays.stream( foo ).filter( e -&gt;
 ! (! done[0] &amp;&amp; Objects.equals( e, item ) &amp;&amp; (done[0] = true) ))
 .toArray(String[]::new);
</code></pre>
can remove <code>null</code> entries

Given an array of n Objects, let's say it is an array of strings, and it has the following values:

<pre><code>foo[0] = "a";
foo[1] = "cc";
foo[2] = "a";
foo[3] = "dd";
</code></pre>

What do I have to do to delete/remove all the strings/objects equal to "a" in the array?

How do I remove objects from an array in Java?

Android

Java

给定一个由n对象组成的数组，假设它是一个由字符串数组组成的数组，它具有以下值：foo[0] = "a";foo[1] = "cc";foo[2] = "a";foo[3] = "dd";要删除/移除数组中等于"a"的所有字符串/对象，我必须做什么？

问如何在Java中从数组中删除对象？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Java中从数组中删除对象？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Java中从数组中删除对象？
EN