Java Programming for Starter(4)

htwenty-1·2021년 12월 9일
0

Java 튜토리얼

목록 보기
4/14
post-thumbnail

안녕하세요. 벌써 Java Programming for Starter가 네번째 포스팅을 맞이했습니다.

자바 입문한지 4일차... JavaScript 하던 버릇이 가끔 혼입되어 컴파일 에러를 자주 발생시키고 있습니다.

뭐 하다보면 적응이 되지 않을까 하는 갑자기 떠오르는 생각도 적어봅시다...

그러면 오늘 학습한 내용을 정리해 나가보겠습니다.

이전 포스팅 복습


어제 우리는 반복문 3대장 for문, while문, do while문 그리고 이들의 실행을 멈추거나 이하 동작을 실행시키지 않는 제어자 breakcontinue에 대해 살펴봤습니다.

우선 for문은 초기값, 반복 조건, 연산식을 선언하고 반복할 작업을 넣어주었습니다.
그리고 for문과 같이 많이 사용하는 예시로 for + if에 대해 살펴보았습니다. 어떤 조건이 참일 때만 반복하는 구조였죠.

그 다음은 for each문을 사용해서 배열에 있는 요소를 한꺼번에 뽑아주는 것도 봤습니다.

그리고 조금 복잡할 수도 있는 for문이 중첩된 형태, 그리고 그 예시로 2차원 배열에서 for문을 중첩 사용하는 것을 실습해봤습니다.

그 다음으로 for문과 성질은 유사하지만 식의 배치가 다른 while문과 do while문을 봤습니다. 이들은 초기값을 먼저 지정해주고 조건을 부여한다음 조건이 참이면 연산을 계속 진행하는 구조였습니다. 주의할 점은 연산식이 블록 내부에 있기 때문에 연산식을 정상적으로 처리해주지 않으면 무한루프에 빠질 가능성이 높아진다는 것이었습니다.

do while문은 while과 조금 다르게 조건의 참거짓 여부를 먼저 확인하지 않고 작업을 우선 한번 실행한 후에 연산을 보여주고 조건의 참거짓을 가려 다시 반복문을 돌리는 구조였습니다.

제어자 break는 반복구문을 탈출하게 해주는 녀석이었고, continue는 조건이 성립한다면 이하의 작업을 실행하지 말고 스킵하라고 알려주는 녀석이었습니다.

다음 코드 예시를 살펴보며 각각의 특징들에 대해 기억해봅시다.

// 반복문 for
// 기본적인 형식
for ( 초기값(변수의 초기화); 조건식; 연산식 ) {
  처리;
}

// 예시1 : 기본 작동방식
for (int i = 0; i < 10; i++) {
  System.out.println("이게 반복문이다!");
}		// -> i가 0부터 9가 될 때까지 메시지 10회 출력

// 예시2 : decrement 적용하기
for (int i = 10; i > 0; i--) {
  System.out.println("i = " + i);
}		// -> i가 10부터 1이될때까지 메시지 10회 출력

/**********************************************/
// 예시3 : for문과 if문 같이 쓰기
String names[] = { "홍길동", "일지매", "성춘향", "홍두깨" };

int number = 0;		// 몇번째에 있는지 알려주기 위해 임의의 변수 선언 및 초기화
for (int i = 0; i < names.length; i++) {
  number++;			// 배열 첫번째 요소를 1로 정의해서 보여줄것임.
  if(names[i] = "성춘향") {
    System.out.println("찾았다~ " + numbers + "번째!");
  }
}

// 예시4 : for each
// 0번째부터 n번째에 있는 배열의 요소 전체를 가져올 수 있다!
String names[] = { "홍길동", "일지매", "성춘향", "홍두깨" };
for (int name : names) {
  System.out.println(name);
}

// 예시5 : for문 중첩
// 구구단을 출력하는 예시
for (i = 1; i < 10; i++) {
  for (j = 1; j < 10; j++) {
    System.out.println("i * j = " + (i*j))
  }
}

// 참고 : for문을 중첩해서 썼을 때 특정조건에서 빠져나오기 위해서는
// 각 for문마다 break를 걸어줍니다!

/**********************************************/
// 반복문 while과 do while
// 기본적인 형식
//// while
변수 초기화;
while (조건식) {
  처리;
  연산식;
}

