标签: kotlin-extension

因此,如果扩展方法和扩展属性确实是静态方法和属性.静态方法,属性和方法不是线程安全的,因此应该避免扩展方法和扩展属性不好.

我们只是被欺骗了,因为我们编写的代码看起来很漂亮或干净,但性能方面则不然.

这是真的？

是否可以在带注释的类型上定义Kotlin扩展函数？

@ColorInt
fun @ColorInt Int.darken(): Int {
    return ColorUtils.blendARGB(this, Color.BLACK, 0.2f)
}

替代形式:

@ColorInt
fun (@ColorInt Int).darken(): Int {
    return ColorUtils.blendARGB(this, Color.BLACK, 0.2f)
}

这将对应于以下静态功能:

@ColorInt
fun darken(@ColorInt color: Int): Int {
    return ColorUtils.blendARGB(color, Color.BLACK, 0.2f)
}

我不认为这可能还在使用Kotlin,但是可以在以后的Kotlin版本中添加该功能吗？

在一个侧面说明:同样的问题也适用于@IntDef,@StringDef,@[resource type]Res以及.

我有一个对象QuickSort,我试图创建2个实例.当我尝试创建2个单独的实例时,我可以看到它只使用一个实例,因为我在QuickSort类中有一个不准确的计数.Kotlin 在语法中没有使用new,那么我该怎么做呢？

object QuickSort {
      var count = 0;
      quickSortOne(...){
          ...
          count++
          ...
      }
      quickSortTwo(...){
          ...
          count++
          ...
      }
  } 

以下是我尝试创建2个实例的方法.我的目标是让quickSort1和quickSort2成为2个独立的实例.

var quickSort1 = QuickSort
quickSort1.quickSortOne(...)

var quickSort2 = QuickSort
quickSort2.quickSortTwo(...)

尝试的解决方案:将QuickSort从对象转换为类.这仍然导致使用相同的实例,如第二种方法的计数所示,包括第一次调用计数.

class QuickSort {
      var count = 0;
      quickSortOne(...){
          ...
          count++
          ...
      }
      quickSortTwo(...){
          ...
          count++
          ...
      }
  }

...

var quickSortFirst = QuickSort()
printTest(quickSortFirst.quickSortFirst(arrayList, 0, arrayList.size - 1))

