array set swift
2016-05-15 18:12:00 weixin_34319374 阅读数 11

编程的世界里,数组和集合都是开发者学习的必经之路,Swift学习亦是如此,先看下它们的特点:
数组(Array):有序、有越界问题
字典(Dictionary):无序、键值对集合
集合(Set):无序、唯一性、集合操作、快速查找
下面具体看看 Swift 集合到底有多强大,能多大程度上解放劳动力。

数组(Array)

初始化

// 静态初始化
var arr = ["iOS", "Android"]

// 动态初始化
var arr1 = Array<String>()
var arr2:Array<String> = []
var arr3 = [String]()
var arr4:[String] = []

// 有默认值的初始化
var arr5 = Array<String>(count: 6, repeatedValue: "")
var arr6 = [String](count: 6, repeatedValue: "")

数组的基本操作

// 数组长度
arr.count

// 数组第一个和最后一个元素
arr.first
arr.last

// 数组判空
arr.isEmpty

延伸一: 数组arr1和Java列表的初始化有点像哈

// Swift Array
var arr1 = Array<String>()
// Java List
List<String> list = new ArrayList<String>();

延伸二: Java数组初始化

// 静态初始化
String[] arr = {"iOS", "Android"};

// 动态初始化
String[] arr1 = new String[2];
String[] arr2 = new String[]{"iOS", "Android"};

增、删、改、查

// 增加一个元素
arr.append("Windows")
arr.append("Mac")
// 在指定位置上插入数据
arr.insert("Linux", atIndex: 2)
print(arr)
// 输出
["iOS", "Android", "Linux", "Windows", "Mac"]
// 这样增加也可以
arr += arr
arr += ["OS X"]

// 删除指定位置的元素
arr.removeAtIndex(3)
// 删除第一个元素
arr.removeFirst()
// 删除最后一个元素
arr.removeLast()
// 删除所有元素
arr.removeAll()

// 修改指定元素或指定范围的数据
arr[4] = "MAC"
arr[2..<arr.count] = ["Mac"]
print(arr)
// 输出
["iOS", "Android", "Mac"]

// 方式一:遍历数组
for index in 0..<arr.count {
    print(arr[index])
}
// 方式二:遍历数组
for index in arr {
    print(index)
}

字典(Dictionary)

字典的主要特点就是无序的键-值对集合,表现形式是 key:value

初始化

var dict = ["name":"sunfusheng", "age":20, "blog":"sunfusheng.com"]

// 初始化空的字典
var dict1:Dictionary<String, String> = [:]
var dict2:[String:String] = [:]
var dict3 = [String:String]()
var dict4 = Dictionary<String, String>()

增、删、改、查

// 有则更新键值对的值,无则增加一个键值对
dict["github"] = "sfsheng0322"
// updateValue: 有则更新键值对的值,无则增加一个键值对,返回 oldValue
dict.updateValue("孙福生微博", forKey: "sina")
dict.updateValue(28, forKey: "age")
print(dict)
// 输出
["age": 28, "blog": sunfusheng.com, "github": sfsheng0322, "sina": 孙福生微博, "sex": 1, "name": sunfusheng]

// 删除指定键的键值对,没有这个键值对相当于无操作
dict.removeValueForKey("sex")
// 删除所有的键值对
dict.removeAll()

// 字典键的集合
print(Array(dict.keys))
// 输出
["age", "blog", "github", "sina", "name"]
// 字典值的集合
print(Array(dict.values))
// 输出
[28, sunfusheng.com, sfsheng0322, 孙福生微博, sunfusheng]

// 遍历字典的键
for key in dict.keys {
    print(key)
}
// 遍历字典的值
for value in dict.values {
    print(value)
}
// 使用元祖遍历字典的键值,for in 真强大!Swift 真强大!
for (key, value) in dict {
    print("\(key):\(value)")
}

集合(Set)

集合(Set)特点:无序、唯一性、集合操作、快速查找。
集合的数据显示和数组是一样的,所以必须显示的声明Set集合!不然!就是数组!

初始化

// 初始化A、B、C三个集合
var A:Set<String> = ["A", "B", "C", "D"]
var B:Set<String> = ["C", "D", "E", "F"]
var C:Set<String> = ["B", "B", "C"]

