Java - StringBuilder & StringBuffer

 
public class Ex {
 
    public static void main(String[] args) {
        
        
        /*
         * String  클래스
         * 문자열을 관리하는 클래스
         * 내부적으로 char[] 타입으로 각각의 문자들을 관리
         * 배열의 인덱스와 동일한 값을 사용하여 다양한 작업 가능
         * final 클래스로 상속 불가능한 클래스
         * 생성자 사용 및 리터럴 할당 방법으로 문자열 생성 가능
         * 한 번 생성된 문자열은 불변이므로 문자열을 수정하면
         * 수정된 내용을 갖는 새로운 문자열을 생성하여 다른 공간에 저장
         * 따라서, 문자열 수정이 빈번한 경우 StringBuilder 나 StringBuffer 클래스가 적합
         * String 클래스에 각종 메서드를 제공하므로, 효율적인 문자열 처리가능
         */
        
        //문자열 생성방법 1. 리터럴을 직접 할당하는 방법
        //동일한 문자열 존재여부를 Constant Pool(상수풀)에서 검색하여
        //존재하지 않으면 새로 생성, 존재할 경우 주소값 공유
        //따라서 동일한 문자열이 존재할 경우 저장공간의 낭비가 없음
        
        String s1="Hello";//기존에 존재하지 않는 문자열이므로 상수 풀에 새 공간 할당 받음
        String s2="Hello";// s1이 가리키는 상수풀과 동일한 위치의 주소값을 전달받음
        
        System.out.println("s1과 s2는 주소값이 같은가? "+(s1==s2));
        System.out.println("s1과 s2는 문자열이 같은가? "+(s1.equals(s2)));
        
        
        //문자열 생성방법2. new 연산자로 String 객체를 생성하여 할당하는 방법
        //동일한 문자열 존재 여부와 관계없이 무조건 힙 공간에 문자열 생성
        String s3=new String("Hello");//힙 공간에 새 String 객체 생성
        String s4=new String("Hello");//힙 공간에 새 String 객체 생성
        //즉, s3와 s4 는 문자열 내용은 같지만, 저장된 공간이 다르다
        System.out.println("s3과 s4는 주소값이 같은가? "+(s3==s4));
        System.out.println("s3과 s4는 문자열이 같은가? "+(s3.equals(s4)));
 
        
    }
 
}
 
 
public class Ex2 {
 
