스물여섯 번째 수업

정혅·2024년 3월 18일
Java

더 조은 아카데미

목록 보기
31/76
post-thumbnail

오전문제

  1. 다음과 같이 정의된 메소드가 존재한다고 가정해보자(이 메소드는 이미 정의되어있고,
    여러분은 이 메소드를 반드시 활용해야만 하는 상황이라고 가정하자.

public static void showData(Object obj)
{
System.out.println(obj);
}

이 메소드를 통해서 출력해야 할 데이터가 정수 3과 실수 7.15이다.
이러한 상황에서는 정수 3과 실수 7.15가 Object 클래스를 상속하는 인스턴스의 형태가 되어야만 위 메소드의 인자로 전달될 수 있다.
이것이 기본 자료형 데이터가 인스턴스로 표현되어야 하는 상황인데,
이렇듯 인스턴스의 참조 값을 요구하는 자리에 기본 자료형 데이터를 놓아야 하는 경우, 기본 자료형 데이터를 인스턴스로 표현해야 한다.
그러면 위에 있는 메소드를 이용하여 정수 3을 출력하도록 하자.

내가 푼 풀이

package com.test.memo;

public class Practice1 {
    public static void showData(Object obj) {
        System.out.println(obj);
    }

    public static void main(String[] args) {
        Integer num1 = new Integer(3);
        Double num2 = new Double(7.15);
        showData(num1);
        showData(num2);

    }
}
  1. 전화번호를 검색하는 프로그램을 작성해보자.

String[] phoneNumArr = {
"012-3456-7890",
"099-2456-7980",
"088-2346-9870",
"013-3456-7890"
};

출력: 234

[012-3456-7890, 088-2346-9870]

package com.test.memo;

import java.util.Scanner;
import java.util.Vector;

public class Practice1 {

    public static void main(String[] args) {
        String[] phoneNumArr = { "012-3456-7890", "099-2456-7980", "088-2346-9870", "013-3456-7890" };
        String findNum = null;
        Vector<String> vec = new Vector<>();

        Scanner sc = new Scanner(System.in);

        while (true) {

            System.out.print("검색하실 전화번호를 입력하세요: ");
            findNum = sc.nextLine().trim();
            if (findNum.equals("")) {
                continue;
            } else if (findNum.equalsIgnoreCase("Q")) {// 대소문자 상관없이 저 문자를 입력하면 시스템 종료
                System.exit(0);
            }
            for (int i = 0; i < phoneNumArr.length; i++) {
                String phoneNum = phoneNumArr[i];
                String temp = phoneNum.replace("-", " ");
                if (temp.contains(findNum)) {// temp안에 findNum 문자열이 포함하는지의 여부

                    vec.add(temp.replace(" ", "-"));// 출력할떄 하이포 표시하기 위해서
                }
            }
            if (vec.size() > 0) {
                System.out.println(vec); // 검색 결과를 출력하고
                vec.clear();// 검색 결과를 삭제 > 비워주기 위함
            } else
                System.out.println("일치하는 번호가 없습니다.");
        }
    }
}
  1. 두 개의 배열을 이용하여
    다음과 같이 출력 결과가 나오도록 하자.

char[] dest = new char[10];
char[] src = {'1', '2', '3', '4'};

왼쪽 정렬
1234000000
오른쪽 정렬
0000001234
가운데 정렬
0001234000

package com.test.memo;

import java.util.Arrays;

class Practice2 {
    public static void main(String[] args) {
        char[] dest = new char[10];
        char[] src = { '1', '2', '3', '4' };

        Arrays.fill(dest, '0');
        // 왼쪽 정렬
        System.out.println("왼쪽 정렬");
        System.arraycopy(src, 0, dest, 0, src.length);
        System.out.println(dest);

        Arrays.fill(dest, '0');
        // 오른쪽 정렬
        System.out.println("오른쪽 정렬");
        System.arraycopy(src, 0, dest, dest.length - src.length, src.length);
        System.out.println(dest);

        Arrays.fill(dest, '0');
        // 가운데 정렬
        System.out.println("가운데 정렬");
        System.arraycopy(src, 0, dest, (dest.length - src.length) / 2, src.length);
        System.out.println(dest);
    }
}
  • 처음에 배열에 0을 채워줄때 Arrays.fill() 메서드를 생각하지 못해서 for문을 하나하나 다 쓸 뻔 했다.
  • 가운데 정렬 할 떄 가운에부터 복사하는 부분의 괄호를 제대로 치지 않아서 오류가 계속 발생했다.

  1. 기본자료형에 8가지에 대한 래퍼 클래스를 서술하시오.

    • Byte

    • Character

    • Integer

    • Float

    • Double

    • Long

    • Short

    • Boolean

  1. 다음의 실행 결과를 적으시오.
import java.util.regex.*;    // Pattern과 Matcher가 속한 패키지

class RegularEx1 {
    public static void main(String[] args) 
    {
        String[] data = {"bat", "baby", "bonus",
                    "cA","ca", "co", "c.", "c0", "car","combat","count",
                    "date", "disc"};        
        Pattern p = Pattern.compile("c[a-z]*");    

        for(int i=0; i < data.length; i++) {
            Matcher m = p.matcher(data[i]);
            if(m.matches())
                System.out.print(data[i] + ",");
        }
    }
}
  1. ca, co, car, combat, count
  1. 다음의 실행결과를 적으시오.
import java.util.regex.*;    // Pattern과 Matcher가 속한 패키지

class RegularEx2 {
    public static void main(String[] args) {
        String[] data = {"bat", "baby", "bonus", "c", "cA",
                        "ca", "co", "c.", "c0", "c#",
                    "car","combat","count", "date", "disc"
                        };        
        String[] pattern = {".*","c[a-z]*","c[a-z]", "c[a-zA-Z]",
                                          "c[a-zA-Z0-9]","c.","c.*","c\\.","c\\w",
                                          "c\\d","c.*t", "[b|c].*", ".*a.*", ".*a.+",
                                          "[b|c].{2}"
                                         };

        for(int x=0; x < pattern.length; x++) {
            Pattern p = Pattern.compile(pattern[x]);
            System.out.print("Pattern : " + pattern[x] + "  결과: ");
            for(int i=0; i < data.length; i++) {
                Matcher m = p.matcher(data[i]);
                if(m.matches())
                    System.out.print(data[i] + ",");
            }
            System.out.println();
        }
    } // public static void main(String[] args) 
}

  1. bat, baby, bonus, c, cA, ca, co, c., c0, c#m carm combatm count, datem disc

  2. c, ca, co, car, combat, count

  3. ca, co

  4. cA, ca, co

  5. cA, ca, co, c0

  6. cA, ca, co, c., c0, c#

  7. c, cA, ca, co, c.m c0, c#, car, combat, count

  8. c.

  9. cA, ca, co, c0

  10. c0

  11. combat, count

  12. bat, baby, bonus, c, cA, ca, co, c., c0, c#, car, combat, count

  13. bat, baby, ca, car, date

  14. bat, baby, car, date

  15. bat, car

  1. 다음 배열을 이용하여, 실행결과가 다음과 같이 나오도록 하세요.

실행 결과
123 숫자입니다.
012 숫자입니다.
3GT 숫자가 아닙니다.
안녕 숫자가 아닙니다.
Hello 숫자가 아닙니다.

String[] data = {"123","012", "3GT", "안녕", "Hello"};

package com.test.memo;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

class Practice2 {
    public static void main(String[] args) {
        String[] data = { "123", "012", "3GT", "안녕", "Hello" };

        Pattern pt = Pattern.compile("\\d{3}");

        for (String s : data) {
            Matcher m = pt.matcher(s);
            if (m.matches()) {
                System.out.println(s + " 숫자 입니다.");
            } else {
                System.out.println(s + " 숫자가 아닙니다.");

            }
        }

    }
}
  • 처음에 출력시킬 때 s가 아닌 m 으로 출력시켜서 아래와 같이 출력되었다.
  • Patterc.compile할 때 "\d"로 놓아서 한문자로 지정해놓아서 다 숫자가 아니라고 출력되었었다.

  1. 배열을 이용하여, 실행결과가 다음과 같이 나오도록 하세요.

    실행 결과

123 영문자가 아닙니다.
012 영문자가 아닙니다.
3GT 영문자가 아닙니다.
안녕 영문자가 아닙니다.
Hello 영문자입니다.

String[] data = {"123","012", "3GT", "안녕", "Hello"};

package com.test.memo;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

class Practice2 {
    public static void main(String[] args) {
        String[] data = {"123","012", "3GT", "안녕", "Hello"};

        Pattern pt = Pattern.compile("[A-Za-z]*");

        for (String s : data) {
            Matcher m = pt.matcher(s);
            if (m.matches()) {
                System.out.println(s + " 영문자 입니다.");
            } else {
                System.out.println(s + " 영문자가 아닙니다.");

            }
        }
    }
}
  • 위처럼 글자수를 지정하는 것보다 *를 이용해서 없거나 1이상이거나로 지정하는게 더 효율적인것같다.

  1. 배열을 이용하여, 실행결과가 다음과 같이 나오도록 하세요.

실행 결과

123 한글이 아닙니다.
012 한글이 아닙니다.
3GT 한글이 아닙니다.
안녕 한글입니다.
Hello 한글이 아닙니다.

String[] data = {"123","012", "3GT", "안녕", "Hello"};

package com.test.memo;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

class Practice2 {
    public static void main(String[] args) {
        String[] data = { "123", "012", "3GT", "안녕", "Hello" };

        Pattern pt = Pattern.compile("[가-힣]*");

        for (String s : data) {
            Matcher m = pt.matcher(s);
            if (m.matches()) {
                System.out.println(s + " 한글 입니다.");
            } else {
                System.out.println(s + " 한글이 아닙니다.");

            }
        }
    }
}

  1. 배열을 이용하여, 실행결과가 다음과 같이 나오도록 하세요.

    실행 결과

hello 유효한 이메일 주소가 아닙니다.
hello@ 유효한 이메일 주소가 아닙니다.
hello@naver 유효한 이메일 주소가 아닙니다.
hello@naver.com 유효한 이메일 주소입니다.
good@good.co.kr 유효한 이메일 주소입니다.

String[] data = {"hello", "hello@", "hello@naver", "hello@naver.com", "good@good.co.kr"};

package com.test.memo;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

class Practice2 {
    public static void main(String[] args) {
        String[] data = { "hello", "hello@", "hello@naver", "hello@naver.com", "good@good.co.kr" };

        Pattern pt = Pattern.compile("\\w+@\\w+\\.\\w+(\\.\\w+)?");// {2,} > 영문자가 두개 이상이게 끝나야한다는 어설션

        for (String s : data) {
            Matcher m = pt.matcher(s);
            if (m.matches()) {
                System.out.println(s + " 유효한 이메일 주소 입니다.");
            } else {
                System.out.println(s + " 유효한 이메일 주소가 아닙니다.");

            }
        }
    }
}
  • [a-z]+@\\w+\\.* 로 조건을 두니까 hello@naver 만 유효한 이메일 주소 라고 나온다.
  1. 다음 배열을 이용하여, 실행결과가 다음과 같이 나오도록 하세요.

실행 결과

02 유효한 전화번호가 아닙니다.
02-123 유효한 전화번호가 아닙니다.
02-123-456 유효한 전화번호가 아닙니다.
02-123-4567 유효한 전화번호입니다.
02-1234-4567 유효한 전화번호입니다.
031-1234-5678 유효한 전화번호입니다.

String[] data = {"02", "02-123", "02-123-456", "02-123-4567", "02-1234-4567", "031-1234-5678"};

package com.test.memo;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

class Practice2 {
    public static void main(String[] args) {
        String[] data = { "02", "02-123", "02-123-456", "02-123-4567", "02-1234-4567", "031-1234-5678" };

        Pattern pt = Pattern.compile("\\d{2,}-\\d{3,}-\\d{4,}");// {2,} > 영문자가 두개 이상이게 끝나야한다는 어설션

        for (String s : data) {
            Matcher m = pt.matcher(s);
            if (m.matches()) {
                System.out.println(s + " 유효한 전화번호 입니다.");
            } else {
                System.out.println(s + " 유효한 전화번호가 아닙니다.");

            }
        }
    }
}

  • 하이폰을 []안에 두는게 아니고 밖에 꺼내놔야하는데 +랑 같이 두니까 안되서 그냥 몇 이상의 숫자만 지정해서 뒀다. 원래 번호는 4자리 이하니까 네개로 설정하는게 당연한건감..

    • 조건은 [4]로 놓으면 다 유효하지않다고 뜬다..
  1. 다음 배열을 이용하여, 실행결과가 다음과 같이 나오도록 하세요.

실행 결과
010 유효한 핸드폰 번호가 아닙니다.
010-1234-5678 유효한 핸드폰 번호입니다.
02-123-456 유효한 핸드폰 번호가 아닙니다.
02-123-4567 유효한 핸드폰 번호가 아닙니다.
02-1234-4567 유효한 핸드폰 번호가 아닙니다.
031-1234-5678 유효한 핸드폰 번호가 아닙니다.

String[] data = {"010", "010-1234-5678", "02-123-456", "02-123-4567", "02-1234-4567", "031-1234-5678"};

package com.test.memo;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

class Practice2 {
    public static void main(String[] args) {
        String[] data = { "010", "010-1234-5678", "02-123-456", "02-123-4567", "02-1234-4567", "031-1234-5678" };

        Pattern pt = Pattern.compile("[0-1]+{3}-\\d{4}-\\d{4}");// {2,} > 영문자가 두개 이상이게 끝나야한다는 어설션

        for (String s : data) {
            Matcher m = pt.matcher(s);
            if (m.matches()) {
                System.out.println(s + " 유효한 전화번호 입니다.");
            } else {
                System.out.println(s + " 유효한 전화번호가 아닙니다.");

            }
        }
    }
}

  • 처음 앞자리 번호범위만 제한시키면 되었던거라 쏘이지 했다..후후
  1. 다음 소스 코드를 이용하여 실행결과가 다음과 같이 나오도록 하세요.

실행 결과
1: 011-1111-1111 -> 011, 1111, 1111
2: 02-999-9999 -> 02, 999, 9999

String source = "HP:011-1111-1111, HOME:02-999-9999 ";
String pattern = "(0\d{1,2})-(\d{3,4})-(\d{4})";

package com.test.memo;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

class Practice2 {
    public static void main(String[] args) {

        String source = "HP:011-1111-1111, HOME:02-999-9999 ";
        String pattern = "(0\\d{1,2})-(\\d{3,4})-(\\d{4})";

        Pattern p = Pattern.compile(pattern);
        Matcher m = p.matcher(source);

        int cnt = 1;
        while (m.find()) {
            System.out.println(cnt++ + ":" + m.group() + "-> " + m.group(1) + ", " + m.group(2) + ", " + m.group(3));

        }
    }
}

  1. 다음 정규식에 해당하는 정규식 문자 또는 정규식의 의미를 서술하시오.

    1. . : 임의의 한 문자를 나타낸다. > 온점

    2. [] : 문자 집합 메타 문자 > 집합 내 포함된 문자는 OR로 작동

    3. *: 없거나 한 개 이상을 의미한다.

    4. + : 한 개 이상

    5. [A-Z] : 범위 지정 메타 문자 마이너스 > 왼쪽 문자를 시작으로 오른쪽 문자까지 순차적으로 문자를 증가

    6. \d : digit의 약자로 한 개의 숫자를 의미한다. [0-9]의 의미와 동일

    7. \s : 공백 문자를 의미

    8. \w : [a-zA-Z0-9_] : 확장문자로, 한 개의 알파벳, 숫자, 언더바를 의미한다.

    9. {n} : n개를 의미한다.

    10. {n, } : n개 이상을 의미한다.

    11. {n, m} : n개 이상 m개 이하를 의미한다.

    12. ? : 없음 또는 한개

    13. () : 그룹핑 > 소괄호 안의 문자를 하나로 인식

    14. ^ : 문자열의 시작

    15. $ : 문자열의 종료 지점

    16. \. : 점 문자를 의미

Chapter9 - java.lang패키지 와 클래스

  1. 다음과 같은 실행결과를 얻도록 SutdaCard클래스의 equals() 를 멤버변수인 num,
    isKwang . 의 값을 비교하도록 오버라이딩하고 테스트 하시오 정답

실행결과
c1=3K
c2=3K
c1.equals(c2):true

package com.test.memo;

class SutdaCard {
    int num;
    boolean isKwang;

    SutdaCard() {
        this(1, true);
    }

    SutdaCard(int num, boolean isKwang) {
        this.num = num;
        this.isKwang = isKwang;
    }

    public boolean equals(Object obj) {

        if (obj instanceof SutdaCard) {
            SutdaCard tem = (SutdaCard) obj;
        //if(obj instanceof SutdaCard tem){  > 이런 형식으로 위 두 줄을 한줄로 줄일 수 있다.
            return this.num == tem.num && this.isKwang == tem.isKwang;
        }
        return false;

    }

    public String toString() {
        return num + (isKwang ? "K" : "");
    }
}

class Practice2 {
    public static void main(String[] args) {
        SutdaCard c1 = new SutdaCard(3, true);
        SutdaCard c2 = new SutdaCard(3, true);
        System.out.println("c1=" + c1);
        System.out.println("c2=" + c2);
        System.out.println("c1.equals(c2):" + c1.equals(c2));
    }
}
  1. 다음과 같은 실행결과를 얻도록 Point3D클래스의 equals()를 멤버변수인 x, y, z
    의 값을 비교하도록 오버라이딩하고 toString()은 실행결과를 참고해서 적절히 오버라이 ,
    딩하시오. 정답

실행결과
[1,2,3][1,2,3]
p1==p2?false
p1.equals(p2)?true

package com.test.memo;

class Point3D {
    int x, y, z;

    Point3D(int x, int y, int z) {
        this.x = x;
        this.y = y;
        this.z = z;
    }

    Point3D() {
        this(0, 0, 0);
    }

    public boolean equals(Object obj) {
        if (obj instanceof Point3D) {
            Point3D pp = (Point3D) obj;
        //if(obj instanceof Point3D pp){ 로 위 두 줄을 한 줄로 변경 가능
            return this.x == pp.x && this.y == pp.y && this.z == pp.z;
        }
        return false;
    }

    public String toString() {
        return "[" + x + "," + y + ", " +  z + "]";
    }
}

class Practice2 {
    public static void main(String[] args) {
        Point3D p1 = new Point3D(1, 2, 3);
        Point3D p2 = new Point3D(1, 2, 3);
        System.out.println(p1);
        System.out.println(p2);
        System.out.println("p1==p2?" + (p1 == p2));
        System.out.println("p1.equals(p2)?" + (p1.equals(p2)));
    }
}

  1. 다음과 같은 실행결과가 나오도록 코드를 완성하시오. 정답

    실행결과
    fullPath:c:\jdk1.8\work\PathSeparateTest.java
    path:c:\jdk1.8\work
    fileName:PathSeparateTest.java

내가 푼 풀이

package com.test.memo;

class Practice2 {
    public static void main(String[] args) {
        String fullPath = "c:\\jdk1.8\\work\\PathSeparateTest.java";
        String path = "";
        String fileName = "";

        path = fullPath.substring(0, 14);
        fileName = fullPath.substring(15, fullPath.length());
                            //substring(15); 와 같은 의미 
        System.out.println("fullPath:" + fullPath);
        System.out.println("path:" + path);
        System.out.println("fileName:" + fileName);
    }
}

답지

class Exercise9_3 {
            public static void main(String[] args) {
                String fullPath = "c:\\jdk1.8\\work\\PathSeparateTest.java";
                String path = "";
                String fileName = "";
                int pos = fullPath.lastIndexOf("\\");
                if (pos != -1) {
                    path = fullPath.substring(0, pos);
                    fileName = fullPath.substring(pos + 1);
                }
                System.out.println("fullPath:" + fullPath);
                System.out.println("path:" + path);
                System.out.println("fileName:" + fileName);
            }
        }
  • 답이 더 효율적, path와 fileName이 구분되는 인덱스를 찾아서 일일이 세지않아도 자를 수 있게끔 작성했다.
  1. 다음과 같이 정의된 메서드를 작성하고 테스트하시오. 정답

메서드명 : printGraph
기 능 : 주어진 배열에 담긴 값만큼 주어진 문자를 가로로 출력한 후 값을 출력한다
반환타입 : 없음
매개변수 : int[] dataArr - 출력할 그래프의 데이터
char ch - 그래프로 출력할 문자

[ ] 실행결과
*3
*7
*1
****4

내가 푼 풀이

package com.test.memo;

class Practice2 {
    static void printGraph(int[] dataArr, char ch) {

        for (int i = 0; i < dataArr.length; i++) {
            int num = dataArr[i];
            for (int j = 0; j < num; j++) {
                System.out.print(ch);
            }
            System.out.println(num);
        }
    }
    public static void main(String[] args) {
        printGraph(new int[] { 3, 7, 1, 4 }, '*');
    }
}
  • 맞긴했으나 정답이 더효율적 굳이 저렇게 여러번 반복시킬 필요가 없었다.
class Exercise9_4 {
            static void printGraph(int[] dataArr, char ch) {
                for (int i = 0; i < dataArr.length; i++) {
                    for (int j = 0; j < dataArr[i]; j++) {
                        System.out.print(ch);
                    }
                    System.out.println(dataArr[i]);
                }
            }

            public static void main(String[] args) {
                printGraph(new int[] { 3, 7, 1, 4 }, '*');
            }
        }
  • for문을 돌려서 안쪽for문에 바로 배열을 조건으로 넣으면 for문이 하나 더 생성될 일이 없다.
  • 나 왜 굳이 배열을 int에 넣어준거지..?
  1. 다음과 같이 정의된 메서드를 작성하고 테스트하시오. 정답- 근데 풀이랑 완전 다름

메서드명 : count
기 능: . 주어진 문자열(src) 에 찾으려는 문자열(target) 이 몇 번 나오는지 세어서 반환한다
반환타입 : int
매개변수 : String src
String target

[실행결과
3
0

내가 푼 풀이

package com.test.memo;

class Practice2 {
    public static int count(String src, String target) {
        int count = 0; // 찾은 횟수
        int pos = 0; // 찾기 시작할 위치

        while ((pos = src.indexOf(target, pos)) != -1) {
            // src문자열에서 target문자열을 pos위치부터 찾아서 그 위치를 반환한다.
            count++;
            pos += target.length();
        }
        return count;

    }

    public static void main(String[] args) {
        System.out.println(count("12345AB12AB345AB", "AB"));
        System.out.println(count("12345", "AB"));
    }
}

답

  • while이 true인것보다 pos != -1인게 깔끔할 수도 있다.

찾은 인덱스 이후로 다시 찾아야 하니까 pos에 더해주는 것이다.

  1. 다음과 같이 정의된 메서드를 작성하고 테스트하시오. 정답

메서드명 : fillZero
기 능 주어진 문자열 숫자 로 주어진 길이의 문자열로 만들고 왼쪽 빈 공간은 으로 : ( ) , '0'
채운다.
만일 주어진 문자열이 이거나 문자열의 길이가 의 값과 같으면 그대로 null length
반환한다.
만일 주어진 의 값이 보다 같거나 작은 값이면 빈 문자열 을 반환한다 length 0 , ("") .
반환타입 : String
매개변수 변환할 문자열 : String src -
int length - 변환한 문자열의 길이

실행결과
0000012345
123

package com.test.memo;

import java.util.Arrays;

class Practice2 {
    public static String fillZero(String src, int length) {
        if (src == null || src.length() == length) {
            return src;
        }
        if (length <= 0) {
            return " ";
        }
        if (src.length() > length) {
            return src.substring(0,length);
        }

        char[] ch = new char[length];
        Arrays.fill(ch, '0');// 0으로 배열 채워주기

        char[] srcChar = src.toCharArray();// String을 char배열로 변경
        System.arraycopy(srcChar, 0, ch, length - src.length(), src.length());

        return new String(ch);// String으로 생성해서 반환

    }

    public static void main(String[] args) {
        String src = "12345";
        System.out.println(fillZero(src, 10));
        System.out.println(fillZero(src, -1));
        System.out.println(fillZero(src, 3));
    }
}
  • if 문은 else if이용해서 써줘도 되었다. 꼭 else가 있어야되는건 아니니까 else if로 끝내도 되는 것이였다.
  1. 다음과 같이 정의된 메서드를 작성하고 테스트하시오. 정답

메서드명 : contains
기 능 첫 번째 문자열 에 두 번째 문자열 이 포함되어 있는지 확인한다 : (src) (target) .
포함되어 있으면 그렇지 않으면 를 반환한다 true, false .
반환타입 : boolean
매개변수 : String src
String target

실행결과
true
false

package com.test.memo;

class Practice2 {

    private static boolean contains(String src, String target) {
        return src.contains(target);
    }

    public static void main(String[] args) {
        System.out.println(contains("12345", "23"));
        System.out.println(contains("12345", "67"));

    }
}

답

  1. 다음과 같이 정의된 메서드를 작성하고 테스트하시오. 틀림

메서드명 : round
기 능 주어진 값을 반올림하여 소수점 이하 n 자리의 값을 반환한다 :
예를 들어 n의 값이 3이면 소수점 4째 자리에서 반올림하여 소수점 이하 3자리의 수를 반환한다.
반환타입 : double
매개변수- 변환할 값 : double d
int n - 반올림한 결과의 소수점 자리

실행결과
3.1
3.14
3.142
3.1415
3.1415

package com.test.memo;

class Practice2 {

    private static double round(double d, int n) {
        // Math.pow를 사용하여 10의 n승을 계산하여 소수점 이하를 반올림할 자리수를 지정합니다.
        double num = Math.pow(10, n);

        // 주어진 값 d에 10의 n승을 곱한 후 0.5를 더한 다음 정수로 변환하여 반올림합니다.
        double roundedValue = Math.round(d * num);

        // 정수로 변환된 값을 다시 10의 n승으로 나누어 원래의 자릿수로 복원합니다.
        return roundedValue / num;
    }

    public static void main(String[] args) {
        System.out.println(round(3.1415, 1));
        //한번 제곱하면 31.415 > 반올림이 안되니까 31 > 다시 제곱으로 나누니까 3.1 (double로 자동 형변환 )
        System.out.println(round(3.1415, 2));
        System.out.println(round(3.1415, 3));
        System.out.println(round(3.1415, 4));
        System.out.println(round(3.1415, 5));
    }
}

9.다음과 같이 정의된 메서드를 작성하고 테스트하시오. 정답

메서드명 : delChar
기 능 주어진 문자열에서 금지된 문자들을 제거하여 반환한다 : .
반환타입 : String
매개변수 변환할 문자열 : String src -
String delCh - 제거할 문자들로 구성된 문자열

실행결과
(1!2@3^4~5) -> 12345
(1 2 3 4 5) -> (12345)

package com.test.memo;

class Practice2 {

    private static String delChar(String src, String delCh) {

        StringBuffer sb = new StringBuffer();

        for (int i = 0; i < src.length(); i++) {
            char ch = src.charAt(i);
            if (delCh.indexOf(ch) == -1) {
                sb.append(ch);
            }
        }
        return sb.toString();//StringBuffer를 String객체로 변환해서 반환한
    }

    public static void main(String[] args) {
        System.out.println("(1!2@3^4~5)" + " -> " + delChar("(1!2@3^4~5)", "~!@#$%^&*()"));

        System.out.println("(1 2 3 4\t5)" + " -> " + delChar("(1 2 3 4\t5)", " \t"));
    }
}

StringBuffer 와 StringBuilder가 비슷한 기능을 한다.(동기화 가능 여부만 다름)

  • StringBuffer를 만들때 복사해서 비교한다는 생각에 src를 복사해줬다.
  1. 다음과 같이 정의된 메서드를 작성하고 테스트하시오. 정답 - 풀이와 다름

메서드명 : format
기 능 : 주어진 문자열을 지정된 크기의 문자열로 변환한다 나머지 공간은 공백으로 채운다 : . .
반환타입 : String
매개변수 :

String str - 변환할 문자열
int length - 변환된 문자열의 길이
int alignment - 변환된 문자열의 정렬조건
(0:왼쪽 정렬 1:가운데 정렬 2: 오른쪽 정렬)

실행결과

가나다
가나다
가나다

package com.test.memo;

import java.util.Arrays;

class Practice2 {

    private static String format(String str, int length, int alignment) {

        if (length < str.length()) {
            return str.substring(0, length);
        }
        char[] ch = new char[length];
        Arrays.fill(ch, ' ');

        int startIndex;
        switch (alignment) {
        case 0:
            startIndex = 0;
            break;
        case 1:
            startIndex = (length - str.length()) / 2;
            break;
        case 2:
            startIndex = length - str.length();
            break;
        default:
            startIndex = 0;
        }

        for (int i = 0; i < str.length(); i++) {
            ch[startIndex + i] = str.charAt(i);
        }
        return new String(ch);

    }

    public static void main(String[] args) {
        String str = "가나다";
        System.out.println(format(str, 7, 0)); // 왼쪽 정렬
        System.out.println(format(str, 7, 1)); // 가운데 정렬
        System.out.println(format(str, 7, 2)); // 오른쪽 정렬

    }
}
  • aligment가 1일 때 가운데 정렬하려고 시작인덱스 잡는 부분에서 /2 를 괄호안에 넣어서 계속 배열을 벗어났다고 에러가 나는 것이였다.

답

switch-case보면 case0밑에 default가 존재하는데, 이는 0 과 1, 2이외의 값이라면 을 내포하고 있는것이다.

  1. 커맨드라인으로 사이의 두 개의 숫자를 받아서 두 숫자사이의 구구단을 출력하는 프로그램을 작성하시오. 정답 / 풀이 - 예외처리 한번 보기

3과 5를 입력하면 3단부터 5단까지 출력한다.

package com.test.memo;

class Practice2 {
    public static void main(String[] args) {

        if (args.length != 2) {
            System.out.println("시작 단과 끝 단, 두 개의 정수를 입력해주세요.");
        }
        int num1 = Integer.parseInt(args[0]);
        int num2 = Integer.parseInt(args[1]);

        if (num1 < 2 || num1 > 9 || num2 < 2 || num2 > 9) {
            System.out.println("단의 범위는 2와 9사이의 값이어야 합니다.");
            System.out.println("USAGE : GugudanTest 3 5");
        }
        for (; num1 <= num2; num1++) {
            for (int i = 1; i <= 9; i++) {
                System.out.println(num1 + "*" + i + "=" + num1 * i);
            }
        }
    }
}
  • 처음에 저 배열을 어떻게 int로 올려서 for문으로 돌리지 고민했는데, 그냥 배열의 값을 int에 넣고 시작하면 되는것이였따.

올바르지 않게 입력하면 메시지도 보내주게 처리

답


)

  1. 다음과 같이 정의된 메서드를 작성하고 테스트하시오.틀림

메서드명 : getRand
기 능 주어진 범위 에 속한 임의의 정수값을 반환한다 : (from~to) .
( ) 양쪽 경계값 모두 범위에 포함
from to . 의 값이 의 값보다 클 경우도 처리되어야 한다
반환타입 : int
매개변수 범위의 시작값 : int from -
int to - 범위의 끝값

내가 푼 풀이 - 틀림

package com.test.memo;

class Practice2 {

    private static int getRand(int from, int to) {
        if (from > to) {
            int ran = (int) (Math.random() * (from + (-to)) + to);
            return ran;
        }
        return 3;
    }

    public static void main(String[] args) {

        for (int i = 0; i < 20; i++)
            System.out.print(getRand(1, -3) + ",");
    }
}

-2~0 > 난수 생성을 잘못 한듯

챗 gpt 풀이

package com.test.memo;

class Practice2 {

    private static int getRand(int from, int to) {
        int max = Math.max(from, to);
        int min = Math.min(from, to);

        if (min == max) {
            return min;
        }
        int ran = (int) (Math.random() * (max - min + 1)) + min;
        return ran;
    }

    public static void main(String[] args) {

        for (int i = 0; i < 20; i++)
            System.out.print(getRand(1, -3) + ",");
    }
}

-3~1

답지

  1. 다음은 하나의 긴 문자열(source)중에서 특정 문자열과 일치하는 문자열의 개수를 구하는 예제이다. 빈 곳을 채워 예제를 완성하시오.

실행결과
aabbccAABBCCaa
aa를 2개 찾았습니다

내가 푼 풀이- 틀림

package com.test.memo;

class Practice2 {
    public static void main(String[] args) {
        String src = "aabbccAABBCCaa";
        System.out.println(src);
        System.out.println("aa를" + stringCount(src, "aa") + "개 찾았습니다.");
    }

    static int stringCount(String src, String key) {
        return stringCount(src, key, 0);
    }

    static int stringCount(String src, String key, int pos) {
        int count = 0;
        int index = 0;
        if (key == null || key.length() == 0)
            return 0;
        if (src.contains(key)) {
            count++;
        }

        return count;
    }
}
  • if문으로 비교해서 count의 수를 +1 시키는데 현재 식으로 보면 contains는 있는지 없는지 비교하는 것이기 때문에 1개 찾았다고 출력된다.
  • indexOf로 해보려고 했는데, 해당 인덱스를 찾고 그 이후에 뭘 어떻게 해야될지 몰랐다. indexOf할때 찾는 위치를 지정할 수 있다는것을 기억하장..

답

package com.test.memo;

class Practice2 {
    public static void main(String[] args) {
        String src = "aabbccAABBCCaa";
        System.out.println(src);
        System.out.println("aa를" + stringCount(src, "aa") + "개 찾았습니다.");
    }

    static int stringCount(String src, String key) {
        return stringCount(src, key, 0);
    }

    static int stringCount(String src, String key, int pos) {
        int count = 0;
        int index = 0;
        if (key == null || key.length() == 0)
            return 0;

        while ((index = src.indexOf(key, pos)) != -1) {
            count++;
            pos = index + key.length();
        }

        return count;
    }
}

  1. 다음은 화면으로부터 전화번호의 일부를 입력받아 일치하는 전화번호를 주어진
    문자열 배열에서 찾아서 출력하는 프로그램이다 알맞은 코드를 넣어 프로그램을 완성하시오.

내가 푼 풀이 - 틀림

package com.test.memo;

import java.util.*;
import java.util.regex.*;

class Practice2 {
    public static void main(String[] args) {
        String[] phoneNumArr = { "012-3456-7890", "099-2456-7980", "088-2346-9870", "013-3456-7890" };
        ArrayList list = new ArrayList();
        Scanner s = new Scanner(System.in);

        while (true) {
            System.out.print(">>");
            String input = s.nextLine().trim();
            if (input.equals("")) {
                continue;
            } else if (input.equalsIgnoreCase("Q")) {
                System.exit(0);
            }

            for (int i = 0; i < phoneNumArr.length; i++) {
                String phonNum = phoneNumArr[i];
                String temp = phonNum.replace("-", " ");

                if (temp.contains(input)) {
                    list.add(temp.replace(" ", "-"));
                }
            }

            if (list.size() > 0) {
                System.out.println(list);
                list.clear();
            } else {
                System.out.println("일치하는 번호가 없습니다.");
            }
        }
    }
}

  • replace해서 띄어쓰기랑 하이폰 교체할때 제대로 안봐서 하이폰이 안나오거나 각 숫자마다 하이폰이 다나오거나..되어버렸다 근데 띄어쓰기하면..똑같은거아닌가 어떻게하지..

  • 아 심지어 Pattern, Matcher이용하는거였네

답

Arrays 클래스

  • Arrays에 정의된 메서드는 모두 static 메서드로, java.util.Arrays 클래스는 항목정렬, 항목 검색, 항목 비교와 같은 배열 조작에 도움을 주는 메소드들로 채워져있다.

    • 모든 메소드는 static(정적) 메소드이므로, Arrays클래스로 바로 사용이 가능하다.

    • 이 클래스에 정의된 메소드들을 사용하면 배열의 복사, 비교, 정렬 및 탐색과 관련된 코드를 비교적 쉽게 작성할 수 있다.

배열 복사

Arrays.copyOf()

배열을 복사하여 새로운배열을 생성하고 반환한다.

원본 배열의 일부를 복사하거나 전체 배열을 복사할 수 있다.

  • public static int[] copyOf(int[] original, int newLength)

    • original 배열을 첫 번째 요소부터 newLength의 길이만큼 복사

      첫 번째 인자로 전달된 배열을 두 번째 인자로 전달된 길이만큼 복사하되 '새로운 배열을 생성'하여 복사한다. 그리고 이렇게 생성된 배열의 참조 값을 반환한다.

import java.util.Arrays;

class CopyOfArrays {
    public static void main(String[] args) {
        double[] arOrg = {1.1, 2.2, 3.3, 4.4, 5.5};

        // 배열 전체를 복사하여 배열 생성
        double[] arCpy1 = Arrays.copyOf(arOrg, arOrg.length);

        // 배열의 세번째 요소까지만 복사하여 배열 생성 > 2번째 인덱스까지만 복사하는 
        double[] arCpy2 = Arrays.copyOf(arOrg, 3);


        for(double d : arCpy1)
            System.out.print(d + "\t");//출력 1.1 2.2 3.3 4.4 5.5
        System.out.println();


        for(double d : arCpy2)
            System.out.print(d + "\t"); //출
        System.out.println();

    }
}

간단히 말해, Arrays.copyOf()는 새로운 배열을 생성하고 복사하는 데 사용되고,
System.arraycopy()는 원본 배열의 일부를 다른 배열에 복사하는데 사용된다.

  • public static int[] copyOfRange(int[] original, int from, int to)

    • original에 전달된 배열을 인덱스 from부터 to-1까지 복사
    double[] arOrg = {1.1, 2.2, 3.3, 4.4, 5.5};
double[] arCpy2 = Arrays.copyOfRange(arOrg, 1, 4);

  • 인덱스 1부터 3까지 복사한다!

배열 항목 정렬

Arrays.sort(arr)

기본 타입 / String 배열은 arr 배열을 사전순(오름차순)으로 정렬할 수 있다.

  • 만약 사용자 정의 클래스 타입이라면, Comparable 인터페이스를 구현하고 있어야 한다.(implements)
import java.util.Arrays;

class Person implements Comparable {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }    

    @Override
    public int compareTo(Object o) {
//Comparable을 구현할 때 제네릭으로 구현한게 아니라면 인자값을 object로 제네릭이라면 해당 기준으로 Person 
        Person p = (Person)o;

        if(this.age > p.age)
            return 1;
        else if(this.age < p.age)
            return -1;
        else
            return 0;
/*
    Person p = (Person)o;
    return this.age - p.age;
*/
    }

    @Override
    public String toString() {
        return name + ": " + age;
    }
}

