如何高效地处理未知长度的大数组

为了高效地处理长度未知的大数组，应避免使用数组，因为它们具有固定大小，需要手动复制和调整大小，增加内存使用和性能下降的风险。相反，建议使用切片，它是一种动态调整大小的数组包装器，可以自动处理调整大小和复制。此外，避免使用多维数组，因为它会使遍历复杂化、降低速度，并可能导致内存泄漏。

有多种方法可以向数组追加内容。想知道是否有已知的最佳执行方法来附加到长度未知的巨大数组（100Mb）？我想避免复制，因为它会增加内存不足的机会，并且会降低性能。我应该考虑使用二维数组吗？

解决方案

在 golang 中，我们有数组和切片。 数组具有固定大小，当您需要更多空间时，您需要创建更大的数组，复制旧数组中的所有值并用新数组替换旧引用。

您不应该保留对旧数组的引用，因此该内存将被垃圾回收。 或者，您可以使用切片（它是数组顶部的包装器）。调整大小和复制将自动为您完成。 您还可以手动控制调整大小，这可以减少 gc。但应该对其进行分析并与切片进行比较。

我添加了一个存储在多维数组中的示例，我强烈建议避免这种方法。它会让遍历变得更复杂、更慢、内存泄漏的可能性很高等等。 golang 中的 gc 非常快。

benchmarkstore/array-6            100000         20090 ns/op           0 b/op          0 allocs/op
benchmarkstore/slice-6              5000        259940 ns/op     4654337 b/op         30 allocs/op
benchmarkstore/custom-6            10000        194152 ns/op     1747860 b/op          8 allocs/op
benchmarkstore/dimensions-6         3000        418654 ns/op     4458593 b/op         20 allocs/op

package main

import (
    "testing"
)

const size = 100000

// Wrapper around slice
type MyStore struct {
    growthFactor int
    watermark    int
    Data         []int
}

func NewMyStore(growthFactor, initialSize int) *MyStore {
    return &MyStore{growthFactor: growthFactor, watermark: -1, Data: make([]int, initialSize)}
}

func (s *MyStore) Append(v int) {
    nextPosition := s.watermark + 1
    currentSize := len(s.Data)
    full := currentSize == nextPosition
    if full {
        dataResize := make([]int, currentSize*s.growthFactor)
        copy(dataResize, s.Data)
        s.Data = dataResize
    }

    s.Data[nextPosition] = v
    s.watermark = nextPosition
}

// Dimensions
const chunkSize = 10
type MyStoreMultiDimensions struct {
    size      int
    watermark int
    data      [][chunkSize]int
}

func NewStoreMultiDimensions(chunks int) *MyStoreMultiDimensions {
    return &MyStoreMultiDimensions{watermark: -1, data: make([][chunkSize]int, chunks)}
}

func (s *MyStoreMultiDimensions) Append(v int) {
    nextPosition := s.watermark + 1
    chunk := nextPosition / chunkSize
    if len(s.data) <= chunk {
        s.data = append(s.data, [chunkSize]int{})
    }

    s.data[chunk][nextPosition%chunkSize] = v
    s.watermark = nextPosition
}

func BenchmarkStore(b *testing.B) {
    b.Run("array", func(b2 *testing.B) {
        for i := 0; i < b2.N; i++ {
            var store [size]int
            for item := 0; item < size; item++ {
                store[item] = item
            }
        }
    })
    b.Run("slice", func(b2 *testing.B) {
        for i := 0; i < b2.N; i++ {
            var store []int
            for item := 0; item < size; item++ {
                store = append(store, item)
            }
        }
    })
    b.Run("Custom", func(b2 *testing.B) {
        for i := 0; i < b2.N; i++ {
            var store = NewMyStore(4, 10)
            for item := 0; item < size; item++ {
                store.Append(item)
            }
        }
    })
    b.Run("Dimensions", func(b2 *testing.B) {
        for i := 0; i < b2.N; i++ {
            var store = NewStoreMultiDimensions(2)
            for item := 0; item < size; item++ {
                store.Append(item)
            }
        }
    })
}

据我所知，您应该考虑使用 arraylist 而不是数组。然后，您可以使用arraylist的add()来追加新元素。

今天关于《如何高效地处理未知长度的大数组》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！