array交换元素 swift
2017-11-07 09:16:00 weixin_34234823 阅读数 3

数组是一个最常用的数据类型的应用程序。使用数组来组织你的应用程序的数据。具体地说,您可以使用数组类型来控制单个的元素类型,数组的元素类型。一个数组可以存储任何类型的元素从整数字符串类。迅速方便地创建数组在代码中使用一个数组文字:仅仅围绕方括号的逗号分隔的值列表。没有任何其他信息,迅速创建一个数组,包括指定的值,自动推断数组的元素类型。例如:

// An array of 'Int' elements
let oddNumbers = [1, 3, 5, 7, 9, 11, 13, 15]

// An array of 'String' elements
let streets = ["Albemarle", "Brandywine", "Chesapeake"]

您可以创建一个空数组通过指定数组的元素类型的声明。例如:

// Shortened forms are preferred
var emptyDoubles: [Double] = []

// The full type name is also allowed
var emptyFloats: Array<Float> = Array()

如果你需要一个数组与固定数量的preinitialized默认值,使用数组(重复计数:)初始值设定项。

var digitCounts = Array(repeating: 0, count: 10)
print(digitCounts)
// Prints "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]"

当您需要执行一个操作数组的所有元素,使用一个工党循环遍历该数组的内容。

for street in streets {
    print("I don't live on \(street).")
}

使用isEmpty属性快速检查是否有任何元素的数组,或者使用count属性找到数组中元素的个数。

if oddNumbers.isEmpty {
    print("I don't know any odd numbers.")
} else {
    print("I know \(oddNumbers.count) odd numbers.")
}
2017-02-25 19:38:00 weixin_34200628 阅读数 29

数组可以存储同一个类型的多个值,而且相同的值可以多次出现在数组中的不同位置。

创建数组

1.定义数据类型有两种形式

var array1: Array<String>
var array2:[String]

2.创建一个空数组
通过初始化函数来创建一个有特定数据类型的空数组

var someInts = [Int]()

3.用字面量构造数组

import UIKit
let array:[String]=["Hello","Hi"]
let array2 = ["zhangsan",18];

4.两个数组相加来创建一个新数组

let array1 = ["张三","李四"];
let array2 = ["王五"]
print(array1+array2)

注意:
数组对于存储数据有着具体的要求,数组元素在被存储进入某个数组之前,必须明确数据类型,方法是通过显式的类型标注或者类型推断。

数组的常见操作

1.获取数组的长度
Array提供了一个count属性,用于获取数组中元素的总个数。
2.数组的遍历

let array = [11,22,33,44,55]
for element in array{
      print(element)
}

3.数组元素的增加、删除

// 定义一个可变数组
var array = ["zhangsan","lisi"]
// 在末尾追加1个元素
array.append("wangwu")
print(array)
// 向指定位置插入1个元素
array.insert("zhaoliu",at:2)
print(array)
// 删除第一个元素
array.removeFirst()
print(array)
// 删除最后一个元素
array.removeLast()
print(array)
// 删除所有的元素
array.removeAll(keepingCapacity:true)
print(array)

4.使用下标语法修改数组元素
使用下标来改变已有索引对应的元素

array[1] = "new"

如果要修改数组中的多个索引对应的元素,可以采用区间的形式表示已经存在的多个索引值。

array[1...2] =["Eight","Nine"]
2016-12-20 21:22:31 L_is_puck 阅读数 141

//数组的创建

let array = ["name","age","height"]

var arrayM = [String]()

var arrayN = Array<String>()


//数组的基本操作

arrayM.append("num")

arrayM.append("score")

arrayM.append("Star")


//删除元素

arrayM.remove(at: 0)

arrayM.removeFirst()

arrayM.removeLast()

arrayM.removeAll()

arrayM


//修改元素

var arrayX = ["1","2","3","4"]

arrayX[0] = "0"


//遍历数组

for i in 0..<arrayX.count {

    print(arrayX[i])

}


for name in arrayX {

    print(name)

}


