2017-04-27 16:03:23 bwf_erg 阅读数 2944
  • Swift不深入只浅出入门教程

    介绍Swift语言的基础知识,同时也是为了完成我原来一个github项目(https://github.com/mengxiangyue/The-Swift-2.0-Programming-Language-playground)上面写的录制一套视频教程的承诺。

    12019 人正在学习 去看看 孟祥月
  

数组是由一组类型相同的元素构成的有序数据集合。数组中的集合元素是有

序的,而且可以重复出现。

数组创建

Swift语言中,数组的类型格式为:

Array<ElementType>或[ElementType]

其中Array<ElementType>中的ElementType表示数组的类型,< ElementType >是泛型写法。[ElementType]是一种简写方式。两者表示的功能是一样的,我们更偏向于使用简写形式,本书里所有数组类型都是使用简写形式。

下面我们来创建一个String类型的数组

  1 |  var strArray1: Array<String>

  2 |  let strArray2: [String]

在声明一个数组的时候可以使用let和var进行修饰,其中let表示不可变数组,var表示可变数组。

    1行代码声明了一个类型为Array<String>的可变数组strArray1。<String>是泛型,说明在这个数组中只能存放字符串类型的数据。

    2行代码声明了一个类型为[String]的不可变数组strArray2。[String]也是声明一个只能存放字符串类型的数组。

接下来我们来学习如何创建一个空数组。

  1 |  var emptyStrs= [String]()

  2 |  let emptyInts = [Int]()

创建一个数组需要对数组进行声明和初始化。上述第1行代码我们创建了一个String类型可变空数组emptyStrs。其中我们var声明表示该数组是可变数组,中括号[]里面的值String表示数组的类型。[String]()是对数组进行初始化,只不过没有任何元素。

2行代码与第1行代码同样是创建一个空数组emptyInts,区别在于我们用let声明了一个不可变数组,该数组的类型是Int类型。let声明的数组是不可变数组,必须在声明的同时进行初始化,一旦初始化,就不可以被修改。

最后我们来学习如何创建非空数组。示例代码如下:

  1 |  var strArray1: Array<String> = ["hello","swift"]

  2 |  var strArray2: [String] =  ["hello","swift"]

  3 |  let strArray3 = ["hello","swift",15]

上述代码都是对数组进行声明和初始化,数组的类型是通过冒号(:)指明数组的类型。数组中的元素由一对中括号([])括起来,数组中的元素之间用逗号分隔。

1行代码是使用标准模板方式声明是一个String类型的可变数组strArray1,并初始化值为["hello","swift"]。其中尖括号<String>表示数组的类型,表示strArray1只能存放String类型的元素。

2行代码是采用简写形式显式声明可变数组strArray2。[String]表示数组的类型,表示strArray2只能存放String类型的元素。

3行代码声明了一个不可变数组,这里没有指明数组的类型,采用的是隐式推断。根据初始化数组的值推断出数组的类型。在strArray3数组中我们存放了String类型的"hello","swift"以及Int类型的15。在没有明确指定数组类型,我们可以在数组中存放不同类型的元素。

不可变数组在访问效率上比可变数组要高,可变数组通过牺牲访问效率换取可变。当我们可以确定数组是不需要修改的,我们应该将它声明为let。如果数组内容需要改变。我们需要将它声明为var。

此外,如果数组中存储多个相同的元素,我们可以通过以下方法快速创建该数组:

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

此时threeDoubles数组的内容为[0.0,0.0,0.0]

 

 

2017-04-15 22:31:40 MHTios 阅读数 353
  • Swift不深入只浅出入门教程

    介绍Swift语言的基础知识,同时也是为了完成我原来一个github项目(https://github.com/mengxiangyue/The-Swift-2.0-Programming-Language-playground)上面写的录制一套视频教程的承诺。

    12019 人正在学习 去看看 孟祥月

import UIKit

/*
 数组:
 1.数组(Array)是一串有序的由相同类型元素构成的集合
 2.数组中的集合元素是有序的,可以重复出现
 3.Swift中的数组 类型是Array, 是一个泛型集合
 
 数组的初始化:
 数组分成: 可变数组  和  不可变数组
 使用let 修饰不可变数组
 使用var 修饰可变数组
 */

//1.定义数组
//1>定义不可变数组
let array = ["summer", "amy", "sun"]

//2>定义可变数组
//var mutableArr = Array<String>()
var mutableArr = [String]()//一般的写法

//2.对可变数组的基本操作
//2.1>添加元素
mutableArr.append("adc")
mutableArr.append("def")
mutableArr.append("hig")
mutableArr.append("klm")
mutableArr.append("nop")

//2.2>删除元素
mutableArr.remove(at: 0)
mutableArr

//2.3>修改元素
mutableArr[0] = "xyz"
mutableArr

//2.4>取出某一个元素
mutableArr[0]

//3.数组的遍历
//3.1> 根据下标值进行遍历
for i in 0..<array.count{
    print(array[i])
}
//3.2> 直接遍历数组的元素
for name in array{
    print(name)
}
//3.3> 遍历数组中前两个元素 (少见这种方法)
for i in 0..<2{
    print(array[i])
}
for name in array[0..<2]{
    print(name)
}
//4.数组的合并
let resultArr = array + mutableArr

//注意: 相同类型的数组才可以进行合并, 不同类型的数组不能相加合并

//let arr1 = ["哈哈哈"]
//let arr2 = [3,4,4]
//let arr3 = arr1 + arr2



2016-02-25 10:11:29 daguanjia11 阅读数 594
  • Swift不深入只浅出入门教程

    介绍Swift语言的基础知识,同时也是为了完成我原来一个github项目(https://github.com/mengxiangyue/The-Swift-2.0-Programming-Language-playground)上面写的录制一套视频教程的承诺。

    12019 人正在学习 去看看 孟祥月

Swift 语言提供了数组和字典两种集合类型来存储集合数据。数组用来按顺序存储相同类型的数据。字典则是以无序的方式来存储键值对(key,value)。数组和字典都是强类型的,也就意味着,数组和字典在声明时必须指明类型。

本篇博客我们来分别讨论swift中的数组和字典

数组

数组就是以一个从头到尾的顺序存储相同类型值的容器。相同的值可以在一个数组中出现多次。下面来创建并初始化两个数组:

创建数组

var intArray : [Int] = [1 , 2 , 3]
var strArray : [String] = ["hello" , "world"]

注意:我现在编写的swift代码的版本是swift2.1,数组的类型是[Type],而不是Type[]
由于swift可以进行类型推测,所以我在创建这两个数组时可以不标注类型,如下

var intArray = [1 , 2 , 3]
var strArray= ["hello" , "world"]

可以这样来创建一个空数组

var emptyArray = [Int]()

访问和修改数组

我们可以通过访问数组下标来获取数组中某个元素的值,也可以通过数组的其它属性和方法来修改数组。

//获取数组中的元素个数
var itemCount = intArray.count
//判断数组是否为空
var isEmpty = intArray.isEmpty
//通过下标来访问数组的某个元素
var item = intArray[0]
//向数组的最后面加入元素
intArray.append(4)
//改变某个位置上元素的值
intArray[0] = 0
//移除某个位置的元素
var removedItem = intArray.removeAtIndex(1)
//判断数组是否包含某个值
intArray.contains(2)
//向数组的某个位置插入一个值
intArray.insert(2, atIndex: 1)
//再次判断
intArray.contains(2)

如果你认为swift关于数组的操作就这么多,那你就错了,下面来两个更强大的功能:数组的拼接和区域内赋值

var anotherIntArray = [4 , 5 , 6]
intArray += anotherIntArray

strArray += ["hello" ,"swift"]

数组的拼接是把第二个数组全部接到第一个数组的最后面

intArray[2...4] = [1,2]
intArray[2...4] = []

这个区域内赋值(这个名字是我瞎编的,哈哈),就是把数组的下标在2到4之间的元素替换为等号后面给定的数组,任意长度哦,(可以为空数组哦,瞬间变成批量移除哦)

数组的遍历

我们可以使用传统的for循环语法来遍历数组,也可以使用for-in的语法来遍历数组

for var i = 0 ;i < intArray.count ; i++ {
    print(intArray[i])
}

for item in intArray{
    print(item)
}

常量数组

如果把一个数组声明为常量,则:

  1. 列表的长度不可被修改,append()等方法不能使用,否则编译器报错
  2. 列表内任意元素的值不可被修改,否则编译器报错
//声明一个常量数组
let intArray = [1,2,3]
intArray.append(4)  //报错,数组长度不可被修改
intArray[0] = 0     //报错,数组内的任意元素不可被修改

字典

字典是一组特定类型的键值对。下面来创建一个字典

var dic = [1:"one",2:"two",3:"three"]
if let value = dic[2]{
    print(value)
}
dic[4]="foure"
print(dic[4])

输出结果为

two
Optional("foure")

我通过字面值来创建了一个Dictionary

字典的遍历

用for…in的方式来遍历字典

for (number,str) in dic{
    print(number)
    print(str)
}

字典中的每个项都通过元组的形式返回。
也可以单独遍历所有的key或所有的value

for key in dic.keys{
    print(key)
}

for v in dic.values{
    print(v)
}

遍历字典时,所有的值都是非可选的。

常量字典

与常量的数组相同,常量的字典中的键的值是不可修改的,字典的长度也是不能修改的。

2016-07-09 15:31:17 desirelll 阅读数 721
  • Swift不深入只浅出入门教程

    介绍Swift语言的基础知识,同时也是为了完成我原来一个github项目(https://github.com/mengxiangyue/The-Swift-2.0-Programming-Language-playground)上面写的录制一套视频教程的承诺。

    12019 人正在学习 去看看 孟祥月

一、声明和创建数组

swift的声明数组变量有两种语法。

  • 使用泛型语法。数组类型的语法格式为:Array<类型>,此处的尖括号就是泛型语法。

  • 使用简化语法。数组类型的语法格式为:[类型]。
    例如,如下代码可用于声明数组变量。
    //使用泛型语法声明数组
    var myArr : Array<String>
    //使用简化语法声明数组
    var names : [String]
    var nums : [Int]

仅仅声明数组变量还不能使用数组,程序还必须创建数组结构体,并将数组赋值给数组变量才能使用它们。创建数组也有两种方式。

  • 使用Array的构造器创建数组
    Array的构造体提供了如下3个常用的构造器。
    • init():创建一个空数组。
    • init(arrayLieral:):以指定的多个元素来创建数组。
    • init(count:,repeatedValue:):创建一个包含count个repeatedValue元素的数组。
      下面程序为上面定义的3个数组变量创建了对应的数组。
      myArr = Array<String>()
      //创建一个包含10个“fkit”元素的数组,并将该数组赋值给names变量。
      names = [String](count: 10, repeatedValue: "fkit")
      //以指定的多个元素创建数组,并将数组赋值为nums变量
      nums = [Int](arrayLiteral:12, 20, 30, -9, -29)
  • 使用简化语法创建数组
    数组的简化语法更加简洁,直接使用方括号列出多个数组值即可。
    如下代码使用简化语法创建了数组。
    var flowers : [String] = ["a","b","c","d"]
    var values = ["1","2","3","e"]

二、使用数组

数组提供了一个只读的count属性,通过这个属性可以方位到数组的长度,一旦获得了数组的长度,就可以通过循环来遍历该数组的每个数组元素。
下面代码师范了输出flowers数组的每个数组元素的值。
for var i = 0; i < flowers.count; i++{
print(flowers[i])
}

除此之外,数组还提供了只读的startIndex和endIndex属性,其中startIndex返回该数组的第一个元素的索引,因此该属性总是返回0;endIndex返回该数组最后一个元素的索引+1,因此该属性的返回值与count属性的返回值相等。例如如下代码:

//访问flowers数组的第一个索引
print(flowers.startIndex)
//访问flowers数组的最后一个索引(实际上返回最后一个元素的索引+1)
print(flowers.endIndex)

三、使用for-in遍历数组

for-in循环遍历数组的语法格式如下:

for element in array{
//element自动迭代访问每个元素
}

在上面语法中,element无须使用let声明,for-in循环将会隐式声明该常量。下面程序示范了如何使用for-in循环来遍历数组元素。

var books:[String] = ["疯狂iOS讲义","疯狂Swift讲义","疯狂Android讲义"]
for book in books{
print(book)
}

当使用for-in循环遍历、访问数组元素时,不允许对循环常量进行赋值,这是因为for-in循环隐式使用let来声明该变量,因为程序不能对循环常量赋值。

四、数组的可变性和数组的修改

  • 添加元素
    Array提供了append(_:)方法添加元素,每调用该方法一次,程序就会在数组的最后添加一个元素,数组的长度也会自动加1.
    如下代码调用Array的append(_:)方法添加元素。

    //使用var定义一个可变数组
    var languages = ["Swift"]
    //追加一个元素
    Languages.append("GO")
    languages.append("Lua")
    //输出Swift,GO,Lua
    print(languages)
    print(languages.count)

    除了调用append方法添加元素之外,Swift的数组还支持使用“+”执行加法,数组的加法可以添加另一个类型匹配的数组。例如如下代码

    languages = languages + ["Ruby"]
    //上面代码可简写如下
    languages += ["Ruby"]
    print(languages)
    print(languages.count)

  • 插入元素
    Array提供了insert(_:Element,atIndex:Int)方法插入元素。需要注意的是,该方法的第二个参数不能超过数组长度。(可以等于数组长度,此时效果与调用append方法完全相同)。
    如下代码调用Array的insert()方法插入元素。

    //使用var定义一个可变数组
    var languages = ["Swift"]
    //插入一个元素
    languages.insert["Go",atIndex:0]
    //插入一个元素,指定atIndex:2,表明该元素插入数组的最后
    languages:insert["Ruby",atIndex:2]
    print(languages)
    print(languages.count)

  • 数组和范围
    Array支持在方括号中使用Range,这样既可以一次性地获取多个数组元素,也可一次性对多个数组元素进行赋值。
    例如以下代码:

    var languages = ["Swift","OC","PHP","Perl","Ruby","Go"]
    //获取languages数组中索引为1-4的元素
    let subRange = languages[1..<4]
    print(subRange)//输出[OC,PHP,Perl]
    //将languages数组中索引为2-4的元素替换成"C/C++","Python"
    languages[2...4] = ["C/C++","Python"]
    print(languages)
    //将languages数组中索引为1-2的元素替换成"a","b","c"
    //两个元素换成三个元素
    languages[1...2] = ["a", "b", "c"]
    print(languages)

    正如上面代码所看到的,当程序对指定范围的数组元素赋值时,并不需要指定范围包含的元素个数与所赋值的元素个数相同,如果所赋值的元素少于范围内包含的元素个数,程序会自动减少Swift数组的长度;如果所赋值的元素多于范围内包含的元素个数,程序会自动增加Swift数组的长度。
    正因为Swift的数组存在这种功能,因此程序可以用过这种方式添加或删除数组元素。例如,如下代码即可清空数组:

    languages[0..<languages.count] = []

    除此之外,数组还提供了replaceRange(_:With:)方法,该方法可以将数组的中间一段替换为指定的子数组。例如如下程序:

    var characters = ["孙悟空","猪八戒","唐僧","牛魔王"]
    characters.replaceRange(1...3,with:["黄袍怪"])
    print(characters)//输出["孙悟空","黄袍怪"]
  • 删除元素
    Array提供了如下方法来删除元素。
    • popLast()->Element:删除数组的最后一个元素,该方法返回即将删除的元素。
    • removeAtIndex(index:Int)->Element:删除指定索引处的元素,该方法返回即将删除的元素。
    • removeLast()->Element:删除数组的最后一个元素,该方法返回即将删除的元素。该方法和popLast方法的作用大致相同。
    • removeAll(keepCapacity:Bool = false):清空数组。其中keepCapacity参数指定是否保留数组底层的数据缓冲,该参数默认false,即不保留数据缓冲。
      如下程序调用了上面方法来删除数组元素。

      var languages = ["Swift","OC","PHP","Perl","Ruby","Go"]
      //删除索引为2的元素,即PHP
      languages.removeAtIndex(2)
      //再次删除索引为2的元素,即Perl
      languages:removeAtIndex(2)
      //删除最后一个元素
      languages.removeLast()
      //删除所有元素
      languages.removeAll()
2015-07-27 23:28:04 RainShenJi 阅读数 609
  • Swift不深入只浅出入门教程

    介绍Swift语言的基础知识,同时也是为了完成我原来一个github项目(https://github.com/mengxiangyue/The-Swift-2.0-Programming-Language-playground)上面写的录制一套视频教程的承诺。

    12019 人正在学习 去看看 孟祥月

  首先数组的定义:以有序的方式存储相同类型的值

(1)数组的简写(shorthand)语法

你可以通过Array<Element>,在这里,Element时数组存储元素的值的类型,也可以通过中括号来写[Element]

(2)创建一个空数组

        var emptyArr = [Int]()(这里使用初始化方法创建一个Int型的空数组)
        emptyArr.append(3)
        emptyArr = [] (这里是用字面语句创建空数组)
note:emptyArr is now an empty array,but is still an type of [Int]

另外,就是我直接用var emptyArr = []创建一个空数组会产生一个错误,报了这是一个不可变数组,大家可以试试

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

swift提供了一种初始化一个数组,并且这个数组带有相同的默认值

    var defaultArr = [Double](count: 3, repeatedValue: 0.0)(值类型是double型的)
    println(defaultArr)

//the println is [0.0, 0.0, 0.0]

(4)通过add两个数组创建一个新的数组

通过(+)号操作将两个已经存在的相同类型的数组创建一个新的数组

        var anotherArr = [Double](count: 3, repeatedValue: 2.5)
        var newArr = defaultArr + anotherArr
        println(newArr)

//the result is [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]

(5)用字面量创建一个数组

中括号里面放一系列的值,以逗号分隔

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

这个声明了一个只存储字符型的数组,由swift的类型推断,我们可以不用写明类型用字面量语法初始化数组存放相同类型的值时,因此,上面的例子可以更加简单点写

       var shopping: = ["Eggs","Milk"]

(6)访问和改变数组

我们学会了创建一个数组,那么接下来就要想怎么访问一个数组,又怎么改变一个数组呢?

访问和改变数组,我们可以通过方法和属性,或者下标语法

我们可以通过数组的只读属性(.count)知道数组的元素个数

        println("The shopping list contains \(shoppingList.count) items")    (The shopping list contains 2 items)

我们可以通过数组的Boolen属性(.isEmpty)检查数组的个数和0是否相等

if shoppingList.isEmpty{
            println("The shopping list is empty")
        }else{
            println("The shopping list isn't empty")
        }

我们可以通过array's append(_:)方法在数组的最后面添加元素

        shoppingList.append("Flour")
        println(shoppingList)       ([Eggs, Milk, Flour])

还有一种方法,我们也可以通过(+=)操作添加一个或多个元素

        shoppingList += ["Baking Powder"]
        shoppingList += ["Chocolate Spread","Cheese","Butter"]
        println(shoppingList)  ([Eggs, Milk, Flour, Baking Powder, Chocolate Spread, Cheese, Butter])

可以通过下标语法检索一个数组的值,在数组名后面加上中括号,在里面写上你想要的值所在的下标就可以取出对应的下标值了,和oc一样,第一个元素也是从0开始算起

       var firstItem = shoppingList[0]
        println(firstItem)  (firstItem is equal to "Eggs")

你也可以通过下标语法改变对应索引处的值

        shoppingList[0] = "Six Eggs"
        println(shoppingList)   ([Six Eggs, Milk, Flour, Baking Powder, Chocolate Spread, Cheese, Butter])和上面对比确实改变了第一个元素

在swift中可以通过下标语法改变一定范围的值,即使替代的值的长度和你替代的范围长度不同,如

        shoppingList[4...6] = ["Bananas","Apples"]
        println(shoppingList)

现在打印的结果是[Six Eggs, Milk, Flour, Baking Powder, Bananas, Apples]也就是数组有6个元素

        shoppingList[4...6] = ["Bananas","Apples","Bananas","Apples"]

现在数组有8个元素了

但是请注意你不能通过下标语法给数组添加元素

往数组中插入元素我们可以通过调用insert(_:atIndex:)方法

        shoppingList.insert("Maple Syrup", atIndex: 0)
        println(shoppingList)      ([Maple Syrup, Six Eggs, Milk, Flour, Baking Powder, Bananas, Apples, Bananas, Apples])

同样的道理,可以通过调用removeAtIndex(_:)方法移除元素。并且可以接收被移除的元素(假如你不需要,就不用接收,直接忽略就好了)

        var removedItem = shoppingList.removeAtIndex(0)
        println(shoppingList)    ([Six Eggs, Milk, Flour, Baking Powder, Bananas, Apples, Bananas, Apples])

调用removeRange移除一定范围内的数组

        var removedRangeItem: () = shoppingList.removeRange(6...7)
        println(shoppingList)      ([Six Eggs, Milk, Flour, Baking Powder, Bananas, Apples])

调用removeLast()语法移除数组最后一个元素,而不是通过调用removeAtIndex(_:)方法,以免遍历数组一遍要

        shoppingList.removeLast()
        println(shoppingList)

数组的遍历

我们可以通过for-in循环遍历

        println(shoppingList)
        for item in shoppingList{
            println(item)
(Six Eggs
Milk
Flour
Baking Powder
Bananas)
        }

如果你需要每个元素的下标和对应的值,你需要用enumerate()方法来遍历数组,这样返回一个元组,包括元素的下标和对应的值

for (index,value) in enumerate(shoppingList){
            println("Item\(index):\(value)")
        }

Item0:Six Eggs
Item1:Milk
Item2:Flour
Item3:Baking Powder
Item4:Bananas
这是swift2.0之前的写法,2.0之后用的是

        for (index,value) in shoppingList.enumerate(){
            println("Item\(index):\(value)")
        }

这个方法


借鉴:https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/CollectionTypes.html#//apple_ref/doc/uid/TP40014097-CH8-ID105   

swift 5. 数组

阅读数 904

Swift 数组

阅读数 190

没有更多推荐了,返回首页