// 上面Array、Dictionary动态初始化有四种,这里面只有两种
var set1 = Set<String>()
var set2:Set<String> = []

集合的基本操作

// 集合的数量
A.count
// 集合第一个元素,因为集合的无序性,它的第一个元素没有意义
A.first
// 集合是否为空
A.isEmpty
// 向集合中插入一个元素
A.insert("C")
// 删除集合中的元素
A.remove("C")
// 判断集合中是否包含某个元素
A.contains("A")
// 遍历集合
for index in A {
    index
}

集合操作

A.union(B): A、B的值不改变
A.unionInPlace(B): A是并集后的值,改变;B的值不变
并集、交集、异或均是如此

// 为了方便大家看清楚输出结果,我将结果有序排列,但要知道集合的无序性哦
A = ["A", "B", "C", "D"]
B = ["C", "D", "E", "F"]
C = ["B", "B", "C"]

// 并集 (A∪B)
A.union(B)
A.unionInPlace(B)
// 输出
Set A: ["A", "B", "C", "D", "E", "F"]
Set B: ["C", "D", "E", "F"]

// 交集 (A∩B)
A.intersect(B)
A.intersectInPlace(B)
// 输出
Set A: ["C", "D"]

// 异或 (A^B)
A.exclusiveOr(B)
A.exclusiveOrInPlace(B)
// 输出
Set A: ["A", "B", "E", "F"]

// C 是否是 A 的子集
C.isSubsetOf(A)
// A 是否是 C 的超集
A.isSupersetOf(C)

今天的内容看起来很多,其实就那些操作,增删改查;由于Xcode强大的提示功能,我们不需要记住那些函数的名字,用的时候去找就OK,但它们的特性还是要记住的,假以时日多加练习,必将游刃有余,信手捏来!

Swift 学习笔记将持续更新,欢迎关注我的公众号,大家加油!

1830662-7af304767f6ddbe9.jpg
孙福生的微信公众号

关于我

个人邮箱:sfsheng0322@126.com
GitHub主页
简书主页
个人博客
新浪微博

2017-09-05 07:59:12 iOSbird 阅读数 326


import UIKit


var str = "Hello, playground"

//1、分别创建字符串China和MyLove,将两个变量拼接成一句话并且对拼接后的新字符串变量进行遍历,并检查其中是否有'L'字符,有则打印

var str1 = "Hello"

var str2 = "MyLove"

var str3 = str1 + str2

for c in str3.characters {

    if c == "L" {

        print(c)

    }

}


//2、删除swertfkf!sdsfs?sfsfs!ads 中的所有!和?

var strd = "swertfkf!sdsfs?sfsfs!ads"

var strdre = String()

for index in strd.characters.indices {

    if strd[index] != "!" && strd[index] != "?" {//不是!或者?的字符就拼接

        strdre.append(strd[index])

    }

}

print(strdre)


//3、将abcdefg进行倒序排列

var strorder = "abcdefg"

var strorderRe = String()

var index = strorder.endIndex //endIndex 字符的个数

while index > strorder.startIndex {

    index = strorder.index(before: index)

    strorderRe.append(strorder[index])

}

print(strorderRe)


//4、将“*”逐个插入到字符串中间,并打印

var strI = "我爱中国"

var strIRe = String()

//for char in strI.characters {//利用字符拼接

////    strIRe.append(String(char+"*"))

//    strIRe.append(char)

//    if char != strI.characters.last {

//        strIRe.append("*")

//    }

//

//}

for index in strI.characters.indices{

    strIRe.append(strI[index])

    if index<strI.index(before: strI.endIndex) {//利用下标拼接

        strIRe.append("*")

    }

}

print(strIRe)


//5、将字符串中的所有abc换成Hello

var strP = "abc中国ab日本c美国abc英国abc俄罗斯"

var strPRes = String()

var range = strP.range(of: "abc")//找到第一个abc的位置


while range != nil {

    strP.replaceSubrange(range!, with: "Hello")//替换

    range = strP.range(of: "abc")

}

print(strP)

//6、将给定字符串进行正负号翻转,并打印

var str6 = "-123"

