Swift学习笔记笔记（三）Swift集合&控制转移&字符串

一、 实验目的：

1.掌握Swift集合
2.掌握Swift控制流

二、实验原理：

1.数组的定义
2.集合的定义
3.字典的定义
4.fallthrough的功能
5.forloop标签的功能
6.字符串的定义方式
7.字符串的遍历方法

三、实验步骤及内容：

1.数组

//数组的初始化1
var animalArray = [String]（）
if animalArray.isEmpty {
print（”animalArray is empty!”）
}
animalArray.append（”tiger”）
animalArray.append（”lion”）
//数组的初始化2
var oneBitNumberArray ： Array = [0,1,2,3,4,5,6,7,8,9]
var botanyArray1 ： [String] = [“rosemary”,”parsley”,”sage”,”thyme”]
var botanyArray2 = [“rosemary”,”parsley”,”sage”,”thyme”]
print（”There are \（botanyArray1.count） kinds of botany.”）
//数组的初始化3
var twoBitNumberArray = [Int]（repeating： 0, count： 6）
var threeBitNumberArray = [Int]（repeating： 11, count： 3）
//数组的相加
var theAddedNumberArray = twoBitNumberArray + threeBitNumberArray
//数组的累加
animalArray += [“hawk”]
animalArray += [“sheep”,”horse”]
//数组的下标操作
var theFirstAnimal = animalArray[0]
animalArray[1] = “hen”
animalArray[2…4] = [“goat”,”rat”,”cock”,”rabbit”]
print（animalArray）
//数组插入元素
animalArray.insert（”snake”, at： 3）
//数组删除元素
animalArray.removeFirst（）
print（animalArray）
animalArray.removeLast（）
print（animalArray）
animalArray.remove（at： 2）
print（animalArray）
//数组的遍历
for animal in animalArray {
print（animal）
}
for （index,animal） in animalArray.enumerated（） {
print（”No.\（index） animal is \（animal）”）
}
print（animalArray）
//数组片段
let myZoo = animalArray[1…2]
print（myZoo）
myZoo[1]
myZoo[2]
//myZoo[0]
//将数组片段转化成数组类型
let newZoo = Array（animalArray[1…2]）
print（newZoo）
newZoo[0]
newZoo[1]
//判断数组是否包含指定元素
animalArray[1…3].contains（”hen”）
animalArray.contains（”hen”）
//数组交换元素位置
print（animalArray）
animalArray.swapAt（2, 3）
//数组排序
print（animalArray）
animalArray.sort（）
//练习题1
var majorCompulsoryCourse = [String]（）
majorCompulsoryCourse.append（”Data Structure”）
majorCompulsoryCourse.append（”Computer Organizagtion”）
majorCompulsoryCourse.append（”Computer Networks”）
var specializedOptionalCourse = [“iOS app development”, “Swift Programming”, “Artifical Intelligence”]
var generalKnowledgeCourse = [String]（repeating： “Music”, count： 3）
generalKnowledgeCourse[1] = “Painting”
generalKnowledgeCourse[2] = “Literature”
var allBookedCourse = majorCompulsoryCourse + specializedOptionalCourse + generalKnowledgeCourse
print（allBookedCourse）
majorCompulsoryCourse[0] = “Discrete Mathematics”
specializedOptionalCourse.insert（”Experiment of Mobile Application Development”, at： 3）
generalKnowledgeCourse.remove（at： 1）
allBookedCourse = majorCompulsoryCourse + specializedOptionalCourse + generalKnowledgeCourse
for （index, course） in allBookedCourse.enumerated（） {
print（”No.\（index） course is \（course）”）
}
let sliceOfAllBookedCourse = allBookedCourse[3…6]
var newArrayFromSlice = Array（sliceOfAllBookedCourse）
print（newArrayFromSlice）
newArrayFromSlice.swapAt（0, 3）
newArrayFromSlice.sort（）
if newArrayFromSlice.contains（”Swift Programming”） {
print（”It contains course： Swift Prgramming”）
} else {
print（”No course： Swift Programming”）
}
if newArrayFromSlice.contains（”Swift”） {
print（”It contains course： Swift”）
} else {
print（”No course： Swift”）
}

2.集合