    public static void main(String[] args) {
        
        /*
         * String  클래스에서 제공되는 다양한 메서드를 활용하여
         * 문자열에 대한 검색, 분리, 추출, 변환, 비교 등 여러 작업을 수행가능
         */
        
        String s1="Java Programming!";
        String s2="         ITWILL    부산 교육센터         ";
        String s3="JAVA/JSP/ANDROID/SPRING";
        
        //int length() : 문자열 길이 리턴
        System.out.println("문자열 s1의 길이 : "+s1.length());
        
        //boolean equals() : 문자열 비교
        System.out.println(s1.equals("JAVA PROGRAMMING!"));
        
        //boolean equalsIgnoreCase() : 문자열 비교(대소문자 구별 없이 비교)
        // 주로, 로그인 환경에서 아이디에 대한 문자열 비교 수행등에 사용!@!#@$!#!$
        System.out.println(s1.equalsIgnoreCase("JAVA PROGRAMMING!"));
        
        // char charAt(int) : int 형 인덱스에 해당하는 위치의 문자 1개 리턴
        System.out.println("5번 인덱스 문자 : "+s1.charAt(5));
        
        // int indexOf(문자 또는 문자열) : 파라미터로 전달된 문자 또는 문자열의 인덱스 리턴 
        // 문자 또는 문자열을 앞쪽 0번 인덱스부터 탐색
        // 두번쨰 파라미터에 인덱스를 지정하면 해당 인덱스부터 탐색가능
        System.out.println("문자 A의 인덱스 : "+s1.indexOf('A'));//없는 문자는 -1 리턴
        System.out.println("문자 A의 인덱스 : "+s1.indexOf('a'));// 첫번째 'a' 인덱스 리턴
        System.out.println("문자열 Program의 인덱스 : "+s1.indexOf("Program"));//
        
        
        // int lastIndexOf(문자 또는 문자열) : 파라미터로 전달된 문자 또는 문자열의 인덱스 리턴 
                // 문자 또는 문자열을 뒷쪽 마지막 인덱스부터 역순으로 탐색
        System.out.println("문자 A의 인덱스 : "+s1.lastIndexOf('a'));
        
        // replace(원본문자 또는 문자열, 바꿀문자 또는 문자열) : 문자 또는 문자열 치환
        System.out.println(s1.replace('a', '@'));
        System.out.println(s1.replace("Java", "JSP"));
        
        // toUpperCase() : 모든 영문 문자열을 대문자로 변환
        System.out.println("모두 대문자로 변환 : "+s1.toUpperCase());
        
        // toLowerCase() : 모든 영문 문자열을 소문자로 변환
        System.out.println("모두 소문자로 변환 : "+s1.toLowerCase());
        
        // substring() : 부분 문자열 추출
        // substring(int beginIndex) : 시작 인덱스부터 끝까지 추출
        System.out.println("5번 인덱스부터 문자열 추출 : "+s1.substring(5));
        
        // substring(int beginIndex, int endIndex) : 시작인덱스부터 끝인덱스 -1 까지 추출
        System.out.println("5번~11번까지의 인덱스의 문자열 추출 : "+s1.substring(5, 12));
        
        // startsWith(String) : 특정문자열로 시작되는지 여부 판별
        System.out.println("문자열 Java로 시작되는가 ? "+s1.startsWith("Java"));
        System.out.println("문자열 JSP로 시작되는가? "+s1.startsWith("JSP"));
        
        // endsWith(String) : 특정 문자열로 끝나는지 여부 판별
        System.out.println("문자열 Programming 으로 끝나는가? "+s1.endsWith("Programming"));
        System.out.println("문자열 Programming! 으로 끝나는가? "+s1.endsWith("Programming!"));
        
        
        // contains(String) : 특정 문자열이 포함되는지 여부 판별
        System.out.println("문자열 Program이 포함되는가? "+s1.contains("Program"));
        System.out.println("문자열 JSP이 포함되는가? "+s1.contains("JSP"));
        
        
        // trim() : 문자열 앞 뒤의 공백 제거(잘라냄)-> 문자열 사이 공백은 그대로 유지
        System.out.println("공백 제거한 s2 : "+s2.trim()+" >>>");
        
        // concat() : 문자열 결합
        System.out.println(s1+s2);//일반적인 문자열 결합 방법(연결연산자 + 사용)
        System.out.println(s1.concat(s2));//연결연산자(+)를 사용한 결합보다 연산속도 빠름
        //문자열 결합 연산이 매우 많이 중첩될 경우 연결연산자보다 concat() 연산자 사용
        
        
        // split(String regex) : 문자열 분리 
        // 파라미터에 전달되는 구분자(분리자, Delimeter)를 기준으로 문자열을 분리하여
        // 분리된 문자열을 String[] 타입으로 리턴함
        // 이 때, 사용되는 구분자(분리자)는 정규표현식을 기초로 하는 문자열 사용
        String[] splitResult = s3.split("/");//문자열 /를 기준으로 앞 뒤 문자열들을 분리
        for(Object o:splitResult) {
            System.out.println(o);
        }
        
 
    }
 
}
 
 
public class Ex3 {
 
