Update 3.Kotlin_数字&字符串&数组&集合.md

KotlinCourse/3.Kotlin_数字&字符串&数组&集合.md

@@ -193,11 +193,10 @@ val str = "$s.length is ${s.length}" // 求值结果为 "abc.length is 3"
 
 ### 字符串判等
 
-Kotlin中的判等性主要有两种类型： 
+Kotlin中的判等性主要有两种类型:  
 
-- 结构相等。通过操作符==来判断两个对象的内容是否相等。
-- 引用相等。通
-引用相等由`===`以及其否定形式`!===`操作判断。`a === b`当且仅当`a`和`b`指向同一个对象时求值为`true`。如果比较的是运行时的原始类型，比如Int，那么===判断的效果也等价于==。
+- 结构相等: 通过操作符==来判断两个对象的内容是否相等。
+- 引用相等: 引用相等由`===`以及其否定形式`!===`操作判断。`a === b`当且仅当`a`和`b`指向同一个对象时求值为`true`。如果比较的是运行时的原始类型，比如Int，那么===判断的效果也等价于==。
 
 ```kotlin
 var a = "Java"
@@ -367,7 +366,7 @@ val newList = list.map{it * 2} // 对集合遍历，在遍历过程中，给每
 
 val mStudents = students.filter{it.sex == "m"} // 筛选出性别为男的学生
 
-val scoreTotal = students.sumBy{it.score} // 拥挤和中的sumby实现求和
+val scoreTotal = students.sumBy{it.score} // 用集合中的sumby实现求和
 ```
 
 #### 通过序列提高效率
@@ -391,7 +390,7 @@ list.asSequence().filter {it > 2}.map {it * 2}.toList()
 toList方法将序列转为列表。将list转换为序列，在很大程度上就提高了上面操作集合的效率。
 因为在使用序列的时候filter方法和map方法的操作都没有创建额外的集合，这样当集合中的元素数量巨大的时候，
 就减少了大部分开销。在Kotlin中，序列中元素的求值是惰性的，这就意味着在利用序列进行链式求值的时候，
-不需要像操作普通集合那样，每进行一次求值操作，就产生一个新的集合保存中间数据。那么什么惰性又是什么意思呢？
+不需要像操作普通集合那样，每进行一次求值操作，就产生一个新的集合保存中间数据。那么惰性又是什么意思呢？
 
 #### 惰性求值
 在编程语言理论中，惰性求值(Lazy Evaluation)表示一种在需要时才进行求值的计算方式。
@@ -406,10 +405,10 @@ toList方法将序列转为列表。将list转换为序列，在很大程度上
 list.asSequence().filter {it > 2}.map {it * 2}.toList()
 ```
 
-在这个例子中，我们序列总共执行了两类操作分别是: 
+在这个例子中，我们序列总共执行了两类操作分别是:  
 
-- `filter{it > 2}.map{it * 2}`:filter和map的操作返回的都是序列，我们将这类操作称为中间操作。
-- `toList()`:这一类操作将序列转换为List，我们将这类操作称为末端操作。
+- `filter{it > 2}.map{it * 2}`: filter和map的操作返回的都是序列，我们将这类操作称为中间操作。
+- `toList()`: 这一类操作将序列转换为List，我们将这类操作称为末端操作。
 
 其实，Kotlin中序列的操作就分为两类： 
 
@@ -432,10 +431,10 @@ list.asSequence().filter {it > 2}.map {it * 2}.toList()
 - 末端操作
 
  在对集合进行操作的时候，大部分情况下，我们在意的只是结果，而不是中间过程。
- 末端操作就是一个返回结果的操作，它的返回值不能是序列，必须是一个明确的结果，
- 比如列表、数字、对象等表意明确的结果。末端操作一般都放在链式操作的末尾，
- 在执行末端操作的时候，会去触发中间操作的延迟计算，也就是将”被需要“这个状态打开了，
- 我们给上面的例子加上末端操作: 
+  末端操作就是一个返回结果的操作，它的返回值不能是序列，必须是一个明确的结果，
+  比如列表、数字、对象等表意明确的结果。末端操作一般都放在链式操作的末尾，
+  在执行末端操作的时候，会去触发中间操作的延迟计算，也就是将”被需要“这个状态打开了，
+  我们给上面的例子加上末端操作: 
 
  ```kotlin
  list.asSequence().filter {
@@ -458,10 +457,10 @@ list.asSequence().filter {it > 2}.map {it * 2}.toList()
  ```
 
  可以看到，所有的中间操作都被执行了。从上面执行打印的结果我们发现，它的执行顺序与我们预想的不一样。
- 普通集合在进行链式操作的时候会先在list上调用filter，然后产生一个结果列表，接下来map就在这个结果列表上进行操作。
- 而序列则不一样，序列在执行链式操作的时候，会将所有的操作都应用在一个元素上，也就是说，第一个元素执行完所有的操作之后，
- 第二个元素再去执行所有的操作，以此类推。放到我们这个例子上面，就是第一个元素执行了filter之后再去执行map，
- 然后第二个元素也是这样。
+  普通集合在进行链式操作的时候会先在list上调用filter，然后产生一个结果列表，接下来map就在这个结果列表上进行操作。
+  而序列则不一样，序列在执行链式操作的时候，会将所有的操作都应用在一个元素上，也就是说，第一个元素执行完所有的操作之后，
+  第二个元素再去执行所有的操作，以此类推。放到我们这个例子上面，就是第一个元素执行了filter之后再去执行map，
+  然后第二个元素也是这样。
 
 #### 序列可以是无限的
 
@@ -525,7 +524,7 @@ if(str == null) {
 }
 ```
 
-那么如果我们需要的就是一个`Int`的结果(事实上大部分情况都是如此)，那又该怎么办呢？在`kotlin`中除了`?`表示可为空以外，还有一个新的符号:双感叹号`!!`，表示一定不能为空。所以上面的例子，如果要对`result`进行操作，可以这么写: 
+那么如果我们需要的就是一个`Int`的结果(事实上大部分情况都是如此)，那又该怎么办呢？在`kotlin`中除了`?`表示可为空以外，还有一个新的双感叹号`!!`符号，表示一定不能为空。所以上面的例子，如果要对`result`进行操作，可以这么写: 
 
 ```kotlin
 var str : String? = null