class ArrayObjSort {
    public static void main(String[] args) {
        Person[] ar = new Person[3];

        ar[0] = new Person("Lee", 29);
        ar[1] = new Person("Goo", 15);
        ar[2] = new Person("Soo", 37);

        Arrays.sort(ar);

        for(Person p : ar) 
            System.out.println(p);
    }
}
//실행 결과
//Goo: 15
//Lee: 29
//Soo: 37

  • 숫자는 컴퓨터가 기준을알고 있지만 현재 위의 Person은 개발자가 정의한 것이기 때문에 Comparable인터페이스를 구현해줘야 한다.

    • Comparable 의 compareTo메서드를 오버라이딩해서 기준을 지정해줘야 한다.

    • 제네릭과 인터페이스가 있는데 제네릭이라면 <> 안에 뭐와 비교할 것인지 지정해주면 된다.

      • 만약 제네릭으로 하지 않는다면 compareTo오버라이딩 할때 인자 값을 Object로 넣어야한다.

우리가 자주 쓰던, String, compareTo()메서드도 이 Comparable을 구현한 것이다.

예제 2

//Member 타입만 비교하기 위해 제네릭<> 사용
class Member implements Comparable<Member>{
    String name;

    Member(String name)
        this.name = name;

    @Override
    int compareTo(Member m)
        return name.compareTo(m.name);
        //내림차순일 떄는 *(-1)를 하여 -1, 0, 1 를 구분한다.
 }
 public class Example{
     public static void main(String[]args){
        Member m1 = new Member("aa");
        Member m2 = new Member("bb");
        Member m3 = new Member("cc");
        Member[] members = {m1, m2, m3};
        Arrays.sort(members);
    }
}

