Array Basic

Array Basic.md

Array Basic

Array Custom

★ 初期化

// Int型の配列（初期化いろいろ）
var intArray: Array<Int> = Array<Int>.init([])
var intArray: Array<Int> = Array<Int>()
var intArray: Array<Int> = [Int].init([])f
var intArray: Array<Int> = [Int]()
var intArray: Array<Int> = []
var intArray: Array = Array<Int>()
var intArray: Array = [Int]()
var intArray: [Int] = Array<Int>()
var intArray: [Int] = [Int]()
var intArray: [Int] = []
var intArray = Array<Int>()
var intArray = [Int]()
var intArray = Array(Array<Int>())
var intArray = Array([Int]())

// Array<Int> = [Int], Array<Int>() = [Int]()

// 型を指定し値を入れて生成
var intArray = [Int](1...3)
var intArray = [Int]([1, 2, 3])
var intArray: [Int] = [1, 2, 3]
var intArray = Array<Int>(1..<4)
var intArray = Array<Int>([1, 2, 3])
var intArray: Array<Int> = [1, 2, 3]

// 型推論で生成
var intArray = [1, 2, 3]
var intArray = Array([1, 2, 3])
var intArray: Array = [1, 2, 3]

// 可変長引数での生成 [1, 2, 3]
var intArray = Array(arrayLiteral: 1, 2, 3)
var intArray = Array<Int>(arrayLiteral: 1, 2, 3)
var intArray = [Int](arrayLiteral: 1, 2, 3)

// 第２引数の値をcount個含む配列を生成 [0, 0, 0]
var intArray = [Int](count: 3, repeatedValue: 0)
var intArray = Array<Int>(count: 3, repeatedValue: 0)

// 開始位置、終了位置(終了位置は含まない)、間隔を指定してArrayを生成
var intArray = Array(0.stride(to: 10, by: 2))
//=> [0, 2, 4, 6, 8]

// Etc...
var intArray = (1..<4).map { $0 }
//=> [1, 2, 3]

// ----------------------

// Int型の配列
intArray.dynamicType
//=> Array<Int>.Type

// Optional型のInt型配列
var optionalIntArray: Optional<[Int]>
var optionalIntArray: [Int]?
var optionalIntArray: Optional<Array<Int>>
var optionalIntArray: Array<Int>?
//=> Optional<Array<Int>>.Type

// ImplicitlyUnwrappedOptional型のInt型配列
var implicitlyUnwrappedOptionalIntArray: ImplicitlyUnwrappedOptional<Array<Int>>
var implicitlyUnwrappedOptionalIntArray: ImplicitlyUnwrappedOptional<[Int]>
var implicitlyUnwrappedOptionalIntArray: Array<Int>!
var implicitlyUnwrappedOptionalIntArray: [Int]!
//=> ImplicitlyUnwrappedOptional<Array<Int>>.Type

// -----------------------

// Optional型のInt型配列
var optionalIntArray: [Int]? = nil
//=> Optional<Array<Int>>.Type

// Optional型のInt型の配列
var optionalIntArray: [Int?] = [nil]
//=> Array<Optional<Int>>.Type

// Optional型のOptional,Int型の配列
var optionalIntArray: [Int?]? = [nil] or nil
//=> Optional<Array<Optional<Int>>>.Type

★ Arrayに入れられる型いろいろ

// Int
var intArray: [Int] = []

// Float
var floatArray: [Float] = []

// Bool
var boolArray: [Bool] = []

// Array (Intの配列)
var arrayArray: [[Int]] = [[]]

// Dictionary(key: String: Value: String)
var dictionaryArray: [[String: String]] = []

// Tuple
var tupleArray: [(String, Int, [String: String])] = []

// Class
class MyClass {}
var myClassArray: [MyClass] = []

// Struct
struct MyStruct {}
var myStructArray: [MyStruct] = []

// enum
enum MyEnum {}
var myEnumArray: [MyEnum] = []

// Protocol
protocol MyProtocol {}
var myProtocolArray: [MyProtocol] = []

// AnyObject
var anyObjectArray: [AnyObject] = []

// Any
var anyArray: [Any] = []

// Func
var myFuncArray: [Int -> Int] = []

// Optional (Int?)
var optionalIntArray: [Int?] = []

★ Array基本操作

// Indexが存在するかどうかを判定する
let isIndexValid = array.indices.contains(index)

