Hyun's_Devlog

Array

배열(Array)이란, 같은 자료형들의 묶음 이라고 생각하면 된다. 같은 자료형의 여러 데이터를 순서대로 저장하는 변수이다.

var 배열이름 : [자료형] = [값1, 값2, 값3, 값4, ... ]

var 배열이름 : Array<자료형> = [값1, 값2, 값3, 값4, ... ]

var arr : [Int] = [20,10,40,70,10]	//배열변수 선언 및 초기화. 배열의 원소는 중복되어도 된다.

print("arr: \(arr)")    		//배열 호출
print("arr[0]: \(arr[0])")    		//배열원소 호출 ::> 배열변수[인덱스번호]
print("arr[1]: \(arr[1])")    		//배열원소 호출 ::> 배열변수[인덱스번호]
print("arr[2]: \(arr[2])")    		//배열원소 호출 ::> 배열변수[인덱스번호]
print("arr[3]: \(arr[3])")    		//배열원소 호출 ::> 배열변수[인덱스번호]
//print("arr[5]: \(arr[5])")    	//없는 원소는 호출 시 에러가 발생한다.

배열의 원소를 호출할 시 배열이름[인덱스번호] 형식을 통해 접근할 수 있다. 배열의 인덱스 번호는 0번부터 시작한다.

빈 배열 선언 및 초기화

//비어있는 배열 생성
var arr1:[Int]          		//초기화하지 않음. 호출불가
var arr2:[Int] = []     		//비어있는 배열로 선언 및 초기화

var arr3:[Int] = [Int]()      		//비어있는 배열로 선언 및 초기화.
var arr4:[Int] = Array<Int>() 		//비어있는 배열로 선언 및 초기화.

var arr5:Array<Int> = [Int]() 		//비어있는 배열로 선언 및 초기화.
var arr6:Array<Int> = Array<Int>() 	//비어있는 배열로 선언 및 초기화.

print("arr2:",arr2)
print("arr3:",arr3)
print("arr4:",arr4)
print("arr5:",arr5)
print("arr6:",arr6)

비어있는 배열을 넣는 방법은 여러가지가 있다. 좌항이나 우항에 한곳이라도 자료형이 명시되어있다면 한 쪽은 자료형 생략도 가능한 점을 알아두자. 변수와 마찬가지로 초기화하지 않은 배열은 호출이 불가능하다.

for문과의 조합

var arr_A = ["호랑이","표범","고양이","재규어","치타","퓨마"]

for i in arr_A{
    print(i)
}

예시와 같이 배열은 for문에서 사용할 경우 편리하게 사용 가능하다. for문의 임시상수 i는 열거형 데이터의 순번을 돌며 원소들을 하나씩 복사해온다는 장점이 있다.

var arr10 = [12,54,67,34,23,98,57,36]
var sum = 0

for i in arr10 {
    sum += i
    print("\(i): \(sum)")
}
print(sum)

배열 속 원소들의 합계를 간단하게 구할 수 있다.

요소추가

배열에 요소를 추가할 수 있는 여러가지 함수가 있다.

append(추가요소)

   ->   배열의 마지막에 요소를 추가한다.

insert(추가요소, at:인덱스)

   ->   인덱스 위치에 요소를 추가한다. 해당 인덱스에 있던 요소는 한자리 밀려난다.

insert(contentsOf:[ 추가요소1, 추가요소2, 추가요소3, ... ], at:인덱스)  

   ->   배열형태의 여러 요소를 해당 인덱스에 한번에 추가한다. 해당 인덱스에 있던 기존 요소는 다음으로 밀려난다.

var arr = [10,20,30]
print("arr: \(arr)")

arr.append(400)		//배열의 마지막 원소 뒤에 요소 400 추가
print("arr.append(400)")
print("arr: \(arr)")

arr.insert(35, at: 1)	//배열의 1번 인덱스 위치에 요소 35 추가
print("arr.insert(35, at: 1)")
print("arr: \(arr)")

arr.insert(contentsOf: [56,33,100], at: 1) //배열의 1번 인덱스에 여러 요소 한번에 추가
print("arr.insert(contentsOf: [56,33,100], at: 1)")
print("arr: \(arr)")

요소삭제

배열 속 요소를 삭제하는 여러가지 함수가 있다.

remove(at:인덱스)

   -> 해당 인덱스의 요소를 삭제한다. 삭제할 요소를 리턴해준다.

removeFirst()

   -> 배열의 가장 첫번째 요소를 삭제한다. 삭제할 요소를 리턴해준다.

removeLast()

   -> 배열의 가장 마지막 요소를 삭제한다. 삭제할 요소를 리턴해준다.

popLast()

   -> 배열의 가장 마지막 요소를 삭제한다. 삭제할 요소를 리턴해준다.(옵셔널)

removeSubrange(범위)

   -> 범위에 해당하는 인덱스의 요소를 삭제한다. 리턴요소가 없다.

