在学习java 数据结构时使用在线的动态模型演示不方便。（https://www.cs.usfca.edu/~galles/visualization/Algorithms.html）
由于使用的是mac 电脑 特此学习 swift 为方便后续开发各种桌面工具。
//基础数据类型：
int float double bool character(char 单个字符) string
// 变量常量：
var a = 1 // 变量
let b = 1 //常量
//制定类型与类型推断
var a = "你好" // 类型推断
var b:String = "我也好" // 制定类型（类型首字母必须大写）
//判断数据类型
var str = "xxxx"
type(of:str)
// 控制台输出
print(item:Any...) // 接受一个任意类型的可变参数
print(str)
print(str,str1)
// 字符串拼接
let s1 = "一只"
let s2 = "小白兔"
var s3 = s1 + s2; // "一只小白兔"
var s4 = "(s1)(s2)(s3)" // 一只小白兔一只小白兔
var s1 = "中国"
var s2 = "china"
s1 += s2
print(s1) // 中国china
// 类型别名 和 typdef 一样
typealias number8 = Int8
typealias number16= Int16
// 类型转换 转换失败返回 nil(null)
var a = 1
var b = "1"
var c = b + String(a)
print(type(of:c))// String
// ?? 语法 空置合并 前面有值就用前面 否则用默认值
var x = "asdf"
var k = Int(x) ?? 10 // 转换失败 返回10
print(k) // 10
// OPtional() 可选类型（不确定是否有值） ≈ Integer a = null
var a:Int? = 123
var b:Int? = nil;
print(a) // Optional(123)
// ! 语法 取出 OPtional() 的真值
print(a!) // 123
print(b!) // 空值会抛出异常
// 元组 不同类型放在一起的数组 ≈ Object[] obj = {1,"2",1.3};
var a = ()// 空元组
var a:(Int) = () // 会抛异常 不允许指定了类型不设置值
var a = (1 , 1.2)
var a:(Int,String) = (1,"123")
// 可以设置属性名称
var a:(arg0:String,arg1:Int) = ("hello",1)
var a = (arg0:"hello"marg1:"word")
// 元组取值
print(a.0) // 去下标 0
a.1 = 10 // 赋值下标 1
a.arg0 = " " // 赋值 属性
// 元组传递 值传递 不是引用
var a = ("hello","world",true)
var b = a
b.0 = "123"
print(a) // ("hello","world",true)
print(b) // ("123","world",true)
// 基础运算符
// 注意：swift 没有 ++（自增） --（自减） 运算符
+ - * 、 % < > = >= <= != && || ?? 三元运算符 += -= *= /=
== === !== & | ! ~ ^ >> <<
// 区间运算符 主要配合 for循环使用
1...5 // 区间值为 1 2 3 4 5
1..<5 // 区间值为 1 2 3 4
1... // 1 到 ∞
// if 语句
if(true){
}else if(true){
}else{
}
// 小括号可以不写
if true {
}else if true {
}else {
}
// switch case 不写break 也不会穿透 想要穿透效果使用多值匹配
var a = 10
switch (a){
case 1 :
break
case 2:
break
default:
break
}
// 匹配多个值
switch(a){
case 1,2,3,4:
break
case 5,6,7,8:
break
default:
break
}
// for in 循环
for index in 1...5 { // 步长 1
print(index) // 1,2,3,4,5
}
for (int a = 1; a<= 5 ;a++ ){
System.out.println(a)
}
// for in 步长不为1 从0开始到10结束 包含10 步长为2
for index in stride(from: 0, through: 10, by: 2) {
print(index)
}
for (int a = 0; a<= 10 ;a+=2 ){
System.out.println(a);
}
// for in 步长不为1 从0开始到10结束 不包含10 步长2
for index in stride(from: 0, to: 10, by: 2) {
print(index) // 0 2 4 6 8 10
}
for (int a = 0; a< 10 ;a+=2 ){
System.out.println(a);
}
// for in 反向
for index in stride(from: 0, to: 10, by: 2).reversed() {
print(index) // 8 6 4 2 0
}
// 跳出
continue // 跳出本次进入下次
break // 跳出本层所有
// while
while(true){
}
// repeat while == do{ }while()
repeat{
}while()
// String 基本操作
var str = "ABCD"
print(str.count) // 长度
// 获取子字符
// String.Index 内部类 用于字符串索引下标 不是Int类型
var i:String.Index = str.startIndex // 字符串的第一个索引
var j:String.Index = str.endIndex // 字符串的最后一个索引 + 1
print(str[i]) // A 获取 i索引的字符
print(str[str.index(after: i)]) // B 获取 i 索引的 after（后偏移1位） 的索引位置字符
print(str[str.index(before: j)]) // F 获取 j 索引 before（前偏移1位） 的索引位置字符
print(str[str.index(i, offsetBy: 2)]) // C 获取 i索引 往后偏移 2 位 的索引位置的字符
var lastIndex = str.index(before: j) // 字符串最后一个字符的索引
print(str[i...lastIndex]) //取区间 ABCD 从 i 索引位置 一直到包含 lastIndex 索引位置
print(str[i.. = [1,2,3,4]
// 添加
a.append(1) // 尾部追加
a += [5]
// 数组合并
var a = [12,11]
var b = [14,44]
var c = a + b // c = [12,11,14,44]
// set 集合 无序不重复
var a:Set = [1,2,3]
var a:Set = ["1","2"]
var a:Set = []
// Dictionary 字典集合 Map
var a = ["A":"a","V":"v"]
var a:Dictionary = ["A":"a","V":"v"]
var a = [String:String]()
var b:Dictionary? = nil
// 遍历
var a = ["1":"1","2":"2"]
for (key,value) in a {
print(key,value)
}
// 函数
// 函数关键字 函数名 （参数名：参数类型） -> 返回值类型
// 形参列表 都是只读的 let 不可更改
func test( a:Int,b:Int) ->Int
{
var i = a;
i *= 2
return i
}
// 传引用 inout
var i = 2
func test( a:inout Int)
{
a *= 2
}
test(a: &i)
print(i) // 4
// arg0 与 arg1 为 外部可见参数名
// a b 内部使用参数名
func test(arg0 a:Int,agr1 b:Int) ->Int
{
var i = a;
i *= 2
return i
}
// 形参 可变参数 类型...
func test( a:Int,b:Int...) -> Int
{
var i = a;
i *= 2
return i
}
print(test(a: 2, b: 1,2,3,4))
//函数的返回值还是函数 以及指向函数的指针
var func1: (Int,Int)->Int // 定义变量 func1 类型是 两个Int参数 返回值也是Int的函数 类型
func sum(a:Int,b:Int)->Int{ // 求和
return a + b
}
func test() -> (Int,Int)->Int // 两个Int参数 返回值也是Int的函数 作为返回值
{
return sum(a:b:) // sum 函数符合需求
}
func1 = test() // 变量接收test（）的返回值 fucn1 == sum
print(func1(10,20)) // 调用func1 就是调用 sum
// 函数指针 匿名函数
var a:(Int,Int)->Int = {(a:Int,b:Int)->Int in
return a + b
}
print(a(10,20)) // 30
// 函数作为参数传递给另一个函数
var func1: (Int,Int)->Int
func sum(a:Int,b:Int)->Int{
return a + b
}
func test(func1:(Int,Int)->Int) -> Int{
return func1(10,20)
}
print(test(func1: sum)) // 30
// 函数嵌套
func sum() -> Int {
func sum2()->Int{
return 10 + 10
}
return sum2()
}
print(sum()) // 20
// guard 拦截语句
func test(arg1 a:Int,arg2 b:Int)->Int{
guard a<10 && b<10 else { // 如果 a < 10 && b < 10 走 a * b
return a + b // 否则 走 a + b
}
return a * b
}
print(test(arg1: 10, arg2: 10)) // 20
// 闭包 就是匿名函数
{
(a:Int , b:Int ) -> void in
}
// 枚举
enum TestEnum : Int{
case ONE = 1
case TWO = 2
}
print(TestEnum.ONE) // ONE
print(TestEnum.ONE.rawValue) // 1
// 结构体 适合用来传递数据 只会传值不会传引用 深拷贝
struct Test{
var name:String
var age:Int
}
