小编use*_*ser的帖子

我找不到以下语法规则的解释：

FunType ::= FunTypeArgs (\xe2\x80\x98=>\xe2\x80\x99 | \xe2\x80\x98?=>\xe2\x80\x99) Type\n

implicitScala 2 中的关键字和Scala 3 中的given+有什么区别？using是否只是implicit被分成了两个关键字，或者语义也不同，如果是，是如何不同的？

我试图List通过将它们添加到 aSet和List同时使用Stream.filter和Stream.map

List<String> strings = Arrays.asList("foo", "bar", "foo", "baz", "foo", "bar");

Set<String> distinct = new HashSet<>();
List<String> extras = new ArrayList<>();

strings
  .stream()
  .filter(x -> !distinct.add(x))
  .map(extra -> extras.add(extra));

最后，我希望distinct是[foo, bar, baz]和extras将是[foo, foo, bar]，因为有 2 个额外的 实例foo和 1 个bar。但是，在我运行这个之后它们都是空的。

从未调用过提供给流的 lambda，我通过尝试在里面打印来验证map：

.map(extra -> {
  System.out.println(extra);
  return extras.add(extra);
})

当我尝试put与Map两者一起使用时，这不起作用。我究竟做错了什么？

注意：可能还有其他与此类似的问题，但我正在寻找一种规范的答案，以解释为什么此类内容不适用于 Java 8 的 …

我正在尝试返回一个具有 name 属性的新对象。但它一直给我这个错误，但代码编译没有任何问题。我正在使用Angular 9和AnfularFirestore访问Firebase

this.db
  .collection('availableExercises')
  .snapshotChanges()
  .pipe(
    map(docArray => {
        return docArray.map(doc => {
            return {
                id: doc.payload.doc.id,
                name: doc.payload.doc.data().name,
                duration: doc.payload.doc.data().duration,
                calories: doc.payload.doc.data().calories
            };
        });
    })
  ).subscribe((exercises: Exercise[]) => {
      this.availableExercises = exercises;
      this.exercisesChanged.next([...this.availableExercises]);
  });

这是我用于练习的界面

export interface Exercise{
  id: string;
  name: string;
  duration: number;
  calories: number;
  date?: Date;
  state?: 'completed' | 'cancelled' | null;
}

Set<Integer> s = new HashSet<Integer>();
s.add(77);
s.add(0);
s.add(1);
 
System.out.println(s);
 
TreeSet<Integer> s1 = new TreeSet<Integer>();
s1.add(77);
s1.add(0);
s1.add(1);
 
System.out.println(s1);

输出：

s = [0, 1, 77]
s1= [0, 1, 77]

根据教程点页面上的定义

Set 是一组没有重复元素的通用值。TreeSet 是对元素进行排序的集合。

为什么输出都s和s1排序？我期望只对s1's 输出进​​行排序。

我有一个名为 Annot 的 Maven 项目，其中包含一个注释“MyAnnot”及其处理器，另一个名为 UseAnnot 的纯 Java 项目包含 MyAnnot（一个名为 User.java 的类用它进行注释。当我指定 UseAnnot 使用“com使用 META-INF.services 目录的 Annot 模块中的“.home.Proc”处理器，一切正常，但现在我使用的是 java 11 并放置了“uses javax.annotation.processing.Processor”和“provides Processor with com” .home.Proc”在各自的模块信息文件中，编译器无法识别注释处理器。

我在Windows cmd中尝试过以下命令：

    javac -cp .;%USERPROFILE%\IdeaProjects\Annot\target\Annot-1.0- 
    SNAPSHOT.jar com\learn\User.java

    javac --module-path 
    %USERPROFILE%\IdeaProjects\Annot\target\Annot-1.0-SNAPSHOT.jar 
    com\learn\User.java

这是 Annot 模块信息文件：

    import javax.annotation.processing.Processor;

    module Annot {
        requires java.compiler;
        exports com.home;
        provides Processor with com.home.Proc;
    }

这是 UseAnnot 模块信息文件：

    module UseAnnot {
        requires java.compiler;
        requires Annot;
        uses javax.annotation.processing.Processor;
    }

UseAnnot\src\com\learn\User.java 看起来像这样：

    package com.learn;

    import com.home.MyAnnot;

    @MyAnnot
    public class User {
        public static …

我一直在尝试使用注释处理器修改 AST。我尝试扩展 Lombok，但这似乎太难了，所以我决定使用 com.sun.source.* 和 com.sun.tools.javac.* 中的东西。但是，我使用的是 java 11，以及我正在学习的文档, "The Hacker's Guide to Javac" http://scg.unibe.ch/archive/projects/Erni08b.pdf，使用 Java 6。他们使用的 api 现在是内部的，我的模块无法读取它。

在 IntelliJ 中，它给了我一些错误，但是我点击了建议（其中说的是“将 --Xxx-xxx 添加到 xxx”之类的内容而没有注意它们。当我尝试使用 Maven 编译时，它失败了，因为模块不读取 jdk.compiler 的内部结构。

这些是我的一些进口：

    import com.sun.source.util.Trees;
    import com.sun.tools.javac.tree.JCTree;
    import com.sun.tools.javac.tree.TreeMaker;
    import com.sun.tools.javac.tree.TreeTranslator;
    import com.sun.tools.javac.util.Context;

我的模块信息文件包含

    requires jdk.compiler;
    requires java.compiler;

我收到诸如“[ERROR]package com.sun.tools.javac.util 已在模块 jdk.compiler 中声明，但不会将其导出到模块 OtherAnnot”和“[ERROR]（包 com.sun.tools.javac.树在模块 jdk.compiler 中声明，它不会将其导出到模块 OtherAnnot)"

编辑：我想这是重复的，但我想知道在 java 9 中是否有一些用于 AST 转换的替代 API。

由于我无法控制的原因，我的方法以元组的形式接收输入。这个元组应该只包含 的实例Foo，即它应该看起来像(Foo, Foo ... Foo)并且不应该有String或Int在里面。我想在编译时检查这个而不是在运行时抛出异常。我怎样才能做到这一点？

以下是我目前拥有的代码，这是不对的：

def f(tupleOfFoos: Tuple): Tuple = {
  for (x <- tupleOfFoos) assert(x.isInstanceOf[Foo])
  mapTuple(tupleOfFoos, irrelevantFunction)
}

我愿意使用 Shapeless 或 Dotty/Scala 3 中引入的新功能。

我有一个不透明类型，它是通过在伴生对象范围中FancyDouble使用从 Double 隐式转换的。given Conversion[Double, FancyDouble] = FancyDouble(_)之后，构造val d: FancyDouble = 0.0工作，但是当我尝试进行类似的比较时if (d == 0.0)，编译器抱怨我无法比较FanceDoubleand Double（我期望它应该将0.0文字隐式转换为 FancyDouble，就像前面的情况一样。

如何启用与隐式转换的比较？

在学习 Scala 3 时，我看到了一种新的编写方式main：

@main def main1 =
  println("main1 printed something")

我检查了来源@main，它只是

class main extends scala.annotation.Annotation {}

使用@main这里发生了什么？