三、swift3.0字符串和集合的基本使用

一、字符和字符串

1、字符

Character类型表示单个字符，swift采用Unicode字符集来存储字符，因此可以存储所有语言的任意字符。

let s : Character = "2"  
let c1 = "\""  
let c2 = "\u{22}"  
print(c1, c2)  
  
let ch1 = "\u{2666}"  
let ch2 = "\u{2663}"  
let ch3 = "\u{2665}"  
let ch4 = "\u{2660}"  

2、字符串

在Swift中字符串类型是String，它表示一个有序的字符集合
Swift中字符串""

String的特点：
String 是一个结构体，性能更高
NSString 是一个 OC 对象，性能略差
String 支持直接遍历
Swift 提供了 String 和 NSString 之间的无缝转换

let str = "hello world"
//把String转化为NSString
let ocStr = str as NSString

//1、遍历字符串
for ch in say.characters {
    print(ch)
}

//2、拼接字符串
let mChar = say + "wre"
print(mChar)

let n = 123
let m = 3.14
let all = "xxx \(mChar) xxx \(n) xxx \(m)"
print(all)

//3、平接字符串时，字符串的格式化
let min = 2
let second = 8
let time = String(format: "%02d:%02d", second, min)

//4、字符串的截取
let url = "www.baidu.com"
//先把String转NSString
//从左往右截3位
let header = (url as NSString).substring(to: 3)
//从第3位以后截取到末尾
let header2 = (url as NSString).substring(from: 3)
//截取第0位到底1位
let header3 = (url as NSString).substring(with: NSMakeRange(0, 2))

二、数组

1、数组的定义

数组（Array）是一串有序的由相同类型元素构成的集合，数组中的集合元素是有序的，可以重复出现
swift数组类型是Array，是一个泛型集合，即创建时必须指定数组存储元素的类型

//1、声明数组
var arr1 : Array        //泛型语法
var arr2 : [String]             //简化语法

//2、创建数组
//不可变数组，基本数据类型在swift中不需要进行对象包装
let arr1 : Array = [1,2,3];

//可变数组
var arr2 : Array = [4,5,6];

//3、数组的初始化
var arr1 : Array
var arr12 = Array()
arr1 = Array()
arr1 = Array.init()

var arr2 : [String]
arr2 = Array.init(arrayLiteral: "1", "2", "3")
arr2 = [String](arrayLiteral: "1", "2", "3");

var arr3 = Array.init(repeating: "12", count: 3)
arr3 = [String](repeating: "21", count: 3)

//4、对可变数组的操作
let arr1 : Array = ["1", "2", "3"]
print("第一个索引\(arr1.startIndex), 第二个索引\(arr1.endIndex)")

//添加元素
arr3.append(contentsOf: ["a", "b"])
arr3.append("aa")
arr3.append("bb")

//添加类型匹配的数组
let arrn = arr3 + ["12"]

//删除元素
arr3.remove(at: 2)

//删除最后一个元素
arr3.popLast()

//删除数组最后一个元素，并将它返回
arr3.removeLast()

//修改元素
arr3[0] = "sdfdf"

//清空数组
arr3[0..

2、数组的遍历

// 遍历数组
for i in 0..

三、字典的使用
字典是由两部分集合构成的，一个是键（key）集合，一个是值（value）集合
键集合是不能有重复元素的，而值集合是可以重复的，键和值是成对出现的
Swift字典类型是Dictionary，也是一个泛型集合

1、字典的定义
// 定义一个可变字典
var dict1 : [String : NSObject] = [String : NSObject]()

// 定义一个不可变字典，进行初始化
let dict2 = ["name" : "why", "age" : 18]

//字典的定义常用写法
var dict1: Dictionary
var dict2: [Int: String]

// swift中任意对象,通常不使用NSObject,使用AnyObject
var dict : Dictionary
dict = ["name" : "why", "age" : 18]

2、字典的基本操作
// 添加数据
dict["height"] = 1.88
dict["weight"] = 70.0
dict

// 删除字段
dict.removeValueForKey("height")

// 修改字典
dict["name"] = "lmj"

// 查询字典
dict["name"]
//把字典中键值获取出来放到数组中
var dict1 : [String : Any]
dict1 = ["1":"2", "2":"3"]

var keys = Array(dict1.keys)
var values = Array(dict1.values)

3、字典的遍历
// 遍历字典中所有的值
for value in dict.values {
    print(value)
}
// 遍历字典中所有的键
for key in dict.keys {
    print(key)
}

// 遍历所有的键值对
for (key, value) in dict {
    print(key)
    print(value)
}

4、字典的合并
// 字典的合并
var dict1 = ["name" : "yz", "age" : 20]
var dict2 = ["height" : 1.87, "phoneNum" : "+86 110"]
// 字典不可以相加合并
for (key, value) in dict1 {
    dict2[key] = value
}

三、元组的使用
元组类似于数组或者字典，它使用圆括号把多个值组合成一个值，元组内的值可以为任意类型，组成元组类型的数据可以称为“元素”，元组常用于函数的返回值。

1、元组的定义
定义并初始化一个元组变量，系统可以自动推断元组的类型

// 给元素加上元素名称,之后可以通过元素名称访问元素
(id:"1001", name:"张三", english_score:30, chinese_score:90)
let score : (Int , Double, String, Int)
score = (12, 12.2, "dfsdf", 23)
print("score的值为：\(score)")
注：定义了元组后，元组的元素个数不能变化，类型即类型顺序不能变化。

2、元组的访问
通过下标访问

四、Set集合
Set集合也是一个结构体，也支持泛型；
Set集合中的元素不能重复，而且无顺序

//1、使用泛型创建Set
var set1 : Set
set1 = Set()

var set2 : Set
set2 = Set(arrayLiteral: 12, 23)

//2、使用简化语法创建Set
var val1 : Set = ["23", "sd"]
var val2 : [String] = ["12", "234"]
//注意：val2的类型为数组，val1的类型为Set

//3、Set集合的属性
var set1 = Set(arrayLiteral: "123", "334")
print(set1.count, set1.isEmpty)

//返回Set集合底层hash表中存储的第一个元素，而并非添加的第一个元素
print(set1.first)

print("set1集合中是否包含: \(set1.contains("123"))")

//4、Set的遍历
var set2 : Set = ["erw", "opj", "sdf"]
for s in set2 {
    print(s)
}

//5、Set集合的使用
//添加元素
var set3: Set = ["123"]
set3.insert("342")

//删除元素
set3.popFirst()     //删除Set底层hash表中第一个元素，返回即将删除的元素
set3.removeFirst()  //删除Set底层hash表中第一个元素，返回值不是可选类型
set3.removeAll(keepingCapacity: true)   //是否保存Set底层的hash表
set3 = ["2343", "2343"]
set3.remove("234")