var quickSortLast = QuickSort()
printTest(quickSortLast.quickSortLast(arrayList, 0, arrayList.size …

我想将我的java项目转换为Kotlin,有超过500个java文件.如何轻松将其转换为Kotlin？

我知道我们可以将一个java文件转换为Kotlin,但是有很多文件.

我可以一次转换吗？

嘿,在将Android Studio更新为3.1稳定版后,我的所有项目都出现以下错误.任何帮助将不胜感激.

无法下载kotlin-reflect.jar(org.jetbrains.kotlin:kotlin-reflect:1.1.3-2):没有可用于离线模式的缓存版本

如果我们想在类型上测试扩展函数,我们可以创建这种类型的实例,调用函数并检查返回的值.但是如何测试类中定义的扩展函数呢？

abstract class AbstractClass<T> {
    fun doStuff(): T = "Hello".foo()

    abstract fun String.foo(): T
}

class SubClass1: AbstractClass<Int>() {
    override fun String.foo(): Int = 1
}

class SubClass2: AbstractClass<Boolean>() {
    override fun String.foo(): Boolean = true
}

我们如何测试方法的逻辑foo()中类SubClass1和SubClass2？它甚至可能吗？

我知道我可以改变设计来测试它.我有两种可能性:

1. 不要使用扩展功能.¯\ _(ツ)_ /¯

   abstract class AbstractClass<T> {
       fun doStuff(): T = foo("Hello")
   
       abstract fun foo(string: String): T
   }
   
   class SubClass1: AbstractClass<Int>() {
       override fun foo(string: String): Int = 1
   }
   

   Run Code Online (Sandbox Code Playgroud)

   然后我们可以创建一个对象SubClass1,调用foo()并检查返回的值. …

我是Kotlin的新手，请帮助我如何在Kotlin中使用ViewModelProviders.of（this）

我在Java中的代码是

 mFavViewModel = ViewModelProviders.of(this).get(FavouritesViewModel.class);

我无法在Kotlin中找到ViewModelProviders类，尝试自动转换，但显示错误。谢谢。

这是我的DataModel类

class FavoritesDataViewModel:ViewModel{
    private var mFavHelper: DatabaseHelper
    private lateinit var mfav:ArrayList<Favorites>
     constructor(application: Application) {
        mFavHelper = DatabaseHelper(application)
    }
    fun getListFav():List<Favorites>{
        if (mfav==null){
            mfav =  arrayListOf<Favorites>()
            createDummyList()
            loadFav()
        }
        val clonedFavs = arrayListOf<Favorites>()
        for (i in 0 until mfav.size) {
            clonedFavs.add(Favorites(mfav.get(i)))
        }
        return clonedFavs
    }
    fun createDummyList(){
        addFav("https://www.journaldev.com", Date().getTime())
        addFav("https://www.medium.com", Date().getTime())
        addFav("https://www.reddit.com", Date().getTime())
        addFav("https://www.github.com", Date().getTime())
        addFav("https://www.hackerrank.com", Date().getTime())
        addFav("https://www.developers.android.com", Date().getTime())

    }
    fun addFav(url:String,date:Long):Favorites{
        val db:SQLiteDatabase = this.mFavHelper.getWritableDatabase();
        val values: ContentValues = ContentValues();
        values.put(DbSettings.DbEntry.COL_FAV_DATE,date)
        values.put(DbSettings.DbEntry.COL_FAV_URL,url) …

我的Android项目有两个模块：

app
common

在settings.gradle中：

rootProject.name='My project'
include ':app'
include ':common'

在我的 build.gradle 中：

implementation project(':common')

在公共包中，我有StringUtil.kt和下一个扩展函数：

fun String.isEmailValid(): Boolean {
    return !TextUtils.isEmpty(this) && android.util.Patterns.EMAIL_ADDRESS.matcher(this).matches()
}

在这个类中我可以使用这样的扩展函数：

val str = ""
str.isEmailValid()

但在app模块中我有课

class RegistrationViewModel(application: Application) : AndroidViewModel(application) {

  fun doClickRegistration(email: String?, password: String?, retypePassword: String?) {
        val str = ""
        str.isEmailValid()
    }
}

但现在我得到编译错误：

未解决的参考：isEmailValid

我想减小if-elseif-else梯形图的大小，但不能仅仅when因为智能广播无法捕获我正在处理的情况而使用。我想知道是否可以将诸如a let或an also和a之类的内容组合when到单个内联函数中以解决此问题。

我已经尝试过将智能投射与一起使用，is但这是有问题的，因为我必须when在外部when进行a 运算才能真正获得想要的结果。我最终做了与这篇文章中的一个响应类似的事情：Kotlin和惯用的方式，基于可变的值，通过使一个let块作用于非null变量，然后执行，来编写“如果不为null，否则...”的when内部的块let。

案例我目前正在处理：

variable?.let { safeVariable ->
    when {
        case1 -> doSomething(safeVariable)
        case2 -> doSomethingElse(safeVariable)
         ...
        else -> catchAll(safeVariable)
    }
    return@let
}
Log.e(TAG, "variable was null")

我考虑过的案例：

when(variable) {
    is Type -> when {
                   case1 -> doSomething(variable)
                   case2 -> doSomethingElse(variable)
                   ...
                   else -> catchAll(variable)
               }
   else -> Log.e(TAG, "variable was null")
}

if (variable is …

Kotlin 的惰性委托属性lazy 和lazyFast 之间有什么区别？因为它看起来像相同的代码。

  private val key: String by lazy {
        if (arguments != null && arguments?.getString(Constants.KEY) != null) {
            return@lazy arguments?.getString(Constants.KEY).toString()
        } else {
            return@lazy ""
        }
    }

 private val key: String by lazyFast {
        if (arguments != null && arguments?.getString(Constants.KEY) != null) {
            return@lazyFast arguments?.getString(Constants.KEY).toString()
        } else {
            return@lazyFast ""
        }
    }