for name in arrayX[0..<2]{

    print(name)

}


//数组合并 只有并类型数组才能用 + 合并

let newArray = array+arrayX

print(newArray)

2019-04-23 15:15:00 weixin_33800593 阅读数 5

demo链接:https://share.weiyun.com/5FHZyK3

数组使用有序列表存储同一类型的多个值。相同的值可以多次出现在一个数组的不同位置中。

注意: Swift 的Array类型被桥接到Foundation中的NSArray类。 更多关于在FoundationCocoa中使用Array的信息,参见 Using Swift with Cocoa and Obejective-C(Swift 3.0.1)使用 Cocoa 数据类型部分。

数组的简单语法

写 Swift 数组应该遵循像Array<Element>这样的形式,其中Element是这个数组中唯一允许存在的数据类型。我们也可以使用像[Element]这样的简单语法。尽管两种形式在功能上是一样的,但是推荐较短的那种,而且在本文中都会使用这种形式来使用数组。

创建一个空数组

我们可以使用构造语法来创建一个由特定数据类型构成的空数组:

var someInts = [Int]()
print("someInts is of type [Int] with \(someInts.count) items.")
// 打印 "someInts is of type [Int] with 0 items."

*注意:通过构造函数的类型,someInts的值类型被推断为[Int]

或者,如果代码上下文中已经提供了类型信息,例如一个函数参数或者一个已经定义好类型的常量或者变量,我们可以使用空数组语句创建一个空数组,它的写法很简单:[](一对空方括号):

someInts.append(3)
// someInts 现在包含一个 Int 值
someInts = []
// someInts 现在是空数组,但是仍然是 [Int] 类型的。

创建一个带有默认值的数组

Swift 中的Array类型还提供一个可以创建特定大小并且所有数据都被默认的构造方法。我们可以把准备加入新数组的数据项数量(count)和适当类型的初始值(repeating)传入数组构造函数:

var threeDoubles = Array(repeating: 0.0, count: 3)
// threeDoubles 是一种 [Double] 数组,等价于 [0.0, 0.0, 0.0]

通过两个数组相加创建一个数组

我们可以使用加法操作符(+)来组合两种已存在的相同类型数组。新数组的数据类型会被从两个数组的数据类型中推断出来:

var anotherThreeDoubles = Array(repeating: 2.5, count: 3)
// anotherThreeDoubles 被推断为 [Double],等价于 [2.5, 2.5, 2.5]

var sixDoubles = threeDoubles + anotherThreeDoubles
// sixDoubles 被推断为 [Double],等价于 [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]

用数组字面量构造数组

我们可以使用数组字面量来进行数组构造,这是一种用一个或者多个数值构造数组的简单方法。数组字面量是一系列由逗号分割并由方括号包含的数值:[value 1, value 2, value 3]
下面这个例子创建了一个叫做shoppingList并且存储String的数组:

var shoppingList: [String] = ["Eggs", "Milk"]
// shoppingList 已经被构造并且拥有两个初始项。

shoppingList变量被声明为“字符串值类型的数组“,记作[String]。 因为这个数组被规定只有String一种数据结构,所以只有String类型可以在其中被存取。 在这里,shoppingList数组由两个String值("Eggs" 和"Milk")构造,并且由数组字面量定义。在这个例子中,字面量仅仅包含两个String值。匹配了该数组的变量声明(只能包含String的数组),所以这个字面量的分配过程可以作为用两个初始项来构造shoppingList的一种方式。

由于 Swift 的类型推断机制,当我们用字面量构造只拥有相同类型值数组的时候,我们不必把数组的类型定义清楚。 shoppingList的构造也可以这样写:

var shoppingList = ["Eggs", "Milk"]

因为所有数组字面量中的值都是相同的类型,Swift 可以推断出[String]是shoppingList中变量的正确类型。

访问和修改数组

我们可以通过数组的方法和属性来访问和修改数组,或者使用下标语法。

可以使用数组的只读属性count来获取数组中的数据项数量:

