前言
上节我们讲了集合Set相关知识,大家感兴趣的可参看以下文章
[1]Kotlin中的算数运算
[2]二元运算符 ?:
[3]Any的使用 - 简书
[4]数组Array
[5]Predicate的使用
[6]字符串String
[7]集合List
[8]集合Set及优化类DataUtil,ArrayUtil
今天我们来讲讲List集合相关的优化。今天涉及的内容有：
1.List，Set集合
2.对集合中retainAll方法的理解
3.ListUtil优化及在Activity中的使用
4.ListUtil及相关优化类源码
一. List,Set集合
我们都知道，List与Set都属于集合的一份子，让我们重温下它们在集合中的各自继承关系：
List集合继承关系如下：
List-> Collection-> Iterable
Set集合继承关系如下：
Set-> Collection-> Iterable
基于List与Set有共同的父类Collection，那么他们在方法使用上应该会有不少的共同点，这也给List的使用做优化提供了空间。
对于集合List与Set的使用，大家可以参考以下文章:
[7]集合List
[8]集合Set及优化类DataUtil,ArrayUtil
二.对集合中 retainAll 方法的理解
在集合List与Set的使用过程中，有一个特别的方法：
public fun retainAll(elements: Collection<E>): Boolean
其使用说明大致如下：
仅保留此集合中包含在指定集合中的元素。
返回:
如果从集合中删除了任何元素，则为True；如果未修改集合，则为false。
这里retainAll方法很显然可用于两个集合取交集时使用，但是对于其返回值，我们需要做进一步论证。
之前，我们写了一个两个集合取交集的方法，如下：
/***
* 取两个集合的交集
*
* @param mutableTempList MutableList<T>
* @param elements Collection<T>
*/
fun <T> retainAll(mutableTempList: MutableList<T>, elements: Collection<T>): Pair<Boolean?, MutableList<T>?> {
var flag = mutableTempList.retainAll(elements)
return PairUtil.createPair(flag, mutableTempList)
}
下面让我们对retainAll做些代码测试：
//取交集
//mutableList6001 与 mutableList6002 元素一样
var mutableList6001 = mutableListOf("a", "b", "c")
var mutableList6002 = mutableListOf("a", "b", "c")
LogUtil.i("取交集前: mutableList6001=${mutableList6001} mutableList6002=${mutableList6002}")
var pair6001 = ListUtil.retainAll(mutableList6001, mutableList6002)
LogUtil.i("retainAll后: flag=${pair6001.first} mutableList=${pair6001.second}")
//mutableList6003 与 mutableList6004 有交集
var mutableList6003 = mutableListOf("a", "b", "c")
var mutableList6004 = mutableListOf("b", "c", "d")
LogUtil.i("取交集前: mutableList6003=${mutableList6003} mutableList6004=${mutableList6004}")
var pair6003 = ListUtil.retainAll(mutableList6003, mutableList6004)
LogUtil.i("retainAll后: flag=${pair6003.first} mutableList=${pair6003.second}")
//mutableList6005 与 mutableList6006 无交集
var mutableList6005 = mutableListOf("a", "b")
var mutableList6006 = mutableListOf("c", "d")
LogUtil.i("取交集前: mutableList6005=${mutableList6005} mutableList6006=${mutableList6006}")
var pair6005 = ListUtil.retainAll(mutableList6005, mutableList6006)
LogUtil.i("retainAll后: flag=${pair6005.first} mutableList=${pair6005.second}")
运行结果如下:
14:23:41.806 I 取交集前: mutableList6001=[a, b, c] mutableList6002=[a, b, c]
14:23:41.808 I retainAll后: flag=false mutableList=[a, b, c]
14:23:41.813 I 取交集前: mutableList6003=[a, b, c] mutableList6004=[b, c, d]
14:23:41.813 I retainAll后: flag=true mutableList=[b, c]
14:23:41.814 I 取交集前: mutableList6005=[a, b] mutableList6006=[c, d]
14:23:41.815 I retainAll后: flag=true mutableList=[]
由此，我们发现retainAll方法的返回值有以下特点:
- 取交集后若原集合没有变化，返回值为
false - 取交集后若原集合有变化且不为
null，返回值返回true - 取交集后若原集合为
null，返回值返回true
综上所述，以retainAll方法的特点，我们无法利用该方法的返回值来判断两个集合是否有交集。于是，我这边在此基础上，做了一些优化，若想获取两个集合的交集，可以使用以下方法：
/***
* 取两个集合的交集
*
* @param mutableCollection MutableCollection<T>
* @param elements Collection<T>
* @return Pair<Boolean?, MutableCollection<T>?>: flag: true 集合mutableCollection与集合elements有交集
* false 集合mutableCollection与集合elements无交集
* collection：集合mutableCollection与集合elements交集之后的结果
*/
fun <T> intersect(mutableCollection: MutableCollection<T>, elements: Collection<T>): Pair<Boolean?, MutableCollection<T>?> {
测试获取交集的代码如下：
//取交集
//mutableList6001 与 mutableList6002 元素一样
var mutableList6001 = mutableListOf("a", "b", "c")
var mutableList6002 = mutableListOf("a", "b", "c")
LogUtil.i("取交集前: mutableList6001=${mutableList6001} mutableList6002=${mutableList6002}")
var pair6002 = ListUtil.intersect(mutableList6001, mutableList6002)
LogUtil.i("取交集后: flag=${pair6002.first} mutableList=${pair6002.second}")
//mutableList6003 与 mutableList6004 有交集
var mutableList6003 = mutableListOf("a", "b", "c")
var mutableList6004 = mutableListOf("b", "c", "d")
LogUtil.i("取交集前: mutableList6003=${mutableList6003} mutableList6004=${mutableList6004}")
var pair6004 = ListUtil.intersect(mutableList6003, mutableList6004)
LogUtil.i("取交集后: flag=${pair6004.first} mutableList=${pair6004.second}")
//mutableList6005 与 mutableList6006 无交集
var mutableList6005 = mutableListOf("a", "b")
var mutableList6006 = mutableListOf("c", "d")
LogUtil.i("取交集前: mutableList6005=${mutableList6005} mutableList6006=${mutableList6006}")
var pair6006 = ListUtil.intersect(mutableList6005, mutableList6006)
LogUtil.i("取交集后: flag=${pair6006.first} mutableList=${pair6006.second}")
运行结果如下：
14:23:41.806 I 取交集前: mutableList6001=[a, b, c] mutableList6002=[a, b, c]
14:23:41.812 I 取交集后: flag=true mutableList=[a, b, c]
14:23:41.813 I 取交集前: mutableList6003=[a, b, c] mutableList6004=[b, c, d]
14:23:41.813 I 取交集后: flag=true mutableList=[b, c]
14:23:41.814 I 取交集前: mutableList6005=[a, b] mutableList6006=[c, d]
14:23:41.815 I 取交集后: flag=false mutableList=[]
如此，便实现了在flag中获取两个集合是否有交集，在MutableCollection中获取交集的结果。
三. ListUtil 优化及在 Activity 中的使用
下面给出优化后的ListUtil在TestActivity中的使用代码(部分其他方法的使用可以参考之前的List集合及Set集合的讲解)：
package com.example.kdemo.ui.test
import android.os.Build
import android.os.Bundle
import android.view.View
import androidx.annotation.RequiresApi
import androidx.appcompat.app.AppCompatActivity
import com.example.kdemo.R
import com.example.kdemo.databinding.ActivityTestBinding
import com.example.kdemo.util.data.collection.ListUtil
import com.example.kdemo.util.data.collection.SetUtil
import com.example.kdemo.util.data.normal.PairUtil
import com.example.kdemo.util.log.LogUtil
import com.example.kdemo.util.toast.ToastUtil
class TestActivity : AppCompatActivity(), View.OnClickListener {
private lateinit var mBinding: ActivityTestBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
mBinding = ActivityTestBinding.inflate(layoutInflater)
setContentView(mBinding.root)
initData()
setListener()
}
private fun initData() {}
private fun setListener() {
mBinding.mBtnTest.setOnClickListener(this)
}
@RequiresApi(Build.VERSION_CODES.Q)
override fun onClick(view: View) {
when (view.id) {
R.id.mBtnTest -> {
test()
}
else -> {
}
}
}
private fun test() {
ToastUtil.showShortToast(this, "begin test")
//添加元素
var mutableList1 = mutableListOf<String>()
LogUtil.i("mutableList1 添加元素前: ${mutableList1}")
var pair1 = ListUtil.add(mutableList1, "a")
LogUtil.i("mutableList1 添加元素后: flag=${pair1.first} mutableList1=${pair1.second}")
//删除元素
var mutableList2 = mutableListOf<String>("a", "b", "c")
LogUtil.i("mutableList2 删除元素前: ${mutableList2}")
var pair2 = ListUtil.remove(mutableList2, "b")
LogUtil.i("mutableList2 删除元素后: ${mutableList2}")
//删除子集合subList3001
var mutableList3001 = mutableListOf<String>("a", "b", "c", "d")
var subList3001 = mutableListOf("w", "g")
var removeSubPair3001 = ListUtil.removeAll(mutableList3001, subList3001)
LogUtil.i(
"删除子集合subList3001${subList3001}结果=${PairUtil.getPairFirst(removeSubPair3001)} mutableList3001=${
PairUtil.getPairSecond(
removeSubPair3001
)
}"
)
//删除子集合subList3002
var mutableList3002 = mutableListOf<String>("a", "b", "c", "d")
var subList3002 = mutableListOf("c", "k")
var removeSubPair3002 = ListUtil.removeAll(mutableList3002, subList3002)
LogUtil.i(
"删除子集合subList3002${subList3002}结果=${PairUtil.getPairFirst(removeSubPair3002)} mutableList3002=${
PairUtil.getPairSecond(
removeSubPair3002
)
}"
)
//删除子集合subList3003
var mutableList3003 = mutableListOf<String>("a", "b", "c", "d")
var subList3003 = mutableListOf("b", "d")
var removeSubPair3003 = ListUtil.removeAll(mutableList3003, subList3003)
LogUtil.i(
"删除子集合subList3003${subList3003}结果=${PairUtil.getPairFirst(removeSubPair3003)} mutableList3003=${
PairUtil.getPairSecond(
removeSubPair3003
)
}"
)
//添加子集合subList4001
var mutableList4001 = mutableListOf("a", "b", "c", "d")
var subList4001 = mutableListOf("b", "c")
var addMuPair4001 = ListUtil.addAll(mutableList4001, subList4001)
LogUtil.i(
"添加子集合subList4001${subList4001}结果=${PairUtil.getPairFirst(addMuPair4001)} mutableList4001=${
PairUtil.getPairSecond(
addMuPair4001
)
}"
)
//清空list
var mutableList5 = mutableListOf("a", "b", "c")
LogUtil.i("mutableList5 清空前: mutableList5=${mutableList5}")
ListUtil.clear(mutableList5)
LogUtil.i("mutableList5 清空后: mutableList5=${mutableList5}")
//取交集
//mutableList6001 与 mutableList6002 元素一样
var mutableList6001 = mutableListOf("a", "b", "c")
var mutableList6002 = mutableListOf("a", "b", "c")
LogUtil.i("取交集前: mutableList6001=${mutableList6001} mutableList6002=${mutableList6002}")
var pair6001 = ListUtil.retainAll(mutableList6001, mutableList6002)
LogUtil.i("retainAll后: flag=${pair6001.first} mutableList=${pair6001.second}")
var pair6002 = ListUtil.intersect(mutableList6001, mutableList6002)
LogUtil.i("取交集后: flag=${pair6002.first} mutableList=${pair6002.second}")
//mutableList6003 与 mutableList6004 有交集
var mutableList6003 = mutableListOf("a", "b", "c")
var mutableList6004 = mutableListOf("b", "c", "d")
LogUtil.i("取交集前: mutableList6003=${mutableList6003} mutableList6004=${mutableList6004}")
var pair6003 = ListUtil.retainAll(mutableList6003, mutableList6004)
LogUtil.i("retainAll后: flag=${pair6003.first} mutableList=${pair6003.second}")
var pair6004 = ListUtil.intersect(mutableList6003, mutableList6004)
LogUtil.i("取交集后: flag=${pair6004.first} mutableList=${pair6004.second}")
//mutableList6005 与 mutableList6006 无交集
var mutableList6005 = mutableListOf("a", "b")
var mutableList6006 = mutableListOf("c", "d")
LogUtil.i("取交集前: mutableList6005=${mutableList6005} mutableList6006=${mutableList6006}")
var pair6005 = ListUtil.retainAll(mutableList6005, mutableList6006)
LogUtil.i("retainAll后: flag=${pair6005.first} mutableList=${pair6005.second}")
var pair6006 = ListUtil.intersect(mutableList6005, mutableList6006)
LogUtil.i("取交集后: flag=${pair6006.first} mutableList=${pair6006.second}")
//集合获取下标index处item,若下标越界则返回defaultValue默认值(默认值为集合中T类型)
//不可变list获取下标处item
var list7001 = listOf("a", "b")
var index7001 = 0
var index7002 = 4
LogUtil.i("不可变list list7001${list7001}获取下标${index7001}处item: ${ListUtil.getElement(list7001, index7001, { index -> "f" })}")
LogUtil.i("不可变list list7001${list7001}获取下标${index7002}处item: ${ListUtil.getElement(list7001, index7002, { index -> "f" })}")
//不可变set获取下标处item
var set7001 = setOf("a", "b")
LogUtil.i("不可变set set7001${set7001}获取下标${index7001}处item: ${SetUtil.getElement(set7001, index7001, { index -> "f" })}")
LogUtil.i("不可变set set7001${set7001}获取下标${index7002}处item: ${SetUtil.getElement(set7001, index7002, { index -> "f" })}")
//集合获取下标index处item,若下标越界则返回null
var list8001 = listOf("a", "b")
var index8001 = 0
var index8002 = 4
var set8001 = setOf("a", "b")
LogUtil.i("不可变list list8001${list8001}获取下标${index8001}处item: ${ListUtil.getElement(list8001, index8001)}")
LogUtil.i("不可变list list8001${list8001}获取下标${index8002}处item: ${ListUtil.getElement(list8001, index8002)}")
//不可变set获取下标处item
LogUtil.i("不可变set set8001${set8001}获取下标${index8001}处item: ${SetUtil.getElement(set8001, index8001)}")
LogUtil.i("不可变set set8001${set8001}获取下标${index8002}处item: ${SetUtil.getElement(set8001, index8002)}")
//返回集合第一个元素,若没有则返回null
var list9001 = listOf("a", "b")
var list9002 = listOf<String>()
LogUtil.i("list9001${list9001}返回第一个元素:${ListUtil.getFirstOrNull(list9001)}")
LogUtil.i("list9002${list9002}返回第一个元素:${ListUtil.getFirstOrNull(list9002)}")
var set9001 = setOf("c", "d")
var set9002 = setOf<String>()
LogUtil.i("set9001${set9001}返回第一个元素:${SetUtil.getFirstOrNull(set9001)}")
LogUtil.i("set9002${set9002}返回第一个元素:${SetUtil.getFirstOrNull(set9002)}")
//返回集合符合predicate条件的第一个元素,若没有则返回null
var list10 = listOf(1, 3, 7)
var resultList10 = ListUtil.getFirstOrNull(list10, { it % 2 == 0 })
LogUtil.i("list10${list10}集合中寻找第一个偶数: resultList10=$resultList10")
var set10 = setOf(1, 3, 7)
var resultSet10 = SetUtil.getFirstOrNull(set10, { it % 2 == 0 })
LogUtil.i("set10${set10}集合中寻找第一个偶数: resultSet10=$resultSet10")
//集合中找元素element对应的下标，若找不到则返回-1
var list11 = listOf(1, 3, 7)
var index11001 = ListUtil.getIndex(list11, 7)
var index11002 = ListUtil.getIndex(list11, 10)
LogUtil.i("list11${list11}中元素7的下标: index11001=$index11001")
LogUtil.i("list11${list11}中元素10的下标: index11002=$index11002")
var set11 = setOf(1, 3, 7)
var index11003 = SetUtil.getIndex(list11, 1)
var index11004 = SetUtil.getIndex(list11, 9)
LogUtil.i("set11${set11}中元素1的下标: index11003=$index11003")
LogUtil.i("set11${set11}中元素9的下标: index11004=$index11004")
//在集合中寻找符合predicate条件的第一个下标,找不到则返回-1
var list12 = listOf(1, 3, 7)
var index12001 = ListUtil.getFirstIndex(list12, { it == 3 })
LogUtil.i("在list12${list12}中找元素为3的第一个下标: index12001=$index12001")
var set12 = setOf(1, 3, 7)
var index12002 = SetUtil.getFirstIndex(set12, { it == 7 })
LogUtil.i("在set12${set12}中找元素为7的第一个下标: index12002=$index12002")
//在集合中找最后一个element对象的下标,找不到则返回-1
var list13 = listOf(1, 3, 7, 3, 9)
var index13001 = ListUtil.getLastIndex(list13, 3)
LogUtil.i("在list13中找最后一个元素3的下标: index13001=$index13001")
var set13 = setOf(1, 3, 7, 3, 9)
var index13002 = SetUtil.getLastIndex(set13, 3)
LogUtil.i("在set13中找最后一个元素3的下标: index13002=$index13002")
//在集合中寻找符合predicate条件的最后一个下标,找不到则返回-1
var list14 = listOf(1, 3, 7, 3, 9)
var index14001 = ListUtil.getLastIndex(list14, { it > 2 })
LogUtil.i("在list14中找元素大于2的最后一个下标: index14001=$index14001")
var linkedHashSet14: LinkedHashSet<Int> = LinkedHashSet()
linkedHashSet14.add(1)
linkedHashSet14.add(3)
linkedHashSet14.add(7)
linkedHashSet14.add(3)
linkedHashSet14.add(9)
var index14002 = SetUtil.getLastIndex(linkedHashSet14, { it > 2 })
LogUtil.i("在linkedHashSet14${linkedHashSet14}中找元素大于2的最后一个下标: index14002=$index14002")
//查找集合最后一个元素,若集合为空则返回null
var list15 = listOf<String>()
var index15001 = ListUtil.getLastOrNull(list15)
LogUtil.i("查找list15中最后一个元素: index15001=$index15001")
var linkedHashSet15 = LinkedHashSet<String>()
var index15002 = SetUtil.getLastOrNull(linkedHashSet15)
LogUtil.i("查找linkedHashSet15中最后一个元素: index15002=$index15002")
//[7]List集合(https://www.jianshu.com/p/400e81929835)文章中已经讲述List的使用
//避免赘述下面讲述set的使用
//返回集合符合predicate条件的最后一个元素,若没有则返回null
var linkedHashSet16 = LinkedHashSet<String>()
linkedHashSet16.addAll(setOf("a","b","k","p"))
var index16001 = SetUtil.getLastOrNull(linkedHashSet16, { it.equals("k") })
LogUtil.i("查找linkedHashSet16中最后一个与k相同的元素: index16001=$index16001")
var index16002 = SetUtil.getLastOrNull(linkedHashSet16, { it.equals("g") })
LogUtil.i("查找linkedHashSet16中最后一个与g相同的元素: index16002=$index16002")
var set17001 = setOf<Int>()
var elementSingle1 = SetUtil.getSingleOrNull(set17001)
LogUtil.i("set17001为空set: elementSingle1=$elementSingle1")
var set17002 = setOf(1)
var elementSingle2 = SetUtil.getSingleOrNull(set17002)
LogUtil.i("set17002为有一个元素的set: elementSingle2=$elementSingle2")
var set17003 = setOf(1,8,9)
var elementSingle3 = SetUtil.getSingleOrNull(set17003)
LogUtil.i("set17003中元素大于1个: elementSingle3=$elementSingle3")
var set18001 = setOf<Int>()
var element18001 = SetUtil.getSingleOrNull(set18001, { it > 1 })
LogUtil.i("set18001为空set: element18001=$element18001")
var set18002 = setOf(1)
var element18002 = SetUtil.getSingleOrNull(set18002, { it == 1 })
LogUtil.i("set18002中等于1的元素个数为1时: element18002=$element18002")
//集合元素个数 >= 1 (至少一个)
var set19001 = hashSetOf<Int>()
var set19002 = setOf(2)
LogUtil.i("$set19001 中是否有元素: ${SetUtil.any(set19001)}")
LogUtil.i("$set19002 中是否有元素: ${SetUtil.any(set19002)}")
//集合中是否有满足predicate条件的元素
var set20 = setOf(1,2,3,4)
LogUtil.i("$set20 中是否有能被2整除的元素: ${SetUtil.any(set20, { it % 2 == 0 })}")
LogUtil.i("$set20 中是否有大于7的元素: ${SetUtil.any(set20, { it > 7 })}")
//集合中所有元素都满足predicate条件返回true,否则返回false
var set21 = setOf(0,2,4,6)
LogUtil.i("$set21 中是否所有元素都为偶数: ${SetUtil.all(set21, { it % 2 == 0 })}")
//集合中无元素返回true,否则返回false
var set22001= setOf<Int>()
var set22002= setOf(1,3)
LogUtil.i("$set22001 中是否无元素: ${SetUtil.none(set22001)}")
LogUtil.i("$set22002 中是否无元素: ${ListUtil.none(set22002)}")
}
}
运行结果如下：
20:01:32.476 I mutableList1 添加元素前: []
20:01:32.488 I mutableList1 添加元素后: flag=true mutableList1=[a]
20:01:32.488 I mutableList2 删除元素前: [a, b, c]
20:01:32.488 I mutableList2 删除元素后: [a, c]
20:01:32.488 I 删除子集合subList3001[w, g]结果=false mutableList3001=[a, b, c, d]
20:01:32.488 I 删除子集合subList3002[c, k]结果=false mutableList3002=[a, b, c, d]
20:01:32.488 I 删除子集合subList3003[b, d]结果=true mutableList3003=[a, c]
20:01:32.488 I 添加子集合subList4001[b, c]结果=true mutableList4001=[a, b, c, d, b, c]
20:01:32.489 I mutableList5 清空前: mutableList5=[a, b, c]
20:01:32.489 I mutableList5 清空后: mutableList5=[]
20:01:32.489 I 取交集前: mutableList6001=[a, b, c] mutableList6002=[a, b, c]
20:01:32.489 I retainAll后: flag=false mutableList=[a, b, c]
20:01:32.490 I checkCollectionType: type=0
20:01:32.492 I 取交集后: flag=true mutableList=[a, b, c]
20:01:32.492 I 取交集前: mutableList6003=[a, b, c] mutableList6004=[b, c, d]
20:01:32.492 I retainAll后: flag=true mutableList=[b, c]
20:01:32.492 I checkCollectionType: type=0
20:01:32.492 I 取交集后: flag=true mutableList=[b, c]
20:01:32.493 I 取交集前: mutableList6005=[a, b] mutableList6006=[c, d]
20:01:32.493 I retainAll后: flag=true mutableList=[]
20:01:32.493 I checkCollectionType: type=0
20:01:32.493 I 取交集后: flag=false mutableList=[]
20:01:32.507 I 不可变list list7001[a, b]获取下标0处item: a
20:01:32.507 I 不可变list list7001[a, b]获取下标4处item: f
20:01:32.568 I 不可变set set7001[a, b]获取下标0处item: a
20:01:32.568 I 不可变set set7001[a, b]获取下标4处item: f
20:01:32.568 I 不可变list list8001[a, b]获取下标0处item: a
20:01:32.569 I 不可变list list8001[a, b]获取下标4处item: null
20:01:32.569 I 不可变set set8001[a, b]获取下标0处item: a
20:01:32.569 I 不可变set set8001[a, b]获取下标4处item: null
20:01:32.570 I list9001[a, b]返回第一个元素:a
20:01:32.570 I list9002[]返回第一个元素:null
20:01:32.572 I set9001[c, d]返回第一个元素:c
20:01:32.572 I set9002[]返回第一个元素:null
20:01:32.572 I list10[1, 3, 7]集合中寻找第一个偶数: resultList10=null
20:01:32.573 I set10[1, 3, 7]集合中寻找第一个偶数: resultSet10=null
20:01:32.573 I list11[1, 3, 7]中元素7的下标: index11001=2
20:01:32.573 I list11[1, 3, 7]中元素10的下标: index11002=-1
20:01:32.573 I set11[1, 3, 7]中元素1的下标: index11003=0
20:01:32.573 I set11[1, 3, 7]中元素9的下标: index11004=-1
20:01:32.573 I 在list12[1, 3, 7]中找元素为3的第一个下标: index12001=1
20:01:32.574 I 在set12[1, 3, 7]中找元素为7的第一个下标: index12002=2
20:01:32.574 I 在list13中找最后一个元素3的下标: index13001=3
20:01:32.574 I 在set13中找最后一个元素3的下标: index13002=1
20:01:32.574 I 在list14中找元素大于2的最后一个下标: index14001=4
20:01:32.575 I 在linkedHashSet14[1, 3, 7, 9]中找元素大于2的最后一个下标: index14002=3
20:01:32.575 I 查找list15中最后一个元素: index15001=null
20:01:32.575 I 查找linkedHashSet15中最后一个元素: index15002=null
20:01:32.575 I 查找linkedHashSet16中最后一个与k相同的元素: index16001=k
20:01:32.575 I 查找linkedHashSet16中最后一个与g相同的元素: index16002=null
20:01:32.575 I set17001为空set: elementSingle1=null
20:01:32.575 I set17002为有一个元素的set: elementSingle2=1
20:01:32.576 I set17003中元素大于1个: elementSingle3=null
20:01:32.576 I set18001为空set: element18001=null
20:01:32.576 I set18002中等于1的元素个数为1时: element18002=1
20:01:32.576 I [] 中是否有元素: false
20:01:32.576 I [2] 中是否有元素: true
20:01:32.576 I [1, 2, 3, 4] 中是否有能被2整除的元素: true
20:01:32.576 I [1, 2, 3, 4] 中是否有大于7的元素: false
20:01:32.577 I [0, 2, 4, 6] 中是否所有元素都为偶数: true
20:01:32.577 I [] 中是否无元素: true
20:01:32.577 I [1, 3] 中是否无元素: false
14:23:41.796 I mutableList1 添加元素前: []
14:23:41.802 I mutableList1 添加元素后: flag=true mutableList1=[a]
14:23:41.804 I mutableList2 删除元素前: [a, b, c]
14:23:41.804 I mutableList2 删除元素后: [a, c]
14:23:41.805 I 删除子集合subList3001[w, g]结果=false mutableList3001=[a, b, c, d]
14:23:41.806 I 删除子集合subList3002[c, k]结果=false mutableList3002=[a, b, c, d]
14:23:41.806 I 删除子集合subList3003[b, d]结果=true mutableList3003=[a, c]
14:23:41.806 I 添加子集合subList4001[b, c]结果=true mutableList4001=[a, b, c, d, b, c]
14:23:41.806 I mutableList5 清空前: mutableList5=[a, b, c]
14:23:41.806 I mutableList5 清空后: mutableList5=[]
14:23:41.806 I 取交集前: mutableList6001=[a, b, c] mutableList6002=[a, b, c]
14:23:41.808 I retainAll后: flag=false mutableList=[a, b, c]
14:23:41.809 I checkCollectionType: type=0
14:23:41.812 I 取交集后: flag=true mutableList=[a, b, c]
14:23:41.813 I 取交集前: mutableList6003=[a, b, c] mutableList6004=[b, c, d]
14:23:41.813 I retainAll后: flag=true mutableList=[b, c]
14:23:41.813 I checkCollectionType: type=0
14:23:41.813 I 取交集后: flag=true mutableList=[b, c]
14:23:41.814 I 取交集前: mutableList6005=[a, b] mutableList6006=[c, d]
14:23:41.815 I retainAll后: flag=true mutableList=[]
14:23:41.815 I checkCollectionType: type=0
14:23:41.815 I 取交集后: flag=false mutableList=[]
14:23:41.832 I 不可变list list7001[a, b]获取下标0处item: a
14:23:41.832 I 不可变list list7001[a, b]获取下标4处item: f
14:23:41.901 I 不可变set set7001[a, b]获取下标0处item: a
14:23:41.901 I 不可变set set7001[a, b]获取下标4处item: f
14:23:41.902 I 不可变list list8001[a, b]获取下标0处item: a
14:23:41.902 I 不可变list list8001[a, b]获取下标4处item: null
14:23:41.902 I 不可变set set8001[a, b]获取下标0处item: a
14:23:41.903 I 不可变set set8001[a, b]获取下标4处item: null
14:23:41.903 I list9001[a, b]返回第一个元素:a
14:23:41.903 I list9002[]返回第一个元素:null
14:23:41.906 I set9001[c, d]返回第一个元素:c
14:23:41.907 I set9002[]返回第一个元素:null
14:23:41.908 I list10[1, 3, 7]集合中寻找第一个偶数: resultList10=null
14:23:41.908 I set10[1, 3, 7]集合中寻找第一个偶数: resultSet10=null
14:23:41.909 I list11[1, 3, 7]中元素7的下标: index11001=2
14:23:41.909 I list11[1, 3, 7]中元素10的下标: index11002=-1
14:23:41.909 I set11[1, 3, 7]中元素1的下标: index11003=0
14:23:41.910 I set11[1, 3, 7]中元素9的下标: index11004=-1
14:23:41.910 I 在list12[1, 3, 7]中找元素为3的第一个下标: index12001=1
14:23:41.911 I 在set12[1, 3, 7]中找元素为7的第一个下标: index12002=2
14:23:41.911 I 在list13中找最后一个元素3的下标: index13001=3
14:23:41.911 I 在set13中找最后一个元素3的下标: index13002=1
14:23:41.911 I 在list14中找元素大于2的最后一个下标: index14001=4
14:23:41.912 I 在linkedHashSet14[1, 3, 7, 9]中找元素大于2的最后一个下标: index14002=3
14:23:41.912 I 查找list15中最后一个元素: index15001=null
14:23:41.912 I 查找linkedHashSet15中最后一个元素: index15002=null
14:23:41.913 I 查找linkedHashSet16中最后一个与k相同的元素: index16001=k
14:23:41.913 I 查找linkedHashSet16中最后一个与g相同的元素: index16002=null
14:23:41.913 I set17001为空set: elementSingle1=null
14:23:41.913 I set17002为有一个元素的set: elementSingle2=1
14:23:41.914 I set17003中元素大于1个: elementSingle3=null
14:23:41.914 I set18001为空set: element18001=null
14:23:41.915 I set18002中等于1的元素个数为1时: element18002=1
14:23:41.915 I [] 中是否有元素: false
14:23:41.915 I [2] 中是否有元素: true
14:23:41.915 I [1, 2, 3, 4] 中是否有能被2整除的元素: true
14:23:41.916 I [1, 2, 3, 4] 中是否有大于7的元素: false
14:23:41.916 I [0, 2, 4, 6] 中是否所有元素都为偶数: true
14:23:41.916 I [] 中是否无元素: true
14:23:41.916 I [1, 3] 中是否无元素: false
四. ListUtil 及相关优化类源码
基于之前SetUtil相关代码架构，而List与Set同宗同源。ListUtil继承关系如下：
ListUtil -> MutableCollectionOperator -> CollectionOperator
下面给出ListUtil,MutableCollectionOperator及CollectionOperator代码。
ListUtil代码如下：
