首页 文章 精选 留言 我的

精选列表

搜索[数据类型]，共7212篇文章
优秀的个人博客,低调大师

Swift基础语法（常量变量、数据类型、元组、可选、断言）

本文来自Swift中文开发组，感谢翻译者的分享。 本文将分几部分对Swift对ios的语法做讲解。本文为第一节，主要讲解基础语法。 常量和变量 常量和变量把一个名字（比如maximumNumberOfLoginAttempts或者welcomeMessage）和一个指定类型的值（比如数字10或者字符串"Hello"）关联起来。常量的值一旦设定就不能改变，而变量的值可以随意更改。 声明常量和变量 常量和变量必须在使用前声明，用let来声明常量，用var来声明变量。下面的例子展示了如何用常量和变量来记录用户尝试登录的次数： let maximumNumberOfLoginAttempts = 10 var currentLoginAttempt = 0 这两行代码可以被理解为：“声明一个名字是maximumNumberOfLoginAttempts的新常量，并给它一个值10。然后，声明一个名字是currentLoginAttempt的变量并将它的值初始化为0.”在这个例子中，允许的最大尝试登录次数被声明为一个常量，因为这个值不会改变。当前尝试登录次数被声明为一个变量，因为每次尝试登录失败的时候都需要增加这个值。 你可以在一行中声明多个常量或者多个变量，用逗号隔开： var x = 0.0, y = 0.0, z = 0.0 注意：如果你的代码中有不需要改变的值，请使用let关键字将它声明为常量。只将需要改变的值声明为变量。 类型标注 当你声明常量或者变量的时候可以加上类型标注(type annotation)，说明常量或者变量中要存储的值的类型。如果要添加类型标注，需要在常量或者变量名后面加上一个冒号和空格，然后加上类型名称。 这个例子给welcomeMessage变量添加了类型标注，表示这个变量可以存储String类型的值： var welcomeMessage: String 声明中的冒号代表着“是...类型”，所以这行代码可以被理解为：“声明一个类型为String，名字为welcomeMessage的变量。”“类型为String”的意思是“可以存储任意String类型的值。” welcomeMessage变量现在可以被设置成任意字符串： welcomeMessage = "Hello" 注意：一般来说你很少需要写类型标注。如果你在声明常量或者变量的时候赋了一个初始值，Swift可以推断出这个常量或者变量的类型，请参考类型安全和类型推断。在上面的例子中，没有给welcomeMessage赋初始值，所以变量welcomeMessage的类型是通过一个类型标注指定的，而不是通过初始值推断的。 常量和变量的命名 你可以用任何你喜欢的字符作为常量和变量名，包括 Unicode 字符： let π = 3.14159 let 你好 = "你好世界" 常量与变量名不能包含数学符号，箭头，保留的（或者非法的）Unicode 码位，连线与制表符。也不能以数字开头，但是可以在常量与变量名的其他地方包含数字。一旦你将常量或者变量声明为确定的类型，你就不能使用相同的名字再次进行声明，或者改变其存储的值的类型。同时，你也不能将常量与变量进行互转。 注意：如果你需要使用与Swift保留关键字相同的名称作为常量或者变量名，你可以使用反引号（`）将关键字包围的方式将其作为名字使用。无论如何，你应当避免使用关键字作为常量或变量名，除非你别无选择。 你可以更改现有的变量值为其他同类型的值，在下面的例子中，friendlyWelcome的值从"Hello!"改为了"Bonjour!": var friendlyWelcome = "Hello!" friendlyWelcome = "Bonjour!" // friendlyWelcome 现在是 "Bonjour!" 与变量不同，常量的值一旦被确定就不能更改了。尝试这样做会导致编译时报错： let languageName = "Swift" languageName = "Swift++" // 这会报编译时错误 - languageName 不可改变 输出常量和变量 你可以用println函数来输出当前常量或变量的值: println(friendlyWelcome) // 输出 "Bonjour!" println是一个用来输出的全局函数，输出的内容会在最后换行。如果你用 Xcode，println将会输出内容到“console”面板上。(另一种函数叫print，唯一区别是在输出内容最后不会换行。) println函数输出传入的String值： println("This is a string") // 输出 "This is a string" 与 Cocoa 里的NSLog函数类似的是，println函数可以输出更复杂的信息。这些信息可以包含当前常量和变量的值。 Swift 用字符串插值（string interpolation）的方式把常量名或者变量名当做占位符加入到长字符串中，Swift 会用当前常量或变量的值替换这些占位符。将常量或变量名放入圆括号中，并在开括号前使用反斜杠将其转义： println("The current value of friendlyWelcome is \(friendlyWelcome)") // 输出 "The current value of friendlyWelcome is Bonjour! 注意：字符串插值所有可用的选项，请参考字符串插值。 注释 请将你的代码中的非执行文本注释成提示或者笔记以方便你将来阅读。Swift 的编译器将会在编译代码时自动忽略掉注释部分。 Swift 中的注释与C 语言的注释非常相似。单行注释以双正斜杠作(//)为起始标记； // 这是一个注释 你也可以进行多行注释，其起始标记为单个正斜杠后跟随一个星号(/*)，终止标记为一个星号后跟随单个正斜杠(*/) /* 这是一个, 多行注释 */ 与C 语言多行注释不同，Swift 的多行注释可以嵌套在其它的多行注释之中。你可以先生成一个多行注释块，然后在这个注释块之中再嵌套成第二个多行注释。终止注释时先插入第二个注释块的终止标记，然后再插入第一个注释块的终止标记： /* 这是第一个多行注释的开头 /* 这是第二个被嵌套的多行注释 */ 这是第一个多行注释的结尾 */ 通过运用嵌套多行注释，你可以快速方便的注释掉一大段代码，即使这段代码之中已经含有了多行注释块。 分号 与其他大部分编程语言不同，Swift 并不强制要求你在每条语句的结尾处使用分号（;），当然，你也可以按照你自己的习惯添加分号。有一种情况下必须要用分号，即你打算在同一行内写多条独立的语句： let cat = " 整数 整数就是没有小数部分的数字，比如42和-23。整数可以是有符号（正、负、零）或者无符号（正、零）。Swift 提供了8，16，32和64位的有符号和无符号整数类型。这些整数类型和 C 语言的命名方式很像，比如8位无符号整数类型是UInt8，32位有符号整数类型是Int32。就像 Swift 的其他类型一样，整数类型采用大写命名法。 整数范围 你可以访问不同整数类型的min和max属性来获取对应类型的最大值和最小值： let minValue = UInt8.min // minValue 为 0，是 UInt8 类型的最小值 let maxValue = UInt8.max // maxValue 为 255，是 UInt8 类型的最大值 Int 一般来说，你不需要专门指定整数的长度。Swift 提供了一个特殊的整数类型Int，长度与当前平台的原生字长相同： 在32位平台上，Int和Int32长度相同。 在64位平台上，Int和Int64长度相同。 除非你需要特定长度的整数，一般来说使用Int就够了。这可以提高代码一致性和可复用性。即使是在32位平台上，Int可以存储的整数范围也可以达到-2147483648~2147483647，大多数时候这已经足够大了。 UInt Swift 也提供了一个特殊的无符号类型UInt，长度与当前平台的原生字长相同： 在32位平台上，UInt和UInt32长度相同。 在64位平台上，UInt和UInt64长度相同。 注意：尽量不要使用UInt，除非你真的需要存储一个和当前平台原生字长相同的无符号整数。除了这种情况，最好使用Int，即使你要存储的值已知是非负的。统一使用Int可以提高代码的可复用性，避免不同类型数字之间的转换，并且匹配数字的类型推测，请参考类型安全和类型推测。 浮点数 浮点数是有小数部分的数字，比如3.14159，0.1和-273.15。浮点类型比整数类型表示的范围更大，可以存储比Int类型更大或者更小的数字。Swift 提供了两种有符号浮点数类型： Double表示64位浮点数。当你需要存储很大或者很高精度的浮点数时请使用此类型。 Float表示32位浮点数。精度要求不高的话可以使用此类型。 注意：Double精确度很高，至少有15位数字，而Float最少只有6位数字。选择哪个类型取决于你的代码需要处理的值的范围。 类型安全和类型推测 Swift 是一个类型安全(type safe )的语言。类型安全的语言可以让你清楚地知道代码要处理的值的类型。如果你的代码需要一个String，你绝对不可能不小心传进去一个Int。由于 Swift 是类型安全的，所以它会在编译你的代码时进行类型检查(type checks)，并把不匹配的类型标记为错误。这可以让你在开发的时候尽早发现并修复错误。当你要处理不同类型的值时，类型检查可以帮你避免错误。然而，这并不是说你每次声明常量和变量的时候都需要显式指定类型。如果你没有显式指定类型，Swift 会使用类型推测(type inference)来选择合适的类型。有了类型推测，编译器可以在编译代码的时候自动推测出表达式的类型。原理很简单，只要检查你赋的值即可。因为有类型推测，和 C 或者 Objective-C 比起来 Swift 很少需要声明类型。常量和变量虽然需要明确类型，但是大部分工作并不需要你自己来完成。当你声明常量或者变量并赋初值的时候类型推测非常有用。当你在声明常量或者变量的时候赋给它们一个字面量(literal value 或 literal)即可触发类型推测。（字面量就是会直接出现在你代码中的值，比如42和3.14159。） 例如，如果你给一个新常量赋值42并且没有标明类型，Swift 可以推测出常量类型是Int，因为你给它赋的初始值看起来像一个整数： let meaningOfLife = 42 // meaningOfLife 会被推测为 Int 类型 同理，如果你没有给浮点字面量标明类型，Swift 会推测你想要的是Double： let pi = 3.14159 // pi 会被推测为 Double 类型 当推测浮点数的类型时，Swift 总是会选择Double而不是Float。 如果表达式中同时出现了整数和浮点数，会被推测为Double类型： let anotherPi = 3 + 0.14159 // anotherPi 会被推测为 Double 类型 原始值3没有显式声明类型，而表达式中出现了一个浮点字面量，所以表达式会被推测为Double类型。 数值型字面量 整数字面量可以被写作： 一个十进制数，没有前缀 一个二进制数，前缀是0b 一个八进制数，前缀是0o 一个十六进制数，前缀是0x 下面的所有整数字面量的十进制值都是17: let decimalInteger = 17 let binaryInteger = 0b10001 // 二进制的17 let octalInteger = 0o21 // 八进制的17 let hexadecimalInteger = 0x11 // 十六进制的17 浮点字面量可以是十进制（没有前缀）或者是十六进制（前缀是0x）。小数点两边必须有至少一个十进制数字（或者是十六进制的数字）。浮点字面量还有一个可选的指数(exponent)，在十进制浮点数中通过大写或者小写的e来指定，在十六进制浮点数中通过大写或者小写的p来指定。如果一个十进制数的指数为exp，那这个数相当于基数和$10^{exp}$的乘积： 1.25e2表示 $1.25 × 10^{2}$，等于125.0。 1.25e-2表示 $1.25 × 10^{-2}$，等于0.0125。 如果一个十六进制数的指数为exp，那这个数相当于基数和$2^{exp}$的乘积： 0xFp2表示 $15 × 2^{2}$，等于60.0。 0xFp-2表示 $15 × 2^{-2}$，等于3.75。 下面的这些浮点字面量都等于十进制的12.1875： let decimalDouble = 12.1875 let exponentDouble = 1.21875e1 let hexadecimalDouble = 0xC.3p0 数值类字面量可以包括额外的格式来增强可读性。整数和浮点数都可以添加额外的零并且包含下划线，并不会影响字面量： let paddedDouble = 000123.456 let oneMillion = 1_000_000 let justOverOneMillion = 1_000_000.000_000_1 数值型类型转换 通常来讲，即使代码中的整数常量和变量已知非负，也请使用Int类型。总是使用默认的整数类型可以保证你的整数常量和变量可以直接被复用并且可以匹配整数类字面量的类型推测。 只有在必要的时候才使用其他整数类型，比如要处理外部的长度明确的数据或者为了优化性能、内存占用等等。使用显式指定长度的类型可以及时发现值溢出并且可以暗示正在处理特殊数据。 整数转换 不同整数类型的变量和常量可以存储不同范围的数字。Int8类型的常量或者变量可以存储的数字范围是-128~127，而UInt8类型的常量或者变量能存储的数字范围是0~255。如果数字超出了常量或者变量可存储的范围，编译的时候会报错： let cannotBeNegative: UInt8 = -1 // UInt8 类型不能存储负数，所以会报错 let tooBig: Int8 = Int8.max + 1 // Int8 类型不能存储超过最大值的数，所以会报错 由于每中整数类型都可以存储不同范围的值，所以你必须根据不同情况选择性使用数值型类型转换。这种选择性使用的方式，可以预防隐式转换的错误并让你的代码中的类型转换意图变得清晰。 要将一种数字类型转换成另一种，你要用当前值来初始化一个期望类型的新数字，这个数字的类型就是你的目标类型。在下面的例子中，常量twoThousand是UInt16类型，然而常量one是Uint8类型。它们不能直接相加，因为它们类型不同。所以要调用UInt16(one)来创建一个新的UInt16数字并用one的值来初始化，然后使用这个新数字来计算： let twoThousand: UInt16 = 2_000 let one: UInt8 = 1 let twoThousandAndOne = twoThousand + UInt16(one) 现在两个数字的类型都是UInt16，可以进行相加。目标常量twoThousandAndOne的类型被推测为UInt16，因为它是两个UInt16值的和。SomeType(ofInitialValue)是调用 Swift 构造器并传入一个初始值的默认方法。在语言内部，UInt16有一个构造器，可以接受一个UInt8类型的值，所以这个构造器可以用现有的UInt8来创建一个新的UInt16。注意，你并不能传入任意类型的值，只能传入UInt16内部有对应构造器的值。不过你可以扩展现有的类型来让它可以接收其他类型的值（包括自定义类型），请参考扩展。 整数和浮点数转换 整数和浮点数的转换必须显式指定类型： let three = 3 let pointOneFourOneFiveNine = 0.14159 let pi = Double(three) + pointOneFourOneFiveNine // pi 等于 3.14159，所以被推测为 Double 类型 这个例子中，常量three的值被用来创建一个Double类型的值，所以加号两边的数类型相同。如果不进行转换，两者无法相加。 浮点数到整数的反向转换同样行，整数类型可以用Double或者Float类型来初始化： let integerPi = Int(pi) // integerPi 等于 3，所以被推测为 Int 类型 当用这种方式来初始化一个新的整数值时，浮点值会被截断。也就是说4.75会变成4，-3.9会变成-3。 注意：结合数字类常量和变量不同于结合数字类字面量。字面量3可以直接和字面量0.14159相加，因为数字字面量本身没有明确的类型。它们的类型只在编译器需要求值的时候被推测。 类型别名 类型别名(type aliases)就是给现有类型定义另一个名字。你可以使用typealias关键字来定义类型别名。 当你想要给现有类型起一个更有意义的名字时，类型别名非常有用。假设你正在处理特定长度的外部资源的数据： typealias AudioSample = UInt16 定义了一个类型别名之后，你可以在任何使用原始名的地方使用别名： var maxAmplitudeFound = AudioSample.min // maxAmplitudeFound 现在是 0 本例中，AudioSample被定义为UInt16的一个别名。因为它是别名，AudioSample.min实际上是UInt16.min，所以会给maxAmplitudeFound赋一个初值0。 布尔值 Swift 有一个基本的布尔(Boolean)类型，叫做Bool。布尔值指逻辑上的(logical)，因为它们只能是真或者假。Swift 有两个布尔常量，true和false： let orangesAreOrange = true let turnipsAreDelicious = false orangesAreOrange和turnipsAreDelicious的类型会被推测为Bool，因为它们的初值是布尔字面量。就像之前提到的Int和Double一样，如果你创建变量的时候给它们赋值true或者false，那你不需要将常量或者变量声明为Bool类型。初始化常量或者变量的时候如果所赋的值类型已知，就可以触发类型推测，这让 Swift 代码更加简洁并且可读性更高。 当你编写条件语句比如if语句的时候，布尔值非常有用： if turnipsAreDelicious { println("Mmm, tasty turnips!") } else { println("Eww, turnips are horrible.") } // 输出 "Eww, turnips are horrible." 条件语句，例如if，请参考控制流。 如果你在需要使用Bool类型的地方使用了非布尔值，Swift 的类型安全机制会报错。下面的例子会报告一个编译时错误： let i = 1 if i { // 这个例子不会通过编译，会报错 } 然而，下面的例子是合法的： let i = 1 if i == 1 { // 这个例子会编译成功 } i == 1的比较结果是Bool类型，所以第二个例子可以通过类型检查。类似i == 1这样的比较，请参考基本操作符。和 Swift 中的其他类型安全的例子一样，这个方法可以避免错误并保证这块代码的意图总是清晰的。 元组 元组（tuples）把多个值组合成一个复合值。元组内的值可以使任意类型，并不要求是相同类型。 下面这个例子中，(404, "Not Found")是一个描述HTTP 状态码（HTTP status code）的元组。HTTP 状态码是当你请求网页的时候 web 服务器返回的一个特殊值。如果你请求的网页不存在就会返回一个404 Not Found状态码。 let http404Error = (404, "Not Found") // http404Error 的类型是 (Int, String)，值是 (404, "Not Found") (404, "Not Found")元组把一个Int值和一个String值组合起来表示 HTTP 状态码的两个部分：一个数字和一个人类可读的描述。这个元组可以被描述为“一个类型为(Int, String)的元组”。你可以把任意顺序的类型组合成一个元组，这个元组可以包含所有类型。只要你想，你可以创建一个类型为(Int, Int, Int)或者(String, Bool)或者其他任何你想要的组合的元组。 你可以将一个元组的内容分解（decompose）成单独的常量和变量，然后你就可以正常使用它们了： let (statusCode, statusMessage) = http404Error println("The status code is \(statusCode)") // 输出 "The status code is 404" println("The status message is \(statusMessage)") // 输出 "The status message is Not Found" 如果你只需要一部分元组值，分解的时候可以把要忽略的部分用下划线（_）标记： let (justTheStatusCode, _) = http404Error println("The status code is \(justTheStatusCode)") // 输出 "The status code is 404" 此外，你还可以通过下标来访问元组中的单个元素，下标从零开始： println("The status code is \(http404Error.0)") // 输出 "The status code is 404" println("The status message is \(http404Error.1)") // 输出 "The status message is Not Found" 你可以在定义元组的时候给单个元素命名： let http200Status = (statusCode: 200, description: "OK") 给元组中的元素命名后，你可以通过名字来获取这些元素的值： println("The status code is \(http200Status.statusCode)") // 输出 "The status code is 200" println("The status message is \(http200Status.description)") // 输出 "The status message is OK" 作为函数返回值时，元组非常有用。一个用来获取网页的函数可能会返回一个(Int, String)元组来描述是否获取成功。和只能返回一个类型的值比较起来，一个包含两个不同类型值的元组可以让函数的返回信息更有用。请参考[函数参数与返回值(06_Functions.html#Function_Parameters_and_Return_Values)。 注意：元组在临时组织值的时候很有用，但是并不适合创建复杂的数据结构。如果你的数据结构并不是临时使用，请使用类或者结构体而不是元组。请参考类和结构体。 可选 使用可选（optionals）来处理值可能缺失的情况。可选表示： 有值，等于 x 或者 没有值 注意：C 和 Objective-C 中并没有可选这个概念。最接近的是 Objective-C 中的一个特性，一个方法要不返回一个对象要不返回nil，nil表示“缺少一个合法的对象”。然而，这只对对象起作用——对于结构体，基本的 C 类型或者枚举类型不起作用。对于这些类型，Objective-C 方法一般会返回一个特殊值（比如NSNotFound）来暗示值缺失。这种方法假设方法的调用者知道并记得对特殊值进行判断。然而，Swift 的可选可以让你暗示任意类型的值缺失，并不需要一个特殊值。 来看一个例子。Swift 的String类型有一个叫做toInt的方法，作用是将一个String值转换成一个Int值。然而，并不是所有的字符串都可以转换成一个整数。字符串"123"可以被转换成数字123，但是字符串"hello, world"不行。 下面的例子使用toInt方法来尝试将一个String转换成Int： let possibleNumber = "123" let convertedNumber = possibleNumber.toInt() // convertedNumber 被推测为类型 "Int?"， 或者类型 "optional Int" 因为toInt方法可能会失败，所以它返回一个可选的（optional）Int，而不是一个Int。一个可选的Int被写作Int?而不是Int。问号暗示包含的值是可选，也就是说可能包含Int值也可能不包含值。（不能包含其他任何值比如Bool值或者String值。只能是Int或者什么都没有。） if 语句以及强制解析 你可以使用if语句来判断一个可选是否包含值。如果可选有值，结果是true；如果没有值，结果是false。 当你确定可选包确实含值之后，你可以在可选的名字后面加一个感叹号(!)来获取值。这个惊叹号表示“我知道这个可选有值，请使用它。”这被称为可选值的强制解析（forced unwrapping）： if convertedNumber { println("\(possibleNumber) has an integer value of \(convertedNumber!)") } else { println("\(possibleNumber) could not be converted to an integer") } // 输出 "123 has an integer value of 123" 更多关于if语句的内容，请参考控制流。 注意：使用!来获取一个不存在的可选值会导致运行时错误。使用!来强制解析值之前，一定要确定可选包含一个非nil的值。 可选绑定 使用可选绑定（optional binding）来判断可选是否包含值，如果包含就把值赋给一个临时常量或者变量。可选绑定可以用在if和while语句中来对可选的值进行判断并把值赋给一个常量或者变量。if和while语句，请参考控制流。 像下面这样在if语句中写一个可选绑定： if let constantName = someOptional { statements } 你可以像上面这样使用可选绑定来重写possibleNumber这个例子： if let actualNumber = possibleNumber.toInt() { println("\(possibleNumber) has an integer value of \(actualNumber)") } else { println("\(possibleNumber) could not be converted to an integer") } // 输出 "123 has an integer value of 123" 这段代码可以被理解为：“如果possibleNumber.toInt返回的可选Int包含一个值，创建一个叫做actualNumber的新常量并将可选包含的值赋给它。”如果转换成功，actualNumber常量可以在if语句的第一个分支中使用。它已经被可选包含的值初始化过，所以不需要再使用!后缀来获取它的值。在这个例子中，actualNumber只被用来输出转换结果。你可以在可选绑定中使用常量和变量。如果你想在if语句的第一个分支中操作actualNumber的值，你可以改成if var actualNumber，这样可选包含的值就会被赋给一个变量而非常量。 nil 你可以给可选变量赋值为nil来表示它没有值： var serverResponseCode: Int? = 404 // serverResponseCode 包含一个可选的 Int 值 404 serverResponseCode = nil // serverResponseCode 现在不包含值 注意：nil不能用于非可选的常量和变量。如果你的代码中有常量或者变量需要处理值缺失的情况，请把它们声明成对应的可选类型。 如果你声明一个可选常量或者变量但是没有赋值，它们会自动被设置为nil： var surveyAnswer: String? // surveyAnswer 被自动设置为 nil 注意：Swift 的nil和 Objective-C 中的nil并不一样。在 Objective-C 中，nil是一个指向不存在对象的指针。在 Swift 中，nil不是指针——它是一个确定的值，用来表示值缺失。任何类型的可选都可以被设置为nil，不只是对象类型。 隐式解析可选 如上所述，可选暗示了常量或者变量可以“没有值”。可选可以通过if语句来判断是否有值，如果有值的话可以通过可选绑定来解析值。有时候在程序架构中，第一次被赋值之后，可以确定一个可选总会有值。在这种情况下，每次都要判断和解析可选值是非常低效的，因为可以确定它总会有值。这种类型的可选被定义为隐式解析可选（implicitly unwrapped optionals）。把想要用作可选的类型的后面的问号（String?）改成感叹号（String!）来声明一个隐式解析可选。当可选被第一次赋值之后就可以确定之后一直有值的时候，隐式解析可选非常有用。隐式解析可选主要被用在 Swift 中类的构造过程中，请参考类实例之间的循环强引用。 一个隐式解析可选其实就是一个普通的可选，但是可以被当做非可选来使用，并不需要每次都使用解析来获取可选值。下面的例子展示了可选String和隐式解析可选String之间的区别： let possibleString: String? = "An optional string." println(possibleString!) // 需要惊叹号来获取值 // 输出 "An optional string." let assumedString: String! = "An implicitly unwrapped optional string." println(assumedString) // 不需要感叹号 // 输出 "An implicitly unwrapped optional string." 你可以把隐式解析可选当做一个可以自动解析的可选。你要做的只是声明的时候把感叹号放到类型的结尾，而不是每次取值的可选名字的结尾。 注意：如果你在隐式解析可选没有值的时候尝试取值，会触发运行时错误。和你在没有值的普通可选后面加一个惊叹号一样。 你仍然可以把隐式解析可选当做普通可选来判断它是否包含值： if assumedString { println(assumedString) } // 输出 "An implicitly unwrapped optional string." 你也可以在可选绑定中使用隐式解析可选来检查并解析它的值： if let definiteString = assumedString { println(definiteString) } // 输出 "An implicitly unwrapped optional string." 注意：如果一个变量之后可能变成nil的话请不要使用隐式解析可选。如果你需要在变量的生命周期中判断是否是nil的话，请使用普通可选类型。
2016-11-13
优秀的个人博客,低调大师

Java的基本数据类型在虚拟机中的实现

前言 首先我们做个小测验，通过下面代码来看看Java语言和Java虚拟机对boolean类型有什么不同： public class Foo { public static void main(String[] args) { boolean flag = true; if (flag) System.out.println("Hello, Java!"); if (flag == true) System.out.println("Hello, JVM!"); } } 我们编译执行后的输出结果如下： $ javac Foo.java $ java Foo $ Hello, Java! Hello, JVM! 下面我们通过asmtools将虚拟机中flag的值改为2，我们再看看输出结果。 $ java -cp /Users/leiqi/Library/sdk/asmtools.jar org.openjdk.asmtools.jdis.Main Foo.class > Foo.jasm.1 $ awk 'NR==1,/iconst_1/{sub(/iconst_1/, "iconst_2")} 1' Foo.jasm.1 > Foo.jasm $ java -cp /Users/leiqi/Library/sdk/asmtools.jar org.openjdk.asmtools.jasm.Main Foo.jasm $ java Foo $ Hello, Java! 这次我们看到输出结果跟上次不一样了。那么我们可能会想到：当一个boolean类型的值为2时，它究竟是true还是false？ 下面我们详细分析一下它背后的逻辑。 Java虚拟机的boolean类型 首先，我们看看Java语言规范和Java虚拟机规范中分别怎么定义boolean类型。 在Java语言规范中boolean类型的值只有两种可能，true或者false。 但是这两者不能直接被虚拟机引用。 在Java虚拟机规范中，boolean类型的值被映射为int类型。true被映射为1,false被映射为0。这个编码映射规则约束了Java字节码的具体实现。也就是说：对于存储boolean数组的字节码 ，虚拟机需要保证存入的是1或0 Java虚拟机同时也要求Java编译器对应也得遵守这个规则，并且用整数相关的字节码来实现逻辑运算，以及基于boolean类型的条件跳转。这样一来，在编译而成的class文件中,除了字段和传入的参数外，基本看不出boolean类型的痕迹。 # Foo.main 编译后的字节码 0: iconst_2 // 我们用 AsmTools更改了这一指令 1: istore_1 2: iload_1 3: ifeq 14 // 第一个 if 语句，即操作数栈上数值为 0 时跳转 6: getstatic java.lang.System.out 9: ldc "Hello, Java!" 11: invokevirtual java.io.PrintStream.println 14: iload_1 15: iconst_1 16: if_icmpne 27 // 第二个if语句，即操作数栈上两个数值不相同时跳转 19: getstatic java.lang.System.out 22: ldc "Hello, JVM!" 24: invokevirtual java.io.PrintStream.println 27: return 在前面的例子中，第一个if语句会被编译成条件跳转字节码ifeq，翻译成人话就是说，如果局部变量flag的值为0，那么不打印“Hello Java!”。 而第二个if语句则会编译为条件跳转字节码if_cmpne,也就是说，如果局部变量的值和整数1相等，则打印“Hello JVM！” ，否则跳过这句。 可以看到，Java 编译器的确遵守了相同的编码规则。当然，这个约束很容易绕开。除了我们之前用得到的AsmTools外，还有一些工具可以修改字节码的java库，如ASM等。 对于JAVA虚拟机来说，他看到的boolean类型，早已被映射为整数类型。因此，将原本声明为boolean类型的局部变量，赋值为除了0，1之外的整数值，在Java虚拟机看来是“合法”的。 在之前的例子中，经过编译器编译之后，java虚拟机看到的不是在问“flag是否非零”，而是变成在问“flag为几”。也就是第一个if语句变成：flag的值为0吗？第二个if语句则变成：flag的值是1吗？ 如果约定俗成，flag只能为0/1，那么第二个if语句还是有意义的。但如果我们打破常规，flag的值为大于1，那么较真的Java虚拟机就会将第二个if语句判定为假。 Java的基本类型 除了上面提到的boolean类型外，Java的基本类型还包括byte、short、char、int、long、float以及double。 Java的基本类型都有对应的值域和默认值。可以看到，byte、short、int、long、float以及double的值域依次扩大，而且前面的值域被后面的值域所包含。因此，从前面的基本类型转换至后面的基本类型，无需强制转换。另外一点值得注意的是，尽管他们的默认值看起来不一样，但是在内存中都是0。 在这些基本类型中，boolean和char是唯二的无符号类型。在不考虑违反规范的情况下，boolean类型的取值范围是0或者1.char类型的取值范围是[0,65535]。通常我们可以认定char类型的值为负数。这种特性十分有用，比如说作为数组索引等。 在前面的例子中，我们能够将整数2存储到一个声明为boolean类型的局部变量中。那么，声明为byte，char以及short的局部变量，是否也能够存储超出它们范围的数值昵？ 答案是可以的。而且，这些超出取值范围的数值依然会带来一些麻烦。比如说，声明为char类型的局部变量实际上有可能为负数。当然，在政策使用Java编译器的情况下，生成的字节码会遵守Java虚拟机规范对编译器的约束，因此你无须过分担心局部变量会超出它们的取值范围。 Java的浮点类型彩印IEEE 754 浮点数格式。以float为例，浮点类型通常有两个0，+0.0F以及-0.0F。 前者在Java里是0，后者是符号位为1，其他位均为0的浮点数，在内存中等同于十六进制整数0x8000000（即-0.0F可通过Float.intBitsToFloat(0x8000000)求得）。尽管它们的内存数值不同，但是在Java中 +0.0F == -0.0F会返回为真。 在有了+0.0F 和 -0.0F这两个定义以后，我们便可以定义浮点数中的正无穷及负无穷。正无穷就是任意正浮点数（不包括+0.0F）除以+0.0F得到的值，而负无穷就是任意负浮点数（不包括-0.0F）除以-0.0F得到的值。 在Java中，正无穷和负无穷是有确切的值，在内存中分别等同于十六进制整数0x7F800000 和 0xFF800000。 而 [0x7F800001, 0x7FFFFFFF] 和 [0xFF800001, 0xFFFFFFFF] 对应的都是NaN(Not-a-Number) 。当然，一般我们计算得出的NaN，比如说通过+0.0F/+0.0F,在内存中应为0x7FC00000。这个数字，我们都称之为标准的NaN，而其他的我们称之为不标准的NaN。 NaN有一个有趣的特性：除了"!="始终返回true之外，所有其它比较结果都会返回false。 举例来说， NaN < 1.0F -> false NaN >= 1.0F -> false f != NaN -> true (f为任意浮点数) f == NaN -> false (f为任意浮点数) 因此，我们在程序里做浮点数比较时，需要考虑上述特性。 Java基本类型的大小 前面有提到 Java虚拟机每调用一个方法，便会创建一个栈帧 为了方便理解，这里我只讨论供解释器使用的解释栈帧(interpreted frame)。 这种栈帧有两个主要的组成部分，分别是局部变量区，以及字节码的操作数栈。这里的局部变量是广义的，除了普遍意义下的局部变量之外，它还包含实例方法的"this指针"以及方法所接受的参数。 在Java虚拟机规范中，局部变量区等价于一个数组，并且可以用正整数来索引。除了long、double值需要用两个赎罪单元来存储外，其它基本类型以及引用类型的值均占用一个数组单元。 也就是说，boolean、byte、char、short 这四种类型，在栈上占用的空间和 int 是一样的，和引用类型也是一样的。因此，在 32 位的 HotSpot 中，这些类型在栈上将占用 4 个字节；而在 64 位的 HotSpot 中，他们将占 8 个字节。 当然，这种情况仅存在于局部变量，而并不会出现在存储于堆中的字段或者数组元素上。对于 byte、char 以及 short 这三种类型的字段或者数组单元，它们在堆上占用的空间分别为一字节、两字节，以及两字节，也就是说，跟这些类型的值域相吻合。 因此，当我们将一个 int 类型的值，存储到这些类型的字段或数组时，相当于做了一次隐式的掩码操作。举例来说，当我们把 0xFFFFFFFF（-1）存储到一个声明为 char 类型的字段里时，由于该字段仅占两字节，所以高两位的字节便会被截取掉，最终存入“\uFFFF”。 boolean 字段和 boolean 数组则比较特殊。在 HotSpot 中，boolean 字段占用一字节，而 boolean 数组则直接用 byte 数组来实现。为了保证堆中的 boolean 值是合法的，HotSpot 在存储时显式地进行掩码操作，也就是说，只取最后一位的值存入 boolean 字段或数组中。 讲完了存储，现在我来讲讲加载。Java 虚拟机的算数运算几乎全部依赖于操作数栈。也就是说，我们需要将堆中的 boolean、byte、char 以及 short 加载到操作数栈上，而后将栈上的值当成 int 类型来运算。 对于 boolean、char 这两个无符号类型来说，加载伴随着零扩展。举个例子，char 的大小为两个字节。在加载时 char 的值会被复制到 int 类型的低二字节，而高二字节则会用 0 来填充。 对于 byte、short 这两个类型来说，加载伴随着符号扩展。举个例子，short 的大小为两个字节。在加载时 short 的值同样会被复制到 int 类型的低二字节。如果该 short 值为非负数，即最高位为 0，那么该 int 类型的值的高二字节会用 0 来填充，否则用 1 来填充。 总结 1、boolean 类型在 Java 虚拟机中被映射为整数类型：“true”被映射为 1，而“false”被映射为 0。Java 代码中的逻辑运算以及条件跳转，都是用整数相关的字节码来实现的。 2、除 boolean 类型之外，Java 还有另外 7 个基本类型。它们拥有不同的值域，但默认值在内存中均为 0。这些基本类型之中，浮点类型比较特殊。基于它的运算或比较，需要考虑 +0.0F、-0.0F 以及 NaN 的情况。 3、除 long 和 double 外，其他基本类型与引用类型在解释执行的方法栈帧中占用的大小是一致的，但它们在堆中占用的大小确不同。在将 boolean、byte、char 以及 short 的值存入字段或者数组单元时，Java 虚拟机会进行掩码操作。在读取时，Java 虚拟机则会将其扩展为 int 类型。 4、将boolean 保存在静态域中,指定了其类型为’Z’,当修改为2时取低位最后一位为0,当修改为3时取低位最后一位为1。 则说明boolean的掩码处理是取低位的最后一位。
2018-09-18
优秀的个人博客,低调大师

Java语言中：float数据类型在内存中是怎么存储的？

=============================================================================java语言中，float类型数字在计算机中用4个字节来存储。遵循IEEE-754格式标准：即：一个浮点数有2部分组成：底数m和指数e---------------------------------------底数m部分：使用二进制数来表示此浮点数的实际值。指数e部分：占用8bit(1个字节)的二进制数，可表示数值范围为0-255。---------------------------------------但是指数可正可负，所以，IEEE规定，此处算出的次方必须减去127才是真正的指数。所以，float类型的指数可从-126到128。---------------------------------------底数部分实际是占用24bit(3个字节)的一个值，但是最高位始终为1，所以，最高位省去不存储，在存储中占23bit。---------------------------------------科学计数法。 格式： SEEEEEEE EMMMMMMM MMMMMMMM MMMMMMMM S表示浮点数正负； E表示指数加上127后的值后得二进制数据； M表示底数。 举例： 17.625在内存中的存储为： 首先要把17.625换算成二进制：10001.101--------------------------------------- 整数部分：除以2，直到商为0，余数反转。（即：模2取余法） 17 / 2 = 8 --- 1 8 / 2 = 4 --- 0 4 / 2 = 2 --- 0 2 / 2 = 1 --- 0 1 / 2 = 0 --- 1 小数部分：乘以2，直到乘位为0，进位顺序取。（即：乘2取整法） 按如下算法进行： 1）首先给小数部分乘2，得到的数，如果小数点前为1；则计1，为0，则计0。 2）再对剩下的小数部分乘2，再计出1或0。 3）重复以上步骤，直至达到需要的精度。 0.625 x 2 = 1.3 --- 计为1 0.3 x 2 = 0.6 --- 计为0 0.6 x 2 = 1.2 --- 计为1 0.2 x 2 = 0.4 --- 计为0 ......（算到需要的精度为止） 再例如： 0.5 x 2 = 1.0 --- 计为1 0 x 2 = 0 --- 结束 所以：0.5(D) = 0.1(B) 十 二 --------------------------------------- 再将10001.101右移，直到小数点前只剩1位： 1.0001101 * 2^4 因为右移动了四位，--------------------------------------- 这个时候，我们的底数和指数就出来了。 底数：因为小数点前必为1，所以IEEE规定只记录小数点后的就好。所以，此处的底数为：0001101， 指数：实际为4，必须加上127(转出的时候，减去127)，所以为131。也就是10000011， 符号部分是正数，所以是0。 综上所述，17.625在内存中的存储格式是： 01000001 10001101 00000000 00000000 --------------------------------------- 换算回去：自己做。=============================================================================我的GitHub地址： https://github.com/heizemingjun 我的博客园地址： http://www.cnblogs.com/chenmingjun 我的蚂蚁笔记博客地址： http://blog.leanote.com/chenmingjun Copyright ©2018 黑泽明军 【转载文章务必保留出处和署名，谢谢！】
2018-02-04
优秀的个人博客,低调大师

聊聊MapReduce处理过程中的数据类型与数据格式

MapReduce处理过程总览 对于MP的处理过程我想大部分人都已经知道了其原理，思路不难，这是肯定的，但是整个过程中需要考虑的细枝末节的点还挺多的，MP的输入输出格式就是其中的一点，那本文就带领大家看看MP中的格式设置问题。 map函数，起到了如下的转换作用：map：(k1,v1)—>list(k2,v2) reduce 函数，则起到了这样的格式转换作用：reduce：(k2,list(v2))—>list(k3,v3) 怎么，你说你看不懂?那看来你还是没有对mapreduce的过程有所理解，看看这幅图，不需要解释，你就明白上面的格式转化是什么意思了： 上面这幅图出自我的另外一篇博文：编写自己的第一个Hadoop实例，如果你设置了combiner函数，那么中间的格式转化将会是这个样子： map：(k1,v1)—>list(k2,v2) combiner：(k2,list(v2))—>list(k2,v2) reduce：(k2,list(v2))—>list(k3,v3) 是的，没错，combiner从功能上来讲就是一个reducer，它的存在大大减小了reducer的压力。 partition函数对中间结果(k2,v2)进行处理，返回一个索引值，即分区号 partition：(k2,v2)—>integer 在前面的文章中，也就是我的博客：MapReduce输入分片详解中，我提到了分片是与map函数数量相等，同时它不是咱们想的那样是一个实物分片，在程序上输入分片在java中表现为InputSplit接口 publicabstractclassInputSpilt{ publicabstractlonggetLength(); publicabstractString[]getLoacations(); } 存储位置供mapreduce使用，以便使map任务尽量在分片附近。分片大小是用来对分片进行排序，以便优先处理最大的最大分片，从而最小化时间。InputSplit不需要MR开发人直接处理，而是由InputFormat创建。 客户端通过调用InputFormat的getSplits()计算分片，然后将他们送到application master(或jobtracker)，am使用存储位置信息调度map任务在tasktracker上处理这些分片数据。map任务把输入分片传递给InputFormat的getRecordReader()方法来获得这个分片的RecordReader。RecordReader类似迭代器，对map任务进行迭代，来生成键/值对，然后传递给map函数。也就是说InputFormat不仅仅可以计算分片，进行数据分割，还可以对分片进行迭代，也就是说获得分片的迭代器，所有有关分片的操作都由InputFormat来支持，可见其强大性。 输入格式 那既然InputFormat这么牛逼，那我们就来看看这个接口到底包含了什么，先来看看下面这张图： FileInputFormat类 FileInputFormat是所有文件作为数据源的InputFormat的实现类，主要有两个功能：指定输入文件位置和输入文件生成分片的实现代码段。换句话说，它并不生成分片，只是返回文件位置，并且实现了分片算法。 FileInputFormat指定输入路径 addInputPath(Jobjob,Pathpath); addInputPaths(Jobjob,Stringpaths); setInputPaths(Jobjob,Path...inputPaths); 可以添加一个路径或者多个路径，其中setInputPaths是以此设定完成的路径列表。其中路径可以是一个文件、一个目录、或者一个glob(通配，通过通配符来获取路径)，当路径是一个目录的时候表示包含目录下的所有文件。当目录中包含目录的时候，这个目录也会被解释称文件，所以会报错。可以通过使用一个文件glob或者一个过滤器根据命名模式限定选择目录中的文件。还可以通过设置属性mapred.input.dir.recursive为true强制对目录进行递归读取。如果需要排除目录中的个别文件，可以通过setInputPathFileter()设置一个过滤器来进行过滤，如果不设置过滤器，也会有默认的过滤器排除隐藏文件(以.和_开头的)。路径和过滤器业可以使用配置文件进行配置：mapred.input.dir和mapred.input.path.Fileter.class 小文件处理 (小文件是指比HDFS块小很多)在Hadoop中使用小文件的弊端： (1)、增加map开销，因为每个分片都要执行一次map任务，map操作会造成额外的开销 (2)、MapReduce处理数据的最佳速度就是和集群中的传输速度相同，而处理小文件将增加作业的寻址次数 (3)、浪费namenode的内存 解决方法： 使用SequenceFile将这些小文件合并成一个大文件或多个大文件：将文件名作为键，文本内容作为值。 但是如果HDFS中已经存在的大批小文件，可以使用CombinerFileInputFormat。 CombinerFileInputFormat把多个文件打包成一个文件以便每个mapper能够处理更过的数据 避免切分 有时候不需要将文件进行切分，mapper完整处理每个输入文件。例如检查一个文件的所有记录是否有序。 可以通过设置最小分片大小大于要处理的文件。第二种就是使用FileInputFormat的具体子类，并且重载isSplitable()方法，把返回值设置为false。 mapper中的信息 通过调用Mapper中的Context的getInputSolit()返回一个InputSplit，如果使用的是FileInputFormat，则可以强转为FileSplit，然后用此访问正在输入文件的路径getPath(),分片开始处的字节偏移量，getLength()分片的长度。 TextInputFormat 文本输入是默认的InputFormat，每条记录是一行输入，键是LongWritable类型，存储该记录在整个文件的字节偏移量。值是该行的内容，不包括终止符(回车、换行等)，它被打包成Text对象。 KeyValueTextInputFormat 当文件中的每一行是一个键/值对，使用某个分界符进行分割，如制表符。可以通过mapreduce.input.keyvaluelinerecordreader.key.value.seperator属性来指定分隔符。默认是一个制表符。其中这个键是分隔符前的文本，值是分隔符后的文本，其类型都是Text类型。如： line1:thisisline1text line2:thisisline2text 则被分为两条记录，分别是: (line1,thisisline1text) (line2,thisisline2text) NLineInputFormat 在TextInputFormat和KeyValueTextInputFormat中，每个mapper收到的输入行数并不确定，行数取决于输入分片的大小和行的长度。如果希望mapper收到固定行数的输入，可以使用NLineInputFormat作为InputFormat。与TextInputFormat奕扬，键是文件中行的字节偏移量，值是行的内容。 N是每个mapper收到的输入行数，默认是1。可以通过mapreduce.input.lineinputformat.linespermap属性设置。如： On the top of the Crumetty Tree The Quangle Wangle sat, But his face you could not see, On account of his Beaver Hat. 当N为2的时候，每个输入分片包含两行。 (0,On the top of the Crumetty Tree) (33,The Quangle Wangle sat,) 另一个mapper则收到后两行 (57,But his face you could not see,) (89,On account of his Beaver Hat.) StreamInputFormat 当解析XMl文件的时候可以使用StreamInputFormat，将stream.recordreader.class属性设置为org.apache.Hadoop.Streaming.StreamXmlRecordReader使用StreamXmlRecordReader类。具体实现(没用过)可以查看该类官方文档 SequenceFileInputFormat Hadoop顺序文件格式存储二进制的键/值对的序列。当需要使用顺序文件作为MapReduce的输入时，应该使用SequenceFileInputFormat。键和值由顺序文件指定，只需要保证map输入的类型匹配。 SequenceFileAsTextInputFormat SequenceFileAsTextInputFormat是SequenceFileInputFormat的变体，将顺序文件的键和值转化为Text对象。 SequenceFileAsBinaryInputFormat SequenceFileAsBinaryInputFormat是SequenceFileInputFormat的一种变体，获取顺序文件的键和值作为二进制对象。 MutipleInputs 一个MapReduce作业可能由多个输入文件，但所有文件都由同一个InputFormat和同一个mapper来处理。但是数据格式却有所不同，需要对不同的数据集进行连接操作。可以使用MutipleInputs类处理 DBInputFormat DBInputFormat用于使用JDBC从关系数据库中读取数据。需要注意在数据库中运行太多mapper读取数据，可能会使数据库受不了，所以一般使用DBInputFormat加载少量数据。可以现将数据导入到HDFS中，一般将关系性数据库中数据导入到HDFS中可以使用Sqoop 输出格式 TextOutputFormat 默认的输出模式TextOutputFormat，每条记录写为一行。键和值是任意的，因为TextOutputFormat都要将其toString()转换为字符串。键值默认使用制表符分割，可以使用mapreduce.output.textoutputformat.separator属性改变分割符 SequenceFileOutputFormat 将输出写为一个顺序文件，当输出需要作为后续的MapReduce输入的时候，这种输出非常合适，因为它格式紧凑，容易被压缩。 SequenceFileAsBinaryOutputFormat SequenceFileAsBinaryOutputForamt与SequenceFileAsBinaryInputFormat对应，将输出的键和值作为二进制格式写到SequenceFile容器中。 MultipleOutputFormat 有时候可能需要将每个reduce输出多个文件，可以使用MutltipleOutputFormat。 LazyOutputFormat 延迟输出，他是封装输出格式，可以保证指定分区第一条记录输出时才真正创建文件。 本文作者：牧师-Panda 来源：51CTO
2017-07-31

资源下载

更多资源
Mario

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

时间: 2026-10-18 大小: 211.28KB 下载: 56次
腾讯云软件源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

时间: 2026-08-21 大小: 1MB 下载: 10次
Spring

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

时间: 2026-08-21 大小: 5MB 下载: 2次
Sublime Text

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。

时间: 2026-08-21 大小: 9.84MB 下载: 40次
热门标签
DeepSeek Jdk25 OpenAi HarmonyOS6 Nacos3 SpringBoot4 SpringCloud Docker Kubernetes Service Mesh Redis Gemini3 Rocky

欢迎您来访！

登录后，您将获得更多功能！
热门文章
联系我们

有任何问题或合作意向欢迎联系我们

Email: 99873273@qq.com

QQ: 99873273

用户登录
用户注册