1๋
์ 3๋ฒ์ ๊ธฐ์ฌ ์ํ ์ค 1์ฐจ๋ 3์ฐจ ์ค ํ๋๋ ์ฝ๊ฒ ๋์ค๋ ํธ์ด๋ค.
์ฌํด 2์ฐจ ์ค๊ธฐ๋ ๋์ฒด๋ก ํ๋ฒํ ์์ค์ผ๋ก ์ถ์ ๋์๊ณ ํฉ๊ฒฉ๋ฅ 20%๋ฅผ ๊ธฐ๋กํ๋ค.
3์ฐจ๋ ์กฐ๊ธ ์ฝ๊ฒ ๋์ค์ง ์์๊น ๊ธฐ๋ํ์ผ๋ ๊ฒฐ๋ก ์ '์ด๋ ค์ ๋ค.'
IT์ปค๋ฎค๋ํฐ ์์ ๋น์์ ์ํ์ 639๋ช
์ ๋์์ผ๋ก ์ค๋ฌธ์กฐ์ฌ ํ ๊ฒฐ๊ณผ
- ์ ์ฒด์ ์ธ ์ฒด๊ฐ๋์ด๋๊ฐ '์ด๋ ค์ ๋ค'๊ณ ๋ตํ ์ฌ๋์ด 46.1%(299๋ช
)๋ก ์ ์ผ ๋ง์๊ณ
- ์ด์ด์ '๋งค์ฐ ์ด๋ ค์ ๋ค'๊ณ ๋ตํ ์ฌ๋์ด 23%(149๋ช
)๋ก ๊ทธ ๋ค์์ ์ฐจ์งํ๋ค.
- ์ฆ ์ด๋ฒ ์ํ์ 69.1%์ ์ํ์์ด ์ด๋ ต๋ค๊ณ ๋๋ ์ํ์ผ๋ก 10๋ช
์ค 7๋ช
์ด ์ด๋ ค์ํ๋ ์ํ์ด์๋ค.
๋ฌธ์ ์ ํ (20๋ฌธ์ )
- ์ด๋ก /์ฉ์ด ๋ฌธ์ (7๋ฌธ์ )
- ํ๋ก๊ทธ๋๋ฐ ์ธ์ด (9๋ฌธ์ )
- ๋ฐ์ดํฐ๋ฒ ์ด์ค (3๋ฌธ์ )
- ๊ณ์ฐ์ (1๋ฌธ์ )
# ์ด๋ก /์ฉ์ด ๋ฌธ์ (7)
๋ณด์ - ์ค๋จธํ/์ค๋จธํ
๋ณด์ - VPN
์น - URL
ํ์ดํธ๋ฐ์ค ํ
์คํธ์ ์ข
๋ฅ - ๋ฌธ์ฅ, ๋ถ๊ธฐ, ์กฐ๊ฑด
์ํํธ์จ์ด ๊ณตํ - ์ฐ๊ด, ์ผ๋ฐํ, ์์กด
๋์์ธํจํด - ํ์ํจํด
๋คํธ์ํฌ - ์ ๋ํน
# ํ๋ก๊ทธ๋๋ฐ ๋ฌธ์ (9)
OOAAA ๋ฌธ์
ํ์ด์ฌ์ ๋ฆฌ์คํธ ์ธ๋ฑ์ฑ
sum๊ตฌํ๊ธฐ
print(func()+func()+func())
์์๊ณผ ๋ฉ์๋์ค๋ฒ๋ผ์ด๋ฉ (์๋ฒ์ง๊ฐ ๋ ๋ณ์ ๋ฌธ์ , ๋ด๊ฐ ๋๋ฅผ ๋ณ์ ๋ฌธ์ )
๊ตฌ์กฐ์ฒด์ ํฌ์ธํฐ
๋ฐฐ์ด
์์ธ์ฒ๋ฆฌ(NullPointerException)
์ ๋ค๋ฆญ new Collection<>(0).print()
# ๋ฐ์ดํฐ๋ฒ ์ด์ค (3)
SQL select count(*)
๊ฐ์ฒด๋ฌด๊ฒฐ์ฑ
์ธ๋ํค/ํ๋ณดํค/๋์ฒดํค/์ํผํค
#๊ณ์ฐ์
ํ์ด์ง๋ถ์ฌ - LRU๊ธฐ๋ฒ์ผ๋ก 3์ฅ์ ํ์ด์ง์ 20๊ฐ์ ์ซ์ ์
์ถ๋ ฅํ๋ฉฐ ํ์ด์ง ๋ถ์ฌ ํ์ ๊ณ์ฐ
๋ฌธ์ 1
์๋ฐ ๋ฌธ์์ด ๋น๊ต
๋ฌธ์์ด์ ์ง์ ๋ฐฐ์ด์ ๋ฃ์ ๊ฒฝ์ฐ์
new String ์์ฑ์๋ฅผ ํตํด์ ๊ฐ์ ์ ๋ฌ ํด ์ค ๊ฒฝ์ฐ
ํด๋น ๋ฐฐ์ด ์์๋ค์ ๊ฐ์ ๊ฐ์ผ๋ก ์ธ์๋๋๊ฐ ์๋๊ฐ ๋น๊ตํ๋ ๋ฌธ์ (๋ฌธ์์ด ๋น๊ต)
- ๋ง์ฝ String์ด๋ผ๋ ์๋ฃํ์ด ๋ด๊ฐ ์ง์ ์์ฑํ ๊ฒ์ด๋ผ๋ฉด ์์ equals() ๋ฅผ ๊ตฌํ ํด ์ฃผ์ด์ผ ๋ฌธ์์ด์ด ๊ฐ์ ๊ฐ์ด๋ผ๊ณ ์ธ์๋๋ค.
- ํ์ง๋ง String ์ ๋ด๊ฐ ๋ง๋ ์๋ฃํ์ด ์๋๊ณ ์๋ฐ์์ ์ด๋ฏธ ๋ง๋ค์ด์ ธ ์๋ ๊ฒ์ด๊ณ equals()๊ฐ ๋ค ๊ตฌํ์ด ๋์ด ์๊ธฐ ๋๋ฌธ์
- ์ง์ ๊ฐ์ ์ง์ด ๋ฃ์ผ๋ ์์ฑ์๋ฅผ ํตํด ๋ฃ์ด ์ฃผ๋ ๊ฒฐ๊ตญ์๋ ๊ฐ์ ๊ฐ์ผ๋ก ์ธ์์ด ๋๋ค
- ๋ฐฐ์ด 0 ๋ฒ ์ธ๋ฑ์ค์ 1๋ฒ ์ธ๋ฑ์ค๋ ๊ฐ์ ๊ฐ์ด๋ ๊ฑธ ์ฝ๊ฒ ์ ์ ์๋๋ฐ, 1๋ฒ๊ณผ 2๋ฒ์ ๊ฐ์ ๊ฐ์ธ์ง ์๋์ง ํท๊ฐ๋ฆฌ๋ ๋ฌธ์ ์๋ค.
String[3] sM = new String[3];
void func(String[] sM, int size) {
for(int i = 1; i < size; i++) {
if(sM[i-1].equals(sM[i])) {
System.out.print("O");
} else {
System.out.print("N");
}
for (String m : sM) {
System.out.print(m);
}
}
}
void main() {
sM[0] = "A";
sM[1] = "A";
sM[2] = new String("A");
func(sM, 3);
}
์์ ๋ต์ : OOAAA
๋ฌธ์ 2
ํ์ด์ฌ ์ธ๋ฑ์ฑ ๋ฌธ์
- ์ธ๋ฑ์ค๊ฐ ์์(๋ง์ด๋์ค)์ธ ๊ฒฝ์ฐ ํด๋น ์ธ๋ฑ์ค์ ์์น๋ฅผ ์ดํดํ๊ณ ์๋๊ฐ
- ๋์
์ฐ์ฐ์ ์ ๋ค๋ก ๊ฐ์ด ๋ ๊ฐ์ฉ ์์ด์ ๋ค์ ์์ํ ํํ
def func(lst):
for i in range(len(lst) // 2):
lst[i], lst[-i-1] = lst[-i-1], lst[i]
lst = [1, 2, 3, 4, 5, 6]
func(lst)
print(sum(lst[::2]) - sum(lst[1::2]))
์์ ๋ต์ : 3
ํ์ด : 12-9
ํ๋ก๊ทธ๋๋ฐ ์ธ์ด ๋ฌธ์ ์ค์๋ ๊ทธ๋๋ง ์ฌ์ ๋ ๋ฌธ์ ์ด๋ค. ๋๋ ์ด ๋ฌธ์ ๋ฅผ ํ๋ ธ๋ค, ๋ต๊น์ง ๋ค ๊ตฌํด๋๊ณ 12์์ 9๋ฅผ ๋นผ์ผ ํ๋๋ฐ ๋ํด์ 21์ด๋ผ๊ณ ์ผ๋ค. ๊ฐ๋จํ ํ์ด ํ์๋ฉด ๋ฆฌ์คํธ์ ๊ธธ์ด 6์ 2๋ก ๋๋๋ฉด 3์ด ๋๋ค. ์ฆ ๋ฐ๋ณต๋ฌธ์ i = [0, 1, 2] ๋ก 3ํ ๋์๊ฐ๋ค. ์ด ๋ ๋ฐ๋ณต๋ฌธ์์ ์ํ๋๋ ํ๋ก๊ทธ๋จ์ ์์ชฝ ๋ ์ธ๋ฑ์ค์ ์์๋ฅผ ์๋ก ๋ฐ๊พธ๋ ๊ฒ์ด๋ค.
i๊ฐ 0์ผ๋ ํ ๋ฒ๋ง ๊ณ์ฐ์์ ์ํํด ๋ณด๋ฉด lst[0] , lst[-1] = lst[-1], lst[0] ์ฆ, 0๋ฒ ์ธ๋ฑ์ค์ -1๋ฒ์ ๋ฐ๊พธ๋ผ๋ ๊ฒ์ด๋ค...
์ด์ฒ๋ผ 0๋ฒ ์ธ๋ฑ์ค์ ์๋ ๊ฐ๊ณผ -1๋ฒ ๊ฐ์ด ๋ฐ๋๊ณ , 1๋ฒ๊ณผ -2, 2๋ฒ๊ณผ -3๋ฒ์ด ๋ฐ๋๋ฉฐ ์ต์ข
์ ์ผ๋ก ๋ฆฌ์คํธ์๋ ์ฒ์ ๋ฐฐ์ด์ ์์๊ฐ ์ญ์์ผ๋ก ๋ค์ด๊ฐ๊ฒ ๋๋ค.
์ด ๋ sum ํจ์๋ฅผ ์ํํ๊ธฐ ์ํด ์ธ๋ฑ์ฑ์ ํด ์ค์ผ ํ๋๋ฐ
lst[์ด๊ธฐ๊ฐ:๋๊ฐ:์ฆ๊ฐ]
์ด ๋ lst[::2]์ ์ด๊ธฐ๊ฐ๊ณผ ๋๊ฐ์ด ์ง์ ๋์ง ์์ ๊ฒฝ์ฐ ๋ฆฌ์คํธ์ ์ฒ์๋ถํฐ ๋์ด๋ผ๊ณ ๋ณด๊ธฐ ๋๋ฌธ์ 0๋ฒ ์ธ๋ฑ์ค๋ถํฐ 2์นธ์ฉ ๋์ด์ ๊ฐ์ ๋ํด๊ฐ๋ฉด ๋๋ค. 6,4,2์ ํฉ์ 12๊ฐ ๋๋ค. ๋ lst[1::2] ๋ 1๋ฒ์งธ ์ธ๋ฑ์ค์์๋ถํฐ 2์นธ์ฉ ๋๋ฉฐ ๊ฐ์ ๊ฐ์ ธ์์ผ ํ๋ฏ๋ก 5+3+1์ ํด์ 9๊ฐ ๋๋ค.
๊ฒฐ๊ตญ 12-9๋ 3์ด๋ค.
๋ฌธ์ 3
์ ์ ๋ณ์(static ๋ณ์)์ ์ดํดํ๋์ง & ๋ณ์์ ์ ํจ ๋ฒ์๋ฅผ ์๋์ง ์์๋ณด๋ ๋ฌธ์
์คํํฑ ๋ณ์๋ ์ฒ์์ ๋ฉ๋ชจ๋ฆฌ์ ์ฌ๋ผ์์ ํ ๋ฒ๋ง ์ด๊ธฐํ๋๊ณ , ๊ทธ ์ดํ์๋ ์ด๊ธฐํ ๊ตฌ๋ฌธ์ ์ํํ์ง ์๋๋ค.
๋ํ ์์
์ด ์ข
๋ฃ๋ ๋๊น์ง ๋ฉ๋ชจ๋ฆฌ์ ์ ์ง๋๋ฉฐ ๊ทธ ๊ฐ์ด ์ฌ์ฌ์ฉ๋๋ค.
๋ํ ๋ณ์์ ์ด๋ฆ์ด ๋์ผํ ๊ฒฝ์ฐ, (์ ์ ๋ณ์์ main์ ์ ์ญ๋ณ์์ ์ด๋ฆ์ด x๋ก ๋์ผ)
๊ณ์ฐ์ ์ํํ๋ฉด์ x๊ฐ ์ด๋ค ๊ฐ์ ๊ฐ๋ฆฌํค๋์ง ์๊ฐํด ๋ณผ ๋ฌธ์ ์ด๋ค
int increase() {
static x = 0;
x += 2;
return x;
}
int main() {
int x = 1;
int sum = 0;
for(int i = 0; i < 4; j++) {
x++;
sum+=increase();
}
print("%d", sum);
}
/* ์... ํฐ์คํ ๋ฆฌ ๋ธ๋ก๊ทธ๋ ํญ์ ์ฝ๋๋ธ๋ญ์์ ๋ค์ฌ์ฐ๊ธฐ ์ค๋ฅ๊ฐ ๋จ....
์ ๊ฐ ์๋ชป ์ด๊ฒ ์๋๊ณ , ์๊ณ ์ณ์ง...
์ ๋ฐ ํฐ์คํ ๋ฆฌ ๊ฐ๋ฐ์๋ค ์ด ์ค๋ฅ์ข ์์ ํด ๋ณด์ธ์....
ํ ๋๋ฒ์ด ์๋๊ณ ๋งค์ผ ๊ทธ๋์
๋ฉ์ธ ์์ญ์์ ํญํค ํ๋ฒ ๋๋ฅด๊ณ x์ ์ธ ํ๋๋ฐ
์ฝ๋๋ธ๋ญ ์์ฑ์ฐฝ ๋๊ฐ๋ฉด ํญํค ๋๋ฒ ๋๋ฅธ ์ํ๋ก ํํ๋จ..
๋ค์ ์ง์ฐ๊ณ ํด ๋ด๋ ๋ง์ฐฌ๊ฐ์ง.... */
์์ ๋ต์ : 20
ํ์ด:
main ์์ญ์ ์ ์ญ ๋ณ์๊ฐ 1๋ก ์ด๊ธฐํ ๋จ.
๊ทธ๋ฆฌ๊ณ ํด๋น for๋ฌธ์์ x++์ด ๊ฐ๋ฆฌํค๋ ๊ฒ์ main์์ญ์ ์ ์ญ๋ณ์์
4ํ ์ํ๋๋ ๋์ 1์ฉ ์ฆ๊ฐํ์ฌ ๋ฉ์ธ x๋ ์ต์ข
์ ์ผ๋ก 5๊ฐ์ด ๋๋
ํ์ง๋ง ํด๋น ์ ์ญ ๋ณ์๊ฐ์ ์ค์ํ๊ฒ ์๋๋ค...
๊ฒฐ๊ตญ sum๊ฐ์ ์ถ๋ ฅํด์ผ ํ๊ธฐ ๋๋ฌธ
sum์ increase() ํจ์๋ฅผ 4๋ฒ ํธ์ถํด์ ๋ฆฌํด๋ฐ์ ๊ฐ์ ๋์ ํฉ์ด๋ค.
์ฒ์ increase() ํธ์ถ์ static x๊ฐ 0์ผ๋ก ์ด๊ธฐํ ๋จ.
๊ทธ๋ฆฌ๊ณ ๋์ ๋ค์ ๋ฐ๋ณต๋ฌธ๋ถํฐ๋ ์ด๊ธฐํ ๊ตฌ๋ฌธ์ ์ํํ์ง ์๊ณ ๋ค์ ๊ตฌ๋ฌธ๋ถํฐ ์์ํจ. 4ํ ํธ์ถ๋๋ ๋์ static x๋ 2,4,6,8์ด ๋จ ๊ทธ๋ฆฌ๊ณ sum์ ๋์ ๋์ด ๊ทธ ํฉ์ 20
์ฌ๊ธฐ์ static๋ณ์๋ ํด๋์ค์ ์ํ๋ ๋ณ์๋ก ๋ชจ๋ ์ธ์คํด์ค๊ฐ ๊ณต์ ํ๋ ๋ณ์์ด๋ค.
๊ทธ๋์ ์ด ๋ณ์๋ ํด๋์ค๊ฐ ๋ฉ๋ชจ๋ฆฌ์ ๋ก๋ ๋ ๋ ํ ๋ฒ๋ง ์์ฑ๋๊ณ ์ข
๋ฃ๋ ๊น์ง ๋ฉ๋ชจ๋ฆฌ์ ์ ์ง๋๋ค...
๋ฌธ์ 4
๋ฐธ๋ฅ์ ํ์
๋น๊ต
ํ์ด์ฌ์์ ๋ฌธ์์ด "100.0" , ์ ์ํ100, ์ค์ํ100.0์ type(์๋ฃํ) ๋น๊ตํ๋ ๋ฌธ์
๋น๊ต๊ตฐ์ ํ์
์ด ๊ฐ์ผ๋ฉด ํด๋น ๋ฐธ๋ฅ์ 1์ ๋ํ๊ณ ,
ํด๋น ๊ฐ์ด Stringํ์
์ด๋ฉด ""(๋น ๋ฌธ์์ด)์ ํ์
๊ณผ ๊ฐ์ผ๋ฏ๋ก value์ ๊ธธ์ด๋ฅผ ๋ฆฌํด
์ ๋ ์กฐ๊ฑด์ ๋ง์กฑํ์ง ์์ผ๋ฉด 20์ ๋ฆฌํดํ๋ค.
func(a)๋ง elif ๋ธ๋ก์ ์กฐ๊ฑด์ ๋ง์กฑํด์ "100.0"์ ๊ธธ์ด์ธ 5๋ฅผ ๋ฆฌํดํ๊ณ ๋๋จธ์ง๋ ํด๋น ์ฌํญ ์์ด์ else๊ตฌ๋ฌธ์ ์ํํด์ ๊ฐ 20์ ๋ฆฌํด
5+20+20 ์ 45๋ค. ์ฌ๊ธฐ์ ์ค์ํ ๊ฒ์ 100.0์ ๊ธธ์ด ์
๋ ์ ๊น์ง ์ธ์ด์ผ ํ๋ค๋๊ฒ
๊ทธ๋ฆฌ๊ณ ์ด ๋ฌธ์ ํ๋ฉด์ ๊ถ๊ธํ๋ ๊ฑฐ๋ (100.0, 200.0)๋ ํ์
์ด ๋ญ์ง??
type(ํํ๋ช
) ํ๋ฉด ์๋ฃํ์ด ๋ญ๊ฐ ๋๋์ง ๊ถ๊ธํ๋ค
def func(value):
if type(value) == type(100):
return value+1
elif type(value) == type(""):
return len(value)
else:
return 20
a = "100.0"
b = 100
c = (100.0, 200.0)
print(func(a) + func(b) + func(c))
๋ฌธ์ 5
์๋ฐ์ ์์๊ณผ ๋ฉ์๋ ์ค๋ฒ๋ผ์ด๋ฉ(์ฌ์ ์ ๋ฌธ์ )
- ์๋ฐ์์ Derived ํด๋์๊ฐ Base ํด๋์ค๋ฅผ ์์ ๋ฐ์
- ์ด ๋ ๋๋ค ์ด๋ฆ์ด ๊ฐ์ ์ ์ํ ๋ณ์ x๋ฅผ ๊ฐ์ง
- ๋ฉ์๋๊ฐ ์ค๋ฒ๋ผ์ด๋ฉ ๋ ๊ฒฝ์ฐ ๋์ผํ ์ด๋ฆ์ ๋ฉ์๋ ์ค ํ์ํด๋์ค์ ์ฐ์ฐ์ ์ํํด์ผ ํจ
public class Base{
int x = 3;
int getX(){
return x * 2;
}
}
public class Derived extends Base{
int x = 7;
@Override
int getX(){
return x * 3;
}
}
main() {
Base a = new Derived();
Derived b = new Derived();
System.out.print(a.getX()+a.x+b.getX()+b.x);
}
์์๋ต์ : 52
ํ์ด :
๋ฉ์ธ ์์ญ์์ ์์
Base ํ์
์ ์ธ์คํด์ค a - ์๋ฒ์ง๊ฐ ๋ ๋ณ์ ํํ
Derived ํ์
์ ์ธ์คํด์ค b - ์์์ด ์์์ ๋ณ์ ํํ
a ์๋ Base.a = 3, Derived.a = 7 ๋ค์ด๊ฐ ์๋ ์ํ
b ์๋ Base.a = 3, Derived.a = 7 ๋ค์ด๊ฐ ์๋ ์ํ
a.getX() ์ค๋ฒ๋ผ์ด๋ฉ ํ์ผ๋ฏ๋ก ์๋ค์ getX() ์ํํด์ 7*3=21 ๊ฐ์ ธ์ด
a.x ์๋ฒ์ง์ x์ธ 3 ๊ฐ์ ธ์ด
b.getX() ์ค๋ฒ๋ผ์ด๋ฉ ํ์์ผ๋ก ์๋ค์ getX() ์ํํด์ 7*3=21 ๊ฐ์ ธ์ด
b.x ์๋ค์ x๊ฐ์ธ 7 ๊ฐ์ ธ์ด
21+3+7+21 = 52
์๋ฐ ๋คํ์ฑ ๊ฐ๋
๋๋ฌธ์ ๋ฉ์๋ ํธ์ถ ์ ๊ฐ์ฒด์ ์ค์ ํ์
(์ฌ๊ธฐ์๋ deprived)์ ๋ฐ๋ผ ์ค๋ฒ๋ผ์ด๋ฉ ๋ ๋ฉ์๋๊ฐ ํธ์ถ ๋๋ค.
a์ ํ์
์ Base ์ด์ง๋ง ์ค์ ๊ฐ์ฒด๋ derived๋ก ์์ฑ์ ํ์ ๊ธฐ ๋๋ฌธ์ derived ํด๋์ค์์ ์ค๋ฒ๋ผ์ด๋ฉ ๋ getX()๊ฐ ํธ์ถ๋จ
๊ทธ๋ฆฌ๊ณ ๊ทธ ์์์ ์ฌ์ฉ๋๋ x ๋ํ ํด๋น ์ฐ์ฐ์ด ์ด๋ฃจ์ด์ง๋ ๊ณต๊ฐ์ธ derived ์ x๊ฐ์ ๋งํ๋ค
๋ฌธ์ 6
C์ธ์ด ๊ตฌ์กฐ์ฒด์ ํฌ์ธํฐ ๋ฌธ์
์ด๋ฒ์ ์ถ์ ๋ ๋ฌธ์ ์ค ๊ฐ์ฅ ๊ธด ๋ฌธ์ ์ด๋ค. ์์ผ๋ก ์จ ๊ฐ๋ฉด์ ๊ฐ๋ง ์ ๋ฐ๋ผ๊ฐ๋ฉด ๋ฌด๋ฆฌ์์ด ํ ์ ์๋ ์ฌ์ด ๋ฌธ์ ์ด๋ค.
struct Node {
int Value;
Node* next;
}
void func(Node* node) {
while(node != NULL && node->next != NULL) {
int t = node->value;
node->value = node->next->value;
node->next->value = t;
node = node->next->next;
}
}
int main() {
Node n1{1, NULL};
Node n2{2, NULL};
Node n3{3, NULL};
n1.next = &n3;
n3.next = &n2;
func(n1);
Node* current = &n1;
while(current != NULL) {
print(current->value);
current = current->next;
}
}
์์ ๋ต์ : 312
main ์์ญ์์ 3๊ฐ์ ๊ตฌ์กฐ์ฒด ์์ฑ
์ ์ํ ๋ณ์ Value์ ํฌ์ธํฐ next๋ฅผ ๊ฐ์ผ๋ก ๊ฐ์ง
์ฃผ์๊ฐ(๊ฐ์ ) | Value | *next | |
100 | n1 | 1 | NULL |
200 | n2 | 2 | NULL |
300 | n3 | 3 | NULL |
n1์ next์ n3์ ์ฃผ์๊ฐ ๋ฃ๊ธฐ
n3์ next์ n2์ ์ฃผ์๊ฐ ๋ฃ๊ธฐ
๊ทธ๋ผ ์๋์ ๊ฐ์ ๋ชจ์ต์ด ๋๋ค
์ฃผ์๊ฐ(๊ฐ์ ) | Value | *next | |
100 | n1 | 1 | 300 |
200 | n2 | 2 | NULL |
300 | n3 | 3 | 200 |
์ด ๋ n1์ ๋งค๊ฐ๋ณ์๋ก func()๋ฅผ ํธ์ถํ๋๋ฐ
๋
ธ๋๊ฐ null๊ฐ์ด ์๋๊ณ ๋
ธ๋์ next๊ฐ์ด null๊ฐ์ด ์๋ ๋์์
int t ์ n1์ value ๊ฐ์ ๋ฃ์ด ์ฃผ๊ณ , n1์ value ๊ฐ ์๋ฆฌ์๋ ํด๋น next๊ฐ ๊ฐ๋ฆฌํค๋ ๊ณต๊ฐ์ value๊ฐ์ swap ํ๊ฒ ๋๋ค.
n1์ next๋ 300๋ฒ์ง๋ฅผ ๊ฐ๋ฆฌํค๋ฏ๋ก n3์ value ์ธ 3๊ณผ n1 ์ 1์ด ์๋ฆฌ๋ฐ๊ฟ ํ๋ค.
์ดํ ์ํ๋ node = node->next->next๊ตฌ๋ฌธ์ ๊ฒฐ๊ตญ null๊ฐ์ ๊ฐ๋ฆฌํค๋ฏ๋ก ์ฌ๊ธฐ์ ์ฐ์ฐ์ ์ข
๋ฃ๋๋ค.
node์ next๋ 300๋ฒ์ง๋ฅผ ๊ฐ์ง๋ฏ๋ก n3๋ฅผ ๊ฐ๋ฆฌํค๊ณ n3์ next๋ 200๋ฒ์ง๋ฅผ ์ฐธ์กฐํ๋ฏ๋ก ๊ฒฐ๊ตญ 200๋ฒ์ง ์
NEXT๊ฐ NULL์ด๋ผ while๋ฌธ์ด ์ข
๋ฃ๋๋ ๊ฒ
์ต์ข
์ ์ธ ๊ตฌ์กฐ์ฒด์ ๋ชจ์ต์ ์๋์ ๊ฐ๋ค
์ฃผ์๊ฐ(๊ฐ์ ) | Value | *next | |
100 | n1 | 3 | 300 |
200 | n2 | 2 | NULL |
300 | n3 | 1 | 200 |
๊ทธ๋ฆฌ๊ณ current ๋ผ๋ ๋
ธํธ ํ์
์ ํฌ์ธํฐ ๋ณ์๋ฅผ ์ ์ธํด ์ฃผ๋๋ฐ
๊ทธ ๊ฐ์ n1์ ์ฃผ์๊ฐ์ ์ฐธ์กฐํ๊ณ ์๋ค. ๊ทธ๋ฌ๋ฏ๋ก current๋ ๊ฒฐ๊ตญ n1๊ณผ ๊ฐ์๊ณต๊ฐ์ ๊ฐ๋ฆฌํค๋ ์
์ด๋ค
current๊ฐ null ๊ฐ์ด ์๋ ๋์ current์ value๋ฅผ ๋จผ์ ์ถ๋ ฅํ๊ณ ๋์ current์ next๊ฐ ๊ฐ๋ฆฌํค๋ ์ด๋ํ๋ค
์ฒ์์๋ n1์ด ๊ฐ์ง 3 ์ถ๋ ฅ ํ, 300๋ฒ์ง๋ก ๊ฐ์ n3์ 1์ ์ถ๋ ฅ, ๊ทธ๋ฆฌ๊ณ n3์ next๊ฐ ๊ฐ๋ฆฌํค๋ 200๋ฒ์ง์ 2๋ฅผ ์ถ๋ ฅํ๋ค
200๋ฒ์ง์๋ next ๊ฐ์ด NULL ์ด๋ฏ๋ก ํ๋ก๊ทธ๋จ์ด ์ข
๋ฃ ๋๋ค.
๋ฌธ์ 7
์์ธ์ฒ๋ฆฌ ๋ฌธ์
- func() ํจ์ ํธ์ถํ๋ฉด NullPointerException ๊ฐ์ ๋ก ๋ฐ์์ํด
- NullPointerException e ๋ธ๋ก์์ ์์ธ๋ฅผ ์ก์ ์ฃผ๋ฉด Exception e ๋ธ๋ญ์ ์ํ ์ ํจ
- finally ๊ตฌ๋ฌธ์ ๋ฌด์กฐ๊ฑด ์ํ๋๋ค.
public class ExceptionHandling {
public static void main(String[] args) {
int sum = 0;
try {
func();
} catch (NullPointerException e) {
sum = sum + 1;
} catch (Exception e) {
sum = sum + 10;
} finally {
sum = sum + 100
}
System.out.print(sum)
}
static void func() throws Exception {
throws new NullPointerException();
}
}
์์ ๋ต์ : 101
์? NullPointerException ์ด ์๋ catch ๋ธ๋ก ์ํ ํ finally ๋ธ๋ก ์ํํ๊ธฐ ๋๋ฌธ
ํฌ์ธํฐ์ ๋ฐฐ์ด ๋ฌธ์ ,
์ ๋ค๋ฆญ ๊ธฐ๋ฒ์ ํผ๊ณคํด์ ๋ค์์ ํฌ์คํ
....ใ
ใ
ใ
ใ
ใ
ใ
'Diary' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
โจ๋ฆฌ๋ ์ค๋ง์คํฐ 2๊ธ ์ทจ๋ ํ๊ธฐ (์ํ ๋ฐฉ์, ๊ณต๋ถ ๋ฐฉ๋ฒ, ๋์ด๋ ๋ฑ)โจ (4) | 2024.10.25 |
---|---|
์ฐ์ธํ ๋ ๋ณด๋ ์์ ใ ใ ใ ใ (๋๋ง ๋ณผ๊บผ๋๊น ํด๋ฆญ ๋ ธ) (1) | 2024.10.24 |
๋นจ๋ฆฌ ๋ ์์ผ๋ฉด ์ข๊ฒ ๋ค (0) | 2024.10.17 |
24/05/21 ํด์ฌํ๋ ๋ง์ (1) | 2024.05.23 |
24/04/29 ์ฌ๋์ ๋ณธ๋ชจ์ต์ด ๋๋ฌ๋๋ ์๊ฐ (0) | 2024.05.02 |