Java：将数组解析为正数组和负数组

下面是我所做的，它工作正常，但我不想固定数量的正负文章，因此代码可以在任何数组上工作：

    int[] array = {15, 22, 71, -27, 33, -44, 0, 334, -82};
    int[] negative = new int[3];
    int[] positive = new int[6];
    int n = 0;
    int p = 0;

    for(int i=0;i<array.length;i++){
        if(array[i]<0){
            negative[n] = array[i];
            n++;
        }else{
            positive[p] = array[i];
            p++;
        }
    }
    System.out.println("Negative array : " + Arrays.toString(negative));
    System.out.println("Positive array : " + Arrays.toString(positive));

int[]数组={15,22,71，-27,33，-44,0334，-82}；
int[]负=新的int[3]；
int[]正=新的int[6]；
int n=0；
int p=0；
对于（int i=0；i使用
列表，它没有固定大小：

int[] array = {15, 22, 71, -27, 33, -44, 0, 334, -82};
List<Integer> negative = new ArrayList<>();
List<Integer> positive = new ArrayList<>();

for(int i = 0;i<array.length;i++){
    if(array[i]<0){
        negative.add(array[i]); // Add negative number
    }else{
        positive.add(array[i]); // Add positive number 
    }
}

int[]数组={15,22,71，-27,33，-44,0334，-82}；
List negative=new ArrayList（）；
List positive=new ArrayList（）；
对于（int i=0；i您可以采用两种不同的方法：


在第一步计算负和正，生成负和正的数组并填充它们
为正片和负片创建
列表
，填充它们并将它们转换为数组

如果不需要正片和负片数组，也可以将原始数组拆分为两个列表（而不是两个数组）


第一种可能性

int numPositives = 0;
int numNegatives = 0;
for(int i=0;i<array.length;i++){
    if (array[i] >= 0) {
        numPositives++;
    } else {
        numNegatives++;
    }
}

int[] negative = new int[numNegatives];
int[] positive = new int[numPositives];
int n = 0;
int p = 0;

for(int i=0;i<array.length;i++){
    if(array[i]<0){
        negative[n] = array[i];
        n++;
    }else{
        positive[p] = array[i];
        p++;
    }
}

List<Integer> positivesList = new ArrayList<Integer>();
List<Integer> negativesList = new ArrayList<Integer>();

for (int i = 0; i < array.length; i++) {
    if (array[i] >= 0) {
        positivesList.add(array[i]);
    } else {
        negativesList.add(array[i]);
    }
} 
int[] positive = positivesList.toArray(new int[positivesList.size()]);
int[] negative = negativesList.toArray(new int[negativesList.size()]);

int numPositives=0；
int numNegatives=0；
对于（int i=0；i=0）{
numPositives++；
}否则{
numNegatives++；
}
}
int[]负=新的int[numNegatives]；
int[]正数=新的int[numPositives]；
int n=0；
int p=0；
对于（int i=0；iJava 8引入了包含lambda谓词过滤的流：

int[] pos = Arrays.stream(array).filter((int i) -> i >= 0).toArray();
int[] neg = Arrays.stream(array).filter((int i) -> i < 0).toArray();

int[]pos=Arrays.stream（array）.filter（（inti）->i>=0.toArray（）；
int[]neg=Arrays.stream（array）.filter（（inti）->i<0.toArray（）；
这里有一个小解决方案，它不涉及列表，也不预先计算负值的数量。它更像是使用本机解决方案来复制尚未找到的值。我还对其进行了更改，以便将负值和正值存储在单个2d数组中

public static void main(String[] args) {
    int[] array = {15, 22, 71, -27, 33, -44, 0, 334, -82};
    int[][] vals = new int[2][0];
    for(int i=0;i<array.length;i++){
        if(array[i]<0){
            int[] buffer = new int[vals[0].length+1]; // create array with one more value
            System.arraycopy(vals[0], 0, buffer, 0, vals[0].length); // Copy old values
            buffer[buffer.length-1] = array[i]; // assign new value
            vals[0] = buffer; // assign old and new values
        } else {
            int[] buffer = new int[vals[1].length+1]; // create array with one more value
            System.arraycopy(vals[1], 0, buffer, 0, vals[1].length); // Copy old values
            buffer[buffer.length-1] = array[i]; // assign new value
            vals[1] = buffer; // assign old and new values
        }
    }
    System.out.println("Negative array : " + Arrays.toString(vals[0]));
    System.out.println("Positive array : " + Arrays.toString(vals[1]));
}

publicstaticvoidmain（字符串[]args）{
int[]数组={15,22,71，-27,33，-44,0334，-82}；
int[]vals=新int[2][0]；
对于（int i=0；i根据@davide，两种方法均可使用

1） 在第一步计算负和正，生成负和正的数组并填充它们

    int numPositives = 0;// davide example
int numNegatives = 0;
for(int i=0;i<array.length;i++){
    if (array[i] >= 0) {
        numPositives++;
    } else {
        numNegatives++;
    }
}

int[] negative = new int[numNegatives];
int[] positive = new int[numPositives];
int n = 0;
int p = 0;

for(int i=0;i<array.length;i++){
    if(array[i]<0){
        negative[n] = array[i];
        n++;
    }else{
        positive[p] = array[i];
        p++;
    }
}

我想要两个数组，而不是列表。如何生成正负数组？
int[] array = {15, 22, 71, -27, 33, -44, 0, 334, -82};
List<Integer> negativeList = new ArrayList<>();
List<Integer> positiveList = new ArrayList<>();

for(int i = 0;i<array.length;i++){
    if(array[i]<0){
        negativeList.add(array[i]); // Add negative number
    }else{
        positiveList.add(array[i]); // Add positive number 
    }
}

int negativeArray[] = negativeList.stream().mapToInt(i->i).toArray();
int positiveArray[] = negativeList.stream().mapToInt(i->i).toArray();