dropFirst()

   -> 첫번째 요소를 제외하고 모든 요소을 리턴한다. 본배열에는 변경이 일어나지 않는다.

dropLast()

   -> 마지막 요소를 제외하고 모든 요소를 리턴한다. 본배열에는 변경이 일어나지 않는다.

var arr = [10,20,30,40,50,60,70]
print("arr: \(arr)")

var no = arr.remove(at: 2)          //2번 인덱스 요소 삭제, 삭제할 요소를 반환해준다.
print("arr.remove(): \(arr)")       //본배열에 2번인덱스요소가 삭제된다.
print("arr.remove() return: \(no)") //삭제된 요소는 반환되어 no변수에 복사된다.

no = arr.removeFirst()              //가장 첫번째 요소 삭제, 삭제할 요소를 반환해준다.
print("arr.removerFirst(): \(arr)")
print("arr.removerFirst() return: \(no)")

no = arr.removeLast()               //가장 마지막 요소 삭제, 삭제할 요소를 반환해준다.
print("arr.removerLast(): \(arr)")
print("arr.removerLast() return: \(no)")

no = arr.popLast()!     	//마지막 요소 삭제, 삭제요소 반환. popFirst()는 없다.
print("arr.popLast(): \(arr)")
print("arr.popLast() return: \(no)")

arr = [10,20,30,40,50,60,70]
print("arr:\(arr)")

var sub = arr.removeSubrange(2...4)    //범위삭제. 리턴요소가 없다. 2번, 3번, 4번 인덱스의 요소 삭제.
print("arr.removeSubrange(2...4): \(arr)")
print("arr.removeSubrange(2...4) return: \(sub)")

var arr2 = arr.dropFirst()  	//본 배열에는 변경없음. 첫번째 요소를 제외하고 리턴을 준다.
print("arr: \(arr)")
print("arr.dropFirst() : \(arr2)")

arr2 = arr.dropLast()  		//본 배열에는 변경없음. 마지막 요소를 제외하고 리턴을 준다.
print("arr: \(arr)")
print("arr.dropLast() : \(arr2)")

인덱스

index(of:요소)

   -> 요소가 위치한 인덱스를 반환한다. 여러개가 있을경우, 그중 가장 첫번째 요소의 인덱스를 반환 (옵셔널)

firstIndex(of:요소).    *index(of: )와 같은 함수. 더 이상 index(of:)는 사용하지 않는다.

   -> 요소가 위치한 인덱스를 반환한다. 여러개가 있을경우, 그중 가장 첫번째 요소의 인덱스를 반환 (옵셔널)

lastIndex(of:요소)

   -> 요소가 위치한 인덱스를 반환한다. 여러개가 있을경우, 그중 가장 마지막 요소의 인덱스를 반환 (옵셔널)

arr = [11,44,22,33,44,66,88,33,44,88,66,44,22]
print("arr: \(arr)")

print("arr.index(of: 44)!:",arr.index(of: 44)!)   //해당 요소가 어느 인덱스에 위치하는지 찾아준다. (옵셔널)
print("arr.index(of: 88)!:",arr.index(of: 88)!)   //해당 요소가 어느 인덱스에 위치하는지 찾아준다.
print("arr.index(of: 100):",arr.index(of: 100))   //해당 요소가 어느 인덱스에 위치하는지 찾아준다.
						  //옵셔널이기에 요소가 없다면 nil이 반환된다.
print("arr.firstIndex(of: 44)!:",arr.firstIndex(of: 44)!) //해당 요소 중 첫번째 인덱스를 찾아준다. (옵셔널)
print("arr.lastIndex(of: 44)!:",arr.lastIndex(of: 44)!)  //해당 요소 중 마지막 인덱스를 찾아준다. (옵셔널)

그렇다면 배열의 중간에 위치한 44의 인덱스를 알고싶은 경우는 어떻게 해야할까? 

arr = [11,44,22,33,44,66,88,33,44,88,66,44,22]

arr2 = arr[2...8]
print(arr2)
print(arr2.index(of:44)!) //-> 배열을 옮겨 담아도 기존에 있었던 인덱스 번호를 그대로 가지고 온다.

//그렇다면 나는 중간에 위치한 44의 인덱스를 찾고싶다.
print("arr의 중간 인덱스:",arr[(arr.firstIndex(of: 44)!+1) ..< (arr.lastIndex(of: 44)!)].firstIndex(of: 44)!)

배열의 범위를 제한하여 찾을 수 있다. 즉 첫 번째 44의 인덱스 이후 ~ 마지막 44의 인덱스 이전 이라는 범위에서 44의 첫 번째 인덱스를 검색하면 중간에 위치한 인덱스를 찾게된다. 

요소

contains(요소)

   -> 요소가 존재하는지 bool형태를 반환하여 알려준다.

replaceSubrange(범위, with=[ 요소1, 요소2, 요소3, ... ])

   -> 범위에 해당하는 인덱스의 명시한 요소들로 바꾼다.

