array类型 swift

2017-02-23 16:19:35 LFYPhoenix 阅读数 459

集合类型

Swift提供了三种主集合类型,称为数组,集合和字典,用于存储值的集合。 数组是值的有序集合。集合是唯一值的无序集合。 字典是键-值关联的无序集合。

 

一、数组

数组(Array)在有序列表中存储相同类型的值。相同的值可以在不同位置多次出现在数组中。

1>.创建数组

//创建空数组

var someInts= [Int]()//使用初始化语法创建特定类型的空数组

someInts.append(3)

print(someInts)//[3]

someInts = []//赋值空数组

print(someInts)//[] 一个空数组,但仍然是类型[Int]

 

//使用默认值创建数组

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

print(threeDoubles)//[0.0, 0.0, 0.0]

 

//通过一起相加(+)两个数组来创建数组

var twoDoubles =Array(repeating:0.12, count:2)

var fourDoubles =Array(repeating:1.5, count:4)

print(twoDoubles +fourDoubles)//[0.12, 0.12, 1.5,1.5, 1.5, 1.5]

 

//使用值列表创建数组  [1,值2,值3] 值用逗号分隔,并用一对方括号括起来

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

 

2>.访问和修改数组

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

//count:数组的元素个数

print("modifyArrayhas\(modifyArray.count) items")//modifyArray has 2items

 

//isEmpty:判断数组的count属性是否等于0

print(modifyArray.isEmpty)//false

 

//append_ :)将新元素添加到数组的末尾:

modifyArray.append("Apple")

print(modifyArray)//["Eggs","Milk", "Apple"]

 

//使用加法赋值运算符(+=)附加一个或多个兼容项目的数组

modifyArray += ["peach"]

print(modifyArray)//["Eggs","Milk", "Apple", "peach"]

 

//使用下标语法从数组中检索值

print(modifyArray[2])//Apple 注:数组中的第一个项目的索引为0,而不是1

 

//使用下标语法来更改给定索引处的现有值

modifyArray[1] ="chicken"

print(modifyArray)//["Eggs","chicken", "Apple", "peach"]

modifyArray[0...2] = ["chicken","chicken","chicken"]

print(modifyArray)//["chicken","chicken", "chicken", "peach"]

//注:不能使用下标语法将新元素附加到数组的末尾。

//注:数组中最大的有效索引将始终为count - 1,因为数组从零开始索引。

 

//insert_at :) 在指定索引处将数据插入数组

modifyArray.insert("Green", at:1)

print(modifyArray)//["chicken","Green", "chicken", "chicken", "peach"]

 

//removeat :)从数组中删除一个元素

modifyArray.remove(at:0)

print(modifyArray)//["Green","chicken", "chicken", "peach"]

 

//removeLast()从数组中删除最后一个项目

modifyArray.removeLast()

print(modifyArray)//["Green","chicken", "chicken"]

 

//removeAll()移除数组的所有元素,变为空数组

modifyArray.removeAll()

print(modifyArray)//print(modifyArray)

 

3>.数组的遍历

//使用for-in循环遍历数组中的整组值

var iterateArray = ["Eggs","Apple"]

for itemin iterateArray {

    print(item)

}

/*

 Eggs

 Apple

 */

 

//enumerated()方法返回一个由整数和项组成的元组。 

for (index, value)in iterateArray.enumerated(){

    print("Item \(index):\(value)")

}

/*

 Item0: Eggs

 Item1: Apple

 */

 

 

二、集合 Sets

集合在集合中存储相同类型的不同值,没有定义的顺序

Sets的哈希值

  Swift的所有基本类型(例如StringIntDoubleBool)在默认情况下是哈希的,并且可以用作设置值类型或字典键类型。默认情况下,没有关联值的枚举值值也是可哈希的。

 

 

集合  Sets

集合在集合中存储相同类型的不同值,没有定义的顺序。

Swift的所有基本类型(例如StringIntDoubleBool)在默认情况下是哈希的,并且可以用作设置值类型或字典键类型。默认情况下,没有关联值的枚举值也是可哈希的。

Swift集合的类型为Set<Element>,其中Element是允许集合存储的类型。

 

1>.集合的创建

//创建和初始化空集

var letters =Set<Character>()//初始化元素为Character类型的空集

letters.insert("a")//插入一个元素a

letters = []//置为空集,但仍是Set<Character>类型

 

//使用数组创建集合

let mybooks:Set = ["ecev","cevev"]

var favoriteFruits:Set<String> = ["Apple","Peach"]

print(mybooks,favoriteFruits)//["ecev", "cevev"]["Apple", "Peach"]

 

2>.访问和修改集合

var modifySet:Set<String> = ["Apple","Peach"]

//count访问集合的子元素个数

print(modifySet.count)//2

 

//isEmpty判断集合是否为空

print(modifySet.isEmpty)//false

 

