1、数据存储读取文件
2、SharedPreferences
3、SharedPreferences简化
4、泛型的基本用法
5、类委托和委托属性
6、依靠委托自己实现个lazy
-
1、数据存储读取文件
fun saveString(context: Context, str: String) {
try {
val fileOutput = context.openFileOutput("data", Context.MODE_PRIVATE)
val bfs = BufferedWriter(OutputStreamWriter(fileOutput))
bfs.use {
it.write(str)
}
} catch (e: IOException) {
e.printStackTrace()
}
}
fun readString(context: Context): String {
val sb = StringBuilder()
try {
val openFileInput = context.openFileInput("data")
val bis = BufferedReader(InputStreamReader(openFileInput))
bis.use {
it.forEachLine {
sb.append(it)
}
}
} catch (e: Exception) {
e.printStackTrace()
}
return sb.toString()
}
由context的方法提供了openFileOutput方法，写入一个str如上述代码。
use是kotlin的一个内置函数，它保证在lambda表达式结束的时候会自动的流关闭。不用像以前要写finally去关闭流了。
-
2、SharedPreferences
val edit = getSharedPreferences("data", Context.MODE_PRIVATE).edit()
edit.putString("name", "1")
edit.apply()
val edit = getSharedPreferences("data", Context.MODE_PRIVATE)
edit.getString("name", "")
-
3、SharedPreferences简化
fun SharedPreferences.open(bolck: SharedPreferences.Editor.() -> Unit) {
val edit = edit()
edit.bolck()
edit.apply()
}
getSharedPreferences("data", Context.MODE_PRIVATE).open {
putString("name", "1")
}
扩展函数的高阶用法，之前的文章也有讲过类似的。
提供个我自己查资料封装的Sp，仅供参考：
object ShareUtils {
private val sharedPreferences: SharedPreferences
init {
sharedPreferences = App.context.applicationContext.getSharedPreferences(
"name",
Context.MODE_PRIVATE
)
}
fun <T> putValue(name: String, value: T) = with(sharedPreferences.edit()) {
when (value) {
is Int -> putInt(name, value)
is Float -> putFloat(name, value)
is Long -> putLong(name, value)
is Boolean -> putBoolean(name, value)
is String -> putString(name, value)
else -> throw IllegalArgumentException("SharedPreference can't be save this type")
}.apply()
}
fun <T> getValue(name: String, default: T): T = with(sharedPreferences) {
val res: Any? = when (default) {
is Int -> getInt(name, default)
is Float -> getFloat(name, default)
is Long -> getLong(name, default)
is Boolean -> getBoolean(name, default)
is String -> getString(name, default)
else -> throw IllegalArgumentException("SharedPreference can't be get this type")
}
return res as T
}
fun removeKey(name: String) = with(sharedPreferences.edit()) {
remove(name).apply()
}
}
-
4、泛型的基本用法
4.1类的泛型
class MyClass<T> {
fun method(params: T): T {
return params
}
}
4.2方法的泛型
class MyClass {
fun <T> method(params: T): T {
return params
}
}
val myClass = MyClass()
val method = myClass.method<Int>(123)
因为Kotlin有出色的类推导机制。
例如传入Int的参数，它就能自动推导出泛型的类型就是Int，所以上述的使用可以，不用传Int
val myClass = MyClass()
val method = myClass.method(123)
.
除此之外，Kotlin还可以对泛型的类型进行约束
class MyClass {
fun <T : Number> method(params: T): T {
return params
}
}
Number就是指定成数字类型。
4.3对泛型知识进行应用
fun <T> T.build(block: T.() -> Unit): T {
block()
return this
}
val build = StringBuilder().build {
append("123123")
append("123123")
append("123123")
}
build.toString()
-
5、类委托和委托属性
委托的意思就是说把实现交给别的类来实现。就跟定义接口，写这个接口的实现类一样，
class MyClass<T>(val helper: HashSet<T>) : Set<T>{
override val size: Int
get() = helper.size
override fun contains(element: T): Boolean {
return helper.contains(element)
}
override fun containsAll(elements: Collection<T>): Boolean {
return helper.containsAll(elements)
}
override fun isEmpty(): Boolean {
return helper.isEmpty()
}
override fun iterator(): Iterator<T> {
return helper.iterator()
}
}
我把HashSet作为参数传入，并且让类继承Set接口。
就上述代码看的话，会发现有些方法是我必须重写的。如果这个方法几十个或者更多的时候， 这样写肯定是非常繁琐的。于是我加了个by
class MyClass<T>(val helper: HashSet<T>) : Set<T> by helper {
override val size: Int
get() = helper.size
override fun contains(element: T): Boolean {
return helper.contains(element)
}
}
Kotlin委托的关键字是By，我们只需要在接口后面声明，使用by，再加上受委托的对象即可。这样的话，我就不需要重写那么多的样板代码了，根据选择重写实现。并且我还仍然可以使用委托类的属性。
- 委托属性
class MyClass {
var p by ImplTest()
}
class ImplTest {
var pro: Any? = null
operator fun getValue(myClass: MyClass, property: KProperty<*>): Any? {
return pro
}
operator fun setValue(myClass: MyClass, property: KProperty<*>, any: Any?) {
pro = any
}
}
将p委托给了ImplTest。
这样在给p赋值的时候就会调用 setValue方法。如果p是val声明的话， 那就在初始第一次的时候赋值，接下来一直调用getValue就好。
set/getValue，第一个参数是指的委托功能可以在什么类中使用。第二个参数是 属性操作类，此处没有什么用，但是必须要声明，不声明编译过不去。
-
6、依靠委托自己实现个lazy
class latter<T>(val block: () -> T) {
var value: Any? = null
operator fun getValue(any: Any?, property: KProperty<*>): T {
if (value == null) {
value = block()
}
return value as T
}
}
fun <T> later(block: () -> T) = latter(block) //kt文件
上述意思就是 支持任意的类型， 并且在获取之前判断是否为空，为空的话执行block逻辑，做了一个简易的缓存。
val name by later {
println("1312321312313")
}
在声明later之后， 如果没有调用的话，是不会打印出来值的，可以在activity中写个按钮或者别的， 调用name。 来验证实现类懒加载。
网友评论