小编sen*_*nia的帖子

如何合并如下地图:

Map1 = Map(1 -> Class1(1), 2 -> Class1(2))
Map2 = Map(2 -> Class2(1), 3 -> Class2(2))

合并后.

Merged = Map( 1 -> List(Class1(1)), 2 -> List(Class1(2), Class2(1)), 3 -> Class2(2))

可以是List,Set或具有size属性的任何其他集合.

字符串插值比串联在scala中构建字符串更高效吗？例如:

val myVal = "def"
val test = s"abs${myVal}ghi"

VS

val test = "abc" + myVal + "ghi"

我问的是因为我需要为具有大量参数的内容编写toString方法,因此内插字符串变得非常冗长且令人困惑,我想将其分解为多行但是担心如果我连接它会表现不好.class

我正在使用Groovy脚本Mule ESB从Oracle存储过程(包括游标)获取输出参数并获得异常.

最小的例子:

import groovy.sql.Sql
import oracle.jdbc.pool.OracleDataSource
import oracle.jdbc.driver.OracleTypes

def ds = new OracleDataSource()
// setting data source parameters here

def sql = new Sql(ds)
def data = []

sql.call("""declare
result_table sys_refcursor;
begin

open result_table for select 1 as a from dual;

insert into CURSOR_TEST (ID) values (1);
commit;

${Sql.resultSet OracleTypes.CURSOR} := result_table;

insert into CURSOR_TEST (ID) values (2);
commit;

end;
"""
){ table ->

  throw new RuntimeException("Never getting this exception.")

  table.eachRow {
    data …

我是一个scala初学者,并试图了解val如何在Scala中工作.我读到vals无法修改.当我执行以下操作时:

for( line <- Source.fromFile(args(0)).getLines() ) {
   val currentLine = line
   println(currentLine)
}

currentLine在每次迭代中都会更新,而我希望它可以用第一行初始化并保持到最后,或者至少给出某种重新初始化错误.为什么会这样？是否在每次迭代中创建并销毁了val？我的第二个问题:如果在下面的代码中我想使用x outside.

if( some condition is satisfied) val x = 2 else val x = 3

截至目前,我正在收到"非法表达简单表达"错误.有没有办法在外面使用x？

为什么我不能在代码块中递归地定义变量？

scala> {
     | val test: Stream[Int] = 1 #:: test
     | }
<console>:9: error: forward reference extends over definition of value test
              val test: Stream[Int] = 1 #:: test
                                            ^

scala> val test: Stream[Int] = 1 #:: test
test: Stream[Int] = Stream(1, ?)

lazy 关键字解决了这个问题,但我无法理解为什么它没有代码块但在代码块中抛出编译错误.

我有类,参数化HList和其他类型.如何使用map对HList在其方法之一？

编译此代码抛出java.lang.AssertionError:

class Test[L <: HList, P](l: L, p: P) {
  type Cont[T] = (P, T)
  object generator extends (Id ~> Cont) {
    def apply[T](t: T) = p -> t
  }
  def test(implicit m: Mapper[generator.type, L]) = {
    l map generator
  }
}

new Test(1 :: HNil, 'a).test // java.lang.AssertionError

我的目标是这样的结果:

type Cont[T] = (Symbol, T)
val p = 'a
object generator extends (Id ~> Cont) {
  def apply[T](t: T) = p …

我更改了一些代码，速度提高了4.5倍。我想知道为什么。过去基本上是：

def doThing(queue: Queue[(String, String)]): Queue[(String, String)] = queue match {
  case Queue((thing, stuff), _*) => doThing(queue.tail)
  case _ => queue
}

我将其更改为此，以极大地提高速度：

def doThing(queue: Queue[(String, String)]): Queue[(String, String)] = queue.headOption match {
  case Some((thing, stuff)) => doThing(queue.tail)
  case _ => queue
}

做_*什么和为什么与headOption相比如此昂贵？

Scala中至少有两种技术可以将默认值传递给方法

1)默认参数值

scala> def f(i: Int = 0) = i
f: (i: Int)Int

scala> f()
res0: Int = 0

scala> f(1)
res1: Int = 1

2)隐含参数

scala> def g(implicit i: Int) = i
g: (implicit i: Int)Int

scala> implicit val default = 0
default: Int = 0

scala> g(1)
res5: Int = 1

scala> g
res7: Int = 0

在哪种情况下你选择一个或另一个？凭借隐式的力量,默认值是一个有用的功能吗？

如何在控制器方法中获取ServerWebExchange或反应ServerHttpResponse？

我一直NestedServletException在尝试调用accept的rest controller方法ServerWebExchange。

我的控制器如下所示：

@RestController
@RequestMapping(path = "/path/{param1}/path", produces = MediaType.APPLICATION_JSON_VALUE)
public class MyController {
    @GetMapping("/path")
    public Mono<Void> method(ServerWebExchange exchange) {
        ...
    }
}

主要方法：

@SpringBootApplication
@ComponentScan(basePackages = {"my.package1", "my.package2"})
@EnableWebFlux
public class MyApp {
    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args);
    }
}

例外：

io.undertow.request：UT005023：对/ path / value / path / path的异常处理请求

org.springframework.web.util.NestedServletException：请求处理失败；嵌套的异常是java.lang.IllegalStateException：没有为接口org.springframework.web.server.ServerWebExchange找到主要或默认构造函数

有两种方法,都返回xml:

 def method1 = 
   <?xml version="1.0" encoding="utf-8"?>
    <soap:Envelope>
      <soap:Header>
        {Elem(....)}
      </soap:Header>
    </soap:Envelope>

 def method2 = 
  <someXml>
    //.......
  </someXml>

还有一种方法可以获得Elem:

def method3(a: Elem) = //....

val xml1 = method1
val xml2 = method2

method3(xml1) //error
method3(xml2) //ok

它说method1回报NodeBuffer并且不能接受它,而method2回报则Elem完全没问题.

这是为什么？我该怎么办？