在Java中计算数组中的不同值

Question

我正在编写一个代码，其中我有一个 int[a] 并且该方法应该返回唯一值的数量。示例：{1} = 0 个不同的值，{3,3,3} = 0 个不同的值，{1,2} = 2 个不同的值，{1,2,3,4} = 4 个不同的值等。我不允许对数组进行排序。

问题是我的方法可能不起作用。我的 for 语句有问题，我无法弄清楚。

public class Program
{

    public static void main(String[] args)
    {
        int[] a = {1, 2, 3, 1};

        System.out.println(differentValuesUnsorted(a));
        //run: 4 //should be 3
    }

public static int differentValuesUnsorted(int[] a)
{
    int values;      //values of different numbers

    if (a.length < 2)
    {
        return values = 0;
    }else if (a[0] == a[1])
    {
        return values = 0;
    }else
    {
        values = 2;
    } 

    int numberValue = a[0];
    for (int i = a[1]; i < a.length; i++)
    {
        if (a[i] != numberValue)
        {
             numberValue++;
             values++;
        }
    }
        return values;
    }
}

有人可以帮忙吗？

Answer 1

首先创建不同的值数组，它可以简单地使用HashSet创建。

然后alreadyPresent.size() 将提供许多不同的值。但是对于诸如 -{3,3,3} = 0 的情况（数组包含相同的元素）； alreadyPresent.size() 的输出为 1。为此使用这个简单的过滤器

if(alreadyPresent.size() == 1)){
    return 0;
}

以下代码将给出不同值的计数。

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

public class Demo {

  public static void main(String[] args)
  {
       int array[] = {9,9,5,2,3};
       System.out.println(differentValuesUnsorted(array));
  }

  public static int differentValuesUnsorted(int[] array)
  {

     Set<Integer> alreadyPresent = new HashSet<Integer>();

     for (int nextElem : array) {
         alreadyPresent.add(nextElem);
     }

     if(alreadyPresent.size() == 1){
         return 0;
     }

     return alreadyPresent.size();

  }
}

Answer 2

您可以使用HashSet，它只能包含唯一元素。 HashSet 将删除重复的项目，然后您可以获得集合的大小。

public static int differentValuesUnsorted(int[] a) {
    Set<Integer> unique = new HashSet<Integer>();
    for (int val : a) {
        unique.add(val); // will only be added if a is not in unique
    }
    if (unique.size() < 2) { // if there are no different values
        return 0;
    }
    return unique.size();
}

Answer 3

使用集合删除重复项

 public static int differentValuesUnsorted(int[] a) {
     if (a.length < 2) {
         return 0;
     }

     Set<Integer> uniques = new HashSet<>(a);
     return singleUnique.size();
 }

Answer 4

这实际上比大多数人想象的要简单得多，这种方法效果很好：

public static int diffValues(int[] numArray){
    int numOfDifferentVals = 0;

    ArrayList<Integer> diffNum = new ArrayList<>();

    for(int i=0; i<numArray.length; i++){
        if(!diffNum.contains(numArray[i])){
            diffNum.add(numArray[i]);
        }
    }

    if(diffNum.size()==1){
            numOfDifferentVals = 0;
    }
    else{
          numOfDifferentVals = diffNum.size();
        } 

   return numOfDifferentVals;
}

---

让我带你了解一下：

1) 提供一个 int 数组作为参数。

2) 创建一个包含整数的 ArrayList：

• 如果该数组列表不包含数组中的整数 作为参数提供，然后将该元素添加到数组参数中 到数组列表
• 如果该 arrayList DOES 包含 int 数组参数中的该元素，则不执行任何操作。 （不要将该值添加到数组列表中）

注意：这意味着 ArrayList 包含 int[] 中的所有数字，并删除重复的数字。

3) ArrayList 的大小（类似于数组的长度属性）将是提供的数组中不同值的数量。

---

试用

输入：

  int[] numbers = {3,1,2,2,2,5,2,1,9,7};

输出：6

Answer 5

试试这个：

import java.util.ArrayList;
public class DifferentValues {

 public static void main(String[] args)
  {
    int[] a ={1, 2, 3, 1};
    System.out.println(differentValuesUnsorted(a));
  }

 public static int differentValuesUnsorted(int[] a)
 {
   ArrayList<Integer> ArrUnique = new ArrayList<Integer>();
   int values=0;      //values of different numbers
   for (int num : a) {
       if (!ArrUnique.contains(num)) ArrUnique.add(num);
   }
   values = ArrUnique.size();
   if (values == 1) values = 0;       
   return values;
 }
}

输入：{1,1,1,1,1} - 输出： 0
输入：{1,2 ,3,1} - 输出： 3

Answer 6

对于小型数组，这是一种快速简洁的方法，不需要分配任何额外的临时对象：

public static int uniqueValues(int[] ids) {
    int uniques = 0;

    top:
    for (int i = 0; i < ids.length; i++) {
        final int id = ids[i];
        for (int j = i + 1; j < ids.length; j++) {
            if (id == ids[j]) continue top;
        }
        uniques++;
    }
    return uniques;
}

Answer 7

试试这个...使用 ArrayList 非常简单。你甚至不需要两个循环。继续

import java.util.*;
public class distinctNumbers{

 public static void main(String []args){
    int [] numbers = {2, 7, 3, 2, 3, 7, 7};
    ArrayList<Integer> list=new ArrayList<Integer>();
    for(int i=0;i<numbers.length;i++)
    {

        if(!list.contains(numbers[i]))  //checking if the number is present in the list
        {
            list.add(numbers[i]); //if not present then add the number to the list i.e adding the distinct number
        }

    }
    System.out.println(list.size());
}
}

Answer 8

试试这个简单的代码 sn-p。

public static int differentValuesUnsorted(int[] a)
{
    ArrayList<Integer> list=new ArrayList<Integer>();   //import java.util.*;
    for(int i:numbers)                                  //Iterate through all the elements
      if(!list.contains(i))                             //checking for duplicate element
        list.add(i);                                    //Add to list if unique
    return list.size();
}

Answer 9

这个怎么样？

private <T> int arrayDistinctCount(T[] array) {
    return Arrays.stream(array).collect(Collectors.toSet()).size();
}