//// do while
변수 초기화
do {
  처리;
  연산식;
} while (조건식);

// 예시6 : 반복구문을 loop시켜 0 ~ 1까지 출력하기
int w = 0;
while (w < 10) {
  System.out.println(w);
  w++;
}

// 예시7 : 예시6을 do while문으로
int dw = 0;
do {
  System.out.println(dw);
  dw++;
} while (dw < 10)

Wrapper Class


주요 개념

우선 클래스라는 것은 객체(Object)를 가리킵니다. 쉽게 생각하면 앞서 살펴본 일반적인 자료형(byte, char, int, double 등)을 사용하기 편하게 만들어 둔 것이죠.
우리가 자료형을 살펴봤을 때 자료형이라고는 말할 수 없지만 문자열을 다뤄주는 녀석이 그것 뿐이라서 그냥 사용했던게 기억이 나실겁니다. 그것의 정체는 바로 String이었고, 왜 문자열을 다루는 자료형은 없는가에 대해 먼저 알아보겠습니다.

Java에서 문자열은 문자 + 문자 + 문자와 같은 구조로 이루어져 있습니다. 예를 들어 Hello라는 문자열을 다룬다면 H + e + l + l + o처럼 되어 있는 것이지요.

얼마나 비효율적입니까? 그래서 String이라는 편리한 도구를 만들었고 이는 문자열을 다룰 수 있게 해주는 획기적인 아이템이 된 것입니다.

그렇다면 일반적인 자료형과 매치되는 클래스 명칭을 살펴보겠습니다.

일반 자료형Wrapper Class(Object)
booleanBoolean
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
charCharacter
char[]String

여기에서 우리가 알 수 있는 것은 클래스는 앞글자가 대문자로 시작한다는 것과 IntegerCharacter는 일반 자료형과 다소 다르게 full-name을 작성해준다는 점입니다.

이렇게 class들은 데이터를 담는 그릇(자료형)에 공간이 구분되어 다양한 기능들을 내재하고 있는, 게다가 자료도 담을 수 있는 그런 멋있는 녀석이라고 보시면 되겠습니다!

Integer

Integer 객체는 int자료형과 동일합니다! 그런데 이제 기능을 좀 곁들인...

원래 우리가 4바이트 정수 자료형을 선언해줄 때 다음과 같이 선언했습니다.

int i = 123;

그렇지만 class를 사용하면 다음과 같이 선언해줄 수 있습니다.

Integer iObj = 123;

객체임을 강조하기 위해 변수명을 iObj으로 선언했습니다.

원래는 정석대로 하자면(?) 다음과 같이 선언해야 합니다.

Integer iObj = new Integer(123);

그런데 뭐 어떤 방식으로 하든 상관없습니다...

그렇다면 class를 어떻게 받아들일 수 있을까?

class는 설계, 구성, 즉 object의 개념으로 봅니다. 위에서 살펴본것처럼 일반 자료형과는 다르게 객체는 어떤 기능을 장착했다는 개념으로 생각한다면 그 안에 다양한 것들을 추가 할 수 있습니다. 정해진 자료형만 담는게 아니라 변수, 함수(메서드)등도 활용할 수 있죠.

숫자 자료형을 문자열로 바꿔보자!

그러면 예시를 보며 객체에 대해 알아보겠습니다.

// 일반 자료형에서 숫자를 문자로 바꾸는 예시
int p = 1;
char q = p;

우선 4바이트 정수형 자료를 2바이트 문자에 집어 넣는다고 하면 에러가 발생한다는 것을 우리는 알고 있습니다.
강제로 밀어넣을 수는 없을까요? 가능합니다! 강제 자료형 변환이라는 것을 사용한다면 충분히 가능합니다.

// 일반 자료형에서 숫자를 문자로 바꾸는 예시
int p = 1;
char q = (char)p;

이렇게 p의 자료형을 2바이트 문자로 바꿔주었습니다.

일반 자료형에서 자료형의 타입을 바꾸기 위해서는 자료형 변환이라는 것을 사용해주었는데, 객체에서는 조금 다릅니다.

정수형 객체를 문자열 객체로 바꿔서 출력해 보겠습니다!

// 정수형 객체 선언...................①
Integer objNum = 123;

