blocks|key|4387771|text|这将通过一次迭代就地完成：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4387772|保存两个索引:原始数组上的src和dst。两者都被初始化为0。|offset|length|style|CODE|4387773|当数字为正数时，将其从num[src]复制到num[dst]，并使两个索引都前进|4387774|当数字为负数时，只需前进src。|4387775|返回新大小为dst的原始数组。|4387776|public+static+int+removeNegativeNumbers(int[]+num)+{
++int+dst=0;
++for+(int+src=0+;+src<num.length+;+%2B%2Bsrc)
++++if+(num[src]>=0)
++++++num[dst%2B%2B]+=+num[src];
++return+dst;
}|code-block|syntax|javascript|4387777|entityMap^0|0|D|3|H|3|0|B|8|M|8|0|C|3|0|6|3|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@$D|W|E|X|F|G]|$D|Y|E|Z|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|10|8|@$D|11|E|12|F|G]|$D|13|E|14|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|15|8|@$D|16|E|17|F|G]]|9|@]|A|$]]|$1|L|3|M|5|6|7|18|8|@$D|19|E|1A|F|G]]|9|@]|A|$]]|$1|N|3|O|5|P|7|1B|8|@]|9|@]|A|$Q|R]]|$1|S|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|T|$]]

This will do it in-place with a single iteration:

Hold 2 indexes: <code>src</code> and <code>dst</code> on the original array. both are initialized to 0.

when a number is positive, copy it from <code>num[src]</code> to <code>num[dst]</code> and advance both indexes

when a number is negative, just advance <code>src</code>.

return the original array with <code>dst</code> as its new size.

<pre><code>public static int removeNegativeNumbers(int[] num) {
 int dst=0;
 for (int src=0 ; src&lt;num.length ; ++src)
 if (num[src]&gt;=0)
 num[dst++] = num[src];
 return dst;
}
</code></pre>

blocks|key|4387276|text|public+static+int[]+removeNegativeNumbers(int[]+num)+{
++++List<Integer>+list+=+new+ArrayList<>();
++++for+(int+n+:+num)+{
++++++++if+(n+>=+0)+{
++++++++++++list.add(n);
++++++++}
++++}
++++return+list.toArray(new+int[list.size()]);
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4387277|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public static int[] removeNegativeNumbers(int[] num) {
 List&lt;Integer&gt; list = new ArrayList&lt;&gt;();
 for (int n : num) {
 if (n &gt;= 0) {
 list.add(n);
 }
 }
 return list.toArray(new int[list.size()]);
}
</code></pre>

blocks|key|4387294|text|Java+8+streams怎么样？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4387295|Arrays.stream(num).filter(s+->+s+>=+0).toArray();|code-block|syntax|javascript|4387296|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|$]]

What about Java 8 streams?

<pre><code>Arrays.stream(num).filter(s -&gt; s &gt;= 0).toArray();
</code></pre>

blocks|key|4387329|text|我认为在效率方面，我们不能比@kaidul伊斯拉姆答案(和@user6904265的简洁性)更好了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4387330|我只是添加了一个解决方案，它在一个非常特殊的场景中应该有一些价值，在这种场景中，负值很少出现，并且数组非常大。|4387331|基本思想是推迟实际复制，直到找到负值，然后使用System.arraycopy复制。如果没有找到负数组，则返回源数组。|4387332|import+java.util.*;

public+class+NotNegativeTest+{

++++public+static+void+main(String[]+args)+{
+++++++++int[]+array+=+{+1,+-3,+4,+-9,+3,+4,+70,+-10,+0,+7+};+
+++++++++System.out.println(Arrays.toString(removeNegativeNumbers(array)));+
++++}+

++++public+static+int[]+removeNegativeNumbers(int[]+num)+{
+++++++++int[]+output+=+new+int[num.length];
+++++++++int+k+=+0;
+++++++++int+i+=+0;+
+++++++++int+last=-1;
+++++++++int+howmany=0;

+++++++++while(i+<+num.length)+{
+++++++++++++if(num[i]+<+0)+{
++++++++++++++++howmany=i-last-1;
++++++++++++++++switch(howmany)+{
++++++++++++++++++++case+0:+break;
++++++++++++++++++++case+1:+
++++++++++++++++++++++++++++output[k]=num[last%2B1];
++++++++++++++++++++++++++++k%2B%2B;
++++++++++++++++++++++++++++break;
++++++++++++++++++++default:++++++++
++++++++++++++++++++++++++++System.arraycopy(num,+last%2B1,++output,+k,+howmany);
++++++++++++++++++++++++++++k%2B=howmany;
++++++++++++++++}
++++++++++++++++last=i;
+++++++++++++}+
+++++++++++++i%2B%2B;
+++++++++}+
+++++++++if+(last>=0)+{
++++++++++++++if(last!=i-1)+{
++++++++++++++++howmany=i-last-1;++
++++++++++++++++System.arraycopy(num,+last%2B1,++output,+k,+howmany);
++++++++++++++++k%2B=howmany;
++++++++++++}
++++++++}+else+{
++++++++++++return+num;
++++++++}

+++++++++return+Arrays.copyOfRange(output,+0,+k);
+++++}

}|code-block|syntax|javascript|4387333|我已经找到时间来编写JMH微基准测试。|4387334|我使用过以下配置：|4387335|Options+opts+=+new+OptionsBuilder()
++.include(MyBenchmark.class.getSimpleName())
++.mode(Mode.AverageTime)
++.warmupIterations(1)
++.warmupTime(TimeValue.seconds(5))
++.measurementIterations(10)
++.measurementTime(TimeValue.seconds(5))
++.jvmArgs("-server")
++.forks(1)
++.build();
new+Runner(opts).run();|4387336|(免责声明:我的第一个JMH测试，所以如果有人有什么建议，我很乐意更改它并更新结果)|4387337|结果如下：|4387338|#+Run+complete.+Total+time:+00:02:54