var intArray = [1, 2, 3]

var lazyValue = intArray.lazy
// mapやfilterなどの操作の実行を実際に値が必要になるまで遅らせることができるインスタンス列を返す
//=> LazyCollection<Array<Int>>

var count = intArray.count
//=> 3 配列の数を返す

var indicesValue = intArray.indices
//=> 0..<3 要素が存在する範囲を返す 終端の添字は最終要素の次の位置 (空配列の場合 0..<0)

for index in numArray.indices {
    print(index)
    // 2
    // 1
    // 0
}

// 逆順のindex
for index in numArray.indices.reverse() {
    print(index)
    // 0
    // 1
    // 2
}

// 先頭のindexを返す
let firstIndex = intArray.indices.first
//=> 0

// 最後のindexを返す
let lastIndex  = intArray.indices.last
//=> 2


var capacity = intArray.capacity
//=> 4 許容量(メモリを新規に獲得せずに格納できる要素数)を返す

intArray.reserveCapacity(10)
//=> 最小の許容量を指定する 配列が小さくてもこの容量は確保される

var value = intArray[1]
//=> 2 添字のIndexに格納されている値を返す

// --------------------------
// 範囲指定で取り出す ArraySlice型

var sliceValue = intArray[1..<3]
//=> [2, 3] 範囲指定して取り出した値はArray型では無くArraySliceという型である 
// public subscript (subRange: Range<Int>) -> ArraySlice<Element>

sliceValue.dynamicType
//=> ArraySlice<Int>.Type

sliceValue.count
//=> 2  countは現在の配列数が返される

var value1 = sliceValue[0]　
// ※エラー！ ArraySlice型の添字のアクセスは取り出す前の配列のIndexと同じ
var value2 = sliceValue[1]
//=> 2
var value3 = sliceValue[2]
//=> 3

// Array型で取り出したい場合は以下のようにArrayにする
var sliceValue = Array(intArray[1..<3])


// 範囲指定で取り出す Array型

var rangeValue = (1..<3).map { intArray[$0] }
//=> [2, 3] こちらはArray<Int>.Type

// --------------------------

var first = intArray.first
//=> 1 先頭の配列の値を返す array[0]

var last = intArray.last
//=> 3 最後の配列の値を返す array[array.count - 1]

var isEmpty = intArray.isEmpty
//=> false 配列が空かどうかの判定ture/falseを返す

var minValue = intArray.minElement()
//=> 1 配列の中で最小の値を返す

var maxValue = intArray.maxElement()
//=> 3 配列の中で最大の値を返す

var contains = intArray.contains(3)
//=> true 引数で渡した値が配列の中に存在するかどうかをBoolで返す

var indexOf = intArray.indexOf(3)
//=> 2 配列の中に引数で渡された値がある場合そのIndexを返す、無い場合はnilを返す

let startIndex = intArray.startIndex
//=> 0 配列の最初のIndexを返す

let endIndex = intArray.endIndex
//=> 3 末尾要素の次の位置の添字を返す

var startsWith = intArray.startsWith([1,2])
//=> true 配列が引数で渡した配列で始まっているかどうかを判定する、空配列の場合はtrueが返る

var prefixValue = intArray.prefix(2)
//=> [1, 2] 先頭からn個(要素数が満たない場合は全要素)の部分列を返す

var suffixValue = intArray.suffix(2)
//=> [2, 3] 末尾からn個(要素数が満たない場合は全要素)の部分列を返す

var prefixUpToValue = intArray.prefixUpTo(2)
//=> [1, 2] 先頭から指定位置(index)の前までの部分列（指定位置を含まない）を返す

var suffixFromValue = intArray.suffixFrom(2)
//=> [3] 指定位置(index)から末尾までの部分列を返す

var prefixThroughValue = intArray.prefixThrough(0)
//=> [1] 先頭から指定位置(index)までの部分列（指定位置を含む）を返す

// --- equal ---

var isEqual = intArray.elementsEqual([1, 2, 3])
//=> true 配列と引数で渡した配列が同じかどうかを判定して返す

var isEqual = intArray == [1, 2, 3]
//=> true 配列どうしが同じかどうかを判定して返す ※ elementは同じもので無くてもよい
var isEqual = intArray == ["1", "2", "3"]
//=> false