    public static void main(String[] args) {
        
        /*
         * StringBuilder & StringBuffer 클래스
         * String 클래스와 무관
         * 문자열 편집에 용이한 클래스
         * 버퍼를 사용하여 문자열을 저장하며, 편집 시 버퍼안의 내용을 직접 조작함
         * String 클래스에 비해 편집속도가 빠름
         * 문자열 편집 결과에 대한 새 문자열 생성되지 않으므로, 공간 낭비 적음
         * 두 클래스의 메서드는 거의 동일하며, 멀티쓰레드 환경에서의 차이가 존재 
         * 문자열생성시 String 클래스와 달리 리터럴 할당은 불가능 하며, 객체 생성만 가능
         * 
         */
        
//        StringBuffer buffer="Hello, World";//리터럴 할당 방법 사용 불가
        
        StringBuffer buffer=new StringBuffer("Hello, World!");
        
        //toString() 메서드가 오버라이딩 되어 있으므로 문자열 출력이 용이함
        System.out.println(buffer);//buffer.toString()과 동일
        String str=buffer.toString();
        
        System.out.println("문자열 길이 : "+buffer.length());
        System.out.println("버퍼 크기 : "+buffer.capacity());
        
        
        // append() : 문자열 뒷 부분에 새 문자열 추가(결합)        
        buffer.append("  Java Programming!");
        System.out.println(buffer);
        //버퍼가 다 차면 자동으로 버퍼크기를 확장
        System.out.println("문자열 길이 : "+buffer.length());
        System.out.println("버퍼 크기 : "+buffer.capacity());
        
        
        // insert() : 특정 인덱스에 문자열 삽입
        buffer.insert(14, "ITWILL");
        System.out.println(buffer);
        
        //reverse() : 문자열 순서 뒤집기(반전)
        buffer.reverse();
        System.out.println(buffer);
        
        //-----------------------------------
        //StringBuffer 객체의 메서드 여러개를 호출하여 다양한 작업을 수행할때
        //각각의 메서드를 별도로 호출할 수도 있지만
        //메서드를 연쇄적으로 연결하여 작업을 처리할 수도 있다.
        //StringBuffer 또는 StringBuilder 클래스의 메서드 리턴타입은 모두 자기 자신이므로
        //실행 결과에 다시 다른 메서드 적용이 가능함.
        StringBuffer buffer2=new StringBuffer("JAVA");
        buffer2.append("JSP ");
        buffer2.append("ANDROID ");
        buffer2.append("SPRING ");
        
        System.out.println(buffer2);
        
        
        //빌더패턴(Builder Pattern) : 메서드 실행 결과에 다시 다른 메서드를 호출하는것
        
        StringBuffer buffer3=new StringBuffer("JAVA");
        buffer3.append("JSP ").append("ANDROID ").append("SPRING ");
        System.out.println(buffer3);
        
        String id="          admin          ";
        if(id.trim().equals("admin")) {
            System.out.println("admin 계정입니다.");
        }else {
            System.out.println("admin 계정이 아닙니다.");
        }
        
        //같은 타입이 아니더라도 메서드 실행 결과에 대한 다른 메서드 호출이 가능함
        int num=10;
        if(Integer.toString(num).equals("10")) {
            System.out.println("10입니다.");
        }
 
        
    }
 
}
 
 
public class Ex4 {
 
