์๊ณ ๋ฆฌ์ฆ ์ฝ๋ฉํ ์คํธ๋ ๋ํ์์ ์๋ฐ๊ฐ ์ฃผ๋ก ์ฌ์ฉ๋์ง ์๋ ๊ฐ์ฅ ํฐ ์ด์ ๋ ๋ฐ๋ก ์๋ ๋๋ฌธ์ด ์๋๊น ์๊ฐํ๋ค.
ํ์ง๋ง ๊ทธ ์ธ์ ๋ด๊ฐ ๊ณต๋ถํ๋ฉฐ ๋๊ผ๋ ๊ฐ์ฅ ํฐ ๋จ์ ?์ ๋ฐ๋ก ์ ์ถ๋ ฅ์ด ๋ถํธํ๋ค ์ด๋ค.
์ฌ์ค ๋ก์ง ์ํด์ ์ฝ๋๋ฅผ ๊ตฌ์ฑํ๋ ๊ณผ์ ์ ํ์ด์ฌ์ด ์๋์ ์ผ๋ก ํธํ๊ฒ ์ง๋ง, ๊ทธ ์ธ์๋ ๋ค ๋น์ท๋น์ทํ๋ค.
๊ทผ๋ฐ ๊ฐ์ฅ ํฐ ๋จ์ ์ธ ์ ์ถ๋ ฅ์ ๊น๋ค๋ก์์ด๋ค.
c++ ์ cin ์ผ๋ก ์ฝ๊ฒ ์ฒ๋ฆฌํ ์ ์๊ณ , python ์ input ์ผ๋ก ์ฒ๋ฆฌํ๋ค. ํ์ง๋ง ์๋ฐ๋ Scanner
๋ BufferedReader
๊ฐ์ฒด๋ฅผ ์ด์ฉํด์ผ ํ๋ค.
ํด๋น ๊ฐ์ฒด์์ ๋ nextInt()
, next()
, read()
, readLine()
๊ณผ ๊ฐ์ ๋ฉ์๋๋ฅผ ํธ์ถํด์ผ ํ๋ค.
๊ทธ๋ฆฌ๊ณ ์ด๋ค ์ ์ถ๋ ฅ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋์ง์ ๋ฐ๋ผ ์ํฅ์ด ๊ฐ๋ ์๋๋ ๋ฌด์ํ์ง ๋ชปํ๋ค.
ํน์ ๋ฌธ์ ์์๋ Scanner
ํด๋์ค๋ฅผ ์ด์ฉํ๋ฉด ํต๊ณผ๋์ง ์๊ณ BufferedReader
๋ฅผ ์ด์ฉํด์ผ๋ง ํต๊ณผ๋๋ ๋ฌธ์ ๋ค์ด ์กด์ฌํ๋ค.
์ค๋์ ์ฃผ๋ก ์ด๋ค ์ ์ถ๋ ฅ์ด ์ฌ์ฉ๋๊ณ ๋ฌธ์ ๋ณ๋ก ์ด๋ป๊ฒ ๋๋ ์ ์ฌ์ฉํ ์ง ๋ฐฉ๋ฒ์ ๋ํ ํฌ์คํ ์ ํด๋ณด๊ฒ ๋ค.
๋ชฉ์ฐจ
- Scanner ์ System.println
- BufferedReader ์ BufferedWriter
- ๋ฌธ์์ด์ ๋ค๋ฅธ ๋ฐ์ดํฐ ํ์ ์ผ๋ก ๋ณํํ๊ธฐ
- ๋ฐฑ์ค ๋ฌธ์ ๋ก ๋ฐฐ์๋ณด๊ธฐ
- ํ ์ค์ ๋์ค๋ ๋ณ์๋ค ์ฒ๋ฆฌํ๊ธฐ
- 1์ฐจ์ ๋ฐฐ์ด ์ฒ๋ฆฌํ๊ธฐ (๋ฌธ์์ด, int)
- 2์ฐจ์ ๋ฐฐ์ด ์ฒ๋ฆฌํ๊ธฐ (๋ฌธ์์ด, int)
์ ๋ ฅ ๋ฐ๋ 2๊ฐ์ง ๋ฐฉ๋ฒ Scanner ๊ณผ BufferedReader
Scanner์ System.out.println
์ฐ์ Scanner ๋ Java ๋ฅผ ์์ํ๋ฉด ๊ฐ์ฅ ๋จผ์ ๋ฐฐ์ฐ๋ ์ ๋ ฅ ์ฒด๊ณ์ด๋ค.
์ฌ์ฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ๋ค.
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String name = scanner.next();
String address = scanner.nextLine();
int age = scanner.nextInt();
int score = scanner.nextDouble();
System.out.println(name + address + age + score);
}
}
nextLine()
์ผ๋ก ๊ฐํ ๋ฌธ์๊น์ง ์
๋ ฅ์ ๋ฐ๋ ๋ฐฉ๋ฒ์ด ์๊ณ , next()
๋ก ๋ฌธ์์ด ๋จ์๋ก ์
๋ ฅ์ ๋ฐ๋ ๋ฐฉ๋ฒ์ด ์์ผ๋ฉฐ ๊ฐ๊ฐ Data
Type ์ ๋ฐ๋ผ์ nextOOO
๋ฉ์๋๋ฅผ ์ด์ฉํ ์ ์๋ค.
Scanner์ System.out.println ์ ๋๋ ๋ณ๋ก ์ ํธํ์ง ์๊ธฐ ๋๋ฌธ์ ์งง๊ฒ ์ค๋ช ํ๊ณ ๋์ด๊ฐ๋๋ก ํ๊ฒ ๋ค.
Scanner ๋ ์๋๊ฐ ๋๋ฌด ๋๋ฆฌ๋ค.
๊ทธ ๋์์ผ๋ก ์ฌ์ฉ๋๋ BufferedReader ์ ๋ํด์ ์์๋ณด์.
BufferedReader ์ BufferedWriter
BufferedReader ๋ ์ด๋ฆ์ฒ๋ผ ๋ฒํผ๋ฅผ ์ด์ฉํด์ ์ฝ๊ณ ์ฐ๋ ๋ฉ์๋์ด๋ค.
๋ฒํผ๋ฅผ ์ฌ์ฉํ๋ ์ ๋ ฅ๊ณผ ๋ฒํผ๋ฅผ ์ฌ์ฉํ์ง ์๋ ์ ๋ ฅ
๊ทธ ์ฌ์ฉ๋ฒ์ ๋ณด๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
ํด๋น ํฌ์คํ ์ BufferedReader ์ ์๋ฆฌ์ ์ญ์ฌ๋ฅผ ์๋ ๊ฒ์ด ๋ชฉ์ ์ด ์๋๋ผ ์ด๋ป๊ฒ ํ๋ฉด ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ํ์ด์์ ์ ์ฌ์ฉํ ์ ์์๊น? ์ ๋ํ ๊ณ ๋ฏผ์ด ๋ชฉ์ ์ด๋ฏ๋ก ์์ธํ ์ค๋ช ์ ํ์ง ์์ต๋๋ค.
BufferedReader ์ BufferedWriter๋ ๊ฐ๊ฐ ์์ฑ์๋ก Stream ์ ๋ฃ์ด์ฃผ๋ฉด ๋๋ค.
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); // ์
๋ ฅ
BufferedWriter br = new BufferedWriter(new OutputStreamReader(System.in)); // ์ถ๋ ฅ
String inputs = br.readLine(); // ๋ผ์ธ ๋ณ๋ก ๋ฐ๊ธฐ
bw.write(inputs);
bw.flush(); // ๋จ์์๋ ๋ฒํผ์ ๋ด์ฉ์ ์ถ๋ ฅ
bw.close(); // ๋ฒํผ ํด์
}
}
BufferedWriter ๋ ๋ฒํผ๋ฅผ ๋น์์ฃผ๋ ๊ณผ์ ์ด ๊ผญ ํ์ํ๊ธฐ ๋๋ฌธ์ bw.flush()
์ close ๋ฅผ ์ํํด์ผ ํ๋ค.
๋ํ Buffered ํด๋์ค๋ ๋ฒํผ๋ฅผ ์ด์ฉํ๊ธฐ ๋๋ฌธ์ IOException ์ throw ํ๋๋ฐ, ์ด์ ๋ํ ์ฒ๋ฆฌ๋ ํ์ํ๋ค.
๊ธฐ๋ณธ์ ์ผ๋ก readLine()
ํจ์๋ฅผ ์ด์ฉํ๋ค๋ฉด String ํ์
์ผ๋ก ์ฐ๋ฆฌ์ ์
๋ ฅ์ ๋ฐ์์จ๋ค.
๊ทธ๋ ๊ธฐ์ ์ซ์๋ฅผ ์ด์ฉํ ๋์๋ ํด๋น String ์ int ๋ก ๋ณํํ๋ ๊ณผ์ ์ด ํ์ํ๋ค.
์ด์ ๋ํด์ ๋ ์์๋ณด์
๋ฌธ์์ด์ ๋ค์ํ ์๋ฃํ์ผ๋ก ๋ณํํ๊ธฐ
์ด ๋ด์ฉ์ ์๊ธฐ ์ํด์๋ Wrapper Class ์ ๋ํ ์ดํด๊ฐ ์์ด์ผ ํ๋ค.
Wrapper Class ์ ๋ํด์๋ ์ํคํผ๋์์ Primitive wrapper class in java ์์ ํ์ธํ ์ ์์ต๋๋ค.
๊ฐ๊ฐ์ Wrapper Class ๋ parse ๋ฉ์๋๋ฅผ ์ ๊ณตํ๋๋ฐ, ์ด๋ ๋ฌธ์์ด์ ํ์ฑํด์ Wrapper ์ ๋ฐ์ดํฐ ํ์ ์ผ๋ก ๋ณํํ๋ค.
๊ทธ๋ผ ๋ค์๊ณผ ๊ฐ์ด ์ฌ์ฉ๋ ์ ์๋ค.
- String ์ int ๋ก ๋ฐ์์ค๊ธฐ
Integer.parseInt("1")
- String ์ double ๋ก ๋ฐ์์ค๊ธฐ
Integer.parseInt("1.3")
- String ์ float ๋ก ๋ฐ์์ค๊ธฐ
Integer.parseInt("1.1")
๊ฐ๋จํ๋ค.
String.valueOf() ๋ฉ์๋๋ฅผ ์ด์ฉํด์ String ํ์ ์ผ๋ก ๋ณํํ๊ธฐ
BufferedWriter.write ๋ String ์ ๋งค๊ฐ๋ณ์๋ก ๋ฐ์์ผ ์ถ๋ ฅํ ์ ์๋ค. ๊ทธ๋ ์ง ์์ผ๋ฉด offset ์ด๋ ๋ค๋ฅธ ๊ธฐ๋ฅ์ผ๋ก ์ํ๋๊ธฐ ๋๋ฌธ์ String ํ์ ์ผ๋ก ๋ณํ์ ํด์ผ์ง๋ง ์ํ๋ ๊ฒ์ ์ถ๋ ฅํ ์ ์๊ฒ ๋๋ค.
์ด๋ฅผ ์ํด์๋ String.value() ๋ฅผ ์ด์ฉํด์ int ํ์ ์ด๋ char, double, boolean ์ ํ์ฑํด์ผ ํ๋ค.
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); // ์
๋ ฅ
BufferedWriter br = new BufferedWriter(new OutputStreamReader(System.in)); // ์ถ๋ ฅ
int number = 10;
char chars = 'c';
double score = 1.1;
bw.write(String.valueOf(number)); // int to String
bw.write(String.valueOf(chars)); // char to String
bw.write(String.valueOf(score)); // double to String
bw.flush(); // ๋จ์์๋ ๋ฒํผ์ ๋ด์ฉ์ ์ถ๋ ฅ
bw.close(); // ๋ฒํผ ํด์
}
}
์ด๊ฒ ์ญ์ ๊ฐ๋จํ๋ค.
๋ฐฑ์ค ๋ฌธ์ ๋ก ๋ฐฐ์๋ณด๊ธฐ
์ฐ๋ฆฌ๋ ์ด ๊ธฐ๋ฒ๋ค์ ์ด์ฉํด์ ์ด๋ป๊ฒ ๋ฌธ์ ํ์ด์ ์ ๋ชฉ๋๋์ง ์์๋ณด์.
ํ ์ค์ ๋ค์ด์ค๋ ์ ๋ ฅ ์ฒ๋ฆฌํ๊ธฐ
๋ค์๊ณผ ๊ฐ์ด ํ ์ค์ ๋ค์ด์ค๋ ์ ๋ ฅ์ ํ์ธํด๋ณด์
์ ๋ ฅ์ผ๋ก๋ 2๊ฐ์ ์ซ์๊ฐ ๋ค์ด์ค๋๋ฐ, ์ฐ๋ฆฌ๋ ์ด๋ฅผ String ์ผ๋ก ๋ฐ์์ ๊ณต๋ฐฑ์ ๊ธฐ์ค์ผ๋ก ๋๋ ๊ฒ์ด๋ค
๊ณต๋ฐฑ์ ๊ธฐ์ค์ผ๋ก ๋๋ ๋๋ String ํด๋์ค์ String[] split(String regex) ๋ฉ์๋๋ฅผ ํตํด์ ๋๋ ์ ์๋ค.
๊ทธ๋ ๊ฒ ๋๋๋ฉด String ๋ฐฐ์ด์ด ๋ฐํ๋๋๋ฐ, ํด๋น ๋ฐฐ์ด์ ๊ฐ์ง๊ณ Integer ๋ก ํ์ฑํ๋ ๊ฒ ๊น์ง๊ฐ ๋์ด๋ค.
์์ ์ด์ผ๊ธฐํ๋ฏ, BufferedWriter.write ๋ฉ์๋๋ int ํ์ ์ด ๋ค์ด๊ฐ ์ ์์ผ๋ฏ๋ก String.valueOf() ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ ๋ฌธ์์ด๋ก ๋ง๋ค์ด์ค์ผ ํ๋ค.
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); // ์
๋ ฅ
BufferedWriter br = new BufferedWriter(new OutputStreamReader(System.in)); // ์ถ๋ ฅ
String[] line = br.readLine().split(" "); // ์ฒซ ๋ฒ์งธ ๋ผ์ธ์ ๋ฐ๊ณ ๊ณต๋ฐฑ์ ๊ธฐ์ค์ผ๋ก ๋๋๊ธฐ
int number1 = Integer.parseInt(line[0]);
int number2 = Integer.parseInt(line[1]);
bw.write(String.valueOf(number1 + number2));
bw.flush(); // ๋จ์์๋ ๋ฒํผ์ ๋ด์ฉ์ ์ถ๋ ฅ
bw.close(); // ๋ฒํผ ํด์
}
}
1์ฐจ์ ๋ฐฐ์ด ์ฒ๋ฆฌํ๊ธฐ
์ด๋ฒ์๋ ๋ค์๊ณผ ๊ฐ์ด 1์ฐจ์ ๋ฐฐ์ด์ด ์ ๋ ฅ์ผ๋ก ๋ค์ด์์ ๋๋ฅผ ํ์ธํด๋ณด์.
1 ์ฐจ์ ๋ฐฐ์ด์ ์ ๋ ฅ๋ฐ๋ ๊ฒ๋ ์์ ๋ฐฉ์๊ณผ ํฌ๊ฒ ๋ค๋ฅด์ง ์๋ค.
์ฐ์ ์ ๋ ฅ๋ string ์ split ๋ฉ์๋๋ฅผ ํตํด์ string ๋ฐฐ์ด๋ก ๋ง๋ค๊ณ , ํด๋น ๋ฐฐ์ด์ iteration ํ๋ฉด์ int ๋ฐฐ์ด์ ๋ฃ์ด์ฃผ๋ฉด ๋๋ค.
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); // ์
๋ ฅ
BufferedWriter br = new BufferedWriter(new OutputStreamReader(System.in)); // ์ถ๋ ฅ
String[] line = br.readLine().split(" "); // ์ฒซ ๋ฒ์งธ ๋ผ์ธ์ ๋ฐ๊ณ ๊ณต๋ฐฑ์ ๊ธฐ์ค์ผ๋ก ๋๋๊ธฐ
int[] arr = new int[line.length]; // ๋ค์ด์จ ์
๋ ฅ ๋งํผ์ int ๋ฐฐ์ด ์์ฑ
for(int i = 0; i < line.length; i++) {
arr[i] = Integer.parseInt(line[i]);
}
bw.write(Arrays.toString(arr));
bw.flush(); // ๋จ์์๋ ๋ฒํผ์ ๋ด์ฉ์ ์ถ๋ ฅ
bw.close(); // ๋ฒํผ ํด์
}
}
2์ฐจ์ ๋ฐฐ์ด ์ฒ๋ฆฌํ๊ธฐ
2์ฐจ์ ๋ฐฐ์ด๋ ์ญ์ ๋น์ทํ๋ค
์ด์ ๊ฐ์ด ๋ค์ด์จ๋ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ์ฒ๋ฆฌํ ์ ์๋ค.
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); // ์
๋ ฅ
BufferedWriter br = new BufferedWriter(new OutputStreamReader(System.in)); // ์ถ๋ ฅ
int n = Integer.parseInt(br.readLine()); // ์
๋ ฅ๊ณผ ๋์์ int ๋ก ๋ณํ
int[][] arr = new int[n][n];
for(int i = 0; i < arr.length; i++;) {
String[] line = br.readLine().split(" ");
for(int j = 0; j < line.length; j++) {
arr[i][j] = Integer.parseInt(line[j]);
}
}
bw.write(Arrays.deepToString(arr));
bw.flush(); // ๋จ์์๋ ๋ฒํผ์ ๋ด์ฉ์ ์ถ๋ ฅ
bw.close(); // ๋ฒํผ ํด์
}
}
ํผ์ ์ฐ์ตํด๋ณด๊ธฐ
์ด์ ์ฐ๋ฆฌ๋ ps ์ ํ์ํ ๊ฑฐ์ ๋ชจ๋ ์ ์ถ๋ ฅ์ ํด๊ฒฐํ ์ ์๊ฒ ๋์๋ค.
์๋์ ์ ์ถ๋ ฅ ํฌ๋งท์ ์์์ ๋ฐฐ์ด ๋ด์ฉ์ ํ ๋๋ก ํ ๋ฒ ์ค์ค๋ก ํด๋ณด๊ธธ ๋ฐ๋๋ค.
์ฐ๋ฆฌ๊ฐ ๋ฐฐ์ด ๊ฒ์ผ๋ก ์ถฉ๋ถํ ์ปค๋ฒํ ์ ์๋ ์์ค์ด๋ค!
๋๊ธ