小编Dun*_*gor的帖子

scala将多个函数调用参数合并到一个元组中 - 这可以被禁用吗？讨论Scala创建一个绑定到一个arg函数的元组.这导致了

scala> println(1, 2)
(1,2)

答案说编译器允许在没有parens的情况下调用一个arg函数,因此逻辑上这是对带有元组的println的调用.

但是不能使用单个元组参数调用println

scala> val t = (1, 2)
t: (Int, Int) = (1,2)

scala> println t
<console>:6: error: value t is not a member of Unit
       println t
           ^

所以其他事情正在发生.为什么元组在这里特别？

我需要@Autowired使用Spring上下文中的字段填充我的ScalaTest测试,但是大多数Scalatest测试(例如FeatureSpecs不能由SpringJUnit4ClassRunner.class-

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="myPackage.UnitTestSpringConfiguration", loader=AnnotationConfigContextLoader.class)
public class AdminLoginTest {
    @Autowired private WebApplication app;
    @Autowired private SiteDAO siteDAO;

(Java,但你得到了主旨).

如何@Autowired从ApplicationContextScalaTest中填充字段？

class AdminLoginFeatureTest extends FeatureSpec with GivenWhenThen with ShouldMatchersForJUnit {

  @Autowired val app: WebApplication = null
  @Autowired val siteDAO: SiteDAO = null

  feature("Admin Login") {
    scenario("Correct username and password") {...}

我期待在使用一个DoubleLinkedList.它的remove()方法说"从双链表中删除当前节点".但页面中没有其他对当前的引用.

什么是当前节点,如何设置它,当然这不是删除项目的唯一方法？

JodaTime有

public final class DateTime extends BaseDateTime {...}

这是最直接的

public interface ReadableInstant extends Comparable<ReadableInstant>

哈姆克雷斯特

public static <T extends java.lang.Comparable<T>> org.hamcrest.Matcher<? super T>
    greaterThan(T value) {...}

如果我试试

greaterThan(new DateTime());

然后我得到一个编译错误(Eclipse提供了最多的线索)

类型为Matchers的泛型方法greaterThan(T)不适用于参数(DateTime).推断类型DateTime不是有界参数的有效替代>

我是否正确地认为签名本greaterThan应该是

public static <T extends java.lang.Comparable<? super T>> org.hamcrest.Matcher<? super T>     
    greaterThan(T value)

？是否有一种方法可以将这些组合在一起而不是原始的铸造Comparable？

我已经浏览了https://kotlinlang.org/docs/reference但我找不到在Kotlin中使用的保留关键字.Kotlin有多少个关键词？只要我们知道Java有自己的关键字列表,就像这里:

Spring Javaconfig的旧文档说我可以使用

@Bean(scope=DefaultScopes.PROTOTYPE)

获得原型bean,但Spring 3.0.5 @Bean似乎没有这个属性.

有没有办法控制Javaconfig中bean的范围？

据我了解,当它们最终出现时,我们将能够用Java闭包代替等效的单方法接口.是否有标准的Scala习惯用法 - 使用Scala闭包实现Java Single Abstract Method接口？

理想情况下,我希望以下内容能够实现自动化

test("Closure") {
  var event: PropertyChangeEvent = null
  var label = new JLabel()
  label.addPropertyChangeListener( {e: PropertyChangeEvent => event = e} )
  label.setText("fred")
  event.getNewValue should be ("fred")
}

为什么ListMap的不可变版本按升序存储,而可变版本按降序存储？

如果你有scalatest-1.6.1.jar和junit-4.9.jar,这是一个你可以使用的测试

  @Test def StackoverflowQuestion()
  {
    val map = Map("A" -> 5, "B" -> 12, "C" -> 2, "D" -> 9, "E" -> 18)
    val sortedIMMUTABLEMap = collection.immutable.ListMap[String, Int](map.toList.sortBy[Int](_._2): _*)
    println("head : " + sortedIMMUTABLEMap.head._2)
    println("last : " + sortedIMMUTABLEMap.last._2)
    sortedIMMUTABLEMap.foreach(X => println(X))
    assert(sortedIMMUTABLEMap.head._2 < sortedIMMUTABLEMap.last._2)

    val sortedMUTABLEMap = collection.mutable.ListMap[String, Int](map.toList.sortBy[Int](_._2): _*)
    println("head : " + sortedMUTABLEMap.head._2)
    println("last : " + sortedMUTABLEMap.last._2)
    sortedMUTABLEMap.foreach(X => println(X))
    assert(sortedMUTABLEMap.head._2 > sortedMUTABLEMap.last._2)
  }

下面是PASSING测试的输出:

head : 2
last : 18
(C,2)
(A,5)
(D,9)
(B,12) …

在Scala中有两个双精度数的表示,一个是一个AnyVal,另一个是AnyRef.在JVM上,它们分别映射到基元double和类java.lang.Double.

现在除了JVM之外的其他平台会发生什么？我可以Scala.Double用于原语,但是如何指定我想要对盒装Double的引用而不指定java.lang.Double？

[背景 - 留下来理解托马斯的答案,但不是根本问题.

我有一个Double,我想将Spring注入Wicket组件:

class MyPanel(id: String) extends Panel(id) {
  @SpringBean(name="rxAlarmLimitDb") var alarmLimitDb: Double = _

如果我scala.Double按上面指定类型,则注入器失败,因为它只能注入对象.

如果我指定java.lang.Double字段的类型,一切都很好

class MyPanel(id: String) extends Panel(id) {
  @SpringBean(name="rxAlarmLimitDb") var alarmLimitDb: java.lang.Double = _

但是我试图减少我对Java API的依赖,那么如何在Double没有它的情况下代表盒装呢？]

如果Kotlin函数调用为原语提供了原因,Int那么"传递的"类就是盒装基元的类,而不是未装箱的版本.

inline fun <reified T> reify() = T::class

@Test fun reified_type_doesnt_match_for_primitive() {
    assertNotEquals(Int::class, reify<Int>())
    assertNotEquals(Int::class.java, reify<Int>().java)
    assertNotEquals<Any>(Int::class, reify<Int?>())

    val nullableInt: Int? = 42
    assertNotEquals(nullableInt!!.javaClass.kotlin, reify<Int>())

    assertEquals<Any>(java.lang.Integer::class.java, reify<Int>().java)
}

@Test fun reified_type_matches_for_class() {
    assertEquals(String::class, reify<String>())
}

这是一个错误吗？