// 문자열 객체 선언...................②
String str = objNum.toString();

①에서 정수형 객체에 123이라는 자료를 넣어주었습니다.
이를 문자열로 반환하기 위해서 ②의 str이라는 객체에 넣어주는데, 숫자 그대로를 문자열로 담을 수는 없기 때문에 한가지 작업을 해주었습니다.

바로 toSring() 메서드를 사용하는 것입니다. 그냥 해석해보면 문자열로 라는 뜻이 되겠죠~?

다시 말해서 objNum.toString();는 정수형 객체 objNumstring으로 바꿔서 str에 담아줘!
라는 말이 되겠죠?

당장 출력을 해보면 정수형 처럼 보이지만 데이터 타입은 문자열임이 틀림 없습니다.

숫자를 문자열로 바꿔주는 또 하나의 방법이 있습니다! 위의 예시보다 간단합니다.

int num = 123;
String str = num + "";
System.out.print(str);

이렇게 정수형 데이터를 그냥 문자열 객체에 때려 박고 뒤에 ""만 넣어주는 것으로도 가능합니다.
아니 이게 된다고?

그다음으로 문자열을 숫자로 바꿔봅시다!

문자열을 숫자로 바꿔보자!

가령 어떤 문자열 객체에 따옴표로 감싸진 숫자가 선언되어있다고 가정해봅시다. 이 때 따옴표가 있음에 주의해야 하는데, 따옴표로 인해서 숫자 자료형은 문자열이 되는 것입니다.

String str = "12345";		// 문자열 객체

자, 그러면 이녀석을 숫자 객체로 바꿔주려면 어떻게 해야할까요?

바로 parseInt() 메서드를 사용하는 것입니다.

String str = "12345";
int n = Integer.parseInt(str);
System.out.println(n);

여기서 중요한것은 parseInt() 메서드를 사용할 때 반드시 Integer가 동반되어야 한다는 것입니다.
Integer.parseInt(str)의 의미인 즉 문자열 객체 str을 정수로 바꿔서 Integer 객체로 만들어줘~~라는 말이 되는것이죠!

마찬가지로 문자열 객체에 들어있는 부동 소수점도 double형태의 객체 즉 Double로 만들어줄 수 있습니다! 이때는 parseDouble() 메서드를 사용합니다!!

String str4 = "1234.5678";
double d = Double.parseDouble(str4);
System.out.println(d);

이해가 되시나요?
그러면 이제 우리는 10진수를 2진수, 8진수, 16진수로 각각 변환하는 메서드도 사용할 수 있게됩니다.
여기서 중요한것은 10진수를 2, 8, 16진수로 변환할 때, 10진수 자체는 int 자료형으로 변수에 저장하여 사용할 수 있지만, 실제로 2진수, 8진수, 16진수 자체를 int 자료형으로 선언하여 사용하게되면 컴퓨터가 알아먹질 못합니다.

그래서! 2, 8, 16진수는 String 객체로 받아서 parseInt() 즉 숫자로 변환해줄 때 메서드의 parameter로 이것이 몇진수인지 알려주어 10진수로 변환해줄 수 있는 것입니다. 반대로 10진수를 2, 8, 16진수로 변환할 때도 각각을 String객체로 변환해서 작성해 주어야 합니다.

자 그러면 각각의 숫자들을 변환하는 예시를 만들어봅시다!

// 10진수를 각각 2, 8, 16진수로 변환하는 예시

int x = 16;			// 임의의 10진수를 x에 선언

String binary = Integer.toBinaryString(x);		// 2진수로 바꾸는 메서드
String octal = Integer.toOctalString(x);		// 8진수로 바꾸는 메서드
String hex = Integer.toHexString(x);			// 16진수로 바꾸는 메서드

자 이제 그러면 임의의 2진수를 10진수로 변환해보겠습니다.

// 2진수를 10진수로 변환하는 예시

String binary = "10101100";
int binToInt = Integer.parseInt(binary, 2);		// binary변수는 2진수야. 
							//10진수로 바꿔서 binToInt에 저장해줘...

이렇게 parInt() 메서드는 2, 8, 16진수를 10진수로 바꿀 때 변수명과 몇진수인지 밝혀서 10진수로 바꿔주는 역할도 합니다..

