Array Capacity VS Length
๋ง์ฝ ๋๊ตฐ๊ฐ๊ฐ ๋น์ ์๊ฒ DVD ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ ์ผ๋ง๋ ๋๋์ง ๋ฌผ์ด๋ณธ๋ค๋ฉด, ๋น์ ์ ๋๋ต์ ๋ฌด์์ผ๊น์?
๋น์ ์ ๋ ๊ฐ์ง ๋ค๋ฅธ ๋๋ต์ ํ ์ ์์ต๋๋ค.
- ์์๊ฐ ๊ฐ๋ ์ฐจ์์ ๊ฒฝ์ฐ, ์์๊ฐ ๋ด์ ์ ์๋ DVD์ ์, ๋๋
- ํ์ฌ ์์์ ๋ค์ด์๋ DVD์ ์.
์ด ๋ ๋ต๋ณ์ ๋ชจ๋ ์ ํํ๋ฉฐ, ๋งค์ฐ ๋ค๋ฅธ ์๋ฏธ๋ฅผ ๊ฐ์ง๋๋ค!
์ด ๋์ ์ฐจ์ด๋ฅผ ์ดํดํ๊ณ ์ฌ๋ฐ๋ฅด๊ฒ ์ฌ์ฉํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค.
์ฐ๋ฆฌ๋ ์ฒซ ๋ฒ์งธ๋ฅผ ๋ฐฐ์ด์ โ์ฉ๋โ์ด๋ผ๊ณ ๋ถ๋ฅด๊ณ , ๋๋ฒ์งธ๋ฅผ โ๊ธธ์ดโ๋ผ๊ณ ๋ถ๋ฆ ๋๋ค.
Array Capacity
DVD[] array = new DVD[6]
array[6]
์ ์์๋ฅผ ์ฝ์
ํ๋ ๊ฒ์ด ์ ํจํ ์์
์ผ๊น์?
array[10]
์ ์ด๋จ๊น์?
์๋์, ์ด ๋ ๊ฒฝ์ฐ ๋ชจ๋ ์ ํจํ์ง ์์ต๋๋ค.
๋ฐฐ์ด์ ์์ฑํ ๋, ์ด ๋ฐฐ์ด์ด ์ต๋ 6
๊ฐ์ DVD๋ฅผ ๋ด์ ์ ์๋ค๊ณ ์ง์ ํ์ต๋๋ค.
์ด๊ฒ์ด ๋ฐฐ์ด์ ์ฉ๋์
๋๋ค.
์ธ๋ฑ์ฑ์ด 0
๋ถํฐ ์์ํ๋ค๋ ๊ฒ์ ๊ธฐ์ตํ๋ค๋ฉด, ์ฐ๋ฆฌ๋ ์ค์ง array[0]
, array[1]
, array[2]
, array[3]
, array[4]
๊ทธ๋ฆฌ๊ณ array[5]
์๋ง ํญ๋ชฉ์ ์ฝ์
ํ ์ ์์ต๋๋ค.
array[-3]
, array[6]
, array[100]
๊ณผ ๊ฐ์ด ๋ค๋ฅธ ๊ณณ์ ์์๋ฅผ ๋ฃ์ผ๋ ค๊ณ ํ๋ฉด ArrayIndexOutOfBoundsExecption
์ผ๋ก ์ฝ๋๊ฐ ์ถฉ๋ํ๊ฒ ๋ฉ๋๋ค.
๋ฐฐ์ด์ ์ฉ๋์ ๋ฐฐ์ด์ด ์์ฑ๋ ๋ ๊ฒฐ์ ๋์ด์ผ ํฉ๋๋ค.
์ฉ๋์ ๋์ค์ ๋ณ๊ฒฝํ ์ ์์ต๋๋ค.
์ฐ๋ฆฌ๊ฐ ์ฌ์ฉํ ์ข
์ด ์์์ DVD๋ฅผ ๋ฃ๋ ๋น์ ๋ก ๋์๊ฐ ๋ณด๋ฉด, ๋ฐฐ์ด์ ์ฉ๋์ ๋ณ๊ฒฝํ๋ ๊ฒ์ ์ข
์ด ์์๋ฅผ ๋ ํฌ๊ฒ ๋ง๋ค๋ ค๋ ๊ฒ๊ณผ ๊ฐ์ต๋๋ค.
๊ณ ์ ๋ ํฌ๊ธฐ์ ์ข
์ด ์์๋ฅผ ๋ ํฌ๊ฒ ๋ง๋๋ ๊ฒ์ ๋นํ์ค์ ์ด๋ฉฐ, ์ปดํจํฐ์ ๋ฐฐ์ด์์๋ ๋ง์ฐฌ๊ฐ์ง์
๋๋ค!
๊ทธ๋ ๋ค๋ฉด 7๋ฒ์งธ DVD๋ฅผ ์ป์์ ๋, ๋ชจ๋ DVD๋ฅผ ๊ฐ์ ๋ฐฐ์ด์ ๋ฃ๊ณ ์ถ๋ค๋ฉด ์ด๋ป๊ฒ ํ ๊น์?
๋ถํํ๋ ์ข
์ด ์์์ ๊ฒฝ์ฐ์ ๋ง์ฐฌ๊ฐ์ง์
๋๋ค.
๋ ํฐ ์์๋ฅผ ์๋ก ๊ตฌํด์, ๊ธฐ์กด์ DVD๋ค๊ณผ ์๋ก์ด ๊ฒ์ ๋ชจ๋ ์ฎ๊ฒจ์ผ ํฉ๋๋ค
์๋ฐ์์ ๋ฐฐ์ด์ ์ฉ๋์ ๋ฐฐ์ด์ length
์์ฑ๊ฐ์ ํ์ธํจ์ผ๋ก์จ ์ ์ ์์ต๋๋ค.
์ด๋ arr.length
๋ผ๋ ์ฝ๋๋ฅผ ์ฌ์ฉํ์ฌ ํ์ธ๋๋๋ฐ, ์ฌ๊ธฐ์ arr
์ ๋ฐฐ์ด์ ์ด๋ฆ์
๋๋ค.
๋ค๋ฅธ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ค์ ๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ ํ์ธํ๋ ๋ฐ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ ์ฌ์ฉํฉ๋๋ค.
int capacity = array.length;
System.out.println("The Array has a capacity of " + capacity);
์ด ์ฝ๋๋ฅผ ์คํํ๋ฉด ๋ค์๊ณผ ๊ฐ์ ์ถ๋ ฅ์ด ๋์ต๋๋ค:
The Array has a capacity of 6
capacity property of Swift
Instance Property
capacity
๋ฐฐ์ด์ด ์๋ก์ด ์ ์ฅ ๊ณต๊ฐ์ ํ ๋นํ์ง ์๊ณ ๋ด์ ์ ์๋ ์์์ ์ด ์์
๋๋ค.
๋ชจ๋ ๋ฐฐ์ด์ ๊ทธ ๋ด์ฉ์ ์ ์ฅํ๊ธฐ ์ํด ํน์ ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์์ฝํฉ๋๋ค.
๋ฐฐ์ด์ ์์๋ฅผ ์ถ๊ฐํ๊ณ ๊ทธ ๋ฐฐ์ด์ด ์์ฝ๋ ์ฉ๋์ ์ด๊ณผํ๊ธฐ ์์ํ๋ฉด, ๋ฐฐ์ด์ ๋ ํฐ ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ํ ๋นํ๊ณ ๊ทธ ์์๋ค์ ์๋ก์ด ์ ์ฅ ๊ณต๊ฐ์ผ๋ก ๋ณต์ฌํฉ๋๋ค.
์๋ก์ด ์ ์ฅ ๊ณต๊ฐ์ ๊ธฐ์กด ์ ์ฅ ๊ณต๊ฐ ํฌ๊ธฐ์ ๋ฐฐ์์
๋๋ค.
์ด ์ง์์ ์ฑ์ฅ ์ ๋ต์ ์์ ์ถ๊ฐ ์์
์ด ํ๊ท ์ ์ผ๋ก ์์ ์๊ฐ ๋ด์ ์ด๋ฃจ์ด์ง๊ฒ ํ์ฌ, ๋ง์ ์ถ๊ฐ ์์
์ ์ฑ๋ฅ์ ํ๊ท ํํฉ๋๋ค.
์ฌํ ๋น์ ์ ๋ฐํ๋ ์ถ๊ฐ ์์
์๋ ์ฑ๋ฅ ๋น์ฉ์ด ๋ค์ง๋ง, ๋ฐฐ์ด์ด ์ปค์ง์ ๋ฐ๋ผ ๊ทธ๋ฐ ์์
์ ์ ์ ๋ ์์ฃผ ๋ฐ์ํฉ๋๋ค.
๋ค์ ์์๋ ๋ฐฐ์ด ๋ฆฌํฐ๋ด๋ก๋ถํฐ ์ ์ ๋ฐฐ์ด์ ์์ฑํ ๋ค์, ๋ค๋ฅธ ์ปฌ๋ ์
์ ์์๋ค์ ์ถ๊ฐํฉ๋๋ค.
์ถ๊ฐ ํ๊ธฐ ์ ์, ๋ฐฐ์ด์ ๊ฒฐ๊ณผ ์์๋ค์ ์ ์ฅํ ์ ์์ ๋งํผ ์ถฉ๋ถํ ํฐ ์๋ก์ด ์ ์ฅ ๊ณต๊ฐ์ ํ ๋นํฉ๋๋ค.
var numbers = [10, 20, 30, 40, 50]
// numbers.count == 5
// numbers.capacity == 5
numbers.append(contentsOf: stride(from: 60, through: 100, by: 10))
// numbers.count == 10
// numbers.capacity == 10
Array Length
๊ธธ์ด(length) ์ ๋ ๋ค๋ฅธ ์ ์๋ ๋ฐฐ์ด์ ํ์ฌ ๋ค์ด ์๋ DVD์ ์, ๋๋ ๋ค๋ฅธ ํญ๋ชฉ๋ค์ ์์
๋๋ค
์ด๊ฒ์ ์ง์ ์ถ์ ํด์ผ ํ ๊ฒ์ด๋ฉฐ, ๊ธฐ์กด DVD๋ฅผ ๋ฎ์ด์ฐ๊ฑฐ๋ ๋ฐฐ์ด์ ๊ณต๋ฐฑ์ ๋จ๊ฒจ๋์ด๋ ์ค๋ฅ๋ ๋ฐ์ํ์ง ์์ต๋๋ค.
์ด์ ์์ ์์ length
๋ณ์๋ฅผ ์ฌ์ฉํ์ฌ ๋ค์ ๋น์ด ์๋ ์ธ๋ฑ์ค๋ฅผ ์ถ์ ํ๊ณ ์๋ ๊ฒ์ ๋์น์ฑ์ ์ ์์ต๋๋ค.
// ์ฉ๋์ด 6์ธ ์ ๋ฐฐ์ด์ ์์ฑํฉ๋๋ค.
int[] array = new int[6];
// ํ์ฌ ๊ธธ์ด๋ 0์ด๋ฉฐ, ์์๊ฐ 0๊ฐ ์๊ธฐ ๋๋ฌธ์
๋๋ค.
int length = 0;
// ๊ทธ ์์ 3๊ฐ์ ํญ๋ชฉ์ ์ถ๊ฐํฉ๋๋ค.
for (int i = 0; i < 3; i++) {
array[i] = i * i;
// ์์๋ฅผ ์ถ๊ฐํ ๋๋ง๋ค ๊ธธ์ด๊ฐ 1์ฉ ์ฆ๊ฐํฉ๋๋ค.
length++;
}
System.out.println("๋ฐฐ์ด์ ์ฉ๋์ " + array.length + "์
๋๋ค.");
System.out.println("๋ฐฐ์ด์ ๊ธธ์ด๋ " + length + "์
๋๋ค.");
์ด ์ฝ๋๋ฅผ ์คํํ๋ฉด ๋ค์๊ณผ ๊ฐ์ ์ถ๋ ฅ์ด ๋์ต๋๋ค:
The Array has a capacity of 6
The Array has a length of 3
count property of Swift
Instance Property
count
๋ฐฐ์ด์ ์์(elements) ์ ์ ๋๋ค.
var count: Int { get }
Handling Array Parameters(๋ฐฐ์ด ๋งค๊ฐ๋ณ์ ์ฒ๋ฆฌํ๊ธฐ)
LeetCode์์์ ๋๋ถ๋ถ์ ๋ฐฐ์ด ๋ฌธ์ ๋ โ๊ธธ์ดโ๋ โ์ฉ๋โ ๋งค๊ฐ๋ณ์ ์์ด ๋งค๊ฐ๋ณ์๋ก ๋ฐฐ์ด์ ์ ๋ฌํฉ๋๋ค.
์ด๊ฒ ๋ฌด์จ ๋ป์ผ๊น์?
์๋ฅผ ๋ค์ด ์ค๋ช
ํด ๋ณด๊ฒ ์ต๋๋ค.
์ฌ๊ธฐ ๋น์ ์ด ํ๊ฒ ๋ ์ฒซ ๋ฒ์งธ ๋ฌธ์ ์ ์ค๋ช
์ด ์์ต๋๋ค.
โ์ด์ง ๋ฐฐ์ด์ด ์ฃผ์ด์ก์ ๋, ์ด ๋ฐฐ์ด์์ ์ฐ์๋ 1์ ์ต๋ ๊ฐ์๋ฅผ ์ฐพ์๋ผ.โ
๊ทธ๋ฆฌ๊ณ ์ฌ๊ธฐ ์ฃผ์ด์ง ์ฝ๋ ํ ํ๋ฆฟ์ด ์์ต๋๋ค.
class Solution {
public int findMaxConsecutiveOnes(int[] nums) {
}
}
์ ์ผํ ๋งค๊ฐ๋ณ์๋ 'nums'
์ธ๋ฐ, ์ด๋ ๋ฐฐ์ด์
๋๋ค. 'nums'
์ ๊ธธ์ด๋ฅผ ๋ชจ๋ฅด๋ฉด ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์์ต๋๋ค.
๋คํํ๋ ์ด๋ ๊ฐ๋จํฉ๋๋ค.
๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋ฐฐ์ด์ ๋ํ ์ถ๊ฐ ์ ๋ณด๊ฐ ์์๋๋ ๊ธธ์ด == ์ฉ๋ (length == capacity) ์ด๋ผ๊ณ ์์ ํ๊ฒ ๊ฐ์ ํ ์ ์์ต๋๋ค.
์ฆ, ๋ฐฐ์ด์ ๊ทธ ๋ฐ์ดํฐ๋ฅผ ๋ชจ๋ ๋ด๊ธฐ์ ์ ํํ ์ ํฉํ ํฌ๊ธฐ์
๋๋ค.
๋ฐ๋ผ์ .length
๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
ํ์ง๋ง ์กฐ์ฌํ์ธ์, ๋ฐฐ์ด์ 0๋ถํฐ ์์ํ๋ ์ธ๋ฑ์ค์
๋๋ค.
์ฉ๋(capacity)/๊ธธ์ด(length)๋ ํญ๋ชฉ์ ์์ด์ง ์ต๊ณ ์ธ๋ฑ์ค๊ฐ ์๋๋๋ค.
์ต๊ณ ์ธํ
์ค๋ .lenght -1
์
๋๋ค.
๋ฐ๋ผ์ ๋ฐฐ์ด์ ๋ชจ๋ ํญ๋ชฉ์ ์ํํ๊ธฐ ์ํด ๋ค์๊ณผ ๊ฐ์ด ํ ์ ์์ต๋๋ค.
class Solution {
public int findMaxConsectiveOnes(int[] nums) {
// ํํธ: ์ฌ๊ธฐ์ ๋ณ์๋ฅผ ์ด๊ธฐํํ๊ณ ์ ์ธํ์ฌ
// ์ฐ์๋ 1์ด ๋ช ๊ฐ์ธ์ง ์ถ์ ํฉ๋๋ค.
for (int i = 0; i < nums.length; i++) {
// nums[i] ์์๋ก ๋ฌด์ธ๊ฐ๋ฅผ ํฉ๋๋ค.
}
}
}
์ด๊ฒ์ด ๋ฐ๋ก ์์ํ๊ธฐ ์ํด ํ์ํ ๋ฐฐ์ด์ ๊ธฐ๋ณธ ์ฌํญ์ ๋๋ค!