//insert_ :)为集合添加新元素

modifySet.insert("chicken")

print(modifySet)//["chicken", "Apple","Peach"]

 

//remove_ :)移除集合的指定元素

//removeAll()移除集合中的所有元素

modifySet.remove("Apple");

print(modifySet)//["chicken", "Peach"]

 

//contains_ :)判断集合是否包含特定项目

print(modifySet.contains("Apple"))//false

 

 

3>.集合的遍历

//使用for-in循环遍历集合中的值

for itemin modifySet{

    print(item)

}

/*

 chicken

 Peach

 */

 

4>.集合的合并

intersection(_:)创建一个只有两个公用集的值的新集。

symmetricDifference_ :)创建一个新集合,其值在两个集合中,但不能同时存在。

union_ :)创建一个包含两个集合中的所有值的新集合。

subtracting_ :)方法创建一个新的集合,其值不在指定集合中。

 

let oddDigits:Set = [1, 3, 5, 7,9]

let evenDigits:Set = [0, 2, 4, 6,8]

letsingleDigitPrimeNumbers:Set = [2, 3, 5, 7]

print(oddDigits.union(evenDigits).sorted())//[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(oddDigits.intersection(evenDigits).sorted())//[]

print(oddDigits.subtracting(singleDigitPrimeNumbers).sorted())//[1, 9]

print(oddDigits.symmetricDifference(singleDigitPrimeNumbers).sorted())//[1, 2, 9]

 

5>.集合元素和相等

== 确定两个集合是否包含所有相同的值。

isSubsetof :)方法来确定集合的所有值是否都包含在指定的集合中。

isSupersetof :)方法来确定集合是否包含指定集合中的所有值。

isStrictSubsetof :)isStrictSupersetof :)方法来确定集合是否为子集或超集,但不等于指定集。

isDisjointwith :)方法来确定两个集合是否具有任何共同的值。

 

字典Dictionary

字典存储相同类型的键和相同类型的值之间的关联,没有定义顺序。

Swift字典的类型为Dictionary<KeyValue>,其中Key是可用作字典键的值的类型,Value是字典为这些键存储的值的类型。

 

1>.字典的创建

//创建空字典

var namesOfIntegers = [Int:String]()

namesOfIntegers[16] ="sixteen"

namesOfIntegers = [:]

 

//直接初始化字典

//[key1: value 1, key 2: value 2, key 3: value 3]

var airports: [String:String] = ["YYZ":"Toronto Pearson", "DUB": "Dublin"]

 

2>.访问和修改字典

var provinceCity: [String:String] = ["Beijing":"Beijing","HeNan":"Zhengzhou"]

 

//count获取字典中键值对的个数

print(provinceCity.count)//2

 

//isEmpty判断字典中键值对的个数是否为0

print(provinceCity.isEmpty)//false

 

//使用适当类型的新键作为下标索引,并分配适当类型的新值

provinceCity["Shandong"] ="Jinan"

print(provinceCity)//["HeNan": "Zhengzhou","Shandong": "Jinan", "Beijing":"Beijing"]

 

//直接修改键对应的值

provinceCity["Shandong"] ="Qingdao"

//updateValue_forKey :) 设置或更新特定键的值。改方法字典值类型的可选值

provinceCity.updateValue("Jinan",forKey:"Shandong")

print(provinceCity)//["HeNan": "Zhengzhou","Shandong": "Jinan", "Beijing":"Beijing"]

 

删除键值对

//使用下标语法通过为该键分配值nil来从字典中删除键值对

provinceCity["Shandong"] =nil//

print(provinceCity)//["HeNan": "Zhengzhou","Beijing": "Beijing"]

 

//removeValueforKey :)方法从字典中删除键值对

provinceCity.removeValue(forKey:"Beijing")

print(provinceCity)//["HeNan": "Zhengzhou"]

 

字典的遍历

for (province, city)in provinceCity {

    print("\(province):\(city)")//HeNan: Zhengzhou

}

2017-06-06 19:58:00 weixin_34144450 阅读数 321

      Array是Swift中的数组数据类型。而NSArray是OC中的数组数据类型。两者有差别有联系。在Swift中有时候难免会使用到OC中的一些东西。今天我们就来Swift中使用NSArray和Array,而且进行转化。

(1)声明一个Array数组。并进行遍历。代码例如以下:

    let stringArray: Array<String> = ["10", "20","30","40","50"]
        for index in stringArray{
        
            println(index)
        }
        

输出结果例如以下:

使用Swift遍历Array数组没有不论什么问题,能够使用for...in循环。


(2)声明一个NSArray数组,并进行遍历,代码例如以下:

     let stringNSArray: NSArray = ["10", "20","30","40","50"]
        
        for index in stringNSArray{
        
            println(index)
        }

输出结果例如以下:

可见NSArray数组也能够在Swift中直接进行声明并进行遍历。


(3)声明一个NSArray数组,转化为Array数组。再进行遍历:

   let stringNSArray: NSArray = ["10", "20","30","40","50"]
        let stringArray:[String] = stringNSArray as! [String]
        
        for index in stringArray{
        
            println(index)
        }

输出结果例如以下:


可见NSArray能够在类型转换后直接赋值给Array数组。然后也能够进行遍历。


(4)声明一个Array数组,转化为NSArray,再进行遍历:

     let stringArray: Array<String> = ["10", "20","30","40","50"]
        let stringNSArray:NSArray = stringArray
        for index in stringNSArray{
        
            println(index)
        }

输出结果例如以下:

能够看到Array数组也能够直接转化为NSArray。并进行遍历。             


      总结,Swift在数组方面Array非常好的兼容了OC中的NSArray。能够直接进行赋值转换。


github主页:https://github.com/chenyufeng1991  。

欢迎大家訪问!














2017-03-03 16:13:13 shenhaifeiniao 阅读数 791

一、引言

Swift中提供了3种集合类型,Array数据类型,Set集合类型,Dictionary字典类型。

Array用于存放一组有序的数据,数据角标从0开始一次递增;
Set用于存放一组无序的数据,数据不可以重复;
Dictionary也用于存放一组无序的数据,只是其是按照键值对的方式存储,键值必须唯一。

这里借用官方文档中的一张图来表示3种集合类型的特点:
这里写图片描述

二、Array类型

Array通常也被称为数组,Swift是一种类型安全语言,其中的Array类型也必须确定其元素的类型,声明数组类型有两种方法,示例如下:

//将数组声明为Int类型值集合的数组
var array1:[Int]
var array2:Array<Int>
//创建空数组
array1 = []
array2 = Array()

数组对象如果通过var变量也接收,则其为可变的数组,可以通过append方法来追加元素,示例如下:

//向数组中追加元素
array1.append(3)    //[3]

在创建数组时,也可以对数组进行初始化,示例如下:

//创建数组[0,0,0]
var array3 = [Double](repeating: 0, count: 3)
//创建数组[2.5,2.5,2.5]
var array4 = Array(repeating: 2.5, count: 3)
//数组可以使用+号直接进行追加 [0,0,0,2.5,2.5,2.5]
var array5 = array3+array4

Swift中提供了许多访问和修改数组的方法,示例代码如下:

//获取数组中元素个数
array5.count    //6
//判断数组是否为空
array5.isEmpty  //false
//判断数组是否包含某个元素,有则返回所包含的元素个数
array5.index(of: 1);    //nil
array5.index(of: 2.5);  //3

//通过下标访问数组中的元素
array5[1]   //0

//通过下标修改数组元素
array5[1]=2 //2
//修改数据中的一组数据
array5[0...3] = [1,1]   //[1, 1, 2.5, 2.5]

//替换数据中的一组数据,作用与修改一样
array5.replaceSubrange(Range(1..<2), with: [66,77,88,99]) //[1, 66, 77, 88, 99, 2.5, 2.5]

//向数组中某个位置插入一个数据
array5.insert(3, at: 1) //[1, 3, 66, 77, 88, 99, 2.5, 2.5]

//移除数组某个角标处的元素
array5.remove(at: 1)    //[1, 66, 77, 88, 99, 2.5, 2.5]

//移除数组的最后一个元素
array5.removeLast() //[1, 66, 77, 88, 99, 2.5]

//移除数组第一个元素
array5.removeFirst()    //[66, 77, 88, 99, 2.5]

//遍历整个数组
for item in array5 {
    print(item)
}
//遍历数组枚举
for (index,item) in array5.enumerated() {
    print(index,item)
}
//移除数组所有元素
array5.removeAll()  //[]

三、Set类型

Set类型集合不关注元素的顺序,但是其可以保证其中元素的唯一性。和Array类型一样,Set类型来声明时也需要确定其内元素的类型,示例如下:

var sets1 = ["qwe","asd","zxc"] //["qwe", "asd", "zxc"]
type(of:sets1)  //Array<String>.Type
//Set类型不能从数组字面量中被单独推断出来,因此Set类型必须显式声明,但是可以不声明具体类型,具体类型可以自检
var sets2: Set = ["qwe","asd","zxc"]    //{"zxc", "qwe", "asd"}
type(of:sets2)  //Set<String>.Type

下面示例代码演示对集合进行操作:

var set1:Set<Character> = ["a","b","c","d"]
//向集合中插入元素
set1.insert("z")    //(.0 true, .1 "z") 返回值中true表示成员不重复,插入成功
set1    //{"b", "a", "d", "c", "z"}
set1.insert("z")    //(.0 false, .1 "z") 返回值中false表示成员重复,插入失败