print("The shopping list contains \(shoppingList.count) items.")
// 输出 "The shopping list contains 2 items."(这个数组有2个项)

使用布尔属性isEmpty作为一个缩写形式去检查count属性是否为0:

if shoppingList.isEmpty {
    print("The shopping list is empty.")
} else {
    print("The shopping list is not empty.")
}
// 打印 "The shopping list is not empty."(shoppinglist 不是空的)

也可以使用append(_:)方法在数组后面添加新的数据项:

shoppingList.append("Flour")
// shoppingList 现在有3个数据项,有人在摊煎饼

除此之外,使用加法赋值运算符(+=)也可以直接在数组后面添加一个或多个拥有相同类型的数据项:

shoppingList += ["Baking Powder"]
// shoppingList 现在有四项了
shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
// shoppingList 现在有七项了

可以直接使用下标语法来获取数组中的数据项,把我们需要的数据项的索引值放在直接放在数组名称的方括号中:

var firstItem = shoppingList[0]
// 第一项是 "Eggs"

我们也可以用下标来改变某个已有索引值对应的数据值:

shoppingList[0] = "Six eggs"
// 其中的第一项现在是 "Six eggs" 而不是 "Eggs"

还可以利用下标来一次改变一系列数据值,即使新数据和原有数据的数量是不一样的。下面的例子把"Chocolate Spread","Cheese",和"Butter"替换为"Bananas"和 "Apples":

shoppingList[4...6] = ["Bananas", "Apples"]
// shoppingList 现在有6项

*注意:不可以用下标访问的形式去在数组尾部添加新项。

调用数组的insert(_:at:)方法来在某个具体索引值之前添加数据项:

shoppingList.insert("Maple Syrup", at: 0)
// shoppingList 现在有7项
// "Maple Syrup" 现在是这个列表中的第一项

这次insert(_:at:)方法调用把值为"Maple Syrup"的新数据项插入列表的最开始位置,并且使用0作为索引值。

类似的我们可以使用remove(at:)方法来移除数组中的某一项。这个方法把数组在特定索引值中存储的数据项移除并且返回这个被移除的数据项(我们不需要的时候就可以无视它):

let mapleSyrup = shoppingList.remove(at: 0)
// 索引值为0的数据项被移除
// shoppingList 现在只有6项,而且不包括 Maple Syrup
// mapleSyrup 常量的值等于被移除数据项的值 "Maple Syrup"

注意:如果我们试着对索引越界的数据进行检索或设置新值的操作,会引发一个运行期错误。我们可以使用索引值和数组的count属性进行比较来在使用某个索引之前先检验是否有效。

数据项被移除后数组中的空出项会被自动填补,所以现在索引值为0的数据项的值再次等于"Six eggs":

firstItem = shoppingList[0]
// firstItem 现在等于 "Six eggs"

如果我们只想把数组中的最后一项移除,可以使用removeLast()方法而不是remove(at:)方法来避免我们需要获取数组的count属性。就像后者一样,前者也会返回被移除的数据项:

let apples = shoppingList.removeLast()
// 数组的最后一项被移除了
// shoppingList 现在只有5项,不包括 Apples
// apples 常量的值现在等于 "Apples" 字符串

数组的遍历

我们可以使用for-in循环来遍历所有数组中的数据项:

for item in shoppingList {
    print(item)
}
// Six eggs
// Milk
// Flour
// Baking Powder
// Bananas

如果我们同时需要每个数据项的值和索引值,可以使用enumerated()方法来进行数组遍历。enumerated()返回一个由每一个数据项索引值和数据值组成的元组。我们可以把这个元组分解成临时常量或者变量来进行遍历:

for (index, value) in shoppingList. enumerated() {
    print("Item \(String(index + 1)): \(value)")
}
// Item 1: Six eggs
// Item 2: Milk
// Item 3: Flour
// Item 4: Baking Powder
// Item 5: Bananas

更多关于for-in循环的介绍请参见for 循环

借助closure,我们还可以使用Array对象的forEach方法:

shoppingList.forEach {print($0)}