compareTo()의 구현방법

interface Comparable > int compareTo(Object o)

  1. 인자로 전달된 o가 작다면 양의 정수 반환

  2. 인자로 전달된 o가 크다면 음의 정수 반환

  3. 인자로 전달된 o와 같다면 0을 반환

배열 항목 검색

검색은 반드시 정렬이 된 상태에서 해야한다.

정렬을 하지 않고 binarySearch()메소드를 사용하거나, 없는 항목을 찾으면 음수값이 리턴된다.

  • Arrays.sort()메소드로 정렬을 한 후에, Arrays.binarySearch()메소드로 원하는 항목의 인덱스 값을 찾을 수 있다.
//Member[] members = {"aa", "bb", "cc"}; 일때
Arrays.sort(members);
int idx = Arrays.binarySearch(members, "bb");
// idx == 1

배열 동일 항목 채우기

fill()메소드로 배열에 동일한 값을 저장할 수 있다.

int[] arr = new int [5];
Arrays.fill(arr, 0);
Arrays.fill(arr,0,3,1);
  1. arr배열 전체를 숫자 0으로 채우는 메소드다.
  2. arr배열의 인덱스 0부터 2까지 1로 채우는 메소드다.

배열 항목 비교

equals(배열, 배열) / deepEquals(배열, 배열)로 얕은 / 깊은 비교를 할 수 있다.

  • ==연산자는 피연산자의 값과의 주소가 같은지 검사하는 것이다.

  • 그러나 equals()메소드는 피연산자의 내용(값) 자체가 같은지를 검사한다.

    예제1