count

   -> 요소의 갯수를 반환해준다.

arr = [11,22,33,44,55,66,77,88,99]
print("arr:",arr)

print(arr.contains(44))   //요소 중 44가 존재하는지 알려준다.
print(arr.contains(100))   //요소 중 100이 존재하는지 알려준다.

arr.replaceSubrange(2..<4, with: [100,200,300])     //2,3번째 요소를 [100,200,300]으로 교체
print("after \"arr.replaceSubrange(2..<4, with: [100,200,300]\" : \(arr)")

print("arr:",arr)
print("arr.count:",arr.count) //원소갯수 출력

정렬

reverse()

   -> 현재 배열을 역순으로 정렬한다. 리턴값은 없다. 

reversed()

   -> 현재 배열의 역순을 리턴한다. 본 배열은 바뀌지 않는다.

var arr = [11,33,55,44,22,66,77,88,99]		//기존 배열 생성

print("arr:\(arr)\n")				//기존 배열 출력

var arr2 = arr.reversed()			//반전된 값을 arr2로 리턴
print(arr2)					//arr2 출력

print("arr.reversed():",terminator: "")		//줄바꿈 없이 출력
for i in arr2{
    print(i,"",separator: " ",terminator: "")	//줄바꿈 없이 출력
}
print("\n")

print("arr:\(arr)")				//기존배열 출력. 변화가 없다는 것을 확인.

arr.reverse()					//기존 배열을 반전.
print("arr.reverse():\(arr)")			//기존 배열 출력

sort()

   -> 현재 배열을 오름차순으로 정렬한다. 리턴값은 없다. (by:<)가 기본값으로 생략되어있다.

sort(by:<)

   -> 현재 배열을 오름차순으로 정렬한다. 리턴값은 없다.

sort(by:>)

   -> 현재 배열을 내림차순으로 정렬한다. 리턴값은 없다.

var arr = [11,33,55,44,22,66,77,88,99]
print(arr)	//기존배열 출력

arr.sort(by:<)	//기존 배열 오름차순 정렬
print(arr)

arr.sort(by:>)	//기존 배열 내림차순 정렬
print(arr)

arr.sort()	//기존 배열 오름파순 정렬
print(arr)

var txtArr = ["현빈","김우빈","원빈","투빈","장희빈","미스터빈"]
print(txtArr)

txtArr.sort() //문자열 배열도 정렬이 가능하다.
print("text.sort():",txtArr)

sorted()

   -> 현재 배열을 오름차순으로 정렬하여 리턴한다. 본 배열에는 변화가 없다. (by:<)가 기본값으로 생략되어있다.

sorted(by:<)

   -> 현재 배열을 오름차순으로 정렬하여 리턴한다. 본 배열에는 변화가 없다.

sorted(by:>)

   -> 현재 배열을 내림차순으로 정렬하여 리턴한다. 본 배열에는 변화가 없다.

print(arr)		//기존 배열 출력

print(arr.sorted(by:<))	//sorted(by:<)함수 리턴 출력

print(arr.sorted(by:>))	//sorted(by:>)함수 리턴 출력

print(arr.sorted())	////sorted()함수 리턴 출력

print(arr)		//기존배열 출력. 변화가 없다는 것을 확인할 수 있다.

대입

배열은 범위를 사용하여 대입연산이 가능하다.

arr = [11,22,33,44,55,66,77,88,99]
print("arr: \(arr)")

var arr2 = arr[2...4]   //arr의 2번부터 4번요소를 arr2에 대입
print("arr[2...4]: \(arr2)")

arr[5...7] = []     	//빈 배열을 대입하여 범위삭제도 가능하다.
print("after \"arr[5...7] =[]\" : \(arr)")

배열을 이용한 자료관리

배열은 같은 자료형만 묶을 수 있다. 따라서 복합적인 자료를 다룰 때에는 자료형에 맞는 배열을 여러개 생성하여 다룬다.

var name = ["한가인","두가인","삼가인","사가인","오가인"]	//이름이 담기는 배열 생성
var score = [78,56,91,85,64]				//점수를 담는 배열을 생성
var glass = [true, false, false, true, true]		//안경을 썼는지 여부를 담는 배열 생성

print("0: \(name[0]) \(score[0]) \(glass[0])")		//각 배열의 요소를 가져오는 방법.
print("1: \(name[1]) \(score[1]) \(glass[1])")
print("2: \(name[2]) \(score[2]) \(glass[2])")
print("3: \(name[3]) \(score[3]) \(glass[3])")
print("4: \(name[4]) \(score[4]) \(glass[4])")
print("--------------------------------------\n")

for i in 0 ..< name.count{    				//count를 사용하여 범위를 정한다.
    print("\(i): \(name[i]) \(score[i]) \(glass[i])")	//반복문을 사용하여 요소를 가져올 수 있다.
}

예시와 같이 반복문과 배열을 사용하면 복합적인 자료를 손쉽에 처리할 수 있다.