//获取集合中元素个数
set1.count  //5
//判断集合是否为空
set1.isEmpty    //false
//判断集合中是否包含某个元素
set1.contains("e")  //false
//将集合中的某个元素移除
set1.remove("a")    //{"b", "d", "c", "z"}

//遍历集合
for item in set1 {
    print(item)
}
//进行从小到大的排序遍历
for item in set1.sorted() {
    print(item)
}

//移除集合中的所有元素
set1.removeAll()    //Set([])

Set也支持进行一些集合的数学运算,例如交集,并集,补集等,下面一张图演示了Set进行集合运算的一些特性:
这里写图片描述
- intersection(_:) 交集,根据两个集合中都包含的值 创建 的一个新的集合。
- symmetricDifference(_:) —> 交集的补集,根据在一个集合中但不在两个集合中的值 创建 一个新的集合。
- union(_:) —> 并集,根据两个集合的值 创建 一个新的集合。
- subtracting(_:) —> 第二个集合的补集,在第一个集合中 根据不在第二个集合中的值 创建 一个新的集合。
- subtract(_:) —> 第二个集合的补集,并且从第一个集合中移除交集的元素。没有返回值!

示例代码如下:

let sets10: Set = [1, 2, 3, 4, 5, 6]
var sets11: Set = [4, 5, 6, 7, 8]


//交集
let set01 = sets11.intersection(sets10) //返回{4, 5, 6},sets11和sets10值不变
sets11
sets10

//交集的补集
let set02 = sets11.symmetricDifference(sets10)  //返回{1, 2, 3, 7, 8},sets11和sets10值不变

//并集
let set03 = sets11.union(sets10)   //返回{1, 2, 3, 4, 5, 6, 7, 8},sets11和sets10值不变

//第二个集合的补集
let set04 = sets11.subtracting(sets10)  //返回[7, 8],sets11和sets10值不变
sets11

//第二个集合的补集,并且从第一个集合中移除交集的元素。没有返回值
sets11.subtract(sets10)  // sets11的值变为[7, 8] 和 sets10值不变
//let set05:Set<Int> = sets11.subtract(sets13)  //错误,subtract没有返回值!
let set05 = sets11  //[7, 8]
  • “相等”运算符 ( == ) —> 判断两个集合是否相等;
  • isSubset(of:) —> 判断第一个集合是否是第二个集合的子集;
  • isSuperset(of:) —> 判断第一个集合是否是第二个集合的超集,即第一个集合是否包含第二个集合的所有值;
  • isStrictSubset(of:) —> 判断是否是某个集合的真子集,即这个集合是某一个集合的子集,但它们并不相等;
  • isStrictSuperset(of:) —> 判断是否是某个集合的真超集,即这个集合是某一个集合的超集,但它们并不相等;
  • isDisjoint(with:) —> 判断两个集合是否没有相同的值。没有相同的值则返回true,有则false。

下面代码显示了与子集相关的运算:

sets11 = [4, 5, 6, 7, 8]
let sets12: Set = [4, 6, 8]
let sets13: Set = [4, 5, 6, 7, 8]
let sets14: Set = [1, 3, 5, 7, 9]

//判断是否相等
sets11 == sets12    //false
sets11 == sets13    //true

//判断第一个集合是否是第二个集合的子集
sets11.isSubset(of: sets12) // false
sets12.isSubset(of: sets11) // true

//判断第一个集合是否是第二个集合的超集
sets11.isSuperset(of: sets12)   // true
sets12.isSuperset(of: sets11)   // false

//判断是否是某个集合的真子集,
sets12.isStrictSubset(of: sets11)   //true
sets13.isStrictSubset(of: sets11)   //false

//判断是否是某个集合的真超集
sets11.isStrictSuperset(of: sets12) //true
sets11.isStrictSuperset(of: sets13) //false

//判断两个集合是否没有相同的值,没有则返回true
sets11.isDisjoint(with: sets12)// false
sets12.isDisjoint(with: sets14)// true

四、Dictionary类型

Swift中的Dictionary在声明时必须明确键的类型和值的类型,示例如下:

var dic:Dictionary<Int,String>
var dic1:[Int:String] = [1:"one",2:"Two"]

访问与操作Dictionary的方法,代码示例如下:

var dic2:[Int:String] = [1:"One",2:"Two",3:"Three",4:"Four"]
//获取字典键值对个数
dic2.count  //4
//判断字典是否为空
dic2.isEmpty    //false
//通过键获取值
dic2[1] //"One"

//添加或修改: 字典变量[键] = 值
//通过键修改值
dic2[1] = "First"   //[2: "Two", 3: "Three", 1: "First", 4: "Four"]
//添加键值
dic2[0] = "Zero"    //[0: "Zero", 2: "Two", 3: "Three", 1: "First", 4: "Four"]


