Arrays Swift中的二维阵列

我对Swift中的2D数组感到非常困惑。让我一步一步地描述。如果我错了，请你纠正我好吗

首先,；空数组的声明：

class test{
    var my2Darr = Int[][]()
}

其次，填充数组。（例如

my2Darr[i][j]=0

其中i，j表示循环变量）

从文档中：

您可以通过嵌套成对的方括号来创建多维数组，其中元素的基本类型的名称包含在最里面的一对方括号中。例如，可以使用三组方括号创建三维整数数组：

var array3D: [[[Int]]] = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]

访问多维数组中的元素时，最左边的下标索引引用最外层数组中该索引处的元素。右边的下一个下标索引引用嵌套在数组中一级的该索引处的元素。等等这意味着在上面的示例中，array3D[0]表示[[1,2]，[3,4]]，array3D[0][1]表示[3,4]，array3D[0][1][1]表示值4。

定义可变数组 或：

或者，如果需要预定义大小的数组（如@0x7fffffff在注释中所述）：

在位置处更换元件 或

更改子数组 或

或

如果在这些更改之前您有0（零）的3x2数组，那么现在您有：

[
  [0, 0, 234, 345, 678], // 5 elements!
  [123, 456, 789],
  [0, 0]
]

所以请注意，子数组是可变的，您可以重新定义表示矩阵的初始数组

在访问之前检查大小/边界 备注：

---

3维和N维数组的标记规则相同。

在Swift 4中

var arr = Array(repeating: Array(repeating: 0, count: 2), count: 3)
// [[0, 0], [0, 0], [0, 0]]

struct Matrix<T> {
    let rows: Int, columns: Int
    var grid: [T]
    init(rows: Int, columns: Int,defaultValue: T) {
        self.rows = rows
        self.columns = columns
        grid = Array(repeating: defaultValue, count: rows * columns) as! [T]
    }
    func indexIsValid(row: Int, column: Int) -> Bool {
        return row >= 0 && row < rows && column >= 0 && column < columns
    }
    subscript(row: Int, column: Int) -> T {
        get {
            assert(indexIsValid(row: row, column: column), "Index out of range")
            return grid[(row * columns) + column]
        }
        set {
            assert(indexIsValid(row: row, column: column), "Index out of range")
            grid[(row * columns) + column] = newValue
        }
    }
}


var matrix:Matrix<Bool> = Matrix(rows: 1000, columns: 1000,defaultValue:false)

matrix[0,10] = true


print(matrix[0,10])

---

使用

Array（repeating:Array（repeating:value}，count:80），count:24）时应该小心

如果该值是由
MyClass（）
初始化的对象，则它们将使用相同的引用

Array（repeating:Array（repeating:MyClass（），count:80），count:24）
不会在每个数组元素中创建
MyClass
的新实例。此方法只创建一次
MyClass
，并将其放入数组中

下面是初始化多维数组的安全方法

private var matrix: [[MyClass]] = MyClass.newMatrix()

private static func newMatrix() -> [[MyClass]] {
    var matrix: [[MyClass]] = []

    for i in 0...23 {
        matrix.append( [] )

        for _ in 0...79 {
            matrix[i].append( MyClass() )
        }
    }

    return matrix
}

根据适用于swift 4.1的Apple文档，您可以非常轻松地使用此结构创建二维数组：

链接：

代码示例：

struct Matrix {
    let rows: Int, columns: Int
    var grid: [Double]
    init(rows: Int, columns: Int) {
        self.rows = rows
        self.columns = columns
        grid = Array(repeating: 0.0, count: rows * columns)
    }
    func indexIsValid(row: Int, column: Int) -> Bool {
        return row >= 0 && row < rows && column >= 0 && column < columns
    }
    subscript(row: Int, column: Int) -> Double {
        get {
            assert(indexIsValid(row: row, column: column), "Index out of range")
            return grid[(row * columns) + column]
        }
        set {
            assert(indexIsValid(row: row, column: column), "Index out of range")
            grid[(row * columns) + column] = newValue
        }
    }
}