// 연습문제 : 10진수 a를 2, 8, 16진수로 바꾸고 역으로 10진수로 바꾸는 프로그램을 작성하세요.

// 10진수를 8진수로
int a = 150;
String b = Integer.toOctalString(a);
System.out.println(b);

// 8진수를 10진수로
int c = Integer.parseInt(b, 8);
System.out.println(c);

// 10진수를 2진수로
String e = Integer.toBinaryString(a);
System.out.println(e);

// 2진수를 10진수로
int f = Integer.parseInt(e, 2);
System.out.println(f);

// 10진수를 16진수로
String g = Integer.toHexString(a);
System.out.println(g);

// 16진수를 10진수로
int h = Integer.parseInt(g, 16);
System.out.println(h);

String 객체의 다양한 활용


계속 언급되고 있는 내용이지만 한 번 더 말씀을 드리면 Java에는 문자열 자료형이 없기 때문에 2바이트 문자 자료형(char)을 문자열로 묶어서 쓸 수 있도록 String이라는 객체를 제공합니다.

우리는 문자열을 활용해서 다양한 것을 할 수 있고 여기에서 어떻게 다양하게 사용할지 살펴보도록 하겠습니다!

문자열의 결합

가령 어떤 String 클래스에 "안녕"이라는 문자열이 저장되어 있고, 또 다른 String 클래스에 "하세요"라는 문자열이 들어있다고 가정해봅시다.

String hello = "안녕";
String word = "하세요";

우리는 연산자에서 살펴봤듯이 문자 또는 문자열끼리의 연산 기능이 제공되는 것을 알고 있습니다.
(물론 +밖에 안되지만...) 마찬가지로 문자열 객체끼리도 합쳐줄 수 있는 연산을 제공하고 있습니다. 그래서 예시에서 hello라는 String 클래스와 word라는 String 클래스를 더하게 되면 두 클래스에 선언된 변수가 더해지게 되는거죠~

String hello = "안녕";
String word = "하세요";

System.out.println(hello + word);	// -> 안녕하세요

문자열의 값 비교

그런데 한가지 재미있는 사실이 있습니다.

String hello = "안녕";
String word = "하세요";

String sayHi = hello + word;
String sayHello = "안녕하세요";

이렇게 주어졌을 때 if문으로 sayHisayHello가 같은지 비교하면 어떤 결과가 나올까요?

if (sayHi == sayHello) {
  System.out.println("같은 문자 입니다!");
} else {
  System.out.println("다른 문자 입니다!");
}

결과는 놀랍게도 "다른 문자 입니다!"라는 결과가 나오게 됩니다.
왜냐하면 sayHisayHello가 같다(==)라고 하는 조건은 값 그자체의 같음을 비교하는게 아니라 메모리에 할당된 주소값을 비교하기 때문에 다르다는 결과를 보여주게 되는 것입니다!

그렇다면, 문자 자체를 비교하기 위해서는 어떻게 해야할까요?

바로 equals() 메서드를 사용하면 됩니다! 이 메서드를 사용해서 값을 비교해봅시다.

String hello = "안녕";
String word = "하세요";

String sayHi = hello + word;
String sayHello = "안녕하세요";

boolean p = sayHi.equals(sayHello);		// 값의 일치 여부에 따라서 true 또는 false가 결정

if (p == true) {
  System.out.println("같은 문자 입니다!");
} else {
  System.out.println("다른 문자 입니다!");
}

논리값을 나타내는 자료형인 boolean에 변수명을 p로 지정하여 값 자체의 비교를 truefalse로 저장합니다.

당연히 같은 값이므로 true가 저장될 것이고 ptrue일때 처리문이 실행될 것입니다.

또 다른 String 객체의 메서드들

String 객체에 사용할 수 있는 메서드는 엄청나게 많은 종류가 있지만, 주로 사용하는것만 간단하게 살펴보겠습니다.

메서드의미
equals()값이 같은 지 비교
indexOf()문자열의 앞에서부터 위치 인덱스 반환
lastIndexOf()문자열의 뒤에서부터 위치 인덱스 반환
length()문자열의 길이
replace()찾아 바꾸기
split()토큰을 기준으로 문자열을 자름
substring()문자열을 범위로 자름
toUpperCase()모두 대문자로 변경
toLowerCase()모두 소문자로 변경
trim()문자열의 앞뒤 공백 제거
charAt()인덱스에 해당하는 문자 반환
contains()특정 문자를 포함하고 있는지 boolean 값으로 반환