Benchmark+++++++++++++++++++++++++++++Mode++Cnt++Score+++Error++Units
MyBenchmark.testMethodUser6904265+++++avgt+++10++0,201+±+0,040+++s/op
MyBenchmark.testMethodInsac+++++++++++avgt+++10++0,093+±+0,022+++s/op
MyBenchmark.testMethodKaidul++++++++++avgt+++10++0,124+±+0,029+++s/op|4387339|现在，在为我欢呼之前，请先看看这个测试有多偏颇：|4387340|+int[]+array+=+new+int[10000000];
+array[0]=-5;
+array[10000]=-3;
+array[40000]=-3;
+array[8000000]=-3;

+int[]+answer=NotNegativeTest.removeNegativeNumbers(array);|4387341|因此，这里需要注意的不是我的方法获胜(测试是为我的方法获胜而写的:-)，而是即使在这种极端的情况下，泛型kaidul伊斯拉姆方法与我的方法是多么接近。|4387342|更新:这里是jmh+benchmark+I+wrote的链接，这样你可以验证更真实的场景(如果有人发现我如何设置测试的问题，请让我知道)。在我对另一个答案的测试中，有一个对Trove的依赖性。|offset|length|4387343|entityMap|0|LINK|mutability|MUTABLE|url|http://pastebin.com/LhVq4Q1a^0|0|0|0|0|0|0|0|0|0|0|0|0|0|6|L|0|0^^$0|@$1|2|3|4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1F|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1G|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|1H|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1I|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1J|8|@]|9|@]|A|$]]|$1|O|3|P|5|H|7|1K|8|@]|9|@]|A|$I|J]]|$1|Q|3|R|5|6|7|1L|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1M|8|@]|9|@]|A|$]]|$1|U|3|V|5|H|7|1N|8|@]|9|@]|A|$I|J]]|$1|W|3|X|5|6|7|1O|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|H|7|1P|8|@]|9|@]|A|$I|J]]|$1|10|3|11|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1R|8|@]|9|@$14|1S|15|1T|1|1U]]|A|$]]|$1|16|3|-4|5|6|7|1V|8|@]|9|@]|A|$]]]|17|$18|$5|19|1A|1B|A|$1C|1D]]]]

I don't think we can get better in terms of efficiency than @kaidul-islam answer (and @user6904265 in terms of conciseness).

I'm just adding a solution that should have some value in a very specific scenario, where negatives rarely appear and array is very large.

Basic idea is to defer the actual copy until a negative value is found and then copy with System.arraycopy. In case no negative is found, the source array would be returned. 

<pre><code>import java.util.*;

public class NotNegativeTest {

 public static void main(String[] args) {
 int[] array = { 1, -3, 4, -9, 3, 4, 70, -10, 0, 7 }; 
 System.out.println(Arrays.toString(removeNegativeNumbers(array))); 
 } 

 public static int[] removeNegativeNumbers(int[] num) {
 int[] output = new int[num.length];
 int k = 0;
 int i = 0; 
 int last=-1;
 int howmany=0;

 while(i &lt; num.length) {
 if(num[i] &lt; 0) {
 howmany=i-last-1;
 switch(howmany) {
 case 0: break;
 case 1: 
 output[k]=num[last+1];
 k++;
 break;
 default: 
 System.arraycopy(num, last+1, output, k, howmany);
 k+=howmany;
 }
 last=i;
 } 
 i++;
 } 
 if (last&gt;=0) {
 if(last!=i-1) {
 howmany=i-last-1; 
 System.arraycopy(num, last+1, output, k, howmany);
 k+=howmany;
 }
 } else {
 return num;
 }

 return Arrays.copyOfRange(output, 0, k);
 }

}
</code></pre>