通过closure参数化对数组元素的变形操作

从循环到map

假设我们有一个简单的Fibonacci序列:[0,1,1,2,3,5]。如果我们要计算每个元素的平方,怎么办呢?
一个最朴实的做法是for循环:

var fibonacci = [0,1,1,2,3,5]
var squares = [Int]()

for value in fibonacci {
    squares.append(value * value)
}  

如果你觉得这还不是个足够引起你注意的问题,那么,当我们要定义一个常量 squares 的时候,上面的代码就完全无法胜任了。怎么办呢?先看解决办法:

//[0,1,1,4,9,25]
let constSquares = fibonacci.map { $0 * $0 }

上面的代码,和之前的for循环执行的结果是相同的。显然,它比for循环更具表现力,并且也能把我们期望的结果定义成常量。当然,map并不是什么魔法,无非就是把for循环执行的逻辑,封装在了函数里,这样我们就可以把函数的返回值赋值给常量了,我们可以通过extension很简单的自己来实现map

extension Array {
    func myMap<T>(_ transform: (Element) -> T) -> [T] {
        var tmp: [T] = []
        //如果明确的知道一个数组的容量大小,可以调用这个方法告诉系统这个数组至少需要的容量,避免在数组添加元素过程中重复的申请内存。
        tmp.reserveCapacity(count)
        for value in self {
            tmp.append(transform(value))
        }
        return tmp
    }
}

虽然和Swift标准库相比,MyMap的实现中去掉了和异常声明相关的部分。但它已经足以表现map的核心实现过程了。除了在append之前使用了reserveCapacity给新数组预留了空间之外,它的实现过程和一开始我们使用的for循环没有任何差别。
完成后,当我们在playground里测试的时候:

// [0,1,1,4,9,25]
let constSuquence1 = fibonacci.myMap { $0 * $0 }

就会发现执行结果和之前的constSequence是一样的了。

参数化数组元素的执行动作

其实,仔细观察myMap的实现,就会发现它最大的意义,就是保留了遍历Array的过程,而把执行的动作留给了myApp的调用者通过参数去定制。而这,就是我们一开始提到的用closure来参数化对数组的操作行为的含义。
有了这样的思路之后,我们就可以把各种常用的带有遍历行为的操作,定制成多种不同的遍历"套路",而把对数组中每一个元素的处理动作留给函数的调用者。但是别急,在开始自动动手造轮子之前,Swift library已经为我们准备了一些,例如:
首先,是找到最小、最大值,对于这类操作来说,只要数组中的元素实现了"Equatable"protocol,我们甚至无需定义对元素的具体操作:

fibonacci.min()  // 0
fibonacci.max()  // 5

使用minmax很安全,因为当数组为空时,这两个方法将返回nil。其次,过滤出满足特定条件的元素,我们只要通过参数制定筛选规则就好了:

fibonacci.filter { $0 % 2 == 0 }

比较数组相等或以特定元素开始。对这类操作,我们需要提供两个内容,一个是要比较的数组,另一个则是比较的规则:

//false
fibonacci.elementsEqual([0,1,1], by: { $0 == $1 })
//true
fibonacci.starts(with: [0,1,1], by: { $0 == $1 })

最原始的for循环的替代品:

fibonacci.forEach { print($0) }
// 0 
// 1
// ...

注意:它和map的一个重要区别:forEach并不处理closure参数的返回值。因此它只适合用来对数组中的元素进行一些操作,而不能用来产生返回结果。

对数组进行排序,这时,我们需要通过参数制定的是排序规则:

sorted(by:)的用法是很直接的,它默认采用升序排列。同事,也允许我们通过by自定义排序规则。在这里>{ $0 > $1 } 的简写形式。Swift中很多在不影响语义的情况下的简写形式。

// [0,1,1,2,3,5]
fibonacci.sorted()
// [5,3,2,1,1,0]
fibonacci.sorted(by: >)