intArray.elementsEqual([1, 2])
//=> false 配列どうしが同じかどうかを判定して返す　※比較するものは同じelement
intArray.elementsEqual(["1", "2"]) // エラー elementが不一致

// --- append ---

var newArray = intArray + [4, 5]
//=> [1, 2, 3, 4, 5] 配列同士を結合した新しい配列を返す

var newArray = intArray + (4...6)
var newArray = intArray + (4..<7)
//=> [1, 2, 3, 4, 5, 6] 範囲指定した配列を結合して新しい配列として返す

intArray.append(4)
//=> intArray = [1, 2, 3, 4] 配列自体の最後に引数の値を追加する

intArray += [4]
//=> intArray = [1, 2, 3, 4] 配列自体の最後に配列を結合する

intArray.appendContentsOf([4])
//=> intArray = [1, 2, 3, 4] 配列自体の最後に引数の配列を結合する

intArray.insert(4, atIndex: 2)
//=> [1, 2, 4, 3] 配列自体にIndexを指定して値を挿入する

intArray.insertContentsOf([4], at: 2)
//=> [1, 2, 4, 3] 配列自体にIndexを指定して引数の配列を挿入する

// --- replace ---

intArray[0...1] = [5, 4]
//=> [5, 4, 3] 配列自体に対して添字の範囲を代入した配列の値で置き換える

intArray.replaceRange(0...1, with: [5, 4])
intArray.replaceRange(0..<2, with: [5, 4])
//=> [5, 4, 3] 配列自体に対して引数の範囲を引数の配列の値で置き換える

// --- remove ---

var dropFirst = intArray.dropFirst()
//=> [2, 3] 先頭の配列を削除した結果を新しい配列として返す intArray = [1, 2, 3]

var dropFirst = intArray.dropFirst(2)
//=> [3] 配列の先頭から引数の数を削除した残りを新しい配列として返す intArray = [1, 2, 3]

intArray.removeFirst()
//=> 1 配列自体の最初の値を削除して返す intArray => [2, 3]

intArray.removeFirst(2)
//=> intArray = [3] 配列自体の先頭から引数の数を削除する

var dropLast = intArray.dropLast()
//=> [1, 2] 最後の配列を削除した結果を新しい配列として返す intArray = [1, 2, 3]

var dropLast = intArray.dropLast(2)
//=> [1] 配列の最後から引数の数を削除した残りを新しい配列として返す intArray = [1, 2, 3]

intArray.popLast()
//=> 3 配列自体の最後の値を削除して返す、配列が空の場合はnilを返す intArray => [1, 2]

intArray.removeLast()
//=> 3 配列自体の最後の値を削除して返す intArray => [1, 2]

intArray.removeAtIndex(1)
//=> 2 配列自体の引数で渡したIndexの値を削除して返す intArray => [1, 3]

intArray.removeRange(0...1)
//=> intArray = [3] 配列自体の引数で渡した範囲を削除する

intArray.removeAll()
//=> [] 配列自体を空の配列にする

intArray = []
//=> [] 配列自体を空の配列にする

intArray.removeAll(keepCapacity: true)
//=> [] 配列自体を空の配列にする メモリ範囲を保持するか引数で設定する falseにするとcapacityは0になる
//=> intArray.isEmpty → true , intArray.capacity → 4

// --- String Array ---

var strArray = ["1", "2", "3"]

//=> "1,2,3" 指定文字列で文字列配列を結合した値を返す where Generator.Element == String
var joinString = strArray.joinWithSeparator(",")

★ NSArray -> Array

let nsarray: NSArray = [1, 2, 3]
nsarray.dynamicType
//=> __NSArrayI.Type

let anyObjectArray = nsarray as Array
anyObjectArray.dynamicType
//=> Array<AnyObject>.Type

var value = anyObjectArray[0]
value.dynamicType
//=> __NSCFNumber.Type

var value = anyObjectArray[0] as! Int
value.dynamicType
//=> Int.Type

// ----------------------

let array: Array<Int> = nsarray as! Array
array.dynamicType
//=> Array<Int>.Type

let array = nsarray as! [Int]
array.dynamicType
//=> Array<Int>.Type

// ----------------------

// Optional NSArray

let array: NSArray = ["a", 2, 3, 4, 5]
array.writeToFile(path, atomically: true)