//集合的初始化1
var weatherOfSanya = Set（）
weatherOfSanya = [“rainy”,”sunny”,”stormy”]
//集合的初始化2
var weatherOfBj ： Set = [“dry”,”windy”,”frogy”,”sunny”]
//判断集合是否位空
if weatherOfSanya.isEmpty {
print（”The set of weather is empty!”）
} else {
print（”There are \（weatherOfSanya.count） kinds weather!”）
}
//集合插入元素
weatherOfSanya.insert（”cloudy”）
//集合删除元素
weatherOfSanya.remove（”stormy”）
weatherOfSanya.remove（”dry”）
//删除集合所有元素
//weatherOfSanya.removeAll（）
//检索特定元素
if weatherOfSanya.contains（”sunny”） {
print（”Sanya is sunny sometimes.”）
}
//遍历集合
for weather in weatherOfSanya {
print（”\（weather）”）
}
//集合排序
print（”the result of unsorted ： “）
for weather in weatherOfSanya {
print（”\（weather）”）
}
print（”the result of sorted ： “）
for weather in weatherOfSanya.sorted（） {
print（”\（weather）”）
}
//集合交集运算
weatherOfBj.intersection（weatherOfSanya）
//集合并集运算
weatherOfBj.union（weatherOfSanya）
//集合差集运算
weatherOfBj.subtract（weatherOfSanya）
//练习题2
var gradeOfTheory = Set（）
if gradeOfTheory.isEmpty {
gradeOfTheory.insert（”Fail”）
gradeOfTheory.insert（”Pass”）
gradeOfTheory.insert（”Common”）
gradeOfTheory.insert（”Good”）
gradeOfTheory.insert（”Excellent”）
} else {
print（”Grade Set of Theory is not empty!”）
}
var gradeOfExperiment： Set = gradeOfTheory
gradeOfExperiment.remove（”Common”）
gradeOfExperiment.remove（”Good”）
gradeOfExperiment.remove（”Excellent”）
if gradeOfExperiment.contains（”Fail”） && gradeOfExperiment.contains（”Pass”） {
print（”Grade Set of Experiment has two levels： Fail and Pass.”）
} else {
print（”Grade Set of Experiment is lack of Fail or Pass level!”）
}
print（”All grades in Theory are： “）
for grade in gradeOfTheory {
print（”\（grade） “）
}
print（”All grades in Experiment are： “）
for grade in gradeOfExperiment {
print（”\（grade） “）
}
gradeOfTheory.sorted（）
print（”All SORTED grades in Theory are： “）
for grade in gradeOfTheory {
print（”\（grade） “）
}
gradeOfExperiment.sorted（）
print（”All SORTED grades in Experiment are： “）
for grade in gradeOfExperiment {
print（”\（grade） “）
}
print（”Intersection results are： “）
for grade in gradeOfTheory.intersection（gradeOfExperiment） {
print（”\（grade）”）
}
print（”Union results are： “）
for grade in gradeOfTheory.union（gradeOfExperiment） {
print（”\（grade）”）
}
print（”Subtract results are： “）
for grade in gradeOfTheory.subtracting（gradeOfExperiment） {
print（”\（grade）”）
}

3.字典

//声明字典
var ascIIDictChar0 = Dictionary<Int, Character>（）
var ascIIDictNum0 = [Int：Int]（）
//初始化字典
var ascIIDictChar = [97：”a”,98：”b”,99：”c”,100：”d”,101：”e”,102：”f”]
var ascIIDictNum = [32：0,33：1,34：2,35：3,36：4,37：5,38：6]
//设置字典的容量
ascIIDictNum.reserveCapacity（10）
//修改字典元素值方法1
ascIIDictChar[103] = “g”//添加元素
print（ascIIDictChar）
ascIIDictChar[97] = “A”
//修改字典元素值方法2
print（ascIIDictChar）
if let originValue = ascIIDictChar.updateValue（”a”, forKey： 97） {
print（”The origin value is \（originValue）”）
}
print（ascIIDictChar）
//删除字典元素值方法1
ascIIDictChar[97] = nil
print（ascIIDictChar）
//删除字典元素值方法2
if let removedValue = ascIIDictChar.removeValue（forKey： 98）{
print（”Value \（removedValue） is removed.”）
}
//遍历字典键值对
for （ascIICode,char） in ascIIDictChar {
print（”ascII code \（ascIICode） express char \（char） “）
}
//便利字典键集合
for ascIICode in ascIIDictChar.keys {
print（”keys：\（ascIICode）;”）
}
//便利字典值集合
for char in ascIIDictChar.values {
print（”chars：\（char）;”）
}
//字典keys属性
let ascIICodeArray = Array（ascIIDictChar.keys）
//字典values属性
let charArray = Array（ascIIDictChar.values）
//练习题3
var schoolOfUniversity = [Int：String]（）
schoolOfUniversity = [1：”Material”, 2：”Electronics”, 3： “Astronics”, 4：”Dynamics”, 5：”Aircraft”, 6：”Computer”]
schoolOfUniversity[3] = “revisedSchool”
schoolOfUniversity.updateValue（”updatedSchool”, forKey： 4）
print（schoolOfUniversity）
schoolOfUniversity[7] = “Mechanism”
schoolOfUniversity[8] = “Management”
print（schoolOfUniversity）
print（”Elements in Dictionary are as below：”）
for （code, schoolName） in schoolOfUniversity {
print（”Code：\（code）—School Name：\（schoolName）”）
}
var codeForSchool = Array（schoolOfUniversity.keys）
var schoolName = Array（schoolOfUniversity.values）
print（”All codes are： “）
for code in codeForSchool {
print（”\（code ）”）
}
print（”All school name are：”）
for name in schoolName {
print（”\（name） “）
}