이 정도 기억하고 있으면 될 것같고, 이제 예시를 통해서 어떻게 사용하는지 보겠습니다.

// indexOf와 lastIndexOf
String str = "Hello World";
int index = str.indexOf("l");		// 앞에서부터 0, 1, 2번째 --> 2
int indexRev = str.lastIndexOf("l");	// 뒤에서부터 1, 2, ..., 8, 9번째 --> 9

// length
int len = str.length();				// 1부터 세서 공백을 포함, 11 --> 11

// replace
String str2 = "A*B*C*D";
String repStr2 = str2.replace("*", "");	// *을 찾아서 아무것도 없게 해줌

// split
String person = "홍길동-25-2001-05-01-서울시";
String personStr[] = person.split("-"); 	// person객체 문자열에서 -를 빼줌.
System.out.println(personStr[0]);		// 홍길동
System.out.println(personStr[1]);		// 25
System.out.println(personStr[2]);		// 2001
System.out.println(personStr[3]);		// 05
System.out.println(personStr[4]);		// 01
System.out.println(personStr[5]);		// 서울시

// substring
String sayHello = "안녕하세요. 반갑습니다.";
String sayHi = sayHello.subString(7, 12);	// 반갑습니다.

// toUpperCase와 toLowerCase
String letter = "abcDEF";
String letters = str10.toUpperCase();		// ABCDEF
String letters = str10.toLowerCase();		// abcdef

// trim
String loveJava = "   java   java   java   ";
String noLove = loveJava.trim();		// java   java   java

// charAt
String korean = "가나다라마바사";
String wordArea = korean.charAt(2);		// 다

// contains
String address = "대전광역시 서구 둔산동";
boolean test = address.contains("서구");		// true

Sorting : 배열 안에 있는 원소들 정렬하기


sorting, 말 그대로 정렬입니다. 숫자를 예로 들면 작은 수부터 큰 수의 차례로 정렬해주는 오름차순 정렬, 그리고 그 반대인 내림차순 정렬이 있습니다.

우리는 배열이라고하는 자료구조에 대해 학습한 사실이 있습니다.

만약 규모가 큰 배열이 있다고 가정해봅시다.
이 배열의 원소는 1부터 1000까지인데 정렬이 되어있지 않고 무작위로 배열 인덱스마다 배치되어 있습니다.

그렇다면 우리가 이 배열안에 있는 원소들을 작은 숫자부터 큰 숫자까지 정렬해야 한다고 할 때, 하나하나 수작업으로 할 수도 없는 노릇입니다.

1000개 쯤이야 라고 하지만 원소가 1억개, 10억개라고 해도 과연 "쯤이야"라는 말이 나올까요?

우리는 컴퓨터에게 배열안에 있는 숫자들을 정확하게 정렬해줘! 라고 명령할 수 있습니다.

바로 Java의 Sorting이라는 개념이 뒤죽박죽이 되어버린 배열을 구해 줄 것입니다.

간단한 예시를 보겠습니다.

int numbers[] = { 1, 7, 10, 3, 6, 5, 2, 8, 4, 9 };

이러한 고정된 배열 안에 있는 숫자를 어떻게하면 효율적으로 빠르게 정렬해서 보여줄 수 있을까요?

컴퓨터에게 배열 안에 있는 원소들을 싹다 뒤져서 작은 놈부터 앞으로 끌어내! 라고 명령하고 싶지만 우리의 컴퓨터는 창의적인 생각을 하진 못합니다.

그렇다면 어떤 방식으로 비교를 해주게 될까요?

바로 0번째 인덱스가 자기 자신을 제외한 n번째 인덱까지 서로의 값을 비교한 후 자신보다 작은 값이 있으면 서로 자리를 바꿉니다.
그 다음 1번째 인덱스가 자기 자신을 제외한 2번째 인덱스부터 n번째 인덱스까지 서로의 값을 비교합니다.
이런식으로 n-1번째 인덱스와 n번째 인덱스가 서로 비교될때까지 순환하게 됩니다.

