在Scala中,我可以使用部分函数轻松地从对象(例如元组)中提取值:
list
.zip(list.reverse)
.foreach{case (x, y) => println(s"$x $y")}
我怎么能在Kotlin那样做？似乎只为赋值和循环支持析构函数.
例如,我从Integer调用一个方法,就像toHexString().
现在我需要通过以下代码将其打印出来.
int i = 123455;
System.out.println(Integer.toHexString(i));
我还没有创建一个名为的新对象Integer.为什么我可以Integer直接使用这个对象？
在Dagger 2中,是否可以注入Map<Class<? extends Foo>, Provider<? extends Foo>>？
假设,我有几个类扩展 Foo
class Bar extends Foo {
@Inject Bar() {}
}
class Baz extends Foo {
@Inject Baz() {}
}
现在我想创建一个FooFactory通过声明
class FooFactory {
@Inject FooFactory(Map<Class<? extends Foo>, Provider<? extends Foo>> providers) {}
}
我能用最小的配置在Dagger 2中做到这一点吗？我读过有关Multibinding但我无法使用它.
几天前,我创建了一个简单的基准测试(没有jmh和所有其他专门的东西,只是为了粗略测量).
我发现,对于同样简单的任务(遍历1000万个数字,对它们进行平方,仅过滤偶数并减少它们的总和),Java的工作速度要快得多.这是代码:
科特林:
fun test() {
println((0 .. 10_000_000L).map { it * it }
.filter { it % 2 == 0L }
.reduce { sum, it -> sum + it })
}
Java的:
public void test() {
System.out.println(LongStream.range(0, 10_000_000)
.map(it -> it * it)
.filter(it -> it % 2 == 0)
.reduce((sum, it) -> sum + it)
.getAsLong());
}
我正在使用Java版本1.8.0_144和Kotlin版本1.2.
在我的硬件上平均需要85毫秒的Java和4,470毫秒的Kotlin执行相应的功能.Kotlin工作速度慢了52倍.
我怀疑Java编译器会产生优化的字节码,但我没想到会看到如此巨大的差异.我想知道我做错了什么？我怎样才能迫使Kotlin更快地工作？我喜欢它,因为它的语法,但52次是一个很大的区别.我只是编写了类似Java 8的代码,而不是普通的旧迭代版本(我相信,它会比给定版本快得多).
我正在尝试为RxKotlin编写自己的扩展函数,这将使Observable句柄成为一个特定的错误类型(Throwable子类),其处理程序作为参数传递并且不再发出任何项目.
大理石图将是:
--- a --- b --- c --- error : T
[ handleError<T>(handler) ]
--- a --- b --- c --- finished
|
handler(error)
我写了以下内容:
public inline fun <reified E : Throwable, R> Observable<R>.handleError(
crossinline handler: (E) -> Unit
) = onErrorResumeNext f@{
return@f when (e) {
is E -> { handler(e); Observable.empty() }
else -> Observable.error(e)
}
}
它工作正常,但要使用它我必须写,例如:
val myObservable: Observable<SomeClass> = ...
myObservable.handleError<IOException, SomeClass> { it.printStackTrace() }
^^^^^^^^^
我不喜欢我必须Observable在handleError …
在Scala中,您可以编写这样的代码.
trait List[T] {
def isEmpty() :Boolean
def head() : T
def tail() : List[T]
}
class Cons[T](val head: T, val tail: List[T]) :List[T] {
def isEmpty = false
}
你不需要覆盖它们已经定义的尾部和头部,但在Kotlin中我必须对此进行编码.
interface List<T> {
fun isEmpty() :Boolean
fun head() : T
fun tail() : List<T>
}
class Cons<T>(val head: T, val tail: List<T>) :List<T> {
override fun isEmpty() = false
override fun head() = head
override fun tail() = tail
}
我的问题是"他们是一个更好的方式来编写我的Kotlin代码吗？"
我想查询任意长度的所有路径
(a)-[:Relation*]->(b)
每对(r1, r2)连续关系的位置
()-[r1]->()-[r2]->()
比如说r2.foo > r1.foo满足了一个条件.
您可以想象foo成为时间戳,我只想找到所有步骤按时间顺序排列的路径.
我现在拥有的是:
MATCH path = ()-[:Relationship*]->()
WITH rels(path) AS rels, path
WHERE reduce(acc = { inOrder: true, previous: rels[0] }, r IN tail(rels) |
{ inOrder: acc.inOrder AND r.foo > acc.previous.foo, previous: r }).inOrder
RETURN path
现在,这似乎有效.但是,我不确定这是否是最有效的查询.有没有更好的方法呢？
我试图将函数传递给Kotlin中的函数,这是我的代码.
fun validateValueWithFunc(value: String, parsefun: (CharSequence) -> Boolean, type: String){
if(parsefun(value))
print("Valid ${type}")
else
print("Invalid ${type}")
}
我传递的函数来自Regex类"containsMatchIn"
val f = Regex.fromLiteral("some regex").containsMatchIn
我知道:: function引用操作符,但我不知道在这种情况下如何使用它
说我有一个Map<String,Pair<String,Any>>.我可以通过使用某种嵌套的多声明来直接迭代所有三个子元素吗？
for ((key, (k, v)) in map)
和
for ((key, k, v) in map)
似乎没有用.
例如Person,只有一种Age方法:
public class Person
{
public int Age()
{
return 6;
}
}
Height()添加了一种方法.
public class Person
{
public int Age()
{
return 6;
}
public int Height()
{
return 6;
}
}
这是一个突破性的变化吗？注意Person不要密封.