//updateValue 方法将更新一个键值 如果此键存在 则更新键值 并且将旧的键值返回 如果此键不存在 则添加键值 返回nil 其返回的为一个Optional类型值 可以使用if let进行处理
dic2.updateValue("9", forKey: 1)    //"First"
//使用if let 处理updateValue的返回值
if let oldValue = dic2.updateValue("One", forKey: 1) {
    print("Old Value is \(oldValue)")   //"Old Value is 9\n"
}
//通过键值获取的数据也将是有个Optional类型的值 也可以使用if let
if let value = dic2[1] {
    print("The Value is \(value)")  //"The Value is One\n"
}

//如果有此键,则移除某个键值对
dic2    //[0: "Zero", 2: "Two", 3: "Three", 1: "One", 4: "Four"]
dic2[9]=nil //没有此键,忽略
dic2[0]=nil //[2: "Two", 3: "Three", 1: "One", 4: "Four"]
//如果有此键,则返回其值,并移除键值对,没有则返回nil
dic2.removeValue(forKey: 0) //没有此键,忽略
dic2.removeValue(forKey: 1) //返回“One”,dic2变为[2: "Two", 3: "Three", 4: "Four"]


//对字典进行遍历
for (key,value) in dic2 {
    print(key,value)
}
//遍历所有键
for key in dic2.keys {
    print(key)
}
//遍历所有值
for value in dic2.values {
    print(value)
}
//进行从小到大的排序遍历
for key in dic2.keys.sorted() {
    print(key)
}

原文https://my.oschina.net/u/2340880/blog/673359,仅针对swift3做少量更改。

2015-09-09 14:58:51 CODE_WORM 阅读数 6275


/*

编程环境: xcode 7.0 beta6

*/




/*---------------------------.数组的创建-------------------------*/

//[someType]  等同于 Array<someType>,都代表可以装有someType这种类型数据的数组,下边我只使用[someType]这种形式:


/*

1. 变量数组,常量数组

变量数组可以进行更改,对应OC可变数组:NSMutableArray,常量数组不可以进行修改, 对应OC不可变数组:NSArray

*/

var arr1_1:[Int]     //变量数组

let arr1_2: [Int]    //常量数组,可以不直接赋值, 但是当第一次赋值过后就不可以更改了


/*

2. 数组的创建你可以指定这个数组装有什么类型,如果你指定特定的类型, 那么这个数组只能装这个类型的数据,或者这个类型的子类的数据;

*/

let arr1_3: [String] = ["ab","cd"] //只能添加字符串类型


/*

3. 如果你不指定的类型, swift会有类型推断,根据你在等号右边赋的值来进行类型推断:

*/

//(1). 如果赋的值都是某个特定类型的数据,比如说都是[1, 2, 3], 那么类型推断为[Int];

var arr1_4 = [1,2, 3]    //这时arr1_4[Int]类型

arr1_4 = []              //这种情况, arr1_4依旧是[Int]类型


//(2). 如果你所赋的值都为NSObject类的对象或者继承与NSObject类的对象,或者String, Int, Double等一些基础类型, 那么swift将这个数组推断为[NSObject]类型;

let NSStr1_1: NSString ="NSString"

let arr1_5 = [1,"123", NSStr1_1]   //这时arr1_5[NSObject]类型


//(3). 如果数组中包含不止继承与NSObject类的数据(没有任何继承与任何类的对象),或者不继承与NSObject又不是基础类型数据,比如说Array Dictionary, swift将其推断为NSArray类型(原来是OC中的类型, swift中一样有这个类型, 实现了部分OC中的方法), NSArray这个类型可以和swift中的[Element]相互转换, [Element](这个涉及到泛型, 就是一个占位类型, 你往数组添加任何类型的数据都可以);

let arr1_6 = [1,"123", arr1_5]   //识别为NSArray类型

let arr1_7 = Array(arr1_6)        //将其转换为[Element]类型,注意[Element]这个类型不可以直接声明;

/*如果想得到一个,空的泛型数组可以这样写:*/

let arr1_8 = []             //这个时候识别为NSArray类型