import java.util.Arrays;

class ArrayEquals {
    public static void main(String[] args) {
        int[] ar1 = {1, 2, 3, 4, 5};
        int[] ar2 = Arrays.copyOf(ar1, ar1.length);

    System.out.println(Arrays.equals(ar1, ar2));        // true
    }
}

  • 이 메소드는 아래와 같이 object형 배열에 대해서도 오버로딩 되어있다.

    • public static boolean equals(Object[] a, Object[] a2)

      이는 인스턴스의 참조 값을 저장하고 있는 두 배열에 대한 비교를 진행하는 것이다.

예제2

import java.util.Arrays;

class INum {
    private int num;

    public INum(int num) {
        this.num = num;
    }
    @Override
public boolean equals(Object obj){
    if(this == obj)    // 두 인스턴스가 동일 인스턴스이면
        return true;
    else
        return false;
    }    // 이렇듯 Object 클래스에 정의된 equals 메소드는 참조 값 비교를 한다.
}

class ArrayObjEquals {
    public static void main(String[] args) {
        INum[] ar1 = new INum[3];
        INum[] ar2 = new INum[3];

        ar1[0] = new INum(1); //객체를 생성해서 그 객체의 주소값을 배열에 넣는 것
        ar2[0] = new INum(1);

        ar1[1] = new INum(2);
        ar2[1] = new INum(2);

        ar1[2] = new INum(3);
        ar2[2] = new INum(3);

        System.out.println(Arrays.equals(ar1, ar2));    // false
    }
}

  • 숫자(= Integer)는 컴퓨터가 크고 작고의 개념을 가지고 있지만, INum은 개발자가 만든 클래스이므로, 컴퓨터는 뭐가 같고 다른지 기준을 모르기 때문에 그 기준을 equals메서드를 메서드 오버라이딩 해서 알려줘야한다.

    배열의 참조 값 비교가 아닌 내용 비교가 목적이라면 다음과 같이 equals 메소드를 목적에 맞게 오버라이딩 해야 한다.