    public static void main(String[] args) {
        /*
         * java.lang.Math 클래스
         * - 수학 관련 기능들을 상수 및 메서드로 제공
         * - final 클래스이므로 상속 불가
         * - 모든 멤버는 static 으로 선언되어 있으므로 클래스명만으로 접근 가능
         */
        
        System.out.println("PI 값 : " + Math.PI);
        
        int a = 10, b = 4;
        System.out.println("a 와 b 중 최대값 : " + Math.max(a, b));
        System.out.println("a 와 b 중 최소값 : " + Math.min(a, b));
        
        System.out.println("-5 의 절대값 : " + Math.abs(-5));
        
        double d = 3.45;
        System.out.println(d + " 의 소수점 첫째자리 반올림 결과 : " + Math.round(d));
        
        
        double d2 = Math.round(d * 10) / 10.0; 
        // 실수 d 의 소수점 둘째자리 반올림 결과를 d2 에 저장(3.5)
        // => 1. 첫째자리 반올림을 수행하므로 둘째자리를 첫째자리로 이동(Math.round(d * 10))
        //    2. 다시 원래 자리로 되돌리기 위해 곱한 값 만큼 나누기 수행
        //       => 이 때, round() 메서드 실행 결과가 정수이므로 나누는 값이 정수이면
        //          소수점 값이 버려지므로 반드시 나누는 값을 실수형태로 지정해야함
        //          (Math.round(d * 10) / 10.0)
        System.out.println(d + " 의 소수점 둘째자리 반올림 결과 : " + d2);
        
        System.out.println("----------------------------------------");
        
        /*
         * 난수 발생을 위한 random() 메서드
         * - double 타입 범위(0.0 <= x < 1.0) 내의 난수 1개를 발생
         * - 결과를 그대로 사용하기 보단 가공하여 원하는 범위 내의 숫자로 변형시켜 사용  
         */
        for(int i = 1; i <= 10; i++) {
//            System.out.println(Math.random()); // 0.0 <= x < 1.0
//            System.out.println(Math.random() * 10); // 0.0 <= x < 10.0
//            System.out.println((int)(Math.random() * 10)); // 0 <= x < 10
            
            //난수 발생을 통해 정수형태로 사용하는 기본 공식
            // (int)(Math.random()*상한값+1)
            System.out.println((int)(Math.random() * 10+1));//1<=x<11
        
        
            //로또번호 1개 생성(1~45 사이의 난수)
            System.out.println((int)(Math.random()*45+1));//1<=x<=45
        
        }        
                    
 
    }
}
 
 
 
public class test2 {
 
    public static void main(String[] args) {
        
        //String 클래스 활용연습
        String jumin="901010-3333333";
        
        //문자열 jumin에 저장된 주민번호의 뒷자리 첫번째 숫자를 추출하여
        //1 또는 3일때 '남성' 출력, 2 또는 4일때 '여성'출력
        
        if(jumin.charAt(7)=='1'||jumin.charAt(7)=='3') {
            System.out.println("남성");
        }else {
            System.out.println("여성");
        }
        
        //[replace() 메서드활용]
        //전화번호 뒷자리 숫자 4자리 마스킹 처리
        String hp= "010-1234-5678";
        String last4=hp.substring(9, hp.length());
        //9번 인덱스(뒷자리 첫 숫자) 부터 문자열 길이-1 (마지막 인데스) 까지 추출
        System.out.println("추출된 번호 : "+last4);
        
        String masked=hp.replace(last4,"****");
        System.out.println("마스킹 결과 : "+masked);
        
        System.out.println("-----------------------");
        
        //전화번호 가운데 숫자 마스킹 처리
        //단, 전화번호 가운데 숫자는 3자리 또는 4자리이다.
        
                
        String centerNumber=hp.substring(4, hp.lastIndexOf('-'));
        System.out.println("추출된 가운데 번호 : "+centerNumber);
        
        
        masked=hp.replace("-"+centerNumber+"-" ,"-****-");
        System.out.println("마스킹 결과 : "+masked);
        
        
        
        
    }
 
}

참조 데이터 타입 String의 여러 메서드를 통해 여러 가지 작업들을 해보았고, 활용이 아주 다양할 거 같아서 차근히 다시 보아야 할 것 같다. 미리 알아 두어야 나중에 활용할 때 바로 생각이 떠올라서 빙빙 돌아가지 않을 테니까.

그리고 StringBuilder와 StringBuffer를 배워보았는데   이름만 비슷할 뿐이지 String과는 별개의 클래스들로 String보다는 빠른 편집 속도로 우리가 사용하기에는 차이가 없지만 작업들이 중첩이 되어 많아진다면 차이가 많이 나게 된다.

그리고 짧게 java.lang.Math클래스를 배워보았는데 random() 메서드를 통해 난수 생성과 반올림 및 여러 작업들을 할 수 있었다. 상수처리가 되어있기 때문에 상속은 불가능하고 클래스 이름만으로 접근 가능하였다.

그리고 String클래스를 활용하여 정보들을 다루어 보았는데 웹을 개발할 때 많이 쓰일 것 같다.