4.fallthrough的功能

//fallthrough的功能
var index = 10
switch index {
case 100 :
print( “index 的值为 100”)
fallthrough
case 10,15 :
print( “index 的值为 10 或 15”)
fallthrough
case 5 :
print( “index 的值为 5”)
default :
print( “默认 case”)
}
//fallthrough的使用
var score=70
var member=true
switch(score){
case 0…<60:
print(“遗憾未中奖!”)
if(membertrue){
fallthrough
}
case 9999:print(“会员额外赠送金币1万！”)
case 60…70:
print(“三等奖!”)
if(membertrue){
fallthrough
}
case 9999:print(“会员额外赠送金币10万！”)
default:print(0)
}

5. forloop标签的功能

//forloop的功能
var i,j:Int
var s:Int

forloop:for i in 1...10 {
    for j in 1...10 {
        s = i*j
        print("i*j=\(s)")
        if (s>50) {
            print("i*j>50,退出外循环");
            break forloop
        }
    }

}
//forloop的使用
loop1:for i in 1…10{
loop2:for j in 1…10{
print(“i=(i),j=(j)”)
if(ji){
break loop2
}
}
if(i5){
break loop1
}
}

6. 字符串的定义方式

7.字符串的定义

//字符的定义
let characterAlphabet：Character = “a”
let characterNumber：Character = “9”
let characterOperator：Character = “*”
//多行文本的定义
let multilinesString = “““
Do the most simple people，
the most happy way：
We often heart will feel tired，just want to too much;
We always say life trival，is actually I don’t understand taste;
Our business is busy ， often is not satisfied;
We are always competitive ， is actually his vanity is too strong.
Don’t compare ， heart is coll ， life is so simple.
“““
//字符串变量定义
var emptyStr = ““
var anotherEmptyStr = String（）
if emptyStr.isEmpty {
print（”This String is empty”）
}
var str1 = “hello world”
var str2 = str1
str2 = “helllo China”
print（str1）
//练习题7
var schoolName = ““
var universityName = String（）
if schoolName.isEmpty {
print（”School Name is empty!”）
} else {
print（”My School is \（schoolName）”）
}
universityName = “Beijing University of Aeronautic and Astronautic”
if universityName.isEmpty {
print（”University Name is empty!”）
} else {
print（”My University is \（universityName）”）
}
var myUniversity = ““
myUniversity = universityName
print（”My university is \（myUniversity）， University Name is \（universityName）”）
myUniversity = “Tsinghua University”
print（”My university is \（myUniversity）， University Name is \（universityName）”）

8.字符串操作

