栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

JVM中性能更好的ArrayList<Int>

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

JVM中性能更好的ArrayList<Int>

前言

众所周知,kotlin中有ArrayList,Array,IntArray,可他们都有什么区别呢?为什么要有这么多大致相同的类型?

正文

我们先看一下他们相对于jvm中的类型

ArrayList = ArrayList

Array = Integer[]

IntArray = int[]

可以看出来前面两种都用到了int的包装类型Integer,而IntArray是用的基础数据类型int,在下面这篇文章中看到,由于jvm的自动装箱和拆箱导致包装类型性能更差(时间和空间上).[Kotlin的基本数值类型问题:是对象?还是基本数据类型?]

但是ArrayList是有可变的数量上限的(扩容机制),而IntArray并没有,如果我们想要一个可以扩容的IntArray,而且也使用基础数据类型(性能更好)时,怎么办呢?我们可以仿照ArrayList写一个基本数据类型的,如下代码:

package com.lt.androidkj.utils.collection


class IntArrayList(initSize: Int = 10) : RandomAccess {
    constructor(intArray: IntArray) : this(intArray.size) {
        data = intArray.copyOf()
        size = data.size
    }

    constructor(intArrayList: IntArrayList) : this(intArrayList.data.copyOf(intArrayList.size))

    constructor(list: Collection) : this(list.size) {
        list.forEach(::add)
    }

    //内部数据
    private var data: IntArray = IntArray(initSize) { 0 }

    
    var size: Int = 0
        private set

    
    operator fun get(index: Int): Int {
        if (index >= size)
            throw IndexOutOfBoundsException("size = $size ,the index = $index")
        return data[index]
    }

    
    inline fun getOrElse(index: Int, defaultValue: () -> Int): Int {
        if (index !in 0 until size)
            return defaultValue()
        return get(index)
    }

    
    fun getOrNull(index: Int): Int? {
        if (index !in 0 until size)
            return null
        return get(index)
    }

    
    fun add(element: Int) {
        if (size == data.size)
            data = data.copyOf(data.size * 2)
        data[size] = element
        size++
    }

    
    fun removeElement(element: Int) {
        val indexOf = indexOf(element)
        if (indexOf >= 0) {
            removeAtIndex(indexOf)
        }
    }

    
    fun removeAtIndex(index: Int) {
        if (index >= size)
            throw IndexOutOfBoundsException("size = $size ,the index = $index")
        val numMoved = size - index - 1
        if (numMoved > 0)
            System.arraycopy(data, index + 1, data, index, numMoved)
        size--
    }

    
    fun removeFirst() = removeAtIndex(0)

    
    fun removeLast() = removeAtIndex(size - 1)

    
    operator fun set(index: Int, element: Int): Int {
        if (index >= size)
            throw IndexOutOfBoundsException("size = $size ,the index = $index")
        val oldElement = get(index)
        data[index] = element
        return oldElement
    }

    
    fun setOrDiscard(index: Int, element: Int) {
        if (index >= size || index < 0) return
        set(index, element)
    }

    
    fun isEmpty(): Boolean = size == 0

    
    fun indexOf(element: Int): Int {
        forEachIndexed { index, datum ->
            if (element == datum)
                return index
        }
        return -1
    }

    
    fun lastIndexOf(element: Int): Int {
        forEachReversedIndexed { index, datum ->
            if (element == datum)
                return index
        }
        return -1
    }

    
    operator fun contains(element: Int): Boolean = indexOf(element) >= 0

    
    operator fun iterator(): MutableIterator = object : MutableIterator {
        private var index = 0
        override fun hasNext(): Boolean = size > index
        override fun next(): Int = get(index++)
        override fun remove() = removeAtIndex(--index)
    }

    
    inline fun forEach(action: (element: Int) -> Unit) {
        forEachIndexed { _, element -> action(element) }
    }

    inline fun forEachIndexed(action: (index: Int, element: Int) -> Unit) {
        var index = 0
        while (index < size) {
            action(index, get(index))
            index++
        }
    }

    
    inline fun forEachReversedIndexed(action: (index: Int, element: Int) -> Unit) {
        var index = size - 1
        while (index >= 0) {
            action(index, get(index))
            index--
        }
    }

    
    fun subList(fromIndex: Int, toIndex: Int): IntArrayList {
        if (toIndex > size)
            throw IndexOutOfBoundsException("size = $size ,the toIndex = $toIndex")
        return IntArrayList(data.copyOfRange(fromIndex, toIndex))
    }

    
    fun subListWithSafe(fromIndex: Int, toIndex: Int): IntArrayList =
        IntArrayList(data.copyOfRange(maxOf(0, fromIndex), minOf(size, toIndex)))

    
    fun addAll(elements: Collection) {
        elements.forEach(::add)
    }

    fun addAll(elements: IntArrayList) {
        addAll(elements.data.copyOf(elements.size))
    }

    fun addAll(elements: IntArray) {
        elements.forEach(::add)
    }

    fun addAllNotNull(elements: Collection?) {
        elements?.forEach {
            if (it != null)
                add(it)
        }
    }

    
    fun removeAll(elements: Collection) {
        elements.forEach(::removeElement)
    }

    fun removeAll(elements: IntArrayList) {
        removeAll(elements.data.copyOf(elements.size))
    }

    fun removeAll(elements: IntArray) {
        elements.forEach(::removeElement)
    }

    
    fun clear() {
        size = 0
    }

    
    fun toIntArray() = data.copyOf(size)

    fun toMutableList() = toIntArray().toMutableList()

    override fun toString(): String {
        return "[" + data.copyOf(size).joinToString(",") + "]"
    }
}

fun intArrayListOf(vararg elements: Int): IntArrayList = IntArrayList(elements)

其性能更好,内部使用基础数据类型,而且支持自动扩容,使用方式基本和ArrayList一样

如果你想装Double的话,只需要copy一份将Int改成Double就可以了

end

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/943881.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号