结构矩阵{
让行：Int，列：Int
变量网格：[双精度]
init（行：Int，列：Int）{
self.rows=行
self.columns=列
网格=数组（重复：0.0，计数：行*列）
}
func indexIsValid（行：Int，列：Int）->Bool{
返回行>=0&&row=0&&columnDouble{
得到{
断言（indexIsValid（行：行，列：列），“索引超出范围”）
返回网格[（行*列）+列]
}
设置{
断言（indexIsValid（行：行，列：列），“索引超出范围”）
网格[（行*列）+列]=newValue
}
}
}

使其成为通用的Swift 4

var arr = Array(repeating: Array(repeating: 0, count: 2), count: 3)
// [[0, 0], [0, 0], [0, 0]]

struct Matrix<T> {
    let rows: Int, columns: Int
    var grid: [T]
    init(rows: Int, columns: Int,defaultValue: T) {
        self.rows = rows
        self.columns = columns
        grid = Array(repeating: defaultValue, count: rows * columns) as! [T]
    }
    func indexIsValid(row: Int, column: Int) -> Bool {
        return row >= 0 && row < rows && column >= 0 && column < columns
    }
    subscript(row: Int, column: Int) -> T {
        get {
            assert(indexIsValid(row: row, column: column), "Index out of range")
            return grid[(row * columns) + column]
        }
        set {
            assert(indexIsValid(row: row, column: column), "Index out of range")
            grid[(row * columns) + column] = newValue
        }
    }
}


var matrix:Matrix<Bool> = Matrix(rows: 1000, columns: 1000,defaultValue:false)

matrix[0,10] = true


print(matrix[0,10])

结构矩阵{ 让行：Int，列：Int 变量网格：[T] init（行：Int，列：Int，默认值：T）{ self.rows=行 self.columns=列 grid=数组（重复：defaultValue，计数：行*列）为！[T] } func indexIsValid（行：Int，列：Int）->Bool{ 返回行>=0&&row=0&&columnT{ 得到{ 断言（indexIsValid（行：行，列：列），“索引超出范围”） 返回网格[（行*列）+列] } 设置{ 断言（indexIsValid（行：行，列：列），“索引超出范围”） 网格[（行*列）+列]=newValue } } } 变量矩阵：矩阵=矩阵（行：1000，列：1000，默认值：false） 矩阵[0,10]=真 打印（矩阵[0,10]）

---

在Swift中使用多维数组之前，请考虑它们对性能的影响。在我的测试中，扁平阵列的性能几乎是2D版本的2倍：

var table = [Int](repeating: 0, count: size * size)
let array = [Int](1...size)
for row in 0..<size {
    for column in 0..<size {
        let val = array[row] * array[column]
        // assign
        table[row * size + column] = val
    }
}

使用append（）填充50x50数组的平均执行时间：2.59s

结论 如果执行速度很重要，请避免多维数组并使用索引访问。1D数组的性能更好，但您的代码可能更难理解

---

从my GitHub repo下载演示项目后，您可以自己运行性能测试：

这只需一行代码即可完成

Swift 5

var my2DArray = (0..<4).map { _ in Array(0..<) }

---

var my2DArray=（0..你的方法有问题吗？正如你所知，你的整个第二步可以简化为这个
var my2DArray=Array（count:10，repeatedValue:Array（count:10，repeatedValue:18））
，你真的应该升级到一个新的beta版。
Int[]
不再是有效语法。它已更改为
[[Int]]（）
。使用重复值的2D init将不起作用。所有行都将指向同一子数组，因此不具有唯一可写性。确定一个dumy问题：我们如何分配该数组，在C中我们是这样做的：arr[i][j]=myVar；但在swift中，当我尝试以同样的方式执行时，我得到了这个错误““[（[（Int）]）].Type'没有名为'subscript'的成员”如果您在答案中定义了
arr
，那么
myVar
应该是Int，是吗？是的，是Int。非常感谢您提供详细的答案。现在很清楚：DIn Swift 3，对于复制粘贴：
var arr=Int（重复：Int（重复：0，计数：2），计数：3）
在Swift 4.2中：例如，3行，2列，3*2
var arr=Array（count:2，repeatedValue:Array（count:3，repeatedValue:0））
Hi作为“anyObject”类型的扩展，我们可以改进它吗？关于引用类型的问题，这是一个很好的观点。但是，为什么要编写
Array（repeated:{value}，可以80）
在
{value}
周围用大括号括起来会
arr[0] += [345, 678]

[
  [0, 0, 234, 345, 678], // 5 elements!
  [123, 456, 789],
  [0, 0]
]

let a = 0
let b = 1

if arr.count > a && arr[a].count > b {
    println(arr[a][b])
}

var arr = Array(repeating: Array(repeating: 0, count: 2), count: 3)
// [[0, 0], [0, 0], [0, 0]]

private var matrix: [[MyClass]] = MyClass.newMatrix()

private static func newMatrix() -> [[MyClass]] {
    var matrix: [[MyClass]] = []

    for i in 0...23 {
        matrix.append( [] )

        for _ in 0...79 {
            matrix[i].append( MyClass() )
        }
    }

    return matrix
}

struct Matrix {
    let rows: Int, columns: Int
    var grid: [Double]
    init(rows: Int, columns: Int) {
        self.rows = rows
        self.columns = columns
        grid = Array(repeating: 0.0, count: rows * columns)
    }
    func indexIsValid(row: Int, column: Int) -> Bool {
        return row >= 0 && row < rows && column >= 0 && column < columns
    }
    subscript(row: Int, column: Int) -> Double {
        get {
            assert(indexIsValid(row: row, column: column), "Index out of range")
            return grid[(row * columns) + column]
        }
        set {
            assert(indexIsValid(row: row, column: column), "Index out of range")
            grid[(row * columns) + column] = newValue
        }
    }
}

struct Matrix<T> {
    let rows: Int, columns: Int
    var grid: [T]
    init(rows: Int, columns: Int,defaultValue: T) {
        self.rows = rows
        self.columns = columns
        grid = Array(repeating: defaultValue, count: rows * columns) as! [T]
    }
    func indexIsValid(row: Int, column: Int) -> Bool {
        return row >= 0 && row < rows && column >= 0 && column < columns
    }
    subscript(row: Int, column: Int) -> T {
        get {
            assert(indexIsValid(row: row, column: column), "Index out of range")
            return grid[(row * columns) + column]
        }
        set {
            assert(indexIsValid(row: row, column: column), "Index out of range")
            grid[(row * columns) + column] = newValue
        }
    }
}


var matrix:Matrix<Bool> = Matrix(rows: 1000, columns: 1000,defaultValue:false)

matrix[0,10] = true


print(matrix[0,10])

var table = [Int](repeating: 0, count: size * size)
let array = [Int](1...size)
for row in 0..<size {
    for column in 0..<size {
        let val = array[row] * array[column]
        // assign
        table[row * size + column] = val
    }
}

var table = [[Int]](repeating: [Int](repeating: 0, count: size), count: size)
let array = [Int](1...size)
for row in 0..<size {
    for column in 0..<size {
        // assign
        table[row][column] = val
    }
}

var table = [Int]()    
let array = [Int](1...size)
for row in 0..<size {
    for column in 0..<size {
        table.append(val)
    }
}

var my2DArray = (0..<4).map { _ in Array(0..<) }

struct MyStructCouldBeAClass {
    var x: Int
    var y: Int
}

var my2DArray: [[MyStructCouldBeAClass]] = (0..<2).map { x in
    Array(0..<2).map { MyStructCouldBeAClass(x: x, y: $0)}
}