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门课程，希望在以后的学习中，我可以越来越主动去学习了解更多的知识。本次实验，我主要的学习情况总结如下：