partition(by:)则会先对传递给它的数组进行重排,然后根据指定的条件在重排的结果中返回一个分界点位置。这个分界点分开的两部分中,前半部分的元素都不满足指定条件;后半部分都满足指定条件。而后,我们就可以使用range operator来访问者两个区间形成的Array对象。

let privot = fibonacci.partition(by: { $0 < 1 })
fibonacci[0 ..< privot] // [5, 1, 1, 2, 3]
fibonacci[privot ..< fibonacci.endIndex] //[0]

把数组中的所有内容“合并”成某种形式的值,对这类操作,我们需要指定的,是合并前的初始值,以及"合并"的规则。例如,我们计算fibonacci中所有元素的和:

fibonacci.reduce(0, +)   //12

在这里,初始值为0,和第二个参数+,则是 { $0 + $1 }的缩写。

filter

filter的用法在Array中过滤满足特定条件的元素。而这个条件,就是通过filterclosure参数来确定的:

var fibonacci = [0,1,1,2,3,5]
//[0,2]
fibonacci.filter { $0 % 2 == 0}

按照实现的map的思路,我们可以自己来实现一个filter:

extension Array {
    func myFilter(_ predicate: (Element) -> Bool) -> [Element] {
        var temp: [Element] = []

        for value in self where predicate(value) {
            temp.append(value)
        }
        
        return temp
    }
}

在上面的实现里,最核心的环节就是通过where条件的for循环找到原数组中符合条件的元素,然后把它们一一添加到temp中,并最终返回给函数的调用者。然后,我们测试下myFilter

fibonacci.myFilter { $0 % 2 == 0 } // [0,2]

结果应该是和标准库中的自带的filter是一样的。理解filter之后,我们就可以自行定义一些标准库中没有的方法。例如:
剔除掉数组中满足条件的元素:

extension Array {
    func reject(_ predicate: (Element) -> Bool) -> [Element]{
        return filter { !predicate($0) }
    }
}

我们只要把调用转发给filter,然后把指定的条件取反就好了。这样,提出元素的代码语义上就会更好看一些:

fibonacci.reject { $0 % 2 == 0 } //[1,1,3,5]

另一个基于filter语义的常用操作是判断数组中是否存在满足条件的元素。下面的代码可以完成任务:

fibonacci.filter { $0 % 2 == 0}.count > 0 //true

但这样做在性能上并不理想,因为即便找到了满足条件的元素,也要遍历完整个数组,这显然是没有必要的。Swift标准库中,提供了一个更方便的方法:

fibonacci.containts { $0 % 2 == 0} //true

contains的一个好处就是只要遇到满足条件的元素,函数的执行就终止了。基于这个contains,我们还可以给Array添加一个新的方法,用来判断Array中所有的元素是否满足特定的条件:

extension Array {
    func allMatch(_ predicate: (Element) -> Bool) -> Bool{
        return !contains { !predicate($0) }
    }
}

allMatch的实现里,只要没有不满足条件的元素,也就是所有的元素都满足条件了。我们可以用下面的代码测试一下:

let events = [2,4,6,8]
events.allMatch { $0 % 2 == 0 } // true

reduce

除了用一个数组生成一个新的数组,有时,我们会希望把一个数组变成某种形式的值。例如,之前我们提到的求和:

fibonacci.reduce(0, +) // 12

了解reduce的进一步用法之前,我们先自己实现一个:

extension Array {
    func myReduce<T>(_ initial: T, _ next: (T, Element) -> T) -> T {
        var temp = initial
        for value in self {
            temp = next(temp,value)
        }   
        return temp
    }
}

从上面可以看出,reduce的实现就是把for循环迭代相加的过程给封装了起来。然后,用下面的代码测试一下,就会发现和标准库里的reduce一样了。

fibonacci.myReduce(0,+) //12

除了求和以外,我们还可以把fibonacci reduce成一个字符串:

let str = fibonacci.myReduce("") { str, num in
    return str + "\(num)"
}
// 011235

参考链接:
http://www.swift51.com/swift4.0/chapter2/04_Collection_Types.html
https://www.jianshu.com/p/8730de8d8778

