[230731] String, Random, Date Time, Scanner (DAY24)

MJ·2023년 7월 31일
Java

수업 TIL🐣💚

목록 보기
25/68

String

    public static void ex01() {

    // 문자열 리터럴(Literal)
    // 문자열 표현 방법 : 큰 따옴표로 문자열을 묶는다.
    String name1 = "tom";
    String name2 = "tom";

    // 문자열 리터럴은 Java에 의해서 최적화되기 때문에
    // 동일한 리터럴이 2번 이상 나타나면 기존 리터럴을 재사용한다.
    //
    //       ┌--------------┐
    //  name1│  0x12345678  │
    //       │--------------│
    //  name2│  0x12345678  │
    //       │--------------│
    //       │      ...     │
    //       │--------------│
    //       │      tom     │0x12345678
    //       │--------------│
    //       │      ...     │
    //       └--------------┘

    // 문자열 리터럴 비교
    // name1과 name2의 참조값이 동일하다.
    boolean isEqual = name1 == name2;
    System.out.println(isEqual); //true

  }

  public static void ex02() {

    // 문자열 객체(Object)
    String name1 = new String("tom");
    String name2 = new String("tom");

    // 문자열 객체는 항상 새로 생성된다.
    //
    //       ┌--------------┐
    //  name1│  0x12345678  │
    //       │--------------│
    //  name2│  0x98765432  │
    //       │--------------│
    //       │      ...     │
    //       │--------------│
    //       │      tom     │0x12345678
    //       │--------------│
    //       │      ...     │
    //       │--------------│
    //       │      tom     │0x98765432
    //       │--------------│
    //       │      ...     │
    //       └--------------┘

    // 문자열 객체 비교
    // name1과 name2의 참조값이 다르다.
    boolean isEqual = name1 == name2;
    System.out.println(isEqual); //false

  }

  public static void ex03() {

    // equals 메소드
    // 문자열이 동일하면 true, 아니면 false 반환

    String name1 = new String("tom");
    String name2 = new String("tom");
    String name3 = new String("Tom");

    boolean isEqual1 = name1.equals(name2);
    System.out.println(isEqual1); //true

    boolean isEqual2 = name1.equals(name3); // 대소문자도 일치해야 동일한 문자열로 인식한다.
    System.out.println(isEqual2); //false

    boolean isEqual3 = name1.equalsIgnoreCase(name3); 
    // 대소문자를 무시하고 문자열을 비교한다. (Case=upper case, lower case)
    System.out.println(isEqual3); //true

  }

  public static void ex04() {

    // toUpperCase 메소드 : 모두 대문자로 변환
    // toLowerCase 메소드 : 모두 소문자로 변환

    String name = "Tom";

    System.out.println(name.toUpperCase()); //TOM
    System.out.println(name.toLowerCase()); //tom

  }

  public static void ex05() {

    // length 메소드 : 문자열의 길이(글자수)를 반환

    String name = "Tom cruise\n";

    int length = name.length();
    System.out.println(length); //11

  }

  public static void ex06() {

    // charAt 메소드
    // 문자열의 특정 인덱스(Index)의 문자를 반환

    String name = "tom";

    char ch1 = name.charAt(0);
    char ch2 = name.charAt(1);
    char ch3 = name.charAt(2);

    System.out.println(ch1 + "," + ch2 + "," + ch3); //t,o,m

  }

  public static void ex07() {

    // substring 메소드
    // 문자열의 일부 문자열을 반환

    // substring 사용법
    // 1. substring(int begin) : 인덱스 begin부터 끝까지 반환
    // 2. substring(int begin, int end) : 인덱스 begin부터 end 이전까지 반환(begin <= 추출범위 < end)

    String name = "tom cruise";

    String firstName = name.substring(0, 3);
    String lastName = name.substring(4);

    System.out.println(firstName); // tom
    System.out.println(lastName); // cruise

  }

  public static void ex08() {

    // indexOf 메소드
    // 1. 특정 문자열의 인덱스를 반환
    // 2. 특정 문자열이 2개 이상 존재하는 경우 발견된 첫 번째 문자열의 인덱스를 반환
    // 3. 발견되지 않으면 -1을 반환

    // indexOf 사용법
    // 1. indexOf(String str) : 인덱스 0부터 String str을 검색
    // 2. indexOf(String str, int index) : 인덱스 index부터 String str을 검색

    String statement = "걱정한다고 걱정이 없어지면 걱정이 없겠네";

    int idx1 = statement.indexOf("걱정"); // 0
    int idx2 = statement.indexOf("걱정", idx1 + 1); // 6
    int idx3 = statement.indexOf("걱정", idx2 + 1); // 15
    int idx4 = statement.indexOf("tom"); // -1

    System.out.println(idx1);
    System.out.println(idx2);
    System.out.println(idx3);
    System.out.println(idx4);

  }

  public static void ex09() {

    // lastIndexOf 메소드
    // 1. 발견된 마지막 문자열의 인덱스를 반환
    // 2. 나머지 특징은 indexOf와 동일함

    String statement = "걱정한다고 걱정이 없어지면 걱정이 없겠네";

    int idx = statement.lastIndexOf("걱정"); // 15
    System.out.println(idx);

  }

  public static void ex10() {

    // contains 메소드
    // 지정된 CharSequence(String, char[] 등)가 포함되어 있으면 true 반환, 아니면 false 반환

    String email = "admin@naver.com";

    // @가 포함되어 있는가?
    if (email.contains("@")) {
      System.out.println("@가 포함되어 있다.");
    } else {
      System.out.println("@가 포함되어 있지 않다.");
    }

  }

  public static void ex11() {

    // isEmpty 메소드
    // 1. 빈 문자열이면 true 반환, 아니면 false 반환
    // 2. 빈 문자열 : ""처럼 문자열의 길이가 0인 문자열
    String name = " ";
    if (name.isEmpty()) {
      System.out.println("이름이 없다.");
    } else {
      System.out.println("이름이 있다.");
    } //이름이 있다.

    // isBlank 메소드
    // 1. 빈 문자열("")이거나 공백 문자(" ")로 구성되었다면 true 반환, 아니면 false 반환
    // 2. JDK 11 이후 버전에서 사용 가능
    if (name.isBlank()) {
      System.out.println("이름이 없다.");
    } else {
      System.out.println("이름이 있다.");
    } //이름이 없다.

  }

  public static void ex12() {

    // format 메소드
    // 1. 문자열을 지정한 형식으로 반환
    // 2. 클래스 메소드이므로 String 클래스를 이용해서 호출함

    // 숫자 형식
    int number = 100; // 10진수 100
    System.out.println(String.format("%o", number)); // %o : 8진수로 표시
    System.out.println(String.format("%d", number)); // %d : 10진수로 표시
    System.out.println(String.format("%x", number)); // %x : 16진수로 표시(0~9, a~f)
    System.out.println(String.format("%X", number)); // %X : 16진수로 표시(0~9, A~F)

    // 문자열 형식
    String str = "hello";
    System.out.println(String.format("%s", str)); // %s : 문자열로 표시

    // 출력 폭 조정
    System.out.println(String.format("%5d", number)); // 5자리 10진수로 표시, 숫자를 오른쪽 정렬 처리
    System.out.println(String.format("%-5d", number)); // 5자리 10진수로 표시, 숫자를 왼쪽 정렬 처리
    System.out.println(String.format("%05d", number)); // 5자리 10진수로 표시, 숫자를 오른쪽 정렬 처리, 빈 자리를 0으로 채움

    System.out.println(String.format("%10s", str)); // 10자리 문자열 표시, 문자열을 오른쪽 정렬 처리
    System.out.println(String.format("%-10s", str)); // 10자리 문자열 표시, 문자열을 왼쪽 정렬 처리

  }

  public static void ex13() {
    // strip 메소드
    // 앞 뒤에 포함된 공백 문자 제거
    String name = "\n tom \n";
    String str1 = name.strip();
    System.out.println(name.length()); //7
    System.out.println(str1.length()); //3

    // trim 메소드
    // 앞 뒤에 포함된 공백 문자 제거
    String str2 = name.trim();
    System.out.println(str2.length());
  }

  public static void ex14() {
    // replace 메소드
    // 1. 지정된 문자열을 다른 문자열로 변환
    // 2. 발견된 모든 문자열을 변환

    String ip = "192.168.0.101";
    String str = ip.replace(".", "_");
    System.out.println(str);

  }

  public static void ex15() {

    // 이 곳의 메소드는 정규식을 배운 다음에 사용합시다.

    // 정규식을 활용한 메소드
    // 1. startsWith : 지정된 정규식 패턴으로 시작하면 true 반환
    // 2. endsWith   : 지정된 정규식 패턴으로 끝나면 true 반환
    // 3. matches    : 지정된 정규식 패턴을 포함하면 true 반환
    // 4. replaceAll : 지정된 정규식 패턴을 만족하는 부분을 다른 문자열로 변환
    // 5. split      : 지정된 정규식 패턴으로 문자열을 분리하여 분리된 String 배열을 반환

    String ip = "192.168.0.101";

    String str = ip.replaceAll(".", "_"); // 192_168_0_101을 기대하지만 정규식 패턴에서 .는 모든 문자를 의미하므로 원하는 결과를 얻을 수 없다.
    System.out.println(str);

  }