여기에서 얻을 수 있는 힌트 하나는 반복문을 써야 한다는 것이고, 단순한 순환구조가 아니라 어떤 값을 기준으로 또 다른 값을 조종해야하는 반복작업이기 때문에 반복문을 중첩해서 정렬해주면 된다는 결론에 이를 수 있습니다!

자, 그러면 위의 numbers[] 배열을 오름차순으로 정렬해보겠습니다.

int numbers[] = { 1, 7, 10, 3, 6, 5, 2, 8, 4, 9 };

// i가 0부터 배열의 길이만큼 1씩 증가하며 작업 수행
for (int i = 0; i < numbers.length; i++) {
  // j가 0부터 배열의 길이만큼 1씩 증가하며 작업 수행
  for (int j = 0; j < numbers.length; j++) {
  
  }
}

초기에 이렇게 코드를 작성해 주었습니다.

우선 배열의 인덱스별로 어떤 값을 참조하며 값을 비교하게 되는지 나타내보겠습니다.

Array[0] >>> Array[1], Array[2], Array[3], ... Array[n]
Array[1] >>> Array[2], Array[3], Array[4], ... Array[n]
Array[2] >>> Array[3], Array[4], Array[5], ... Array[n]
Array[3] >>> Array[4], Array[5], Array[6], ... Array[n]
    .
    .
    .
Array[n-1] >>> ....., Array[n]
Array[n]   >>> 비교 대상이 없으므로 고정

이러한 관계를 갖기 때문에 자기 자신과의 비교 그리고 n번째 원소는 또 자기 자신과 비교할 필요가 없게된다는 사실을 알 수 있습니다.

그래서,

int numbers[] = { 1, 7, 10, 3, 6, 5, 2, 8, 4, 9 };

// 마지막 요소 자신과의 비교는 필요하지 않음.
for (int i = 0; i < numbers.length-1; i++) {
  // j는 i다음으로 오는 요소와 비교해야 함.
  for (int j = i+1; j < numbers.length; j++) {
  
  }
}

이렇게 먼저 for문을 세팅해주었습니다.

int numbers[] = { 1, 7, 10, 3, 6, 5, 2, 8, 4, 9 };

int p;		// 비교 대상이 되는 원소를 임시로 보관하는 변수

for (int i = 0; i < numbers.length-1; i++) {
  for (int j = i+1; j < numbers.length; j++) {
  	
    if (numbers[i] > numbers[j]) {
      p = numbers[i];
      numbers[i] = numbers[j];
      numbers[j] = p;
    }
  
  }
}

끝입니다. 출력까지 해보면 오름차순으로 정렬되어 있는 것을 보실 수 있습니다.

오늘 준비한 내용은 여기까지입니다. 도움이 많이 되셨나요? 그럼 문제를 해결하며 오늘 정리한 내용을 다시 한 번 확인해 보겠습니다.


과제


과제 1

문제 1
주어진 변수의 값이 숫자로만 되어있는지, 문자로만 되어있는지 판별해주는 프로그램을 작성하시오.

// 주어지는 변수
char ch = '9'

/******************************/

// 필요한 변수 선언
int ascci = (int)ch;		// 문자를 아스키코드로 변환
boolean x = true;

if (ascci < 48 || ascci > 57) {		// 숫자를 제외시켜주는 범위
  x = false;
}

if (x) {
  System.out.println("숫자입니다.");
} else {
  System.out.println("문자입니다.");
}

문제 2
입력된 문자열이 모두 숫자로 되어있는지 아니면 모두 숫자로 되어있지 않은지 판별하는 프로그램을 작성하시오.

// 필요한 변수 선언
Scanner input = new Scanner(System.in);
char p = 0;
boolean q = true;

// 값 입력받기
System.out.println("아무 숫자나 입력하세요>> ");
String number = input.next();

// 입력받은 숫자의 i번째에 있는 문자를 조사해서 아스키코드와 대조
// 조건은 0부터 9까지를 피한 나머지, 여기에 속하면 q는 false가 됨.
for(int i = 0; i < number.length(); i++) {
  p = number.charAt(i);
  if (p < 48 || p > 57) {
    q = false;
    break;
  }
}

if (q == true) {
  System.out.println("숫자로만 되어 있네요");
} else {
  System.out.println("문자도 들어있는 것 같아요...");
}