2016-07-15 14:16:47 liuwin7 阅读数 751

1.相遇

有个业务需求,把表格中的数据整合到一个数组中,如下

Name Age Item1 Item2 Item3 Country
Jack 21 32 43 null China
Tom 23 83 67 75 US

整合后的结果是这样

[
    {
        "Name": "Jack",
        "Age": 21,
        "score": [
            {
                "Item1": 32
            },
            {
                "Item2": 43
            }
        ],
        "Country": "China"
    },
    {
        "Name": "Tom",
        "Age": 23,
        "score": [
            {
                "Item1": 83
            },
            {
                "Item2": 67
            },
            {
                "Item3": 75
            }
        ],
        "Country": "US"
    }
]

有个中间的状态,就是把一条记录整合出来之后,取中间的几个元素作为一个整体,所以需要把中间的几个数据切片到一个新的数组中。
之前在学习Swift的时候,了解过一下数组的用法,以为是非常了解了,实则不然。

2.对于切片数组的 subscript ,你了解多少?

一个简单例子

let array = ["A", "B", "C", "D"]
let slicedArray = array[1..<3]
print(slicedArray.count) // 2
print(slicedArray[0]) // error

WHY?

明明数组中有两个元素,但是为什么用subscript访问,却报错呢?
还有

let slicedArray String = slicedArray.reduce("start: ") { (acc, item) -> String in
    "\(acc)\(item)"
}
print(slicedString) // start: BC

很明显这个”数组”中是有数据的呀,怎么就是取不出来呢?

3.startIndex & endIndex

slicedArray 的 startIndex 和 endIndex 是多少呢?

print(slicedArray.startIndex) // 1 instead 0
print(slicedArray.endIndex) // 3

所以,在用[0]访问slicedArray的时候,其实是越界的 out of bounds !!!!

4.怎么解决这个问题

不去详细的解释为什么,这个跟swift对数组的设计理念相关,copy-on-write,目的之一提高性能
两个方案解决这个问题:

  1. 违背swift的设计原则
    直接创建一个新的数组变量

    let lastedArray = Array(array[1..<3])
    print(lastedArray.startIndex) // 0
    print(lastedArray.endIndex) // 2
    print(lastedArray[0]) // B
  2. 使用数组的属性startIndex,endIndex

    combinedArray[combinedArray.startIndex] // B
    combinedArray[combinedArray.startIndex.advancedBy(1)] // C

5.参考文献

  1. swift-subarrays-array-and-arrayslice
  2. swift-array-and-arrayslice-xcode-7.2

swift——复合类型——Array

阅读数 108

swift——复合类型——Array

博文 来自: mardax

Swift 数组Array

阅读数 442

//===============================数组Array===================================    //在Swift中,数组中存放的元素的数据类型必须是一样的,而且可以存放基本数据类型。也可以存放类的对象。         varlist=[12,14,17];   /

博文 来自: WiKi_Su

swift 学习笔记 --> Array

阅读数 220

//// main.swift// S2ArrayLearn//// Createdbyivanon15/10/22.// Copyright©2015年bingxu.Allrightsreserved.//importFoundation//数组的用法varsho

博文 来自: ivan21

Swift Array Slice

阅读数 7

1.相遇有个业务需求,把表格中的数据整合到一个数组中,如下NameAgeItem1Item2Item3CountryJack213243nullChinaTom23836775US整合后的结果是这样[{"Name":"Jack","Age":...

博文 来自: weixin_34221332

Swift - 数组(Array)

阅读数 964

数组数组是swift中最普通的集合,数组是有序的容器,并且容器中的每一个元素都是相同的类型,可以随机访问元素,相同的值可以多次出现在一个数组的不同位置中。数组的简单语法写Swift数组应该遵循像Array这样的形式,其中Element是这个数组中唯一允许存在的数据类型。我们也可以使用像[Element]这样的简单语法。尽管两种形式在功能上是一样的,但是推荐[

博文 来自: longshihua
没有更多推荐了,返回首页