java.lang.StringBuffer

  1. JDK 1.0부터 사용 가능 (자바 만들어졌을 때부터)
  2. String을 연결하는 클래스 (문자열 연결 연산자 +를 대체하는 클래스, +는 메모리 소비가 심해서)
  3. synchronized(동기화) 처리되어 멀티스레드 환경에서 사용할 수 있음
  4. 동작 느림 (3번 이유로)
  5. String 클래스에 비해서 메모리 낭비가 적음
    // StringBuffer 객체 선언
    StringBuffer sb;
    
    // StringBuffer 객체 생성
    sb = new StringBuffer();
    
    // append 메소드를 이용한 문자열 연결
    sb.append("ha");
    sb.append("va"); // +라면 hava같은 중간과정도 다 저장돼서 메모리 소비 심함
    sb.append("na"); // 반복적으로 연결되는 경우에는 빌더나 버퍼 사용
    
    // StringBuffer 객체에 저장된 문자열을 String으로 변환
    String str = sb.toString();
    System.out.println(str);

java.lang.StringBuilder

  1. JDK 1.5부터 사용 가능
  2. String을 연결하는 클래스 (문자열 연결 연산자 +를 대체하는 클래스, +는 메모리 소비가 심해서)
  3. synchronized(동기화) 처리가 되지 않아서 싱글스레드 환경에서 사용할 수 있음
  4. StringBuffer에 비해 동작 빠름 (버퍼가 느려서 3번 동기화 없애고 싱글로 바꿔 나온거)
  5. String 클래스에 비해서 메모리 낭비가 적음
    // StringBuilder 객체 선언
    StringBuilder sb;

    // StringBuilder 객체 생성
    sb = new StringBuilder();

    // append 메소드를 이용한 문자열 연결
    sb.append("ha");
    sb.append("va"); // +라면 hava같은 중간과정도 다 저장돼서 메모리 소비 심함
    sb.append("na"); // 반복적으로 연결되는 경우에는 빌더나 버퍼 사용
    
    // StringBuilder 객체에 저장된 문자열을 String으로 변환
    String str = sb.toString();
    System.out.println(str);

Random

java.lang.Math 클래스의 random 메소드

  1. 0 이상 1 미만의 난수를 반환
  2. 클래스 메소드이므로 Math 클래스를 이용해서 호출
    public static void ex01() {
    double randomNumber = Math.random(); // 0.0 <= 난수 < 1.0 (0.0에서 0.999999999...의 난수 발생)

    // 확률 처리하기
    if (randomNumber < 0.1) { //대략 10%
      System.out.println("대박");
    } else {
      System.out.println("꽝");
    }
  }

  public static void ex02() {
    /*
     * 정수 난수로 바꿔서 사용하기
     * 
     * 1단계 : Math.random() 호출                      0.0<=n<1.0
     * 2단계 : Math.random() *3                        0.0<=n<3.0
     * 3단계 : (int)(Math.random()*3) 정수로 캐스팅      0<=n<3
     * 4단계 : (int)(Math.random()*3)+1 시작값 더하기    1<=n<4 (1부터 3개)
     * -----------------------------------------------------------
     *         (int)(Math.random()*개수)+시작값
     *         (int)(Math.random()*개수+시작값)
     */

    int randomNumber = (int) (Math.random() * 3) + 1; //1부터 3개의 난수 발생
    System.out.println(randomNumber);
  }

java.util.Random 클래스

  1. 전달된 시드(seed)에 따라서 서로 다른 난수를 발생함
  2. 전달된 시드(seed)가 없는 경우에는 현재 시간을 시드(seed)로 사용
  3. 동일한 시드(seed)를 사용하면 동일한 난수 발생
  • Random() : 시드가 없는 경우
  • Random(long seed) : 시드가 없는 경우
    //Random 객체 선언 & 생성
    Random random = new Random();

    //실수
    double randomNumber1 = random.nextDouble(); // 0.0<=n<1.0

    //정수
    int randomNumber2 = random.nextInt(); //Integer.Min_VALUE <= n <=Integer.MAX_VALUE
    int randomNumber3 = random.nextInt(5); // 0 ~ 4 (5개 난수)

java.security.SecureRandom 클래스

  1. 보안 처리된 난수를 발생함
  2. Random 클래스와 같은 사용법

java.util.UUID

  1. 전역 고유 식별자(Universal Unique IDentifier)라는 뜻
  2. 32개의 16진수를 랜덤하게 생성함 (하이픈(-) 4개 별도 포함)
  3. UUID를 이용해서 생성한 값은 중복이 없는 것으로 취급
  4. 생성된 UUId 값은 String으로 바꿔서 사용

Date Time

시간 단위

  • 나노초: 어떤 작업 수행 시간을 정밀하게 계산할 때 사용하는 시간

Timestamp(타임스탬프)

  1. 현재 시간을 long 타입의 값으로 가지고 있는 것
  2. 1970년 1월 1일 0시부터 1/1000초마다 1씩 증가하고 있는 값

java.util.Date

    //현재 날짜와 시간
    Date date1 = new Date();
    System.out.println(date1);

    // 타임스탬프 값에 해당하는 날짜와 시간
    Date date2 = new Date(24 * 60 * 60 * 1000); //1일이 지난 타임스탬프
    System.out.println(date2);

java.sql.Date

  • DB의 DATE 타입을 처리하는 date 클래스
    Date date = new Date(System.currentTimeMillis()); //현재 날짜
    System.out.println(date);

    //java.sql.Timestamp 클래스
    //DB의 TIMESTAMP 타입을 처리하는 Timestamp 클래스
    Timestamp timestamp = new java.sql.Timestamp(System.currentTimeMillis()); //현재 날짠
    System.out.println(timestamp);

java.text.SimpleDateFormat

  1. 날짜, 시간 형식을 지정할 수 있는 클래스이다.
  2. 원하는 형식을 패턴(Pattern)으로 전달할 수 있다.
  3. 패턴
    1) yy : 년도 2자리
    2) yyyy : 년도 4자리
    3) M : 월 1자리(1~12)
    4) MM : 월 2자리(01~12)
    5) MMM : 문자열(1월~12월)
    6) d : 일 1자리(1~31)
    7) dd : 일 2자리(01~31)
    8) E : 요일(일~토)
    9) a : 오전/오후(오전, 오후)
    10) h : 12시각 1자리(1~12)
    11) hh : 12시각 2자리(01~12)
    12) H : 24시각 1자리(0~23)
    13) HH : 24시각 2자리(00~23)
    14) m : 분 1자리(0~59)
    15) mm : 분 2자리(00~59)
    16) s : 초 1자리(0~59)
    17) ss : 초 2자리(00~59)
Date date = new Date();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd a hh:mm:ss");
    String strDate = sdf.format(date);
    System.out.println(strDate);

    System.out.println(new SimpleDateFormat("yy/MM/dd E HH:mm:ss").format(date));

java.util.Calendar

  1. 특정 날짜를 생성할 수 있다.
  2. 날짜의 구성 요소(년, 월, 일, ...)를 쉽게 가져다 사용할 수 있다.
// 현재 날짜와 시간
    Calendar calendar = Calendar.getInstance();

    // 구성요소 가져오기
    int year = calendar.get(Calendar.YEAR); // Calendar.YEAR == 1 이므로 int year = calendar.get(1)과 같다.
    int month = calendar.get(Calendar.MONTH) + 1; // 월(0~11) : 주의가 필요하다.
    int day = calendar.get(Calendar.DAY_OF_MONTH); // 일(1~31)
    int weekNo = calendar.get(Calendar.DAY_OF_WEEK); // 일(1), 월(2), ... 토(7)
    int ampm = calendar.get(Calendar.AM_PM); // 오전(0), 오후(1)
    int hour12 = calendar.get(Calendar.HOUR); // 12시각(1~12)
    int hour24 = calendar.get(Calendar.HOUR_OF_DAY); // 24시각(0~23)
    int minute = calendar.get(Calendar.MINUTE); // 분(0~59)
    int second = calendar.get(Calendar.SECOND); // 초(0~59)

    System.out.println(year);
    System.out.println(month);
    System.out.println(day);
    System.out.println(weekNo);
    System.out.println(ampm);
    System.out.println(hour12);
    System.out.println(hour24);
    System.out.println(minute);
    System.out.println(second);

    // 현재 날짜와 시간
    Calendar calendar = Calendar.getInstance();

    // 특정 날짜로 변경
    calendar.set(Calendar.YEAR, 2022); // 년도만 2022로 수정

    // 특정 기간 이후/이전으로 변경
    calendar.add(Calendar.MONTH, 1); // 1개월 후
    calendar.add(Calendar.DAY_OF_MONTH, -1); // 1일 전

    // Calendar를 이용해서 타임스탬프 알아내기
    long timestamp = calendar.getTimeInMillis();
    System.out.println(timestamp);

    // Calendar를 이용해서 Date 알아내기
    Date date = calendar.getTime();
    System.out.println(date);

LocalDateTime

JDK 1.8 이후
1. 날짜 : java.time.LocalDate
2. 시간 : java.time.LocalTime
3. 둘다 : java.time.LocalDateTime

  • 날짜
    // 현재 날짜
    LocalDate date1 = LocalDate.now();
    System.out.println(date1);

    // 특정 날짜
    LocalDate date2 = LocalDate.of(2023, 7, 31); // 2023년 7월 31일
    System.out.println(date2);

    // 문자열 날짜 처리
    LocalDate date3 = LocalDate.parse("2023-07-31"); // 기본 패턴 : yyyy-MM-dd
    System.out.println(date3);

  • 시간
    // 현재 시간
    LocalTime time1 = LocalTime.now();
    System.out.println(time1);

    // 특정 시간
    LocalTime time2 = LocalTime.of(15, 25, 30); // 15시 25분 30초
    System.out.println(time2);

    // 문자열 시간 처리
    LocalTime time3 = LocalTime.parse("14:25:30"); // 기본 패턴 HH:mm:ss
    System.out.println(time3);

  • 둘다
    // 현재 날짜와 시간
    LocalDateTime dateTime1 = LocalDateTime.now();
    System.out.println(dateTime1);

    // 특정 날짜와 시간
    LocalDateTime dateTime2 = LocalDateTime.of(2023, 7, 31, 15, 25, 30);
    System.out.println(dateTime2);

    // 문자열 형식의 날짜와 시간
    LocalDateTime dateTime3 = LocalDateTime.parse("2023-07-31T15:28:30"); 
    //날짜와 시간 사이에 대문자 T 적어서 날짜, 시간 구분

    System.out.println(dateTime3);

  • 패턴 지정
    // 패턴 지정하기
    LocalDateTime dateTime = LocalDateTime.now();
    DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy년 MM월 dd일 E요일 a hh시 mm분 ss초");
    String strDateTime = dtf.format(dateTime);
    System.out.println(strDateTime);

  • 날짜/시간 구성요소 가져오기
    LocalDateTime dateTime = LocalDateTime.now();

    int year = dateTime.getYear(); // 년
    int month = dateTime.getMonthValue(); // 월(1~12)
    int day = dateTime.getDayOfMonth(); // 일
    int hour = dateTime.getHour(); // 시(0~23)
    int minute = dateTime.getMinute(); // 분
    int second = dateTime.getSecond(); // 초

    System.out.println(year);
    System.out.println(month);
    System.out.println(day);
    System.out.println(hour);
    System.out.println(minute);
    System.out.println(second);

java.util.Scanner

  1. 어떤 정보를 읽어 들일 때 사용한다.
  2. 파일, 사용자 입력 정보 등을 읽어 들일 수 있다. (사용자 입력에 초점을 맞춘다.)
  3. 사용자가 입력하는 데이터의 타입에 따라서 입력 메소드가 구분되어 있다.
    1) int : nextInt();
    2) long : nextLong();
    3) double : nextDouble();
    4) String
    (1) 공백 없는 문자열 : next()
    (2) 공백 있는 문자열 : nextLine()
  4. 사용자 입력을 위해서 사용해야 하는 입력 스트림(InputStream)은 System.in이다.
    // Scanner 객체 선언 & 생성
    Scanner sc = new Scanner(System.in);

    // String 입력
    System.out.println("이름을 입력하세요");
    String name = sc.next(); // 이름에 공백이 없어야 한다.
    System.out.println("입력된 이름: " + name);

    // int 입력
    System.out.println("나이를 입력하세요");
    int age = sc.nextInt();
    System.out.println("입력된 나이: " + age);

    // double 입력
    System.out.println("키를 입력하세요");
    double height = sc.nextDouble();
    System.out.println("입력된 키: " + height);

    // 사용한 입력 스트림 종료(생략 가능하다.)
    sc.close();

랜덤 흥미롭당

profile
MJ
이전 포스트

[230728] 해시맵 (DAY23)

다음 포스트

[230801] 예외처리 (DAY25)

1개의 댓글

comment-user-thumbnail
happy
2023년 7월 31일

잘 읽었습니다. 좋은 정보 감사드립니다.

답글 달기