if let nsarray = NSArray(contentsOfFile: path) where nsarray is [Int] {

    // NSArrayが取得できて[Int]型にキャストできる時のみ実行
    let intArray = nsarray as! [Int]
}

// ----------------------

// NSArray of NSDictionary -> Array of Dictionary

var dict1 = NSDictionary(dictionary: ["key1": 1, "key2": 2])
var dict2 = NSDictionary(dictionary: ["key3": "value3", "key4": "value4"])
//=> __NSDictionaryI.Type

var dictMArray = NSMutableArray(arrayLiteral: dict1,dict2)
dictMArray.dynamicType
//=> __NSArrayM.Type

var dictArray  = NSArray(array: dictMArray)
dictArray.dynamicType
//=> __NSArrayI.Type

var dictarrary = dictArray as! [[String: AnyObject]]
dictarrary.dynamicType
//=> Array<Dictionary<String, AnyObject>>.Type

★ Array -> NSArray

var array: Array = [1, 2, 3]
array.dynamicType
//=>Array<Int>.Type

var nsarray = NSArray(array: array)
nsarray.dynamicType
//=> __NSArrayI.Type

var value = nsarray[0]
value.dynamicType
//=> __NSCFNumber.Type

// ----------------------

// Array of Dictionary -> NSArray of NSDictionary

var dict: [[String: AnyObject]] = [["key1": 1, "key2": 2], ["key3": "value3", "key4": "value4"]]
dict.dynamicType
//=> Array<Dictionary<String, AnyObject>>.Type

var nsdicarr: NSArray = NSArray(array: dict)
nsdicarr.dynamicType
//=> __NSArrayI.Type

★ generate()

var intArray = [1, 2, 3]

var generateValue = intArray.generate()
// 以下と同じ
var generateValue = IndexingGenerator<Array<Int>>([1, 2, 3])
// ジェネレーターのインスタンスを返す

var value1 = generateValue.next()
//=> 1
var value2 = generateValue.next()
//=> 2
var value3 = generateValue.next()
//=> 3

for i in generate {
    print(i)
}

//=>
1
2
3

★ enumerate()

var enumerate = intArray.enumerate()
// 以下と同じ
var enumerate = EnumerateSequence<Array<Int>>([1, 2, 3])
// 要素と通し番号をタプルにした列を返す

for (index,value) in enumerate {
    print("index = ",index,"value = ",value)
}

//=> 
index =  0 value =  1
index =  1 value =  2
index =  2 value =  3

★ reverse()

var reverse = intArray.reverse()
// 以下と同じ
var reverse = ReverseRandomAccessCollection<Array<Int>>([1, 2, 3])
// 列の要素を逆順に含む配列を作って返す

for i in reverse {
    print(i)
}

//=>
3
2
1

// reverse()を実行した戻りをArrayとして使用するならば以下の様にする
var reverse = Array(intArray.reverse())
//=> [3, 2, 1]

★ flatten()

var values = [[1, 2], [3, 4], [5, 6]]

var flatten = values.flatten()
// 以下と同じ
var flatten = FlattenBidirectionalCollection<Array<Array<Int>>>([[1, 2], [3, 4], [5, 6]])
// ネスト構造を平坦化し、インスタンスを順番に取り出せる構造体を返す

for i in values.flatten() {
    print(i)
}

//=>
1
2
3
4
5
6

★ split

let intArray = [1, 2, 3]

let splitValue = intArray.split { (i: Int) -> Bool in return i == 2 }
//=> [ArraySlice([1]), ArraySlice([3])] 指定した値が配列にある場合その値で配列を分割した新しい配列を返す
// 省略記法
let splitValue = intArray.split (isSeparator: { $0 == 2 })
let splitValue = intArray.split(2)

★ forEach

var intArr: [Int] = []
intArray.forEach ({ (i: Int) -> () in intArr.append(i * 2) })
//=> intArr = [2, 4, 6] 配列の全ての値に先頭から順にクロージャーを実行する intArray = [1, 2, 3]

// 省略記法
intArray.forEach { intArr.append($0 * 2)}

// -------------------

// filterとforEachの組み合わせ
let views:[UIView] = [UIView(), UIView(), UIView()]
views.filter { $0.tag > 5 }.forEach { $0.hidden = true }

★ filter

var filterValue = intArray.filter ({ (i: Int) -> Bool in return i > 2 })
//=> [3] 配列にクロージャーを実行してtrueのみを新しい配列として返す

