小编Mar*_*lic的帖子

假设我有一个带有一些业务逻辑的 Java 类：

package examples;

import java.util.List;
import java.util.Map;

public class Inner {
    public void consume(Map<Integer, List<Double>> map) {
        map.forEach((k, v) -> {
            System.out.println("Key: " + k);
            v.forEach(i -> System.out.println("  item: " + i));
        });
    }
}

现在我想编写一个高性能的、尽可能原生的Scala 包装器（因为这个包装器可能会被高频调用），所以：

第一次尝试

package examples

class Wrapper(val asJava: Inner) extends AnyVal {
  implicit def consume(map: Map[Int, List[Double]]): Unit = asJava.consume(map)
}

但得到错误：

[error]  found   : Map[Int,List[Double]]               (in scala.collection.immutable)
[error]  required: Map[Integer,java.util.List[Double]] (in java.util)
[error]   implicit def consume(map: Map[Int, List[Double]]): Unit = …

如果我有一个这样的案例类：

case class Foo(s : String, k : Int)

如何为此指定一个空的构造函数？我需要这个的原因是因为我想将这个类的值传递给一个 Java API，它要求该类有一个空的构造函数。我是否为此指定默认值？我想我必须这样做，我别无选择。

我想知道是否有任何方法可以避免 Scala REPL 通过设置环境变量或其他方式来截断输出？

例子

scala> typeOf[Iterator[_]].members.mkString("\n")
res6: String =
override def toString(): String
def toStream: scala.collection.immutable.Stream[A]
def toIterator: Iterator[A]
def toTraversable: Traversable[A]
def sameElements: <?>
def copyToArray[B >: A](xs: Array[B],start: Int,len: Int): Unit
def patch: <?>
def duplicate: <?>
def length: <?>
def sliding$default$2: <?>
def sliding: <?>
def grouped: <?>
class GroupedIterator extends
def buffered: <?>
def indexOf: <?>
def indexOf: <?>
def indexWhere: <?>
def indexWhere: <?>
def find(p: A => Boolean): Option[A]
def contains: <?>
def …

对于我的测试，我创建了一个对象，其中包含我所有的案例类（即我的生成器）的任意实例：

object Generators
    extends
    FooGen
  {


  def sample[A](implicit gen: Gen[A]): A =
    gen.sample.getOrElse(sys.error(s"Could not generate instance with $gen"))

  implicit def arb[A](implicit g: Gen[A]): Arbitrary[A] = Arbitrary(g)

}

trait FooGen { this: GenUtils =>

  implicit val fooGen: Gen[Foo] = gen[Foo]

}

这当前位于我的 /test 文件夹下，因为我需要它为我的单元测试生成我的案例类的任意实例。但现在我想创建一些集成测试，这些测试将在我的 /it 文件夹下。将 /test 文件夹中的此生成器文件与 /it 文件夹中的测试共享的最佳方法是什么？

我的所有案例类都会有很多这样的生成器，所以我不想复制代码，这就是我问的原因。

抽象成员方法在单例对象中是非法的

scala> object Foo {
     |   def g: Int
     | }
         def g: Int
             ^
On line 2: error: only traits and abstract classes can have declared but undefined members

as is 抽象值成员

scala> object Foo {
     |   val x: Int
     | }
         val x: Int
             ^
On line 2: error: only traits and abstract classes can have declared but undefined members

但是抽象类型成员在单例对象中是合法的

scala> object Foo {
     |   type A
     | }
object Foo

很明显，类型成员抽象的意义与其他抽象成员不同。有什么不同？抽象类型成员如何能有用，因为对象是最终的，它似乎无法具体化？

请考虑以下的基准，其分配List的String与长度为8的长度为1的

@State(Scope.Benchmark)
@BenchmarkMode(Array(Mode.Throughput))
class SoMemory {
  val size = 1_000_000
  @Benchmark def a: List[String] = List.fill[String](size)(Random.nextString(1))
  @Benchmark def b: List[String] = List.fill[String](size)(Random.nextString(8))
}