let theString = “It’s my world!”
//字符串大写
let upString=theString.uppercased（）
print（”the uppercaseString is \（upString）”）
//字符串小写
let lowString=theString.lowercased（）
print（”the lowercasesSteing is \（lowString）”）
//字符串索引
let courseTitle = “Swift”
//获取字符串第一个字符的索引与值
let firstIndex = courseTitle.startIndex
let firstCharacter = courseTitle[firstIndex]
//获取字符串最后一个字符的索引与值
let endIndex = courseTitle.index（before： courseTitle.endIndex）
let endCharacter = courseTitle[endIndex]
//获取中间位置字符的索引与值
let middleIndex = courseTitle.index（courseTitle.startIndex， offsetBy： 2）
let middleCharacter = courseTitle[middleIndex]
//字符串的子串
let studentName = “luo liang”
let spaceIndex = studentName.index（of： “ “）//xcode10.2中才有firstIndex（of：”“）
let firstName = studentName[studentName.startIndex …< spaceIndex!]
let firstName2 = studentName[…<spaceIndex!]
let surname = studentName[studentName.index（after： spaceIndex!）…studentName.index（before： studentName.endIndex）]
let bookInfo1 = “History book： world history”
//判断字符串是否含有前缀
if bookInfo1.hasPrefix（”History book”） {
print（”book1 is a history book.”）
}
let bookInfo2 = “History book： China history”
//判断字符串时候含有后缀
if bookInfo2.hasSuffix（”history”） {
print（”book2 is a history book.”）
}
//练习题8
var myHobbies = “Music Basketball Philosophy”
for char in myHobbies {
print（char）
}
print（”The number of characters in myHobbies is \（myHobbies.count）”）
let str1 = “My hobbies”， str2 = “is”
var info = str1 + str2 + myHobbies
print（info）
let space = “ “
info = str1 + space + str2 + space + myHobbies
print（info）
print（info.uppercased（））
print（info.lowercased（））
var firstIndex = myHobbies.startIndex
let firstChar = myHobbies[firstIndex]
let lastIndex = myHobbies.index（before： myHobbies.endIndex）
let lastChar = myHobbies[lastIndex]
var middleIndex = myHobbies.index（firstIndex， offsetBy： 6）
var middleChar = myHobbies[middleIndex]
middleIndex = myHobbies.index（lastIndex， offsetBy： -20）
middleChar = myHobbies[middleIndex]
var spaceIndex = myHobbies.index（of： “ “）!
let hobby1st = myHobbies[firstIndex…<spaceIndex]
firstIndex = myHobbies.index（after： spaceIndex）
let restOfMyHobbies = myHobbies[firstIndex…]
spaceIndex = restOfMyHobbies.index（of： “ “）!
let hobby2nd = restOfMyHobbies[restOfMyHobbies.startIndex…<spaceIndex]
firstIndex = restOfMyHobbies.index（after： spaceIndex）
let hobby3rd = restOfMyHobbies[firstIndex…]
print（”The first hobby is \（hobby1st）”）
print（”The second hobby is \（hobby2nd）”）
print（”The third hobby is \（hobby3rd）”）
//compare hobby
if hobby1st == hobby2nd {
print（”The two hobbies are equal.”）
}
if hobby1st.hasPrefix（”musi”） {
print（”The first hobby： \（hobby1st） has prefix： musi”）
} else {
print（”The first hobby： \（hobby1st） hasn’t prefix： musi”）
}
if hobby2nd.hasSuffix（”sophy”） {
print（”The first hobby： \（hobby2nd） has suffix： sophy”）
} else {
print（”The first hobby： \（hobby2nd） has suffix： sophy”）
}

四、实验结果与分析：

continue
告诉循环停止正在做的事情并且再次从头开始循环的下一次遍历.他是说"我不再继续当前的循环遍历了"而不是离开整个的循环.
break
会立即结束整个控制流语句.当你想要提前结束switch或者循环语句或者其他情况的可以在switch语句或者循环语句中使用break语句.
当在循环语句中使用时,break会立即结束循环的执行,并且转移控制到循环结束花括号(})后的第一行代码上.当前遍历循环里的其他代码都不会执行,并且余下的遍历循环也不会开始了.
当在switch语句里使用时,break导致switch语句立即结束它的执行,并且转移控制到switch语句结束花括号(})之后的第一行代码上.
fallthrough
如果你需要C或者OC风格的贯穿行为,你可以选择在switch每一个case末尾使用fallthrough关键字.
可以使用语句标签来给循环语句或者条件语句做标记.在一个条件语句中,你可以使用一个语句标签配合break语句来结束被标记的语句.在循环语句中,你可以使用语句标签来配合break后者continue语句来结束或者继续执行被标记的语句.

五、实验总结：

本次课程的学习，我主要学习了Swift集合&控制转移&字符串让我对swift编程语言有了一个基本的认识。在罗老师的带领学习下，我越来越喜欢这IOS门课程，希望在以后的学习中，我可以越来越主动去学习了解更多的知识。本次实验，我主要的学习情况总结如下：