얕은복사

데이터를 복사하는데, 복사 객체는 원본 객체와 같은 메모리 주솔르 참조한다.

int a = 1;
int b = a; //얕은 복사
  • 두 변수는 같은 주소의 값을 참조하기 때문에, 한쪽이 다른 한쪽에도 영향을 미친다.

깊은 복사

객체를 복사할 때 해당 객체와 인스턴스 변수까지 복사하여 새 주소에 담는다.

  • Cloneable인터페이스의 추상 메소드인 clone()메소드를 이용한다. (Object클래스)
    • protected Object메소드이므로 바로 사용할 수 없고, 메소드를 오버라이딩 하여 사용해야 한다.

오버라이딩 하는 코드

class Arr implements Cloneable{
    String name;
    Arr(String name){
        this.name = name;
    }
    public Object clone() throws CloneNotSupportedException{
        return super.clone();
    }
}
//후에 clone()메소드 사용 시 CloneNotSupportedException 에러 try-catch

clone()메서드를 사용하려면 반드시 Cloneable 인터페이스를 구현해줘야 하고, CloneNotSupportedException을 명시적으로 던져주고, 예외처리를 해줘야 한다.

Arrays 클래스 문제

  1. 주어진 예제 ArrayObjSort.java에서는 Person의 인스턴스들을 나이순으로 정렬하였는데, 이를 수정하여 나이의 역순으로 정렬이 되도록 해보자. 다시 말해서, 많은 나이의 인스턴스일수록 배열의 앞쪽에 위치하도록 예제를 수정해보자.