문제 3
영단어를 입력받아 toUpperCase나 toLowerCase를 사용하지 않고 모두 대문자로 바꿔주는 프로그램을 작성하시오.

// 필요한 변수 선언
Scanner input = new Scanner(System.in);
String res = "";

// 단어 입력받기
System.out.println("영단어를 입력하세요~ >> ");
String word = input.next();

for(int i = 0; i < word.length(); i++) {
  char c = word.charAt(i);
  int n = (int)c;
  
  if (n >= 97) {		// 97 ~ 122까지 소문자
  	n -= 32;			// 대문자에 대한 아스키코드
  }
  res += (char)n;
}

System.out.println(res);

과제 2

문제
입력받은 수를 각각 변환해주는 프로그램을 작성하시오.

Scanner sc = new Scanner(System.in);

System.out.println("Menu >>> ");
System.out.println("1. 10진수를 2진수로 변경");
System.out.println("2. 10진수를 8진수로 변경");
System.out.println("3. 10진수를 16진수로 변경");
System.out.println("4. 2진수를 10진수로 변경");
System.out.println("5. 8진수를 10진수로 변경");
System.out.println("6. 16진수를 10진수로 변경");
System.out.print("원하시는 처리번호를 입력해주세요. >> ");

int work = sc.nextInt();

System.out.print("변경하고자 하는 숫자를 입력하세요. >> ");

// 2, 8, 16진수를 고려해서 String으로 받는다.
String numStr = sc.next();

switch(work) {
  case 1:
    int num10 = Integer.parseInt(numStr);
    String num2 = Integer.toBinaryString(num10);
    System.out.println("10진수 " + numStr + "의 2진수는 " + num2 + "입니다.");
    break;
    
  case 2:
    int num102 = Integer.parseInt(numStr);
    String num8 = Integer.toOctalString(num102);
    System.out.println("10진수 " + numStr + "의 8진수는 " + num8 + "입니다.");
    break;
    
  case 3:
    int num103 = Integer.parseInt(numStr);
    String num16 = Integer.toHexString(num103);
    System.out.println("10진수 " + numStr + "의 16진수는 " + num16 + "입니다.");
    break;
    
  case 4:
    int num104 = Integer.parseInt(numStr, 2);
    System.out.println("2진수 " + numStr + "의 10진수는 " + num104 + "입니다.");
    break;
    
  case 5:
    int num105 = Integer.parseInt(numStr, 8);
    System.out.println("8진수 " + numStr + "의 10진수는 " + num105 + "입니다.");
    break;
    
  case 6:
    int num106 = Integer.parseInt(numStr, 16);
    System.out.println("16진수 " + numStr + "의 10진수는 " + num106 + "입니다.");
    break;
  }

과제 3

문제
다음 조건에 맞춰 정렬하는 프로그램을 작성하시오.
1. 사용자에게 몇개의 숫자를 정렬할 것인지 입력 받기
2. 정렬할 숫자 입력 받기
3. 오름차순/내림차순 여부 입력 받기
4. 정렬 처리하기
5. 결과 출력하기

// 필요한 변수를 선언
Scanner input = new Scanner(System.in);
int sortCount;
int wantSort;
int p;
		
// 사용자에게 몇개 숫자를 정렬할 것인지 입력 받기
System.out.print("몇개의 숫자를 정렬하시겠어요? >>> ");
sortCount = input.nextInt();
		
// 정렬할 숫자 입력받기
int sortArr[] = new int[sortCount];
for (int i = 0; i < sortCount; i++) {
  System.out.print("정렬할 숫자를 입력해주세요! >> ");
  sortArr[i] = input.nextInt();
}
		
// 오름차순/내림차순 여부 입력 받기
System.out.print("오름차순으로 하시려면 1, 내림차순으로 하시려면 2를 입력하세요. >> ");
wantSort = input.nextInt();
		
// 오름차순/내림차순 여부 입력받아 정렬해주기
		
switch(wantSort) {
  case 1:
    for (int i = 0; i < sortArr.length-1; i++) {
      for (int j = i+1; j < sortArr.length; j++) {
        if(sortArr[i] > sortArr[j]) {
          p = sortArr[i];
          sortArr[i] = sortArr[j];
          sortArr[j] = p;
        }
      }
    }
    break;
				
  case 2:
    for (int i = 0; i < sortArr.length-1; i++) {
      for (int j = i+1; j < sortArr.length; j++) {
        if(sortArr[i] < sortArr[j]) {
          p = sortArr[i];
          sortArr[i] = sortArr[j];
          sortArr[j] = p;
        }
      }
    }
    break;
  default:
    System.out.println("처음부터 다시 시도하세요.");
}
		