哪里sbt "jmh:run -i 10 -wi 10 -f 2 -t 1 -prof gc bench.SoMemory"给

[info] Benchmark                                     Mode  Cnt           Score          Error   Units
[info] SoMemory.a                                   thrpt   20          16.650 ±        0.519   ops/s
[info] SoMemory.a:·gc.alloc.rate                    thrpt   20        3870.364 ±      120.687  MB/sec
[info] SoMemory.a:·gc.alloc.rate.norm               thrpt   20   255963282.822 ±       61.012    B/op
[info] SoMemory.a:·gc.churn.PS_Eden_Space           thrpt   20        3862.090 ±      161.598 …

我有一些这样的代码，带有嵌套的迭代器。如果 find 返回和 Some(value)，我想停止，退出 foreach/map 和 return(value)，并继续 incase 的 None。这里的正确方法是什么？

编辑：这是完整的功能

Line Schema: line_id, name

Stop Schema: stop_id, x, y

Time Schema: line_id, stop_id, time

给定时间和 x,y 我想找到 line_id 和 name。所以暂时我坚持获取 valueWhichImTryingToGet。

  def findVehicle(time: String, x: String, y: String) = {
    val stopIter = Source.fromFile("stops.csv").getLines().drop(1)
    val stopCols = stopIter.map(_.split(",").map(_.trim))
    val stopIds = stopCols.filter(arr => arr(1) == x && arr(2) == y)

     val valueWhichImTryingToGet = stopIds.map { arr =>
      val iter = Source.fromFile("times.csv").getLines().drop(1)
      val cols = iter.map(_.split(",").map(_.trim))
      cols.find(col => col(1) …

我在 Scala 中有两个可变映射。

val oldMap = Map(10 -> 100, 20 -> 200, 30 -> 300)
val newMap = Map(10 -> 101, 20 -> 200, 30 -> 299, 40 -> 400)

我想合并newMap成oldMap得到outputMap如下具有从两个地图的所有键，但其值越大匹配键的值。

Map(20 -> 200, 40 -> 400, 10 -> 101, 30 -> 300)

我在下面尝试过并且它有效，但我想知道 Scala 的做法。

import scala.collection.mutable.Map

object Test extends App {

  val oldMap = Map(10 -> 100, 20 -> 200, 30 -> 300)
  val newMap = Map(10 -> 101, 20 -> 200, …

我有一个类似于下面的代码的 Scala 代码。在类/对象级别有一个隐式定义，我想用方法中定义的隐式“覆盖”它。（如果您真的需要知道，我需要ExecutionContext专门针对所讨论的方法更改我的内容）。

在这个例子中，我想在方法的范围内b用作隐式 for 。我怎样才能做到这一点？Intbar

object Foo {
  implicit val a: Int = 1
  def bar: Int = { // Didn't pass implicit Int parameter
    implicit val b: Int = 2
    implicitly[Int]
  }
}

这抱怨

错误：不明确的隐式值：Int 类型的对象 Foo 中的值 a 和 Int 类型的值 b 均匹配预期的 Int 类型

所以我认为 Scala 不能在隐式类范围和隐式方法范围之间进行选择。

我正在努力理解apply函数是否有可能返回特定类的实例。下面是一个例子：

我有一个抽象的特质

trait BaseTrait {
  def add(s: Int): Int
}

以及两个继承此特征的类，以及：

1. 覆盖抽象方法
2. 指定方法 another_method

class Child1 extends BaseTrait {

  override def add(s: Int): Int = {
    s + s
  }

  def another_method(): Unit = {
    println("Another method in Child1")
  }
}

class Child2 extends BaseTrait {

  override def add(s: Int): Int = {
    s + s
  }

  def another_method(): Unit = {
    println("Another method in Child2")
  }
}

当我尝试从 Base Trait 中的实用程序函数访问子类的内容时

object BaseTrait {
  def apply(t: String): …