// 省略記法
var filterValue = intArray.filter { $0 > 2 }

// クロージャーに関数を渡しても同じ事ができる
func filterFunc(value: Int) -> Bool {
    return value > 2
}
var filterValue = intArray.filter (filterFunc)

★ map

var mapValue = intArray.map ({ (i: Int) -> Int in return i * 2 })
//=> [2, 4, 6] 配列にクロージャーを実行した結果を新しい配列として返す intArray = [1, 2, 3]

// 省略記法
var mapValue = intArray.map { $0 * 2 }

// ------------------------

let year: [Int] = (1965...2015).map{ $0 }
//=> [1965, 1966, 1967....2015]

let year: [String] = (1965...2015).map{ String($0) }
//=> ["1965", "1966", "1967"...."2015"]

★ flatMap

// nilを含んだ配列
var intNilArray: [Int?] = [1, ,nil ,2, 3, nil]

var flatMapValue = intNilArray.flatMap { (i: Int?) -> Int? in return i }
//=> [1, 2, 3] 配列にクロージャーを実行した結果を新しい配列として返す。nilは返り値の配列に含まれない

// 省略記法
var flatMapValue = intNilArray.flatMap { $0 }

// 上記のmapと同じ事をしたい場合（nilを含まない配列に対して再度mapを実行する）
var map_flatMapValue = intNilArray.flatMap { $0 }.map { $0 * 2}
//=> [2, 4, 6]

★ sort

var sortArray = intArray.sort ({ (num1: Int, num2: Int) -> Bool in return num1 > num2 })
//=> [3, 2, 1] 引数で渡されたクロージャーの結果を新しい配列として返す intArray = [1, 2, 3]
// 省略記法
var sortArray = intArray.sort { $0 > $1 }
var sortArray = intArray.sort(>)

intArray.sortInPlace ({ (num1: Int, num2: Int) -> Bool in return num1 > num2 })
//=> intArray = [3, 2, 1] 配列自体にクロージャーの結果を反映する
// 
intArray.sortInPlace { $0 > $1 }
intArray.sortInPlace(>)

★ reduce

var reduceValue = intArray.reduce(0) { (num1: Int, num2: Int) -> Int in return num1 + num2 }
//=> 6 配列のすべての要素をまとめて1つの値に集約して返す。 この場合初期値を0 その値に全ての値を足している
// 省略記法
var reduceValue = intArray.reduce(0) { $0 + $1 }

// 末尾クロージャー以外の書き方
var reduceValue = intArray.reduce(0, combine: +)

★ Array関数組み合わせ

let dat = [2, 80, 45, 13]

//10以上を昇順に並べて文字列に変換する
let strArray = dat.filter{ $0 >= 10}.sort{ $0 < $1}.map{ "\($0)" }
strArray
//=> ["13", "45", "80"]

//10以上の要素を全て足す
let sumThanTenNumber = dat.filter{ $0 >= 10}.reduce(0){ $0 + $1 }
sumThanTenNumber
//=> 138

★ ブロック省略記法

var intArray = [1, 2, 3]

// 全て記述した場合
var sortArray = intArray.sort ({ (num1: Int, num2: Int) -> Bool in return num1 > num2 })

// 引数の型と戻り値の型を省略
var sortArray = intArray.sort ({ (num1, num2) in return num1 > num2 })

// ()を省略
var sortArray = intArray.sort ({ num1, num2 in return num1 > num2 })

// returnを省略
var sortArray = intArray.sort ({ num1, num2 in num1 > num2 })

// ショートハンド引数名を使用する
var sortArray = intArray.sort ({ $0 > $1 })

// 最後の引数がブロックの時は{}を外に出せる
var sortArray = intArray.sort(){ $0 > $1 }

// ブロック以外の引数がない場合、()も省略できる
var sortArray = intArray.sort { $0 > $1 }

//=> sortArray = [3, 2, 1]

// -------------

// 変数自体を逆順にソートする場合
intArray.sortInPlace { $0 > $1 }
//=> intArray =  [3, 2, 1]

// -------------

// オペレータ関数（Operator Functions）を使う方法
var sortArray = intArray.sort(>)

★ 多次元配列

// 2次元配列(Two-dimensional array)
var value = (1...3).map { [$0, $0 + 1] }
//=> [[1, 2], [2, 3], [3, 4]]

