如何计算数组中有多少整数元素在java中相等？

假设我有一个由3个整数组成的数组。我希望能够使用just-if语句或for循环从这些数组中获得这些结果

[0,1,2] = 0 equal
[0,1,0] = 2 equal
[0,0,0] = 3 equal

这就是我到目前为止所做的，它是有效的，但我认为它可以简化

int numequal = 0;

if(intarr[0] != null && intarr[1] != null && intarr[0].numequals(intarr[1])) {
    numequal++;
}

if(intarr[0] != null && intarr[2] != null && intarr[0].numequals(intarr[2])) {
    numequal++;
}

if(intarr[1] != null && intarr[2] != null && intarr[1].numequals(intarr[2])) {
    numequal++;
}

if(numequal == 1) {
    numequal = 2;
}

---

同时，我也在努力保持它的基本性。也许只是为了循环。没有哈希集或字典。

这是一个算法问题，可以优化

我将使用一个不同步的键值存储，对于键，我将int作为字符串，对于his计数的值

首先，您将尝试像：hashMap.get（“0”）一样获取它，如果它返回null，则计数为0，然后将其放回：hashMap.put（“0”，新整数（1））

---

除非你不需要，使用非同步版本的hashMap，用谷歌搜索它

这是我的解决方案。它不简单，但非常有效。目前它也计算空元素，如果不需要，可以很容易地修复

    Integer[] a = { null, 2, 1, null, 0, 1 };
    Arrays.sort(a, new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            if (o1 == null) {
                return -1;
            }
            if (o2 == null) {
                return 1;
            }
            return o1.compareTo(o2);
        }
    });
    // [null, null, 0, 1, 1, 2]
    int n = 0;
    Integer prev = null;
    Boolean first = null;
    for (Integer e : a) {
        if (first != null && (e == prev || e != null && e.equals(prev))) {
            if (first == Boolean.TRUE) {
                n += 2;
                first = Boolean.FALSE;
            } else {
                n++;
            }
        } else {
            first = Boolean.TRUE;
        }
        prev = e;
    }
    System.out.println(n);

Integer[]a={null，2，1，null，0，1}；
sort（一个新的比较器（）{
@凌驾
公共整数比较（整数o1，整数o2）{
如果（o1==null）{
返回-1；
}
如果（o2==null）{
返回1；
}
返回o1。与（o2）相比；
}
});
//[null，null，0，1，1，2]
int n=0；
整数prev=null；
布尔第一=空；
for（整数e:a）{
if（first！=null&（e==prev | | e！=null&&e.equals（prev）））{
if（first==Boolean.TRUE）{
n+=2；
first=Boolean.FALSE；
}否则{
n++；
}
}否则{
first=Boolean.TRUE；
}
prev=e；
}
系统输出println（n）；

您可以使用Array.sort并精确地计算它们：

    int[] a = {0,1, 2, 1, 3, 0, 1 };
    int size = 0;
    int counter = 0;
    //sort it and you will get all the equal inters in a sequance.
    Arrays.sort(a);// {0,0,1,1,2,3}
    for(int i = 1; i < a.length; i++){          
        if ( a[i-1] == a[i]){
            counter++;
            if(counter  > size){
                size = counter;
            }
        }else{
            counter = 0;
        }
    }
    return size;

int[]a={0,1,2,1,3,0,1}；
int size=0；
int计数器=0；
//对它排序，你会在一个序列中得到所有相等的间隔。
数组。排序（a）；//{0,0,1,1,2,3}
对于（inti=1；i大小）{
尺寸=计数器；
}
}否则{
计数器=0；
}
}
返回大小；

您可能正在寻找非常简单的解决方案，因此我尝试稍微优化一下您的代码：

int[] intarr = {'0','1','2'};
int numequal = 0; 

if(intarr[0] == intarr[1] || intarr[0] == intarr[2] ){
    numequal++;
}
if( intarr[1] == intarr[2]){
    numequal++;
}

if (numequal > 0 ){
    numequal++;
}

如果您的数组声明为

int[]

，则无需检查

null

intar[1]！=空

---

如果未设置某些项目，则默认为

0

我认为这是最简单的方法（有些可能会要求不同）：

---

您可能已经注意到，您的代码只适用于大小为3的数组。您应该努力编写一个可重用的方法，该方法适用于任何大小的数组（包括0）。一些提示：您需要一个循环（事实上，您需要一个嵌套的循环）。它看起来不太可伸缩-如果数组有1000000个元素怎么办？那么你的代码会是什么样子？我只想用一个for循环就可以了。伙计，他正在学习编程。让他先学会走路。使用for循环，你可以通过迭代一个介于0和“array_size-1”之间的整数索引来迭代数组的元素。对我来说似乎太复杂了。既然你的比较函数考虑了

null

，你为什么不迭代第一个非null元素（

O（N）

）然后只比较相邻元素？不需要考虑角情况，即

null

？另外，为什么要使用

布尔

而不是

布尔

？因为它不是一个基本数组，并且允许空值，所以您需要特殊的比较器，否则Arrays.sort会失败。使用布尔值是因为它也是处理[0]的标志.

因为它不是一个基本数组，允许空值，所以您需要特殊的比较器，否则Arrays.sort会失败。

这与我的评论有什么关系？我的意思是比较器会增加程序的兼容性。比较器会将所有

空值

值放在数组的开头，然后是实际值。所以在排序之后，只需跳过

null

条目（

O（N）

），然后开始寻找相等的相邻对。对于

i=1

的arrayStart区域，您不需要任何角盒，如果（i==0）

int[] x = { 1, 1, 2, 4, 6, 7, 5, 6, 4, 2, 3, 1, 6, 6, 5, 6, 5, 6, 4, 5, 9,
    7, 8, 6, 5, 4, 6 };
int rep = 0;
int finalc = 0;

for (int i = 0; i < x.length; i++) {
  int basec = 0;
  for (int j = 0; j < x.length; j++) {
    if (x[i] == x[j]) {
      basec++;
    }
  }
  if (basec > finalc) {
    finalc = basec;
    rep = x[i];
  }
}

System.out.println("The number " + rep + " is repeated " + finalc +" times");

The number 6 is repeated 8 times