小编Ily*_*lya的帖子

我有一个像下面这样的抽象类:

abstract class AbstractSync<out C : Configuration<*>> : ISync {
    internal abstract val configuration: C
    ...
}

我想要另一个继承自此的抽象类:

abstract class CascadedSync : AbstractSync {}

CascadedSync类不应该修改泛型参数C,实际上它应该只实现一个ISync方法而不是其他方法.

我正在尝试不同的语法来实现这个看似简单的任务.在Java中,这看起来像这样:

abstract class CascadedSync extends AbstractSync {    
}

在IntelliJ的帮助下将其翻译成Kotlin会产生以下结果:

abstract class CascadedSync : AbstractSync<*>()

但同时给出以下错误:

对于超类型的直接子类型,不允许进行投影

什么是正确的语法？

我正在尝试kotlin,我在这里有一个简单的例子:

var byteToAdd: Byte = 3
var byteArray = byteArrayOf(1, 2, 3, 4, 5)
byteArray[0] += byteToAdd
println(byteArray[0])

但在执行的时候,我得到的第3行的错误,因为它说,这byteToAdd是一个Integer,即使我设置的类型byteToAdd,以Byte1号线.

为什么会这样？

我正在处理一个相当古老的项目，其中包含大量 Java 代码，要替换它，这太麻烦了，而且由于 kotlin 比 Java 好得多，我正在尝试将所有新代码混合在一起kotlin 中的代码，但是当我尝试使用此 kotlin 代码访问 java 代码时

val params = mutableMapOf<String, String>(
    "name" to response.name,
    "type" to response.type
)
product.params = params

我在下面有一个红色下划线params，它说

Required: Hashmap<String!, Any!>!
Found: MutableMap<String, String>

这是我的 java setter

public void setParams(HashMap<String, Object> params){
    this.params = params;
}

我可以在不更改 java 代码的情况下解决这个问题吗？如果可能，请提供帮助，如果可能，请提供帮助，以及解决此问题的解决方法是什么。

让我们想象一下这样的事情:

var num: Float = 0.0f
num = 2.4 * 3.5 / 3.8

num 有几个小数,但我只想要2.

在JS我会用num.toFixed(2).

这里的其他答案建议使用"%.2f".format(num)或num.format(2).后者需要自定义扩展乐趣:

fun Double.format(digits: Int) = java.lang.String.format("%.${digits}f", this)

但是,这些选项中的任何一个都会导致"未解析的引用"的编译器错误.我不认为是进口的问题,因为编译器会建议它.

是否有捷径可寻？

我没有找到如何在Kotlin中声明具有预定义大小的数组而不对其进行初始化。

还行吧：

lateinit var v:Array<Int>

但我猜想不能在数组类型中指定大小。

如果需要指定尺寸。必须做的事：

var v2:Array<Int> = Array<Int>(2){5}

在这种情况下，向量的所有元素都等于 5

下面是一个包含类和数组的示例：

data class But(
    val fufo: Int=0,
    val tp: Int = 1 
)  
typealias  ArBut = Array<But>
data class CArray (
   var arrayC: ArBut = ArBut(2){But()}
)    
val a =   CArray(arrayOf(But(2,2),But(5,4),But(3,3)))
println(a.arrayC[2])

有用！有趣的是，初始化不是类型的一部分，您可以将任意大小的数组放入类中，而无需进行边界检查。如果尺寸是类型规格的一部分，情况会有所不同。

现在是一个例子，使用矩阵。请注意，语法有点复杂。

data class CMatr (
   val matrC: Array<ArBut>  = Array<ArBut>(2){ArBut(0){But()}}
)    
 val m =   CMatr(arrayOf( arrayOf(But(2,2),But(5,4)),   
         arrayOf(But(-2,2),But(3,4)), arrayOf(But(1,1),But(5,3))  ))
 println(m.matrC[2][1])  // Also works! 

是否不可能将大小放入数组类型规范中，或者我遗漏了一些东西？

我试图继承以下类型,但编译器说它是最终的.

class Dice(private var side : Int)
{
    constructor(D : DiceTypesK) : this(D.value) {}
}

class ExplodedDice(private val D : DiceTypesK) : Dice(D) 
                                              // ^^^^ this class is final and
                                              //      can not be inherited from

为什么我的类型是最终的,因为我不打算这样做？

fun main(args: Array<String>) {

  var _array = arrayOf(1 , 2 , 3.14 , 'A', "item" , "a b c d", 4)

  println("$_array[3]")  // [Ljava.lang.Object;@1b6d3586[3]
  println("${_array[3]}") // A
  println(_array[3]) // A

  println( _array[3] + " is _array's item") // ERROR
  println( "" + _array[3] + " is _array's item") // A is _array's item

} 

我很困惑为什么上面的代码产生不同的输出

我正在尝试使用我在这个答案toInt()中找到的函数将字符串转换为 Kotlin 中的整数值，但我得到的是 ascii 值。

我做错了什么？

var input = "8569 2478 0383 3437"

val regex = "[^0-9]".toRegex()
var value = regex.replace(input, "")

val iterator = value.iterator()

var sum : Int = 0
var v : Int
for((index, value) in iterator.withIndex()){
    if(index % 2 == 0){
        var v = value.toInt() * 2 
        if(v > 9) v -= 9

        print("$v:$value ")
        sum += v
    }else{
        print("$value ")
        sum += value.toInt()
    }
}

执行上面的代码，这是打印的数字

103:8 5 99:6 9 91:2 4 101:7 …

最近我遇到了一个问题，我有一个函数必须返回一个Is数组，以 enum 的所有值的形式E，E实现 interface I，我想到的每个代码编译器都抱怨类型不匹配：

Error:(x, x) Kotlin: Type mismatch: inferred type is Array<E> but Array<I> was expected

一个最小的例子：

    interface I {}
    enum class E: I {
        A, B, C;
    }
    fun getMoreInterfaces(): Array<I> {
        return E.values()
    }

当尝试分配E.values()给类型的变量时会发生这种情况，Array<I> 我很确定这应该是可能的，因为E实现了I.

我在测试时想到的另一件事是，像这样使用时它工作得很好：

    interface I {}
    enum class E: I {
        A, B, C;
    }
    fun getMoreInterfaces(): Array<I> {
        return arrayOf(E.A, E.B, E.C)
    }

我在这个主题上做了很多搜索，但没有运气（也许我选择了错误的描述方式？）

我对generateSequenceKotlin 中的感到困惑。我似乎阅读手册都错了：

这是函数签名（用于generateSequence种子）：

fun <T : Any> generateSequence(
    seed: T?, 
    nextFunction: (T) -> T?
): Sequence<T>

所以Sequence应该是相同类型的种子，下一个值也应该是下一个迭代代......

但是男人的例子是：

fun fibonacci(): Sequence<Int> {
    return generateSequence(Pair(0, 1), { Pair(it.second, it.first + it.second) }).map { it.first }
}
?
println(fibonacci().take(10).toList()) // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

所以看起来SequenceisInt的类型是种子 is Pair<Int, Int>。

生成器函数映射Pair<Int, Int>TO Int。下一个值如何发送到生成器，下一个Pair<Int, Int>构造在哪里（生成器的输出是Int...）？

这个函数到底是怎么知道什么时候停止的？生成器永不返回null