var str61 = "+234"


 func  transformStr(str:String) ->(String){

    var newStr = String(str)

    if str .hasPrefix("-") {

    let range = str.range(of: "-")

        newStr.replaceSubrange(range!, with: "+")

    }

    if str .hasPrefix("+") {

        let range = str.range(of:"+")

        newStr.replaceSubrange(range!, with: "-")

    }

    return newStr

}

str6 = transformStr(str: str6)

str61 = transformStr(str: str61)

print(str6,str61)


//7、将数组中的0去掉并返回新的数组

var arr = [1,2,0,23,345,0,22,0,34,23,0,0,0,36]

var newArr = Array<Int>()

for index in arr.indices {

//    if arr[index] == 0 {

//        continue

//    }

//    newArr.append(arr[index])

    

    if arr[index] != 0 {

        newArr.append(arr[index])

    }

    

}

print(newArr)

//8、定义一个包含10个元素的数组,对其进行赋值,使每个元素等于其下标,然后输出

var preArr = Array<Int>()

for index in 0...9{

    preArr.append(index)

}

print(preArr)

//倒置

preArr.sort { (a, b) -> Bool in

    return a>b

}

print(preArr)


//9、工程测量到两组数据分别是2、4、3、5和3、4、7、1.对两组数据进行整合使其合成一组数据,重复的数据只算一次

var set1 : Set<Int> = [2,4,3,5]

var set2 : Set<Int> = [3,4,7,1]

var set3 = set1.union(set2)

print(set3)


//10、期末考试中,王晓成绩98,周明成绩86,李小伟成绩93,用字典结构来对3人的成绩进行存储,并进行从高到低的排序输出

var table = ["王晓":98,"周明":86,"李小伟":93]

for item in table.sorted(by: { (student1, student2) -> Bool in

        return student1.value > student2.value

}){

    print(item)

}

print(table.sorted(by: { (student1, student2) -> Bool in

    return student1.value > student2.value

}))


var tap1 = (3,4,"5")

var tap2 = (2,6,"7")

tap1<tap2

//上面是两个元组的比较,其原则是:首先要比较的元组中元素个数和对应位置的元素类型必须相同,其次元组中每一个元素必须支持比较运算操作。上面的tap1和tap2的元组个数和对应位置的元素类型相同可以比较,tap1中的3,4比tap2中的2大,所以是false

var i = 0

while i<10 {

    print(i)

    i += 1

}


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.")
}
2016-09-01 13:49:00 weixin_34216196 阅读数 16
// 数组
public struct Array<Element> : RandomAccessCollection, MutableCollection { }

// 字典
public struct Dictionary<Key : Hashable, Value> : Collection, ExpressibleByDictionaryLiteral { }

// 集
public struct Set<Element : Hashable> : SetAlgebra, Hashable, Collection, ExpressibleByArrayLiteral { }

1. Array

1.1 数组的创建

数组创建的 api

// 默认的初始化方法
public init()

// 传入一个 序列 元素创建
public init<S : Sequence where S.Iterator.Element == Element>(_ s: S)

// 字面值创建
public init(arrayLiteral elements: Element...)

// 创建一个固定大小 重复值的数组
public init(repeating repeatedValue: Element, count: Int)

常见的空数组创建的方式

var arr1 = [Double]()                    // 推荐使用
var arr2 = Array<Double>()
var arr3: [Double] = []                  // 推荐使用
var arr4: [Double] = Array()
var arr5: Array<Double> = []
var arr6: Array<Double> = Array()
446092-357ecc02de0cc18e.png
Snip20160901_14.png

推荐使用 arr1 和 arr3 的数组的创建方式。理由,简洁高效。

1.2 推荐的数组创建方式

let numbers = [1, 3, 5, 7, 9, 11, 13, 15]

let streets = ["Albemarle", "Brandywine", "Chesapeake"]
446092-cce1c0449c191e08.png
Snip20160901_15.png

注:使用 let 声明的数组不能再被修改。

**使用的是上面第三个 Array 的 init 函数。 **

这种创建数组的方式更加的高效和简洁。

1.3 Array 初始化演示

Array 结构体的申明

public struct Array<Element> : RandomAccessCollection, MutableCollection { }

api

public init()

在初始化的时候必须指定 数组中存储的 数据类型

// Array<Element> 
var arr = Array<Int>()

