array循环 swift

2018-08-25 23:19:59 qq_36487644 阅读数 6661

在swift中,最常使用的for循环是for-in结构,并且可以和范围(...和...<)配合使用

for i in 0..<5 {
  print(i)
}

控制台输出:

0
1
2
3
4

使用for-in循环遍历数组

let array = ["宝马", "奔驰", "奥迪", "兰博基尼", "凯迪拉克", "法拉利"]
for arrayItem in array {
   print(arrayItem)
}

控制台输出:

宝马
奔驰
奥迪
兰博基尼
凯迪拉克
法拉利

获取下标的遍历方法:

let array = ["宝马", "奔驰", "奥迪", "兰博基尼", "凯迪拉克", "法拉利"]  
for (index, value) in array.enumerated() {
  print("下标:\(index)值=\(value)")
}

控制台输出:

下标:0值=宝马
下标:1值=奔驰
下标:2值=奥迪
下标:3值=兰博基尼
下标:4值=凯迪拉克
下标:5值=法拉利

使用for-in循环遍历字典:

let dictionry = ["name":"小明", "age": "22", "sex": "男"]
for (key, value) in dictionry {
    print("\(key) is \(value)")
}

控制台输出:

name is 小明
age is 22
sex is 男

遍历字段中的所有键或值

let dictionry = ["name":"小明", "age": "22", "sex": "男"]
for key in dictionry.keys {
    print("key = \(key)")
}
for value in dictionry.values {
     print("value= \(value)")
}

控制台输出:

key = name
key = age
key = sex
value= 小明
value= 22
value= 男

注意:在swift2.2中可以使用C语言风格的for循环:  但是这种写法在swift3.0中已经被删除

for var in = 0; i < 5, i++ {
    print(i)
}

 

 

2018-03-14 09:31:16 qq_35612929 阅读数 12738

循环语句

OC中常用的普通for循环 for(int i=0;i<10;i++){}在Swift3.0已经移除掉了,现在Swift用的for in 循环很具有Swift特色,举例如下:

for i in 0...10 {
//0...10表示包含头尾的0到10之间所有的整数
//0..<10表示包含头不包含尾的0到9之间所有的整数
//0...10这种条件区间内不能出现任何的空格
} 
//如果不关心循环本身的索引,可以直接用下划线如下
for _ in 0...10 {
}
//在遍历数组的时候,Swift还提供了一种特别方便的方式(利用元祖)
for (index,value) in array.enumerated() {
//index是下标,value是值
//这样使得遍历数组能写的更加简洁优雅
}
2015-08-19 14:26:42 CHENYUFENG1991 阅读数 11575

      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  。欢迎大家访问!














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-11-25 18:13:28 dylan_lwb_ 阅读数 18236
// Playground - noun: a place where people can play

import UIKit

//------------------------------------------------------------------------------
// 1. for
// 传统的for循环方式在swift中同样支持
var num = 0
for(var i = 0; i < 10 ; i++) {
    num += i
}
num

//------------------------------------------------------------------------------
// 2. for-in用来遍历一个区间(range)、序列(sequence)、集合(collection)、系列(progression)
//    所有的元素执行一系列语句

// 1> 闭区间循环,从1循环到10
num = 0
for i in 1...10 {
    num += i
}
num

// 2> 开区间循环,从1循环到9
num = 0
for i in 1..<10 {
    num += i
}
num

// 3> 如果不需要知道区间内每一项的值,可以使用下划线(_)替代变量名,忽略对区间数值的访问
num = 0
for _ in 1...10 {
    num++
}
num

num = 0
for i in 0...5 {
    for j in 0...5 {
        num = i + j
    }
}
num

//------------------------------------------------------------------------------
// 3. 循环生成数组
var array = [String]()
for i in 0..<10 {
    array.append("dylan \(i)")
}
array

//------------------------------------------------------------------------------
// 4. 循环遍历字典
var ageDict:Dictionary<String, Int> = ["mary": 19, "rose": 20]

var names = [String]()
var ages = [Int]()
for (key, value) in ageDict {
    names.append(key)
    ages.append(value)
}
names
ages

var keys = [String]()
var values = [String]()
var dict1 = ["name": "mike", "age": "18"];
for (name, age) in dict1 {
    keys.append(name)
    values.append(age)
}
keys
values

//------------------------------------------------------------------------------
// 5. 使用标签退出循环
// 使用标签的其中1个作用是:可以明确指定要退出哪个循环,以下示例是退出名字为"mainloop"的循环
var result = 1;
mainloop : for i in 1...5 {
    for j in 1...5 {
        result += j
        
        if (i == 3 && j == 3) {
            break mainloop
        }
    }
}
result