Question

在下面的代码中，您需要获得一系列负面文章和一系列正面文章。如何获得没有零的数组。

package niz;

import java.util.HashSet;

public class Niz {

    public static void main(String[] args)
    {
        int[] array = {12, 23, -22, 0, 43, 545, -4, -55, 43, 12, 0, -999, -87};

        int array1[] = new int[array.length];
        int array2[] = new int[array.length];

        for (int i = 0; i < array.length; i++)
            if (array[i] < 0)
                array1[i] = array[i];
            else
                if (array[i] > 0)
                    array2[i] = array[i];

        HashSet<Integer> notDupes = new HashSet<>();
        HashSet<Integer> duplicates = new HashSet<>();
        for (int i = 0; i < array.length; i++) 
        {
            if (!notDupes.contains(array[i]))
            {
                notDupes.add(array[i]);
                continue;
            }   
            duplicates.add(array[i]);
        }

        System.out.println("negative members of the array: " + java.util.Arrays.toString(array1));
        System.out.println("positive members of the array : " + java.util.Arrays.toString(array2));
        System.out.println("number of duplicates : " + duplicates.size());

    }
}

以下是输出：

run:
negative members of the array: [0, 0, -22, 0, 0, 0, -4, -55, 0, 0, 0, -999, -87]
positive members of the array : [12, 23, 0, 0, 43, 545, 0, 0, 43, 12, 0, 0, 0]
number of duplicates : 3
BUILD SUCCESSFUL (total time: 1 second)

Answer 1

初始化整数数组时，数组中的默认元素为零。因此，在填充这些数组之后，您仍然会在其中包含与您未填充的数字相对应的零元素。要解决此问题，您可以使用List代替您不必将其初始化为固定大小。如果您仍希望最后有数组，可以将List转换为数组。

List<Integer> list1 = new ArrayList<Integer>();
List<Integer> list2 = new ArrayList<Integer>();
for (int i = 0; i < array.length; i++)
    if (array[i] < 0)
        list1.add(array[i]);
    else if (array[i] > 0)
        list2.add(array[i]);

Integer array1[] = list1.toArray(new Integer[list1.size()]);
Integer array2[] = list2.toArray(new Integer[list2.size()]);

顺便说一句，使用调试器检测它不会花费太多时间。

Answer 2

作为一个懒惰的人，我会做以下事情：

public static void main(String... args) {
    int[] numbers = {12, 23, -22, 0, 43, 545, -4, -55, 43, 12, 0, -999, -87};

    int[] positiveNumbers = Arrays.stream(numbers).filter(n -> n > 0).toArray();
    int[] negativeNumbers = Arrays.stream(numbers).filter(n -> n <= 0).toArray();
    int numOfDuplicates = numbers.length - (int)Arrays.stream(numbers).distinct().count();

    System.out.println("negative members of the array: " + java.util.Arrays.toString(positiveNumbers));
    System.out.println("positive members of the array : " + java.util.Arrays.toString(negativeNumbers));
    System.out.println("number of duplicates : " + numOfDuplicates);
}

Answer 3

Java数组的大小不是动态的。当您创建两个数组（一个负数，一个正数）但两个数组都与原始数组相同时;您将获得0的条目（因为这是数组中int的默认初始值）。使用两个List（s），

List<Integer> al1 = new ArrayList<>();
List<Integer> al2 = new ArrayList<>();

for (int i = 0; i < array.length; i++)
    if (array[i] < 0)
        al1.add(array[i]);
    else if (array[i] > 0)
        al2.add(array[i]);

然后打印List（s），

System.out.println(al1);
System.out.println(al2);

Answer 4

在为正数组和负数组插入数据时，您都维护了一个计数器。否则，对于尚未放置数据的位置，数组将显示0。这是因为int数组上的所有元素默认都包含0。例如

if(array[i] < 0)
array1[i] = array[i];

应该是

if(array[i] < 0)
array1[negativeInde++] = array[i];

此外，我认为使用原始数据类型更适合您的原因，因为使用像Integer这样的包装器将意味着更多的开销，并且如果您拥有大型数组，则需要花费太多时间来执行。

Answer 5

您的代码应该是这样的，但是由于您的大小不合适，您最终仍会得到零。

    int ctr1 =0;
    int ctr2 =0;
    for(int i=0;i<array.length;i++)
        if(array[i] < 0)
            array1[ctr1++] = array[i];

        else

        if(array[i] > 0)
            array2[ctr2++] = array[i];

也要摆脱它们。使用以下代码。

int ctr1 = 0;
int ctr2 = 0;
for (int i = 0; i < array.length; i++){
    if (array[i] < 0) {
        ctr1++;
    } else if (array[i] > 0) {
        ctr2++;
    }
}
int array1[] = new int[ctr1];
int array2[] = new int[ctr2];
ctr1=ctr2=0;
for (int i = 0; i < array.length; i++){
    if (array[i] < 0) {
        array1[ctr1++] = array[i];
    } else if (array[i] > 0) {
        array2[ctr2++] = array[i];
    }
}

Answer 6

使用List代替数组来充分利用它们缩小的力量，只要添加新项目并删除其他项目，就会越来越大。

请注意，当您实例化新的array对象时，它会使用默认类型初始化所有元素，在这种情况下，int项将初始化为0，因此您将拥有数组大小为零。

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;

public class Niz
{

  public static void main(String[] args)
  {
    int[] array = {12, 23, -22, 0, 43, 545, -4, -55, 43, 12, 0, -999, -87};

    List<Integer> array1 = new ArrayList<Integer>();
    List<Integer> array2 = new ArrayList<Integer>();

    for (int i = 0; i < array.length; i++)
      if (array[i] < 0)
        array1.add(array[i]);
      else
        array2.add(array[i]);

    HashSet<Integer> notDupes = new HashSet<Integer>();
    HashSet<Integer> duplicates = new HashSet<Integer>();
    for (int i = 0; i < array.length; i++)
    {
      if (!notDupes.contains(array[i]))
      {
        notDupes.add(array[i]);
        continue;
      }
      duplicates.add(array[i]);

    }

    System.out.println("negative members of the array: " + array1);
    System.out.println("positive members of the array : " + array2);
    System.out.println("number of duplicates : " + duplicates.size());

  }

}

作为旁注，你应该避免不必要的条件阻塞，例如else if语句，因为当int文字是负数（if (array[i] < 0)）时，那么它肯定是肯定的，因此不需要（else if (array[i] < 0)）检查。

Answer 7

我建议你采用面向对象的方法，推进Collections API的设施。它更清楚：

编译ArrayList的扩展，覆盖add（）方法，以便它只包含正数。编码负面的另一个扩展名。

然后，您只需要创建四个集合：

包含原始数组项的列表。
一个积极的ArrayList。
否定ArrayList。
不重复的设置。

...只有一个循环，迭代原始数组，为每个集合添加一个项目。毕竟，通过removeAll方法从原始列表中删除不重复项。

Java - 数组 - 流控制，循环和分支

7 个答案: