Java 정리 11

// length()는 문자열의 길이(int)를 반환하는 method
 
// 기본형 형식으로 String method 사용
String s = "ABC";
int len = s.length();       // 3
 
// 참조형 형식으로 String method 사용
String str = new String("ABC");
len = str.length();         
 
// 리터럴로 String method 사용
len = "ABC".length(); 

// 문자열을 영어대문자로 반환하는 메소드 toUpperCase()
String s = "abCDef";
String s1 = s.toUpperCase();    // ABCDEF
 
// 문자열을 영어소문자로 반환하는 메소드 toLowerCase()
String s2 = s.toLowerCase();    // abcdef
 
// 특정문자의 인덱스를 반환하는 메소드 indexOf(String s)
int i = s.indexOf("C")          // 2
int j = s.indexOf("k")          // -1, 없는 문자열이면 -1이 나옴
 
s = "aCbdCe";
//   012345
 
// indexOf는  -> 방향으로 찾아나감
System.out.println(s.indexOf("C"));     // 1
 
// lastIndexOf는 뒤에서부터(<-) 찾아나감
System.out.println(s.lastIndexOf("C")); // 4
 
// index에 해당하는 문자를 반환하는 메소드 charAt(int index)
char c = s.charAt(0);    // a
c = s.charAt(1);         // C
 
// 문자열 끝에는 null문자가 있기 때문에 시작주소만 전달해도 단어의 끝까지 출력이 가능하다.
// 자식문자열 얻기 substring(시작인덱스, 끝인덱스) 또는 substring(시작인덱스)
// 매개변수 두개를 받을 때 끝인덱스는 null문자를 넣는 위치
 
s = "abcdef";
//   012345
System.out.println(s.substring(3));        // def
System.out.println(s.substring(1, 4));     // bcd 
// 끝인덱스는 뽑아내고자 하는 문자열+1을 해줘야 원하는 결과가 나온다.
 
// 문자열 앞뒤 공백제거 trim() (중간공백은 제거할 수 없다)
s = "    abc      ";
String s1 = s.trim(); // abc
 
s = "    a   b   c     ";
s.trim(); // a   b   c
 
// 문자열 합치기 concat(String str)
s = "hello";
s1 = s.concat(" world");    // hello world;
s1 = s + " world";         // hello world;
 
// 특정문자열 치환 replace(char oldChar, char newChar)
// 또는 replaceAll(정규식, 바꿀문자열)
 
s = "abcdefg";
 
// c를 k로 변경
System.out.println(s.replace("c", "k"));        // abkdefg
System.out.println(s.replaceAll("cde", "kkk")); // abkkkfg
 
// replace는 trim대신 사용가능
s = "   AAA BBB   ";
s.replace(" ", "");    // AAABBB
 
// 문자열이 아무것도 없을 때 isEmpty()
s.isEmpty();    // 비었다면 true, 문자열 있으면 false;
 
// 문자열 비교시 사용, equals("비교할문자열") true, false 반환
s = "ABC";
s.equals("ABC"); // true
 
// 어떤 prefix로 시작되었는지 확인하는 startsWith(String prefix)
s.startWith("abc"); // false
 
// 어떤 문자열(suffix)로 끝났는지 확인하는 endsWith(String suffix)
s.endsWith("C");    // true
 
// 이 문자열이 포함되는지 contains("문자열") 앞뒤 상관없잎 포함여부확인 불린반환
s.contains("B");    // true
 
// 기본형 데이터형을 문자열로 변경 static메소드 valueOf()
int i = "1234";
s = String.valueOf(i);
 
// 특정 문자열로 구분하여 배열로 얻을 때 split("구분할문자열")
s = "1,2,3,4,5,6,7";
String[] str_arr = s.split(",");
 
for(String str : str_arr) {
    System.out.print(str+" "); // 1 2 3 4 5 6 7
}

s = "";    // empty, 리터럴의 주소는 있으나 값이 없는 상태
s = null;  // null, heap의 주소가 없는 상태

String mail = "young@ssang.kr";           
// 계정명만 얻기
System.out.println(mail+"에서 계정명만 얻기  "+mail.substring(0,mail.indexOf("@")));
 
// 도메인 주소만 얻기
System.out.println(mail+"에서 도메인 주소만 얻기  "+mail.substring(mail.indexOf("@")+1));
 
// 문자열이 완벽하게 같은지 비교
str = "정택성";
System.out.println(str+"은(는)  "+(str.equals("이재찬")?"반장":"평민"));
 