// 정렬 결과 출력하기
System.out.print(Arrays.toString(sortArr));

번외편

강사님 따라하다 터져버린 계산기를 복구함

import java.util.*;
public class MainClass {

	public static void main(String[] args) {
		
		// 멀캠 강사님 따라하다가 터져버린 계산기 재작성하기
		
		/*
			로직 정리하기
			0. 필요한 변수를 선언해주자.
			1. 첫번째 수를 입력받는다.
			1-1. 이 때 숫자가 아니면 처음으로 돌아간다.
			2. 연산자를 입력 받는다. (+, -, *, /)
			2-1. 이 때 연산자가 아니라면 처음으로 돌아간다.
			3. 두번째 숫자를 입력받는다.
			3-1. 이 때 숫자가 아니라면 처음으로 돌아간다.
			4. 각 연산자에 맞는 연산결과를 임의의 변수에 저장한다.
			5. 연산 결과를 출력한다.
		*/
		
		// 필요한 변수 선언
		Scanner input = new Scanner(System.in);
		String firstNum, secondNum;		// 입력받을 숫자들
		int x;
		int firstNumber, secondNumber;
		boolean p;						// p값은 선언만 해놓고 while문 돌때마다 초기화해줘야함..
		String oper;					// 연산자
		int result = 0;					// 연산 결과를 담을 변수
		
		// 첫번째 숫자 입력 받기
		while(true) {
			p = true;
			System.out.print("첫번 째 숫자를 입력해 주세요 >>> ");
			firstNum = input.next();
			// 숫자가 아니라면 다시 입력 요청하기
			//// 문자가 입력되었을 경우 : 아스키코드로 숫자와 비교
			for (int i = 0; i < firstNum.length(); i++) {
				x = firstNum.charAt(i);
				if (x < 48 || x > 57) {
					p = false;
					break;
				}
			}
			if(p == true) {
				break;
			}
			
			// 잘못입력하면 메시지 띄워주기
			System.out.println("숫자를 정확히 입력하세요!");
		}
		
		
		// 연산자 입력 받기
		while(true) {
			System.out.print("연산자를 입력해 주세요(+, -, *, /) >>> ");	
			oper = input.next();
			if(oper.equals("+") || oper.equals("-") || oper.equals("*") || oper.equals("/")) {
				break;
			}
			
			// 잘못입력하면 메시지 띄워주기
			System.out.println("올바른 연산자를 입력하세요!");
		}
		
		// 두번째 숫자 입력 받기
		while(true) {
			p = true;
			System.out.print("두번 째 숫자를 입력해 주세요 >>> ");
			secondNum = input.next();
			// 숫자가 아니라면 다시 입력 요청하기
			//// 문자가 입력되었을 경우 : 아스키코드로 숫자와 비교
			for (int i = 0; i < secondNum.length(); i++) {
				x = secondNum.charAt(i);
				if (x < '0' || x > '9') {
					p = false;
					break;
				}
			}
			if(p == true) {
				break;
			}
			// 잘못입력하면 메시지 띄워주기
			System.out.println("숫자를 정확히 입력하세요!");
		}
		
		// 문자로 입력 받았던 것들을 숫자로 바꿔주기~
		firstNumber = Integer.parseInt(firstNum);
		secondNumber = Integer.parseInt(secondNum);
		
		// 연산하여 변수에 저장하기
		switch (oper) {
			case "+":
				result = firstNumber + secondNumber;
				break;
			
			case "-":
				result = firstNumber - secondNumber;
				break;
				
			case "*":
				result = firstNumber * secondNumber;
				break;
			
			case "/":
				result = firstNumber / secondNumber;
				break;
				
			default:
				System.out.println("입력이 잘못되었습니다. 처음부터 다시 시도하세요.");
				break;
		}
		
		// 연산결과 출력해주기
		System.out.println(result);

	}

}
profile
tried ? drinkCoffee : keepGoing;

0개의 댓글