// 型推論
var value = [[1, 2], [2, 3], [3, 4]]

// 型指定
var value: [[Int]] = [[1, 2], [2, 3], [3, 4]]
var value = [[Int]]([[1, 2], [2, 3], [3, 4]])
var value: Array<Array<Int>> = [[1, 2], [2, 3], [3, 4]]
var value = Array<Array<Int>>([[1, 2], [2, 3], [3, 4]])

value.dynamicType
//=> Array<Array<Int>>.Type

// 値へのアクセス(取得)
value[1][0]
//=> 2

// 値へのアクセス(代入)
value[1][0] = 5
//=> [[1, 2], [5, 3], [3, 4]]

// 値の削除
value[1].removeAtIndex(0)
//=> 2 削除した値が返される
//=> value = [[1, 2], [3], [3, 4]]

★ Int配列の最大値、最小値を取得

let numbers = [8, 7, 3, 2, 4, 6]

let minNum = numbers.min()
//=> 2

let maxNum = numbers.max()
//=> 8

★ Int型の可変長引数の最大値、最小値を取得

min(8, 7, 3, 2, 4, 6)
//=> 2

max(8, 7, 3, 2, 4, 6)
//=> 8

★ メソッドチェーン

① flatMapでIntに変換できないもの(nil)を排除する
② filterで値が2より小さいものを抽出する
③ mapで値を2倍する

let value = ["1", "2", "3", ""].flatMap { Int($0) }.filter { $0 < 2 }.map { $0 * 2 }
//=> value = [2]

★ メソッドチェーンが長すぎるとエラーでコンパイルできない

// 型推論不可
let value = ["4", "", "3", "2", "1"].flatMap { Int($0) }.filter { $0 < 3 }.map { $0 * 2 }.sort(>)
// Error!  Expression was too complex to be solved in reasonable time; consider breaking up the expression into distinct sub-expressions

// ギリギリ型推論できる
let value: [Int] = ["4", "", "3", "2", "1"].flatMap( {(s:String) -> Int? in return Int(s)}).filter { (i: Int) -> Bool in return i < 3 }.map { $0 * 2 }.sort(>)
value
//=> value = [4,2]

// 全て記述した場合
let value: [Int] = ["4", "", "3", "2", "1"].flatMap( {(s:String) -> Int? in return Int(s)}).filter ({ (i: Int) -> Bool in return i < 3 }).map ({ (i: Int) -> Int in return i * 2 }).sort ({ (i: Int, ii: Int) -> Bool in return i > ii })
value
//=> value = [4,2]

★　タプルから配列を生成する

// ※ この記述だと取り出した後にキャストしないと使用できない ※

let values = (1.0, 2, ["a", "b", "c"], NSDate(), [6: "dict"], "7")

var array = Array(Mirror(reflecting: values).children.map { $0.value })
array.dynamicType
//=> Array<protocol<>>.Type


var a = array[0]
a.dynamicType
//=> Double.Type

let b = array[1]
b.dynamicType
//=> Int.Type

let c = array[2]
c.dynamicType
//=> Array<String>.Type

let d = array[3]
d.dynamicType
//=> __NSDate.Type

let e = array[4]
e.dynamicType
//=> Dictionary<Int, String>.Type

let f = array[5]
f.dynamicType
//=> String.Type

// protocol<>型なのでキャストしないと使用不可
var str = f as! String + "abc"

// --------------------

// 変換時にキャストをするとそのまま使用できる(違う型が入っていた場合落ちる)
let tuple = (1, 2, 3, 4)

var intArray = Array(Mirror(reflecting: tuple).children.map { $0.value as! Int })
//=> Array<Int>.Type

★ extension

// NSMutableArray(removeObject(anObject: AnyObject)) in Swift

extension RangeReplaceableCollectionType where Generator.Element : Equatable {
    
    // Remove first collection element that is equal to the given `object`:
    mutating func removeObject(object : Generator.Element) {
        if let index = self.indexOf(object) {
            self.removeAtIndex(index)
            self.removeObject(object)
        }
    }
}


var array = [1, 2, 3, 2]
array.removeObject(2)
print(array)
//=>  [1, 3]

var array = NSMutableArray(array: [1, 2, 3, 2])
array.removeObject(2)
//=>  [1, 3]