내가 푼 문제

package com.test.memo;

import java.util.Arrays;

class Person implements Comparable<Person> {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Person p) {

        if (this.age > p.age)
            return -1;
        else if (this.age < p.age)
            return 1;
        else
            return 0;
    }

    @Override
    public String toString() {
        return name + ": " + age;
    }
}

class Practice2 {

    public static void main(String[] args) {
        Person[] ar = new Person[3];

        ar[0] = new Person("Lee", 29);
        ar[1] = new Person("Goo", 15);
        ar[2] = new Person("Soo", 37);

        Arrays.sort(ar);

        for (Person p : ar)
            System.out.println(p);

    }
}

정답

compareTo메서드 부분이 다르다.

return p.age - this.age; - 이렇게 하면 내림차순이 된다.

  1. 주어진 예제 ArrayObjSort.java에서는 Person의 인스턴스들을 나이순으로 정렬하였는데, 이를 이름의 길이 순으로 정렬이 되도록 수정해보자. 즉 이름이 길이가 짧은 인스턴스일수록 배열의 앞쪽에 위치하도록 예제를 수정해야 한다.

내가 푼 문제

package com.test.memo;

import java.util.Arrays;

class Person implements Comparable<Person> {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Person p) {

        if (this.name.length() > p.name.length())
            return 1;
        else if (this.name.length() < p.name.length())
            return -1;
        else
            return 0;
    }

    @Override
    public String toString() {
        return name + ": " + age;
    }
}

class Practice2 {

    public static void main(String[] args) {
        Person[] ar = new Person[3];

        ar[0] = new Person("Threee", 29);
        ar[1] = new Person("T", 15);
        ar[2] = new Person("One", 37);

        Arrays.sort(ar);

        for (Person p : ar)
            System.out.println(p);

    }
}

정답

compareTo메서드에서

return name.length() - p.name.length(); 이렇게 해주면 길이순으로 정렬된다.

알파벳 순으로 정렬하고 싶다면

return name.compareTo(p.name); - 하면 사전적 순서대로 정렬이 된다.

profile
정혅
이전 포스트

스물다섯 번째 수업

다음 포스트

스물일곱 번째 수업

0개의 댓글