I've found the time to write a JMH microbenchmark.

I've used used these configurations:

<pre><code>Options opts = new OptionsBuilder()
 .include(MyBenchmark.class.getSimpleName())
 .mode(Mode.AverageTime)
 .warmupIterations(1)
 .warmupTime(TimeValue.seconds(5))
 .measurementIterations(10)
 .measurementTime(TimeValue.seconds(5))
 .jvmArgs("-server")
 .forks(1)
 .build();
new Runner(opts).run();
</code></pre>

(disclaimer: my first JMH test, so if someone has some suggestions, I'll be glad to change it and update the results)

And here are the results:

<pre><code># Run complete. Total time: 00:02:54

Benchmark Mode Cnt Score Error Units
MyBenchmark.testMethodUser6904265 avgt 10 0,201 ± 0,040 s/op
MyBenchmark.testMethodInsac avgt 10 0,093 ± 0,022 s/op
MyBenchmark.testMethodKaidul avgt 10 0,124 ± 0,029 s/op
</code></pre>

Now, before cheering me, please take a look to how biased the test was:

<pre><code> int[] array = new int[10000000];
 array[0]=-5;
 array[10000]=-3;
 array[40000]=-3;
 array[8000000]=-3;

 int[] answer=NotNegativeTest.removeNegativeNumbers(array);
</code></pre>

So here the thing to notice it is not that my method won (the test was written for my method to win :-) but how close the generic kaidul-islam method was to mine even in this extreme scenario.

UPDATED: here is the link to the <a href="http://pastebin.com/LhVq4Q1a" rel="nofollow noreferrer">jmh benchmark I wrote</a> so you can verify more realistic scenario (if someone finds issues with how I setup the test, please let me know). There is a depenendency on Trove for a test I've done on another answer.

blocks|key|4387853|text|遵循以下代码(Java+8)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4387854|int+test[]+=+new+int[]+{+15,+-40,+-35,+45,+-15+};
++++//+here+we+can+take+the+test+array+in+to+stream+and+filter+with+condition+(>=0).
++++int[]+positives+=+Arrays.stream(test).filter(x+->+x+>=+0).toArray();

++++System.out.println("Here+is+the+positive+array+elements");

++++for+(int+i+:+positives)+{
++++++++System.out.print(i+%2B+"\t");
++++}|code-block|syntax|javascript|4387855|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|$]]

Follow the below code (Java 8)

<pre><code>int test[] = new int[] { 15, -40, -35, 45, -15 };
 // here we can take the test array in to stream and filter with condition (&gt;=0).
 int[] positives = Arrays.stream(test).filter(x -&gt; x &gt;= 0).toArray();

 System.out.println("Here is the positive array elements");

 for (int i : positives) {
 System.out.print(i + "\t");
 }
</code></pre>

blocks|key|4387379|text|使用迭代器|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4387380|++Iterator<Integer>+itr+=+objArray.iterator();
+++++while(itr.hasNext())+{
+++++Integer+next+=+itr.next();
+++++if(next+<+0)+{
++++++++itr.remove();
+++++}
++}|code-block|syntax|javascript|4387381|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|$]]

Use iterator
<pre><code> Iterator&lt;Integer&gt; itr = objArray.iterator();
 while(itr.hasNext()) {
 Integer next = itr.next();
 if(next &lt; 0) {
 itr.remove();
 }
 }
</code></pre>

My objective is to remove all negative numbers from an array in Java.

I have written the below code. How do I improve the complexity of code or is there a good algorithm?

<pre><code>public static void main(String[] args) {
 int[] array = { 1, -3, 4, -9, 3, 4, 70, -10, 0, 7 };
 System.out.println(Arrays.toString(removeNegativeNumbers(array)));
}

public static int[] removeNegativeNumbers(int[] num) {
 List&lt;Integer&gt; list = new ArrayList&lt;&gt;();
 for (int n : num) {
 if (n &gt;= 0) {
 list.add(n);
 }
 }
 int[] result = new int[list.size()];
 for (int i = 0; i &lt; result.length; i++) {
 result[i] = list.get(i).intValue();
 }
 return result;
}
</code></pre>

Removal of negative numbers from an array in Java

我的目标是在Java中删除数组中的所有负数。我已经写了下面的代码。我如何提高代码的复杂性，或者有一个好的算法？public static void main(String[] args) {    int[] array = { 1, -3, 4, -9, 3, 4, 70, -10, 0, 7 };    Syste...

问在Java中删除数组中的负数
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中删除数组中的负数EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中删除数组中的负数
EN