Intro
ํ๋ก๊ทธ๋๋ฐ์์ ๊ธฐ๋ณธ์ ์ ๋ ฅ๊ณผ ์ถ๋ ฅ์ด๋ค.
์ ๋ ฅ(input)์ ๋ช ๋ น์ ํ์ํ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅํ๋ ๊ฒ์ด๊ณ , ์ถ๋ ฅ(output)์ ์ ๋ ฅ๋ฐ์ ๋ฐ์ดํฐ๋ก ๋ช ๋ น์ ์ํํ ๊ฒฐ๊ณผ๋ฅผ ๋ณด์ฌ์ฃผ๋ ๊ฒ์ด๋ค.
๋ณดํต ๋์ ํฉ์ณ ์ ์ถ๋ ฅ(I/O)๋ผ๊ณ ํ๋ฉฐ, ์ผ๋ฐ์ ์ผ ๋ง์ฐ์ค๋ ํค๋ณด๋ ๋ฑ์ ์ ๋ ฅ์ฅ์น๋ก ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅ ๋ฐ์ ๋ชจ๋ํฐ ํ๋ฉด์ ์ถ๋ ฅํ๋ค.
2.1. ์ถ๋ ฅํ๊ธฐ
์๋ฐ์์ ์ถ๋ ฅ์ ์ํํ๋ ๋ํ์ ์ธ ๋ช ๋ น์ด๋ ๋ค์๊ณผ ๊ฐ๋ค.
- print()
- printf()
- println()
์ถ๋ ฅ ๋ช ๋ น์ ๋ด๋ฆด ๋๋ ๋ค์๊ณผ ๊ฐ์ ํํ๋ก ๋ช ๋ น๋ฌธ์ ์์ฑํด์ผํ๋ค.
System.out.print("Hello");
System.out.printf("Hello");
System.out.println("Hello");
์๋ฐ๋ ์ผ๋ฐ ํ๋ก๊ทธ๋จ๊ณผ ๋ฌ๋ฆฌ JVM ์์์ ์คํ๋๋ค. ๋ฐ๋ผ์ ํ๋ก๊ทธ๋จ์ด ์ง์ ์ด์์ฒด์ ์ ์ ๊ทผํ ์๊ฐ ์๋ค.
์๋ฐ ํ๋ก๊ทธ๋จ์์ ์ด์์ฒด์ ์ ๊ธฐ๋ฅ(ํค๋ณด๋ ์ ๋ ฅ, ํ๋ก๊ทธ๋จ ์ข ๋ฃ ๋ฑ)์ ์ฌ์ฉํ๋ ค๋ฉด ์ฐ๊ฒฐ๊ณ ๋ฆฌ๊ฐ ํ์ํ๋ฉฐ, System ํด๋์ค๊ฐ ์ด ์ฐ๊ฒฐ๊ณ ๋ฆฌ ์ญํ ์ ๋ด๋นํ๋ค.
-> ๊ทธ๋์ ์ถ๋ ฅ ๋ช ๋ น์ด ์์ System ํด๋์ค๋ฅผ ์ฐ๊ฒฐํด ์ฌ์ฉํ๋ค.
2.1.1. println() ์ฌ์ฉ ๋ฐฐ๊ฒฝ
public class Main{
public static void main(String[] args){
System.out.print("Hello");
System.out.print("Java");
}
}
print()๋ ๋ช ๋ น์ด ๋ด์ฉ์ ์ถ๋ ฅํ ๋ค ์ค์ ๋ฐ๊พธ์ง ์๋๋ค. ์ฆ ์ฝ๋๋ ๋ ๊ฐ์ print()๋ฅผ ๋ ์ค์ ๊ฑธ์ณ ์ฐ๊ณ ์์ง๋ง, ์ถ๋ ฅ๋ ๋๋ ์ค ๋ฐ๊ฟ๋์ง ์๊ณ ํ ์ค์ ์ด์ด์ ธ ์จ์ง๋ค.
์ค ๋ฐ๊ฟ์ ํ์ฌ ๋ค์ ์ค์ ๋ฌธ์์ด์ ์ถ๋ ฅํ๊ณ ์ถ๋ค๋ฉด ํน์๋ฌธ์(๊ฐํ๋ฌธ์) \n์ ์ฌ์ฉํ๋ฉด ๋๋ค.
๊ฐํ๋ฌธ์๋ ๋ฌธ์์ด ๋ด์ ๊ทธ๋ฅ ๋ฌธ์์ฒ๋ผ ์ฐ๋ฉด ๋๋ค(ํน์"๋ฌธ์"๋๊น!!)
public class Main{
public static void main(String[] args){
System.out.print("Hello\n");
System.out.print("Java");
}
}
2.1.2. ํน์๋ฌธ์
์๋ฐ์๋ ํน์ํ ์ญํ ์ ํ๋ ๋ฌธ์๋ค์ด ์๊ณ , ํน์ ๋ฌธ์์์ ๋ํ๋ด๊ธฐ ์ํด \๋ฅผ ๋ถ์ธ๋ค.
๋ฐฑ์ฌ๋์๋ ๋ค์ ๋ค๋ฅธ ๋ฌธ์๊ฐ ์ค๋ฉด ๋ฌธ์์ ์๋ฏธ๋ฅผ ํ์ฅ์ํค๊ธฐ ๋๋ฌธ์ ์ด์ค์ผ์ดํ ๋ฌธ์(escape character)๋ผ๊ณ ๋ ๋ถ๋ฆฐ๋ค.
์์ฃผ ์ฐ์ด๋ ํน์๋ฌธ์๋ ์๋์ ๊ฐ๋ค. \b์ \r์ ์ ์ดํด๊ฐ ๋์ง ์์ ์๋ ์ฝ๋์ ๋จ๊ฒจ๋ดค๋ค.
ํน์ ๋ฌธ์ | |
\b | ์ปค์๋ฅผ ํ ๋ฌธ์ ์์ผ๋ก(๋ฐฑ์คํ์ด์ค=์์ ๋ฌธ์๋ฅผ ํ๋ ์ง์) |
\r | ์ค์ ๋งจ ์์ผ๋ก(์บ๋ฆฌ์ง ๋ฆฌํด) |
\n | ์ค ๋ฐ๊ฟ |
\t | ํญ, ๋ค์ฌ์ฐ๊ธฐ |
\0 | ๋น์นธ(null) |
System.out.print("Hel\blo");
//HeloJava
System.out.print("Hel\rlo");
//loJava
2.1.3. println()์ผ๋ก ์ค ๋ฐ๊ฟ ์ถ๋ ฅํ๊ธฐโ
์ถ๋ ฅํ ๋ด์ฉ์ ์์ฑํ ๋๋ง๋ค ๊ฐํ ๋ฌธ์๋ฅผ ๋ฃ์ด์ผ ํ๋๊ฑด ๋๋ฌด ๊ท์ฐฎ๋ค. ์ด๋ด๋ ์ฌ์ฉํ๋ ๋ช ๋ น์ด๊ฐ printIn()์ด๋ค.
ln์ line์ ์๋ฏธํ๋ฉฐ println()์ 'ํ๋ฆฐํธ ๋ผ์ธ'์ด๋ผ๊ณ ์ฝ๋๋ค.
public class Main{
public static void main(String[] args){
System.out.println("Hello");
System.out.println("Java");
}
}
2.2. ์ ๋ ฅ ๋ฐ๊ธฐ
์ถ๋ ฅ์ด ๋ช ๋ น์ ์คํํ ๊ฒฐ๊ณผ๋ฅผ ๋ณด์ฌ์ฃผ๋ ๊ฒ์ด๋ผ๋ฉด, ์ ๋ ฅ์ ๋ช ๋ น์ ์คํํ๋๋ฐ ํ์ํ ๋ฐ์ดํฐ๋ฅผ ๋ฃ์ด์ฃผ๋ ๊ฒ์ด๋ค.
2.2.1. read()๋ก ์ ๋ ฅ๋ฐ๊ธฐ
๋ํ์ ์ธ ์ ๋ ฅ ๋ช ๋ น์ด๋ก๋ read()๊ฐ ์๋ค.
์ถ๋ ฅ ๋ช ๋ น์ด์ ๋ง์ฐฌ๊ฐ์ง๋ก ํ์์ด ์ ํด์ ธ ์์ผ๋ฉฐ, ์๋์ ๋ช ๋ น๋ฌธ์ฒ๋ผ ์ด๋ค. ์๋ฏธ๋ 'ํค๋ณด๋๋ก ๊ฐ(๋ฐ์ดํฐ)๋ฅผ ์ ๋ ฅ๋ฐ์๋ผ'์ด๋ค.
System.in.read()
read() ๋ช ๋ น์ด๋ ๊ฐ์ ์ฝ์ด๋ง ์ค๊ธฐ ๋๋ฌธ์, ๊ฐ์ ์ด๋๊ฐ์ ์ ์ฅํด์ผํ๋ค.
-> ์ด ๋ถ๋ถ์ 3์ฅ์์ ๋ฐฐ์ฐ๋ฏ๋ก(=์์ง ์ ๋ฐฐ์ ์) ์ฌ๊ธฐ์๋ ์ถ๋ ฅ ๋ช ๋ น์ด์ ํจ๊ป ์ฌ์ฉํ๋๊ฑธ๋ก ๋์ฒดํ๋ค.
์์ ์ฝ๋๋, ํค๋ณด๋๋ก ๊ฐ์ ์ฝ์ด์์ ํ๋ฉด์ ์ถ๋ ฅํ๋ผ๋ ์๋ฏธ์ด๋ค.
๊ทธ๋ฐ๋ฐ read ๋ถ๋ถ์์ ์ค๋ฅ๊ฐ ๋ฐ์ํ๊ณ ์๋ค. Unhandled exception: java.io.IOException
ํ๋ก๊ทธ๋จ์ ์คํํ๋ค ๋ณด๋ฉด ๋ฌธ์ ๊ฐ ๋ฐ์ํด ํ๋ก๊ทธ๋จ์ด ๋ฉ์ถ๋ ๊ฒฝ์ฐ๊ฐ ์๋ค. ์ด๋ ๋ฐ์ํ๋ ๋ฌธ์ ๋ 2๊ฐ์ง์ด๋ค.
1) ์ค๋ฅ(error)
2) ์์ธ(exception)
์ค๋ฅ๋ ์์ธกํ๊ธฐ ์ด๋ ต์ง๋ง, ์์ธ๋ ์์ธกํด์ ์ฒ๋ฆฌํ ์ ์๋ค. ์๋ฐ๋ ์์ธ์ ๋ํ ์ฒ๋ฆฌ ๋ฐฉ๋ฒ์ ์ง์ํ๋ฉฐ ๋๋ฌธ์ ์์ธ ์ฒ๋ฆฌ๊ฐ ๋์ง ์์ผ๋ฉด ์์ฒ๋ผ ๊ฒฝ๊ณ ๋ฉ์์ง๋ฅผ ์ถ๋ ฅํ๋ค.
์๋ฐ๋ ์ ๋ ฅ ๋ช ๋ น์ด(read๊ฐ์)๋ฅผ ์ฌ์ฉํ ๋ ๊ฐ์ด ์๋ชป ์ ๋ ฅ๋๋ ์ค๋ฅ๊ฐ ๋ฐ์ํ์ง ์๋๋ก ํ์๋ก ์์ธ์ฒ๋ฆฌ๋ฅผ ์๊ตฌํ๋ค. ์ด ์์ธ ์ฒ๋ฆฌ๋ฅผ ์ด๋ป๊ฒ ํ๋์ง ์ดํด๋ณด์.
read์ ๋ง์ฐ์ค๋ฅผ ๊ฐ์ ธ๋ค๋ ๋ค "Add exception to method signature"์ ํด๋ฆญํ์.
-> ๊ทธ๋ฌ๋ฉด ๋งจ ์์ import java.io.IOException;๊ณผ main() ๋ฉ์๋ ๋ค์ throw IOException(์์ธ ๊ฑฐ๋ฅด๊ธฐ)์ด ์ถ๊ฐ๋๋ค.
-> ์๋ฐ์์ ์ ์ถ๋ ฅ๊ณผ ๊ด๋ จ๋ ์์ธ ์ฒ๋ฆฌ๋ IOExceprion ํด๋์ค์์ ๋ด๋นํ๋ค
(์์ธํ ์์ธ ์ฒ๋ฆฌ๋ 9์ฅ์์ ๋ค๋ฃจ๋, ์ฌ๊ธฐ์๋ ํด๋น ํด๋์ค๊ฐ ์ ์ถ๋ ฅ์์ ๋ฐ์ํ๋ ์์ธ์ฒ๋ฆฌ๋ฅผ ๋ด๋นํ๋ค๋ ๊ฒ๋ง ์๊ณ ๋์ด๊ฐ์)
2.2.2. import
์๋ฐ์์ ํจํค์ง(package)๋ ํด๋์ค์ ํ์ผ ๋ฑ์ ํ๋๋ก ๋ฌถ์ ๋จ์์ด๋ค. ํด๋๋ผ๊ณ ์๊ฐํ๋ฉด ์ดํดํ๊ธฐ ํธํ๋ค.
IOExcetion ํด๋์ค๋ java.io ํจํค์ง์ ํฌํจ๋์ด์๋ค.
๋ค๋ฅธ ํจํค์ง์ ์ํ ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ ค๋ฉด ํ์ฌ ํด๋์ค๋ช ์์ ํด๋น ํจํค์ง ๋ช ์ ๋ชจ๋ ๋ถ์ฌ์ผํ๋๋ฐ ์ด๊ฑด ๋๋ฌด ๊ท์ฐฎ์ผ๋ฏ๋ก ์ด ๊ณผ์ ์ ๊ฐ์ํ ํ๊ธฐ ์ํด import ์์ ์ ํ๋ค.
ํด๋์ค ์์ ์๋ ํ์์ผ๋ก importํ๋ฉด ๋ค๋ฅธ ํจํค์ง์ ํด๋์ค๋ฅผ ๋ถ๋ฌ์ ์ฌ์ฉํ ์ ์๋ค.
import [ํจํค์ง๋ช
].[ํด๋์ค๋ช
];
//import java.io.IOException
2.2.3. Scanner ํด๋์ค ์ฌ์ฉ ๋ฐฐ๊ฒฝ
์์์ ์์ฑํ ์ฝ๋์ด๋ค. ์ด๋ ์ฝ๋๋ฅผ ์คํํ๊ณ 1์ ์ ๋ ฅํ๋ฉด ์ถ๋ ฅ๊ฐ์ด 49๊ฐ ๋์ค๋๋ฐ ์๊ทธ๋ฌ๋์ง ์ดํด๋ณด์.
import java.io.IOException;
public class Main{
public static void main(String[] args) throws IOException {
System.out.println(System.in.read());
}
}
1์ ์ ๋ ฅํ๋๋ฐ 49๊ฐ ๋์ค๋ ์ด์ ๋, read() ๋ช ๋ น์ด๊ฐ ์ ๋ ฅ๊ฐ์ ASCII ์ฝ๋๋ก ๋ฐ์์ ๊ทธ๋ ๋ค. ASCII ์ฝ๋๋ ์ํ๋ฒณ์ด๋ ์ซ์ ๋ฑ์ ์ปดํจํฐ๊ฐ ์ดํดํ ์ ์๊ฒ ๋ณํ(์ธ์ฝ๋ฉ)ํ ๋ ์ฌ์ฉํ๋ค. ์ซ์ 1์ ์์คํค ์ฝ๋์์ 10์ง๋ฒ์ผ๋ก 49์ด๋ฏ๋ก 49๊ฐ ์ถ๋ ฅ๋ ๊ฒ์ด๋ค.
๋ํ read() ๋ช ๋ น์ด๋ 1๋ฐ์ดํธ๋ง ์ฝ์ด์ค๊ธฐ ๋๋ฌธ์ 123์ ์ ๋ ฅํ๋ฉด 1๋ง ๋ฐํํ๋ค.
์ฐธ๊ณ ๋ก ์ซ์ & ์ํ๋ฒณ = 1๋ฐ์ดํธ, ํ๊ธ 1๊ธ์ = 2๋ฐ์ดํธ
read() ๋ช ๋ น์ด๋ฅผ ์ฌ์ฉํ๋ฉด์ ์ ๋ ฅํ ๊ทธ๋๋ก 1์ ์ถ๋ ฅํ๊ณ ์ถ๋ค๋ฉด ์ ๋ ฅ ๋ช ๋ น์ด System.in.read() ์์ (char)์ ์ถ๊ฐํ๋ฉด ๋๋ค.
import java.io.IOException;
public class Main{
public static void main(String[] args) throws IOException {
System.out.println((char)System.in.read());
}
}
/*
1
1
*/
2.2.4. Scanner ํด๋์ค๋ก ์ ๋ ฅ๋ฐ๊ธฐโ
์๋ฐ๋ ์ ์ถ๋ ฅ์ด ์คํธ๋ฆผ์ ํตํด ์ด๋ฃจ์ด์ง๋ค. ์คํธ๋ฆผ(Stream)์ ์ ์ถ๋ ฅ ์ฅ์น์ ํ๋ก๊ทธ๋จ์ ์ฐ๊ฒฐํ๋ ํต๋ก์ด๋ค.
์คํธ๋ฆผ์ ํตํด ์ ๋ ฅ์ฅ์น๋ก ์ ๋ ฅํ ๊ฐ์ ํ๋ก๊ทธ๋จ์ผ๋ก ์ ๋ฌ๋๊ณ , ํ๋ก๊ทธ๋จ์ ์คํํ ๊ฒฐ๊ณผ๋ ์ถ๋ ฅ ์คํธ๋ฆผ์ ํตํด ์ถ๋ ฅ ์ฅ์น์ ํ์๋๋ค.
-> ์คํธ๋ฆผ์๋ '๋ฌผ์ค๊ธฐ'๋ผ๋ ๋ป์ด ์๋๋ฐ, ๋ฌผ์ค๊ธฐ๊ฐ ํ ๋ฐฉํฅ์ผ๋ก๋ง ํ๋ฅด๋ฏ ์คํธ๋ฆผ๋ ํ ๋ฐฉํฅ์ผ๋ก๋ง ์ ๋ฌ์ด ๊ฐ๋ฅํ๋ค.
-> ๊ทธ๋์ ์ ๋ ฅ๊ณผ ์ถ๋ ฅ ์คํธ๋ฆผ์ด ๋ฐ๋ก ์กด์ฌํ๋ค.
์ ๋ ฅ ๋ช ๋ น์ด๋ฅผ ์ฌ์ฉํ ๋ ๋์จ System.in์ด ์ ๋ ฅ ์คํธ๋ฆผ์ด๋ฉฐ, ๋ง์ฐฌ๊ฐ์ง๋ก System.out์ด ์ถ๋ ฅ ์คํธ๋ฆผ์ด๋ค.
(์ ์ถ๋ ฅ ์คํธ๋ฆผ์ ๋ํ ์์ธํ ๋ด์ฉ์ 11์ฅ์์ ๋ฐฐ์ฐ๋ ๊ฐ๋ณ๊ฒ ์ฝ๊ณ ๋์ด๊ฐ์)
read()๋ 1๋ฐ์ดํธ๋ง ์ฝ์ด์ฌ ์ ์์ผ๋ฏ๋ก, ์๋ฐ์์๋ ๊ฐ์ ์ ๋ ฅ๋ฐ์๋ ์ฃผ๋ก Scanner ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ค.
Scanner ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ฉด ๋ค์ํ ํํ์ ๊ฐ์ ์ ๋ ฅ๋ฐ์ ์ ์๋ค!
Scanner ํด๋์ค๋ ์๋์ ๊ฐ์ ํํ๋ก ์ฌ์ฉํ๋ค. Scanner ํด๋์ค๋ก ๊ฐ์ ์ ๋ ฅ๋ฐ์ ํ๋ก๊ทธ๋จ์์ ์ฌ์ฉํ๋ ค๋ฉด ์ด ๊ฐ์ ์ด๋๊ฐ์ ์ ์ฅํด์ผํ๋๋ฐ, ์ด ์ญํ ์ ํ๋ ๊ฒ์ด ๋ณ์์ด๋ค. ์ฌ๊ธฐ์๋ scan์ด ๋ณ์์ ํด๋นํ๋ค.
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner scan = new Scanner(System.in); //Scanner ๋ถ๋ถ
System.out.println(scan.nextLine()); //์ถ๋ ฅ ๋ถ๋ถ
scan.close
}
}
/*
์๋
์๋
์๋
์๋
*/
//Scanner ๋ถ๋ถ
-> ๋ฑํธ ์ด์ ์ Scanner scan์ Scanner์ ๊ฐ์ฒด ์ด๋ฆ์ด scan์์ ๋ช ์ํ๋ค๋ ์๋ฏธ์ด๋ค
-> ๋ฑํธ ์ดํ์ new Scanner(System.in)์ new๋ ๋ฉ๋ชจ๋ฆฌ์ ์๋ก์ด Scanner ๊ฐ์ฒด๋ฅผ ์์ฑํ๊ฒ ๋ค๋ ํค์๋์ด๋ค.
//์ถ๋ ฅ ๋ถ๋ถ
-> nextLine()์ Scanner ํด๋์ค์ ์ํ ๋ช ๋ น์ด๋ก, ๊ฐ์ ํ ์ค ๋จ์(์ฌ์ฉ์๊ฐ Enter์ ์น๊ธฐ ์ ๊น์ง)๋ก ์ ๋ ฅ๋ฐ๋๋ค. ๊ฐ์ ๊ฐ์ ธ์ค๋ ๋์์ ์์์ ๋ง๋ scan ๋ณ์์ด๋ค.
-> ์ถ๊ฐ๋ก next()๋ ์ ๋ ฅ๋ฐ์ ๋ด์ฉ ์ค์์ ๊ณต๋ฐฑ ๋ฌธ์ ์ ๊น์ง๋ง ์ถ๋ ฅํ๋ค(ex. Hello world -> Hello)
-> ์ถ๊ฐ๋ก, Scanner ํด๋์ค๋ก ์ ๋ ฅ ์คํธ๋ฆผ์ ์ฌ์ฉํ๋ค๊ฐ ์ฌ์ฉ์ด ๋๋๋ฉด close() ๋ช ๋ น์ด๋ก ๋ซ์์ฃผ๋ ๊ฒ์ด ์ข๋ค. ๋ซ์ง ์์ผ๋ฉด ๊ณ์ํด์ ์์์ ์ฌ์ฉํ๋ ์ํ๊ฐ ๋์ด ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ญ๋น๋๊ธฐ ๋๋ฌธ์ด๋ค.
2.3. ํด์ฆโ
read()๋ก ์ซ์๋ฅผ 123์ ์ ๋ ฅ๋ฐ์ ๊ทธ๋๋ก ์ถ๋ ฅํ๋ค๊ณ ํ์ ๋ , 1~3์ ๋ค์ด๊ฐ ์ฝ๋๋ฅผ ์์ฑํด๋ณด์์ค.
์๊ฐ)
123์ด ๋ณ์์ ์ ์ฅ๋๋๊ฒ๋ ์๋๋ฐ, ์ด๋ป๊ฒ ๊ฐ๊ฐ์ ๋ช ๋ น์ด๊ฐ 1,2,3์ ์์ฐจ์ ์ผ๋ก ์ถ๋ ฅํ์ง...?
ํ์ด)
์ ๋ ฅํ 123\n์ ๋ฒํผ์ ์ ์ฅ๋๋ฉฐ, read๋ ๋ฒํผ์์ ํ ๋ฐ์ดํธ์ฉ ๊บผ๋ด์ค๋ ๋ฐฉ์์ผ๋ก ๋์ํ๋ค.
-> ์ ๋ ฅ ํ ๋ฐ๋ก ์ถ๋ ฅ๋๋ ๊ฒ ์ฒ๋ผ ๋ณด์ด์ง๋ง, ์ฌ์ค์ ์ ๋ ฅ๋ ๋ฐ์ดํฐ๋ฅผ ์์ฐจ์ ์ผ๋ก ์ฒ๋ฆฌํ๋ ๊ณผ์ ์ด๋ค!
import java.io.IOException;
public class Main{
public static void main(String[] args) throws IOException{
System.out.print((char)System.in.read()); //(1)
System.out.print((char)System.in.read()); //(2)
System.out.print((char)System.in.read()); //(3)
}
}
์ถ๊ฐ๋ก Scanner์ ์ฌ์ฉํ๋ฉด ์๋์ ์ฝ๋์ฒ๋ผ ์์ฑํ๋ฉด ๋๋ค.
import java.io.IOException;
import java.util.Scanner;
public class Main{
public static void main(String[] args) throws IOException{
Scanner scan = new Scanner(System.in); //์
๋ ฅ ๋ฐ๊ณ
System.out.println(scan.nextLine()); //์
๋ ฅ๋ฐ์ scan ๊ฐ์ฒด๋ฅผ ์ถ๋ ฅํ๋ค
}
}
2.4. ๋ง๋ฌด๋ฆฌ
1) ์ ๋ ฅ๊ณผ ์ถ๋ ฅ
2) ์ถ๋ ฅ ๋ช ๋ น์ด - print, printf, println
3) read() - ๊ฐ์ 1๋ฐ์ดํธ์ฉ ์ฝ์ด์ค๋ฉฐ ๊ธฐ๋ณธ์ ์ผ๋ก ๊ฐ์ ์์คํค ์ฝ๋๋ก ์ถ๋ ฅ. ์ด๋ฅผ char๋ก ๋ฐ๊ฟ์ผ ๋ฌธ์ ์ถ๋ ฅ ๊ฐ๋ฅ
4) ์ ์ถ๋ ฅ ์คํธ๋ฆผ
5) Scanner ํด๋์ค
2.5. ์ ํ ์ฒดํฌโ โ
์์์ ๋ฐฐ์ด ๋ช ๋ น์ด๋ฅผ ์ฌ์ฉํด ์คํ ๊ฒฐ๊ณผ์ฒ๋ผ ๋ด์ฉ์ ์ ๋ ฅ๋ฐ์ ์ถ๋ ฅํ๋ ์ฝ๋๋ฅผ ์์ฑํด ๋ณด์ธ์.
๋ด๊ฐ ์ง ์ฝ๋) ํ๋ฆฐ๊ฑด ์๋
๊ฐ ๋ฌธ์ฅ์ ์๋ก ๋ค๋ฅธ ๋ณ์๋ก ๋์ด์ผํ ๊ฒ ๊ฐ์์ scan1, scan2, scan3๋ก ๋๋์ด ์ ๋ ฅ๋ฐ์
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner scan1 = new Scanner(System.in);
System.out.println(scan1.nextLine()); //println()์ ์ฌ์ฉํ๋๊ฑฐ ์์ง ๋ง๊ธฐ
Scanner scan2 = new Scanner(System.in);
System.out.println(scan2.nextLine());
Scanner scan3 = new Scanner(System.in);
System.out.println(scan3.nextLine());
}
}
์ ๋ต ์ฝ๋)
์ ๋ ฅ ๋ฐ๋ ์ฝ๋๋ฅผ ํ ๋ฒ๋ง ์์ฑํ๊ณ , ์ถ๋ ฅ ๋ช ๋ น์ด๋ฅผ ์ฐ์์ผ๋ก 3๋ฒ ์์ฑํจ
์ดํด๊ฐ ์ ์๋์๋ ๋ถ๋ถ)
์ฝ๋๋ ์์์๋ถํฐ ์๋๋ก ํด์๋๋, System.in์์ ์ ๋ ฅ๋ฐ์ ๋ฌธ์์ด์ 3๋ฒ ๋ฐ๋ณตํด์ ์ถ๋ ฅํด์ผํ๋ ๊ฒ ์๋๊ฐ?
-> Scanner sacn = new Scanner(System.in)์์ ์ ๋ ฅ์ ๋ฐ๋ ๊ฒ์ด ์๋!! ์ด ๋ถ๋ถ์ ์ ๋ ฅ ๋ฐ์ ์ค๋น๋ฅผ ํ๋๊ฑฐ์
-> ์ฒซ ๋ฒ์งธ nextLine()์ด ํธ์ถ๋๋ฉด, ํ๋ก๊ทธ๋จ์ ์ ๋ ฅ์ ๊ธฐ๋ค๋ฆฌ๋ ์ํ๋ก ๋ฉ์ถค
-> ์ฌ์ฉ์๊ฐ ํค๋ณด๋ ์ ๋ ฅ ํ Enter์ ์น๋ฉด ์ ๋ ฅ ๋ฒํผ์ ๋ฐ์ดํฐ๊ฐ ์ ์ฅ๋๊ณ println()์ ์ํด ๋ฐ์ดํฐ๊ฐ ์ถ๋ ฅ๋๋ค
-> ๋ ๋ฒ์งธ nextLine()์ ํด์ํ ๋๋ ์์ ๊ฐ์ด ์์ฉํ๋ค.
-> ๋ฐ๋ผ์ System.in์ ์ํด ์ ๋ ฅ์ ๋ฐ์ ์ ์๋ ์ํ๊ฐ ๋๋ฉฐ, ๊ฐ๊ฐ์ nextLine()์ ๊ฑธ๋ฆด ๋๋ง๋ค ์ ๋ ฅ ๋๊ธฐ, ์ถ๋ ฅ์ ํ๋ค.
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println(scan.nextLine());
System.out.println(scan.nextLine());
System.out.println(scan.nextLine());
}
}
Scanner scan = new Scanner(System.in)
: System.in์ด๋ผ๋ ์ ๋ ฅ ์คํธ๋ฆผ์ Scanner ๊ฐ์ฒด์ ์ฐ๊ฒฐํ๋ ์ฝ๋์ด๋ค. ์ฆ ์ ๋ ฅ ๋ฐ์ ์ค๋น๋ง ํ๋ ๊ฒ์ด๋ค
-> System.in์ ์์ ์ ๋ ฅ์ ๋ฐ๋๋ค๋ ์๊ฐ์ ๋ฒ๋ฆฌ์.. System.in์ ํค๋ณด๋๋ก๋ถํฐ ์ ๋ ฅ์ ๋ฐ์ ์ ์๋๋ก ์ฐ๊ฒฐ๋ ์ ๋ ฅ ์คํธ๋ฆผ์ด๋ค!!!
System.out.println(scan.nextLine())
: ์ค์ ๋ก ์ ๋ ฅ์ ๋ฐ๋ ๋ถ๋ถ์ด๋ค. nextLine()์ด ํธ์ถ๋๋ ์๊ฐ ์ ๋ ฅ์ ๊ธฐ๋ค๋ฆฌ๋ ๋๊ธฐ ์ํ๊ฐ ๋๋ฉฐ, ์ ๋ ฅ ํ Enter์ ๋๋ฅด๋ฉด ๋ฒํผ์ ์ ์ฅ๋ ๋ฐ์ดํฐ๋ฅผ ์ถ๋ ฅํ๋ค.
-> Scanner์ ์ ๋ ฅ์ ๋ฐ๋ ๋๊ตฌ์ผ ๋ฟ์ด๋ฉฐ, nextLine(), next() ๊ฐ์ ๋ฉ์๋๋ค์ด ์ค์ ๋ก ์ ๋ ฅ์ ์ฒ๋ฆฌํ๋ค.
'๐ฆ Private > Java Language' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
6์ฅ - ์ฌ๋ฌ ๊ฐ ํ ๋ฒ์ ์ ์ฅํ๊ธฐ: ๋ฐฐ์ด (0) | 2025.03.05 |
---|---|
5์ฅ - ๊ฐ์ ์์ ๋ฐ๋ณตํ๊ธฐ: ๋ฐ๋ณต๋ฌธ (1) | 2025.02.19 |
4์ฅ - ์กฐ๊ฑด์ ๋ฐ๋ผ ํ๋ฆ ๋ฐ๊พธ๊ธฐ: ์กฐ๊ฑด๋ฌธ (0) | 2025.02.16 |
3์ฅ - ๊ธฐ์ด ๋ฌธ๋ฒ ๋ฐฐ์ฐ๊ธฐ (0) | 2025.02.13 |
1์ฅ - Hello, Java! (1) | 2025.02.11 |