api

public init<S : Sequence where S.Iterator.Element == Element>(_ s: S)

// S 类型,遵守 Sequence 协议。 
// 所有遵守 Sequence 协议的实例,并且 S 类型迭代出来的元素的类型 和 Array 中保存的元素的类型一致。
// 都可以往里面传。
let namedHues: [String: Int] = ["Vermillion": 18,
                                "Magenta": 302,
                                "Gold": 50,
                                "Cerise": 320]

let colorNames = Array(namedHues.keys)
let colorValues = Array(namedHues.values)
446092-ccc1bb5fa9d53107.png
Snip20160901_16.png
let numbers = Array(0...10)

// 等效
let numbers1 = [0,1,2,3,4,5,6,7,8,9,10]
446092-abfed79b4c1822b4.png
Snip20160901_17.png

api

// 这个函数不能直接调用,这个方法是由编译器调用,通过使用字面量来触发,
public init(arrayLiteral elements: Element...)
let ingredients = ["cocoa beans", "sugar", "cocoa butter", "salt"]
446092-ebf3dcd874133dd8.png
Snip20160901_18.png

api

// 创建一个,元素值重复,个数固定的数组
public init(repeating repeatedValue: Element, count: Int)
let fiveZs = Array(repeating: "Z", count: 5)
446092-16c5b368d571df65.png
Snip20160901_19.png

1.4 数组的常用操作

  • **数组的遍历 **
    **for - in **
let numbers = Array(0...10)

// 这个是遍历所有的元素
for number in numbers {
    print(number)
}

//  这种方式和上面是等价的 (区别: ..<  通过区间的调整,可以遍历数组中的部分元素)
for index in 1..<numbers.count {
    print(numbers[index])
}
446092-b1d09cce59c15559.png
Snip20160901_21.png

forEach

let numbers = Array(0...10)

numbers.forEach { (number) in
    print(number)
}
446092-be08dcdf357ccb41.png
Snip20160901_22.png
2018-05-31 09:32:00 weixin_34161083 阅读数 6

数组 — Array

通过一个默认值重复创建数组

var threeDoubles = Array(repeating: 0.0, count: 3)
var anotherThreeDoubles = Array(repeating: 0.1, count: 3)

通过两个数组创建一个新的数组

var sixDoubles = threeDoubles + anotherThreeDoubles

通过字面量创建

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

由于 Swift 的数据推断,初始化的时候可以不加数据类型

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

访问和修改数组

shoppingList.count
shoppingList.isEmpty
shoppingList.append("Flour")
shoppingList += ["Baking Powder"]
shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
var firstItem = shoppingList[0]
shoppingList[0] = "Six eggs"
shoppingList[4...6] = ["Bananas", "Apples"] // 4.5.6 -> 4.5
shoppingList.insert("Maple Syrup", at: 0)
var returnRemoveString = shoppingList.remove(at: 0)
var returnRemoveLast = shoppingList.removeLast()

遍历

for item in shoppingList {
    print(item)
}

同时获取 index 和 item

for (index, item) in shoppingList.enumerated() {
    print("Item \(index + 1): \(item)")
}

集合 — Set

存储不同值并且相同类型、不排序

Hash Values for Set Types

  • 类型必须是以 Hashable 以存储在集合中,Int 类型
  • if a == b,a.hashable == b.hashable
  • 使用自定义类型作为集合值类型或者字典key类型,遵循 Hashable
  • 遵循 Hashable 协议必须提供 get Int hashValue,该值不需要在相同程序或者不同程序的不同执行中相同
  • Hashable 遵循 Equatable,所以还必须提供一个 == 操作符的实现
  • == 必须满足三个条件:
    (1)a == a 自反性
    (2)a == b 等效于 b == a
    (3)a == b && b == c 等效于 a == c

创建和实例化空集合

var letters = Set<Character>()
letters.insert("a")
letters = []
var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]
// 不能从一个数组字面量被推断为 Set 数据类型,必须显示声明
// but 不需要写 set 中  的类型
let favoriteGenresNew: Set = ["Rock", "Classical", "Hip hop"]

访问和修改集合

