Java从数组中删除零

Question

我正在尝试编写一个程序，该程序在执行时将通过一个数组并删除所有0.0的实例，并将该数组的大小改为等于非零元素的数量，并将这些元素以先前的顺序排列。即，如果n = 10和[J]中的内容，j = 0到N - 1最初是

0.0, 1.2, 0.0, 0.0, 0.0, 2.3, 0.0, 9.7, 5.6, 0.0 

则代码执行后的内容应该是

n=4, a[0]=1.2, a[1]=2.3, a[2]=9.7, and a[3]=5.6. 

这是我到目前为止：

import java.util.Scanner; 
public class hw2 
{ 
    public static void main(String[] args) 
    { 
     Scanner scan = new Scanner(System.in); 
     final double KEY = 0.0; 
     int n = scan.nextInt(); 
     double[] a = new double[n]; 
     for(int i=0; i<n; i++) 
     { 
      a[i] = scan.nextDouble(); 
     } 
     for(int k = 0; k<n; k++) 
     { 
      if(a[k] == KEY) 
      { 
       a[k] = a[k+1]; 
       n--; 
      } 
      System.out.println(a[k]); 
     } 
    } 
} 

只是在正确的方向微调，将不胜感激。

Answer 1

你的实现（第二for循环）是不正确的，它将无法简单的测试案例： 输入> 5 2.0 2 0.0 3 0.0 你的程序将有错误的输出： 2.0 2.0 3.0 3.0

，但它应该是2.0 2.0 3

此外，您不能使用==来比较两个双。

下面的代码是你当前的代码我的解决方案筑底：

public class hw21 { 
    public static void main(String[] args) { 
     Scanner scan = new Scanner(System.in); 
     final double KEY = 0.0; 
     final Double ACCEPTABLE_TOLERANCE = 0.000000000001d; 

     int n = scan.nextInt(); 
     double[] a = new double[n]; 
     for (int i = 0; i < n; i++) { 
      a[i] = scan.nextDouble(); 
     } 
     for (int k = 0, j = 0; k < n; k++) { 
      if (Math.abs(a[k] - KEY) < ACCEPTABLE_TOLERANCE) { 
       continue; 
      } 
      a[j] = a[k]; 
      System.out.println(a[j]); 
      j++; 
     } 
    } 
} 

此外，我更喜欢使用象下面这样一个ArrayList：

public class hw2 { 
public static void main(String[] args) { 
    Scanner scan = new Scanner(System.in); 
    final double KEY = 0.0; 
    final Double ACCEPTABLE_TOLERANCE = 0.000000000001d; 

    int n = scan.nextInt(); 
    double[] a = new double[n]; 
    for (int i = 0; i < n; i++) { 
     a[i] = scan.nextDouble(); 
    } 

    List<Double> newList = new ArrayList<Double>(); 
    for (int k = 0; k < n; k++) { 
     if (Math.abs(a[k] - KEY) < ACCEPTABLE_TOLERANCE) { 
      continue; 
     } 
     newList.add(a[k]); 
    } 

    System.out.println("There are " + newList.size() + " no-zero double:"); 
     System.out.println(newList); 
    } 
} 

Answer 2

考虑使用ArrayList，这将允许您在需要时添加项目，根据需要进行增长并保持准确的计数。

虽然在这种情况下，如果你想/需要使用一个数组，你可能根本不保存值，如果它是“0”，也许。 （除非添加，否则不要增加“已使用的数组变量”，因此您知道多少包含“非0”数据或将迭代期间遇到的第一个“0”视为“有用数据结束” - 数组是使用该类型的默认值进行初始化）

如果您想从具有零的数组转换为完全不带零的数组，则必须使用两个传递 - 一个用于计算非零，以构造一个适当大小的新数组，然后复制非零值。这也可以在相反的情况下完成（压缩初始数组，然后复制它的“已填充”部分），但稍微复杂一些。

如果你与你目前的做法继续（其结果数组将零，但在年底），你需要保持索引指针 - 一个是主循环迭代，第二个是下一个地方放置非零值，只有在复制值（或不移动，因为两个索引相同时，才会遇到前面的0）时才增加该值。确保将零点移动到非零位置。如果订单不需要保留，可以减少的移动次数。

Answer 3

import java.util.Arrays; 
import java.util.Scanner; 

public class StackOverflow1 
{ 
    public static final double KEY = 0.0; 
    private static final Scanner INPUT = new Scanner(System.in); 

    public static void main(String[] args) { 


     int length = INPUT.nextInt(); 
     double[] array = new double[length]; 

     for(int i=0; i<length; i++) { 
      array[i] = INPUT.nextDouble(); 
     } 

     int index = 0; 
     for(int k = 0; k < length ; k++) { 
      if(array[k] == KEY) { 
       continue; 
      } 
      array[index] = array[k]; // bring the non-zeroth element forward 
      if (index != k) array[k] = 0; //make the non-zeroth element zero in the actual location 
      index++; 
     } 
     System.out.println("n = " + index + " array = " + Arrays.toString(array)); 
    } 
} 

Answer 4

您可以按如下方式删除那些不需要的零，但在这种情况下它会被排序。

@org.junit.Test 
public void test15() throws Exception { 
    double[] arr = new double[]{0.0,1.1,0.1,0.0,2.1}; 
    double[] nonZeroArr = arr; 

    Arrays.sort(nonZeroArr); 
    int index = -1; 
    while((index = Arrays.binarySearch(nonZeroArr, 0.0)) > -1){ 
     double[] newArr = new double[nonZeroArr.length-index-1]; 
     System.arraycopy(nonZeroArr, index+1, newArr, 0, newArr.length); 
     nonZeroArr = newArr; 
    } 
    for (double d : arr) { 
     System.out.print(d +","); 
    } 
    System.out.println(); 
    for (double d : nonZeroArr) { 
     System.out.print(d + ","); 
    } 
} 

Answer 5

如果你想要的声音在课堂上点真聪明这是一个在很多语言比Java生产效率更高的单线程:)