// 치환 : 문자열 내의 모든 문자열을 찾아 치환
str="나 지금 피씨방인데 넌 어디니 씨 방새야";
// 메소드를 연결해서 호출하는 것을 method chain이라 한다.
System.out.println(str.replaceAll("씨",  "*").replaceAll("방", "*")); 
 
// valueOf(method)를 사용하는게 더 Java스러운 방식
double d = 11.27;
System.out.println(d+"");                // 권장하진 않는다.
System.out.println(String.valueOf(d));
 
// 객체를 생성하지 않으면 그 클래스가 제공하는 method는 사용할 수 없다.
// 클래스 != 객체

// 이메일을 입력받아 이메일의 유효성을 검증하여 boolean형으로
// 결과를 만들어 반환하는 일을 하는 메소드를 만들어 호출하여 사용해보세요.
public class UseString3 {
     private boolean validEmail(String email) {
           boolean flag = false;
           
           if (email.length()>5 && email.indexOf("@")!=-1
                     && email.indexOf(".")!=-1) {
                flag = true;
           }
                return flag;
 
           // 이렇게 짧게 리펙토링 가능
           /*return email.length()>5 && email.contains("@")
                     && email.contains(".");*/
     }
 
     public static void main(String[] args) {
     
           String email = "yg@mm.com";
           UseString3 us = new UseString3();
           
           if (us.validEmail(email) == true) {
                System.out.println("유효한 메일입니다.");
           } else {
                System.out.println("유효하지 않은  메일입니다.");
           }
     }
}
// 메소드는 출력안한다!(일만한다)
// 특별한 요구사항이 없다면 메소드 내에서 출력안함.

// 1. 선언
// [] : 배열기호
데이터형[] 배열명 = null;
 
// 2. 생성
// 생성되는 배열의 모든 방(요소, Element)은 초기화됨
배열명 = new 데이터형[방의수];
 
// 1,2를(선언, 생성) 같이 만들 수 있음
데이터형[] 배열명 = new 데이터형[크기];
 
// 3. 값 할당
배열명[방의번호] = 값;
 
// 4. 값 얻기
some_var = 배열명[방의번호];
 
// 인덱스로 방에대한 접근을 수행하기 때문에 
// 잘못된 인덱스를 사용하면 ArrayIndexOutOfBoundsException 발생
 
// 배열 방의 갯수 얻기
배열명.length
 
// 일괄처리
for(int i=0; i<배열명.length; i++) {
    배열명[i] // 인덱스로 참조하는 배열의 값 사용
}

public class UseArray {
     
  public UseArray() {
    // 1.배열 선언) 데이터형[] 배열명 = null;
    int[] arr = null;
    
    // 2.배열 생성) 배열명 = new 데이터형[방의갯수];
    // 배열을 생성하면 모든 방의 값이 초기화가 된다.
    arr = new int[6];
    
    // 선언과 생성을 동시에
    int[] arr1 = new int[8];
    
    // 3.값 할당) 배열명[방의인덱스] = 값;
    arr[0] = 11;
    arr[1] = 27;
    arr[2] = 14;
    arr[3] = 46;
    
    // 4.값 얻기) 일괄처리로 출력
    for(int i : arr) {
        System.out.print(i+" ");
    }
    System.out.println();
 
    // 배열에 없는 인덱스를 사용하면 error
    // ArrayIndexOutOfBoundsException
    // System.out.println(arr[7]);
  }
  
  public static void main(String[] args) {
    new UseArray();
  }
}

데이터형[] 배열명 = { 값, 값, 값, 값, ... };
// 원형 : 데이터형[] 배열명 = new 데이터형[]{ 값, ... };
 
int[] arr = { 10, 20, 30, 40,  50 };

public class UseArray2 {
  public void arrayPrimitive() {
    
    // 데이터형[] 배열명 = {값,값, ... };
    int[] arr = { 2018, 11, 27, 15, 20 };
    
    // 방의 갯수를 정의하면 error
    // int[] arr1 = new int[6] { 1,2,3,4,5,6,7 };
    int[] arr1 = new int[] { 1,2,3,4,5,6,7 };
    
    // 향상된 for : 배열이나 Collection(List, Set)의  처음 방부터 끝방까지
    // 모든방의 값을 순차적으로 손쉽게 출력할 때 사용
    /*
    * for(배열의 값을 저장할 변수 : 배열) {
    *    변수명
    * }
    */
    for(int i : arr) {
        System.out.print(i+" ");
    }
    System.out.println();
 
    // arr1배열의 마지막방부터 처음 방까지 출력
    for(int i=arr1.length-1; i>-1; i--) {
        System.out.printf(arr1[i]+" ");
    }
    System.out.println();
  }
  public static void main(String[] args) {
    new UseArray2().arrayPrimitive();
  }
}