favoriteGenres.count
favoriteGenres.isEmpty
favoriteGenres.insert("Jazz")
if let removedGenre = favoriteGenres.remove("Rock") {
    print("\(removedGenre)? I'm over it")
}else {
    print("I never much cared for that")
}
if favoriteGenres.contains("Funk") {
    print("I get up on the good foot.")
}else {
    print("It's too funky in here")
}

遍历集合

for genre in favoriteGenres {
    print("\(genre)")
}

for genre in favoriteGenres.sorted() { // < 排序
    print("\(genre)")
}

集合操作

var a: Set = Set<String>()
var b: Set = Set<String>()
a.intersection(b) // 交集,共有部分
a.symmetricDifference(b) // 非共有部分总和
a.union(b) // 并集,a + b
a.subtracting(b) // a - a.intersection(b)(交集)
a == b // a 和 b 有所有相同值
a.isSubset(of: b) // a 是不是 b 的子集
a.isSuperset(of: b) // a 是不是 b 的父集
a.isStrictSubset(of: b) // a 是不是 b 的子集,但是不等于 b
a.isStrictSuperset(of: b) // a 是不是 b 的父集,但是不等于 b
a.isDisjoint(with: b) // a 和 b 没有公共部分

字典 — Dictionary

var namesOfIntegers = [Int: String]() // 空数组
namesOfIntegers = [:] // 空数组
var airports: [String: String] = ["YYZ": "Toronto Person", "DUB": "Dublin"] // key: value

访问和修改字典

airports.count
if airports.isEmpty {
    print("The airports dictionary is empty")
} else {
    print("The airports dictionary is not empty")
}

airports["LHR"]  = "London"// 添加一个新值 或 修改值
var returnOldValue = airports.updateValue("London", forKey: "LHR") // 添加一个新值 或 修改值
if let oldValue = airports.updateValue("Dublin Airport", forKey: "DUB") {
    print("The old value for DUB was \(oldValue).")
}

if let airportName = airports["DUB"] {
    print("The name of the airport is \(airportName)")
} else {
    print("The airport is not in the airports dictionary")
}

移除

airports["APL"] = nil
if let removedValue = airports.removeValue(forKey: "DUB") {
    print("The removed airport's name is \(removedValue)")
} else {
    print("The airport dictionary does not contain a value for DUB")
}

遍历

for (airportCode, airportName) in airports {
    print("\(airportCode) : \(airportName)")
}
// 取出 keys, values
for airportCode in airports.keys.sorted() {
    print("Airport code: \(airportCode)")
}

for airportName in airports.values.sorted() {
    print("Airport code: \(airportName)")
}

keys,values 初始化数组

let airportName = [String](airports.values)
let airportCode = [String](airports.keys)

swift——Array

阅读数 29

数组可以存储同一个类型的多个值,而且相同的值可以多次出现在数组中的不同位置。创建数组1.定义数据类型有两种形式vararray1:Array&lt;String&gt;vararray2:[String]2.创建一个空数组通过初始化函数来创建一个有特定数据类型的空数组varsomeInts=[Int]()3.用字面量构造数组...

博文 来自: weixin_34200628

swift之数组(Array)、集合(Set)、字典(Dictionary)

阅读数 3140

swiftArraySetDictionary

博文 来自: lvdezhou

swift set

阅读数 272

AsofSwift1.2(Xcode6.3beta),Swifthasanativesettype.Fromthereleasenotes:Anew Set datastructureisincludedwhichprovidesagenericcollectionofuniqueelements,withfullval

博文 来自: yeshennet

swift——Set

阅读数 10

Set用来存储相同类型并且没有确定顺序的值。与数组不同的是,Set里的元素是无序的,并且每个元素都不能重复。Set&lt;Element&gt;//Element表示Set中允许存储的类型创建Set1创建空Setvarletters=Set&lt;Character&gt;()2用数组字面量创建Setvarfavorit...

博文 来自: weixin_33727510

swift set

阅读数 19

Set是用来存储相同类型并且无序的集合类型,这是一个简单的Set集合:varset:Set=[“1”,”2”,”3″]set是一个Set类型的集合,集合中只能出现String类型的数据,如果放入了其他类型,会报错。但是如果没有指定集合中的数据类型,那就没有关系。varset:Set=[“1”,”2”,”3”,4,5,6,7]Set集合另外一个特...

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