Java 我们如何使用map‽；

我目前正在解决以下编程练习：语句是：

有一个包含一些数字的数组。除下列数字外，所有数字都相等 一个。试着找到它

Kata.findUniq（新的双[]{1,1,1,2,1,1}）；//=>2. Kata.findUniq（新的双[]{0,0,0.55,0,0}）；//=>0.55

保证数组包含3个以上的数字

测试包含一些非常庞大的阵列，所以请考虑性能

首先，我的想法是将所有元素的频率作为一个映射，然后返回频率值仅为1的键

我写了以下内容：

import java.util.stream.*;

 public class Kata {
    public static double findUniq(double arr[]) {

      Map<Double, Long> frequencies = Arrays.stream(arr)
        .collect(Collectors.groupingBy(n -> n, Collectors.counting()));

      System.out.println("Map: "+map);

    }
}

import java.util.stream.*；
公共类卡塔{
公共静态双findUniq（双arr[]{
映射频率=数组.流（arr）
.collect（Collectors.groupingBy（n->n，Collectors.counting（））；
System.out.println（“Map:+Map”）；
}
}

因此，它输出：

./src/main/java/Kata.java:8: error: method collect in interface DoubleStream cannot be applied to given types;
        .collect(Collectors.groupingBy(n -> n, Collectors.counting()));
        ^
  required: Supplier<R>,ObjDoubleConsumer<R>,BiConsumer<R,R>
  found: Collector<Object,CAP#1,Map<Object,Long>>
  reason: cannot infer type-variable(s) R
    (actual and formal argument lists differ in length)
  where R is a type-variable:
    R extends Object declared in method <R>collect(Supplier<R>,ObjDoubleConsumer<R>,BiConsumer<R,R>)
  where CAP#1 is a fresh type-variable:
    CAP#1 extends Object from capture of ?
./src/main/java/Kata.java:10: error: cannot find symbol
      System.out.println("Map: "+map);
                                 ^
  symbol:   variable map
  location: class Kata
2 errors

/src/main/java/Kata.java:8:错误：接口DoubleStream中的方法collect无法应用于给定类型；
.collect（Collectors.groupingBy（n->n，Collectors.counting（））；
^
必需：供应商、对象双消费者、双消费者
发现：收集器
原因：无法推断类型变量R
（实际参数列表和正式参数列表长度不同）
其中R是一个类型变量：
R扩展方法collect中声明的对象（Supplier、ObjDoubleConsumer、BiConsumer）
其中CAP#1是一个新类型变量：
CAP#1将对象从捕获扩展到？
./src/main/java/Kata.java:10:错误：找不到符号
System.out.println（“Map:+Map”）；
^
符号：变量映射
地点：卡塔级
2个错误

我想解决这个问题的方法是理解：

required: Supplier<R>,ObjDoubleConsumer<R>,BiConsumer<R,R>
  found: Collector<Object,CAP#1,Map<Object,Long>>

必填项：供应商、对象双消费者、双消费者
发现：收集器

我知道它期望：

供应商，ObjDoubleConsumer，BiConsumer

，我正在写：

收集器

，但这意味着什么？我们怎样才能修复它？它为什么会产生

然后我尝试了第二种方法：使用HashSet获取所有不同的double，然后删除不唯一的double，并返回存储在HashSet中的唯一double

import java.util.*;
import java.util.stream.*;

 public class Kata {
    public static double findUniq(double arr[]) {
      System.out.println("\nOriginal array: "+Arrays.toString(arr));

      Set<Double> unique = new HashSet<Double>();
      double repeated = Double.MIN_VALUE;

      for(int i = 0; i < arr.length; i++){
        if(repeated != arr[i] && !unique.add(arr[i])){
          repeated = arr[i];
        }
      }
      unique.remove(repeated);
      System.out.println("Set: "+Arrays.toString(unique.toArray()));
      return (double)unique.toArray()[0];
    }
}

import java.util.*；
导入java.util.stream.*；
公共类卡塔{
公共静态双findUniq（双arr[]{
System.out.println（“\n原始数组：“+Arrays.toString（arr））；
Set unique=新的HashSet（）；
双重重复=双重最小值；
对于（int i=0；i

我的问题是，我们如何实现返回唯一元素，使用第一种方法，使用map计算频率，然后返回值为1的键

我也读过：

---

编译器错误发生的原因是您正在使用的

收集器

无法处理

双流

——原语

双流

的专用

流

类型。您可以先将

双流

转换为

流

，然后应用

收集器

：

Map<Double, Long> frequencies = Arrays.stream(arr)
        .boxed() // this is the key method to call
        .collect(Collectors.groupingBy(n -> n, Collectors.counting()));

---

请注意，还有比这更快的解决方案。请记住，只有一双是不同的

通过使用只能保存唯一元素的

集合

，您可以更轻松地执行此操作。以下是完整的代码：

import java.util.Arrays;
import java.util.Iterator;
import java.util.Set;
import java.util.stream.Collectors;

public class PrintSubarrayMain {

    public static void main(String args[]) {
        int [] arr= {1,1,1,2,1,1};
        Set<Integer> set = Arrays.stream(arr).boxed().collect(Collectors.toSet());  
        Iterator<Integer> itr=set.iterator();
        if(itr.hasNext()) {
            int first = itr.next();
            if(isRepeated(arr,first) && itr.hasNext())
                System.out.println("The unique element is: "+itr.next());
            else
                System.out.println("The unique element is: "+first);
        }               
    }
    static boolean isRepeated(int arr[],int n) {
        int count=0;
        for(int i=0;i<arr.length;i++) {
            if(arr[i]==n)
                count++;
            if(count>1)
                return true;
        }
        return false;
    }
}

---

为标题末尾的问号和感叹号向上投票。以下是您试图调用的DoubleStrem的collect（）方法：。如您所见，它需要3个参数。但你只通过一个论点。所以这不可能编译。您正在使用的collect（）方法存在于类流中，但不存在于您正在使用的类DoubleStream中。因为这个解决方案已经需要装箱，所以您可以使用DoubleStream.boxed（）创建一个流强制注释：装箱所有数字并创建大量映射条目，这样您就不关心性能了。您应该相信，除了一个之外，所有数字都是相等的，并且数组至少有3个元素。如果前两个元素相等，则查找与第一个元素不同的元素。如果它们不同，则使用第三个元素的值来了解唯一元素是第一个元素还是第二个元素。不需要装箱，不需要收集，尽可能快。一个更好的解决方案是避免装箱和填充收集，并依赖于除一之外所有数字都相等的事实。@JBNizet是的，但问题的重点不是解决挑战，所以我会让OP来解决这个问题，我同意。我的评论更多的是为了OP而不是你。我对这个问题加了一句评论。

import java.util.Arrays;
import java.util.Iterator;
import java.util.Set;
import java.util.stream.Collectors;

public class PrintSubarrayMain {

    public static void main(String args[]) {
        int [] arr= {1,1,1,2,1,1};
        Set<Integer> set = Arrays.stream(arr).boxed().collect(Collectors.toSet());  
        Iterator<Integer> itr=set.iterator();
        if(itr.hasNext()) {
            int first = itr.next();
            if(isRepeated(arr,first) && itr.hasNext())
                System.out.println("The unique element is: "+itr.next());
            else
                System.out.println("The unique element is: "+first);
        }               
    }
    static boolean isRepeated(int arr[],int n) {
        int count=0;
        for(int i=0;i<arr.length;i++) {
            if(arr[i]==n)
                count++;
            if(count>1)
                return true;
        }
        return false;
    }
}

The unique element is: 2