var arr1_9 = Array(arr1_8//arr1_9就是一个空的[Element]类型的数组


//4. 创建一个有多个元素重复的数组

var arr1_10 = Array(count:3, repeatedValue: 1.3)

print(arr1_10)

/*打印结果

[1.3, 1.3, 1.3]  //含有3 1.3的数组

*/


//5. 通过两个数组相拼接的方式获取新数组

var arr1_11 = arr1_7 + arr1_9//等号后边两个数组必须是相同类型的数组,比如这两个都是泛型数组[Element]

print(arr1_11)

/*打印结果

[1, 123, (

1,

123,

NSString

)]

*/


//6. 通过 Array(arrayLiteral: <#T##Element...##Element#>)来创建数组:

var NSStr1_2: NSString ="NSString2"

let arr1_12 = Array(arrayLiteral:1, "123",1.23, NSStr1_2)     //这后边只能填NSObject类的对象或者继承与NSObject类的对象,以及Int, Double, String 一些基础类型,这时arr1_12被识别为[NSObject]类型


//7. 通过范围运算符 0...1来创建数组:

//0...1 表示 0 1 的开区间(0..<1表示0 1 的半开半闭区间,不包括1)

let arr1_13 = [0,1, 2, 3, 4, 5]

var arr1_14 = arr1_13[0...3]   //这个时候arr1_14ArraySlice类型(ArraySlice类型和Array类型很像,像截取数组的一部分的时候, 都会被识别为ArraySlice类型,可以被理解为迷你版的Array, Array ArraySlice 类型和可以相互转换)

var arr1_15 = Array(arr1_14)  //转换为Array<Int>类型




/*---------------------------.遍历数组-------------------------*/


//1 首先说一下如何查看数组的元素,以及获取数组的一些基础属性

var arr2_1 = [999,10, 99, 4]

//(1)首先说一下数组名[下标]的方式来访问或者修改数组元素 eg:

print(arr2_1[0])

/*打印结果

999

*/


arr2_1[0] =110

print(arr2_1)

/*修改后的打印结果

[110, 10, 99, 4]

*/


//(2)通过0...1(这个表示0 1 的开区间)的这种范围方式来访问数组:

print(arr2_1[0...1])

/*打印结果

[110, 10]

*/


//(3)获取数组某些特定位置的元素:

print(arr2_1.first)    //获取数组的第一个元素    打印结果: Optional(110)

print(arr2_1.last)     //获取数组的最后一个元素  打印结果: Optional(4)


//(4)获取数组元素的数量:

print(arr2_1.count)   //打印结果: 4


//2. for in 数组遍历

//(1)for in 遍历全部元素

for id in arr2_1 {

    print(id)

}

/*打印结果

999

10

99

4

*/


//(2)for in 遍历数组某一个区间的元素

for id in arr2_1[1...3]{

    print(id)

}

/*打印结果:

10

99

4

*/


//3. for 循环数组遍历

for var i =0; i < arr2_1.count; ++i {

    let id = arr2_1[i]

    print(id)

}

/*打印结果

999

10

99

4

*/


//4. 使用枚举法,进行遍历

for (a, b) inarr2_1.enumerate(){

    print("\(a) =\(b)")

}

/*打印结果

0 = 999

1 = 10

2 = 99

3 = 4

*/


//5. 模拟系统给出的枚举法遍历数组

var en = arr2_1.enumerate().generate()

var temp: (Int,Int)? = en.next()

while temp !=nil {

    print(temp!)

    temp = en.next()

}

/*打印结果

(0, 999)

(1, 10)

(2, 99)

(3, 4)

*/




/*---------------------------.给数组添加元素-------------------------*/

//1. 在数组的后边添加一个元素

var arr3_1 = ["hello"]

arr3_1.append("world")

print(arr3_1)

/*打印结果:

[hello, world]

*/


//2. 在数组的某个位置添加元素:

arr3_1.insert("my", atIndex:1)

print(arr3_1)

/*

[hello, my, world]

*/


//3.使用 +=给数组拼接另一个数组在老版本是可以使用 +=拼接一个元素的, 但这个版本把这个功能去掉了

arr3_1 += ["codeWorm","dear"]

print(arr3_1)

/*打印结果:

[hello, my, world, codeWorm, dear]

*/


//4. 在数组的某个index位置,添加一个相同类型的数组:

arr3_1.insertContentsOf(["123","456"], at:0)

print(arr3_1)

/*打印结果:

["123", "456", "hello", "my", "world", "codeWorm", "dear"]

*/




/*---------------------------.删除数组的元素-------------------------*/

var arr4_1 = [1,2, 3, 4, 5]


//1. 删除最后一个元素,返回值为被删除的元素

let remove1 = arr4_1.removeLast()

print(arr4_1)

/*打印结果

[1, 2, 3, 4]

*/


//2. 删除某个index的元素,返回值为被删除的元素

let remove2 = arr4_1.removeAtIndex(0)

print(arr4_1)

/*打印结果

[2, 3, 4]

*/


//3. 删除某个范围的元素

arr4_1.removeRange(Range(start:0, end: 1))

print(arr4_1)

/*打印结果

[3, 4]

*/


//4. 删除数组的所有元素,并且不保留数组所占的空间

arr4_1.removeAll()


//5. 删除数组的所有元素,但是所占的内存空间将被保留

arr4_1.removeAll(keepCapacity:true)




/*---------------------------.修改数组的元素-------------------------*/

var arr5_1 = [1,2, 3, 4, 5, 6,7]


//1. 可以用数组名[下标数]这种形式 来修改某个index的元素值

arr5_1[0] =99 //将第0个元素的值修改为99

print(arr5_1)

/*打印结果

[99, 2, 3, 4, 5, 6, 7]

*/



//2. 将数组某个范围的元素替换为后面的这段数组的元素,注意这个范围最大数不能超过数组的count - 1否则会运行时崩溃

arr5_1[1...3] = [100,101, 102]

print(arr5_1)

/*打印结果

[99, 100, 101, 102, 5, 6, 7]

*/


//3. 使用 arr5_1.replaceRange(<#T##subRange: Range<Int>##Range<Int>#>, with: <#T##C#>) 来替换元素, 这里第一个参数为范围, 第二个参数是要替换的数组或者表示数组的指针

arr5_1.replaceRange(Range(start:0, end: 4), with: [0,1, 2, 3, 4])

print(arr5_1)

/*打印结果

[0, 1, 2, 3, 4, 5, 6, 7]

*/


//replaceRange 替换UnsafeMutableBufferPointer数组的指针类型:

var arr5_2 = [999,1000, 1001]

var pointer = UnsafeMutableBufferPointer<Int>(start: &arr5_2, count:arr5_2.count)    //这是用来表示字符串的指针类型

arr5_1.replaceRange(0..<1, with: pointer)    //第一个参数range的另一种表现形式, 0 1 的半开半闭区间(0...1 表示0 1的开区间), 这里也就是表示, arr5_1的第0个元素替换成这个数组指针对应数组的元素

print(arr5_1)

/*打印结果

[999, 1000, 1001, 1, 2, 3, 4, 5, 6, 7]

*/





/*---------------------------.对于数组的一些基础的判断-------------------------*/


//1. 判断数组是否为空

var arr6_1: [Int] = []

print(arr6_1.isEmpty)//判断的前提是数组已经被实例化

/*打印结果

true

*/


//2. 判断数组是否包含某个元素:

var arr6_2 = ["hello","world", "I","am", "code"]

//(1)可以直接这么调用:

print(arr6_2.contains("hello"))

/*打印结果

true

*/

//(2) 可以使用闭包为参数进行判断

let isContain =arr6_2.contains { (obj) -> Boolin      //这个运行原理就是,编译器调用你的闭包,将数组内的元素顺次作为闭包的参数传入, 进行判断, 当然判断逻辑是你写的,直到闭包的返回值为true 或者将数组内的所有元素传参完毕闭包调用结束,否则继续传入下一个数组的元素作为参数调用这个闭包,如果闭包的返回值出现为true的情况,contains返回值为true,如果直到闭包调用完毕都没有出现true的情况,contains返回值为false

    if obj == "木哈哈" {

        return true

    }

    return false

}

//简写:

let isContainSam =arr6_2.contains{$0 =="木哈哈"}   //$0 就是第一个参数的意思, $1第二个, 多个参数同理, 当一个闭包只有一个return语句时, return可以省略

print(isContain)

/*打印结果

false

*/




/*---------------------------.数组分割为字符串, 字符串拼接数组-------------------------*/

//这个如果有OC基础就知道这个:

//1. 使用某个字符串来分割字符串,分割结果为数组:

let str7_1 = "www.baidu.com/www.v1.cn/haha"

let arr7_1 = str7_1.componentsSeparatedByString(".")

print(arr7_1)

/*打印结果

["www", "baidu", "com/www", "v1", "cn/haha"]

*/


//2. 使用NSCharacterSet类型来分割字符串:

let arr7_2 = str7_1.componentsSeparatedByCharactersInSet(NSCharacterSet(charactersInString:"./"))    //分别以. /来分割

print(arr7_2)

/*打印结果

["www", "baidu", "com", "www", "v1", "cn", "haha"]

*/


//3. 将数组拼接成字符串

let str7_2 = arr7_2.joinWithSeparator("我是 (空格)")

print(str7_2)

/*打印结果

www我是 (空格)baidu我是 (空格)com我是 (空格)www我是 (空格)v1我是 (空格)cn我是 (空格)haha

*/




/*---------------------------.数组的一些其他方法-------------------------*/


//1. sortInPlace 排序

var arr8_1 = [2,32, 1, 5, 3, 4]

//sortInPlace方法就是原来的sort方法

arr8_1.sortInPlace { (id1, id2) ->Bool in     //传入闭包的原理类似与将冒泡排序的排序准则传入,编译器来实现冒泡排序, 然后根据你的准则来判断是否交换元素位置, eg:

    if id1 > id2{

        return true

    }

    return false

}

//上边这个可以简写为:

//arr8_1.sortInPlace {$0 > $1}       //$0 就是第一个参数的意思, $1 第二个, 多个参数同理,当一个闭包只有一个return语句时, return可以省略

print(arr8_1)

/*打印结果

[32, 5, 4, 3, 2, 1]

*/


//2. reverse 翻转数组:

let arr8_2 = [9,6, 3, 0, 2, 4,5]

let arr8_3 = Array(arr8_2.reverse())

print(arr8_3)

/*打印结果:

[5, 4, 2, 0, 3, 6, 9]

*/


//3. filter 过滤数组:

let arr8_4 = [-5, -4, -3, -2,0, 1, 2, 3, 4,5, 6, 7, 8]

let arr8_5 = arr8_4.filter{$0 %2 == 0 && $0 >0//过滤出数组中的正偶数

//展开为:

//let arr8_5 = arr8_4.filter { (obj) -> Bool in

//    return obj % 2 == 0 && obj > 0

//}

print(arr8_5)

/*打印结果:

[2, 4, 6, 8]

*/


//4. map 遍历计算数组

let arr8_6 = [1,2, 3, 4, 5]

let arr8_7 = arr8_6.map{$0 *2} //通过计算形成新数组

print(arr8_7)

/*打印结果:

[2, 4, 6, 8, 10]

*/


//5. reduce 方法

let arr8_8 = [2.0 ,9.0]

let result8_1 = arr8_8.reduce(9.0) { (obj1, obj2) ->Double in

    return obj1/obj2

}

//reduce, 需要传一个初始值,这里传的是9.0, 第一次传入闭包两个参数分别为初始值本身 数组的第一个元素,第二次传的两个参数分别为, 第一次闭包的运算结果和数组的第二个元素,直到所有数组的元素全部被运算完毕, 最后一次调用闭包完毕返回的值为最终的值, 这里做的计算也就是: 9.0/2.0/9.0 = 0.5


//简写为:

//let result8_1 = arr8_8.reduce(9.0){$0/$1}    这里涉及到尾随闭包的知识, 在网上搜一下尾随闭包就知道怎么回事了


print(result8_1)

/*打印结果:

0.5

*/




/*---------------------------.数组拷贝-------------------------*/

/*

swift刚一出现的时候,数组是作为引用类型出现的, 虽然作为一个结构体,但是更像是类的对象的性质, 这可见数组的这个结构体的底层不单单是像C语言和OC中在栈区开辟空间去存储值类型那么简单,猜测也是要去堆区开辟空间的, 在后来更新版本中, Array取消了这样的性质,而是只作为值类型出现, 这样就让新学习swift的人来说不会有"为什么值类型还可以做引用的操作?"这样的困惑, 下面是一个eg:

*/

var arr9_1 = [1,2, 3]

var arr9_2 = arr9_1

arr9_2[0] =999

print("arr9_1 =\(arr9_1) arr9_2 =\(arr9_2)")

/*打印结果:

arr9_1 = [1, 2, 3] arr9_2 = [999, 2, 3]

*/


//可见现在的数组是一个值类型了!



2016-07-21 09:25:14 mydo 阅读数 3142

我们知道Swift可以扩展已存在的类或结构,这些类或结构可以存在于标准库(或称为核心库)中.如果结构是一个集合类型(比如Array)就更有趣了.我们想尝试写一个限定Type数组的扩展,So我们就拿Array< Int>为例吧.

本猫想是不是可以这么写:

extension Array<Int>{
    //....
}

不过显然不可以 :[

翻看了一下Apple官方的Swift编程语言,一无所获.于是上网溜了一圈,发现一个可行的解决方法,是滴,必须要用where子句:

extension _ArrayType where Element == Int{
    func count(index:Int)->Int{
        print("In _ArrayType")
        return 11*11
    }
}

[1,2,3].count(2)
["1"].count(2) //error!!!

主要思想是我们不能直接拿Array开刀,但是可以间接用_ArrayType类型,可以看到最后一行代码出错,因为它是一个[String]型的数组.

不过别高兴太早了,上面的代码在Swift3中行不通,因为Swit3中压根就找不到_ArrayType类型 ;(

然而车到山前必有路,不能从Array入手,我们可以间接从其遵循的协议入手.于是在Swift3中有两种方法可以达到目的:

extension Sequence where Iterator.Element == Int{
    func count(index:Int)->Int{
        print("In Sequence")
        return index * index
    }
}

extension Collection where Iterator.Element == Int{
    func count(index:Int)->Int{
        print("In Collection")
        return index * index
    }
}

需要注意的是如果要把以上代码用在Swift2.x中需要在Sequence和Collection后面加上Type:

SequenceType
CollectionType

值得一提的是如果我们希望Array扩展中的元素遵循某个协议(而不是等于某种类型)的话可以这么写:

protocol Lovable{
    func fallInLove(with name:String)
}

struct Love:Lovable{
    func fallInLove(with name:String){
        print("fall in love with \(name)")
    }
}

extension Array where Element:Lovable{
    func count(index:Int)->Int{
        print("In Array")
        return index * index
    }
}

let loves = [Love(),Love()]
loves.count(index: 12)

Swift 数组Array

阅读数 2202