오브젝트-조영호 책을 보면서 공부하면서 정리한 글입니다.

소프트웨어 모듈의 세 가지 목적

1. 실행 중에 제대로 동작하는 것
2. 변경을 위해 존재하는 것
3. 코드를 읽는 사람과 의사소통하는 것

설계의 목표

• 객체 사이의 결합도를 낮춰 변경이 용이한 설계를 만드는 것이어야 한다.
  • 목표를 이루기 위해서는?
    1. 캡슐화를 이용해 의존성을 적절히 관리함으로써 객체 사이의 결합도를 낮추는 것
    2. 자율성을 높인다 -> 자신의 문제를 스스로 해결하도록 코드를 변경
    3. 기본적인 원칙을 따라야한다.
       • 인터페이스(Interface)와 구현(Implementation)으로 나누고 인터페이스는 공개하고 구현은 공개하지 않는 것이 객체 사이의 결합도를 낮추고 변경하기 쉬운 코드를 작성하기 위해 따라야하는 기본적인 설계원칙이다.

응집도 높게? 낮게?

• 응집도를 높게 해야한다.
  • 밀접하게 연관된 작업만을 수행하고 연관성 없는 작업은 다른 객체에게 위임하는 객체를 가리켜 응집도가 높다고 말한다.
  • 결합도를 낮추면 응집도가 높아짐
  • 자신의 데이터를 책임져야 응집도가 높아짐

절차지향과 객체지향

• 절차적 프로그래밍 : 프로세스와 데이터를 별도의 모듈에 위치시키는 방식
• 객체지향 프로그래밍 : 프로세스와 데이터가 동일한 모듈 내부에 위치하도록 프로그래밍하는 방식 (자신의 문제를 스스로 처리한다(자율성))
  • 훌륭한 객체지향 설계의 핵심 : 캡슐화를 이용해 의존성을 적절히 관리함으로써 객체 사이의 결합도를 낮추는 것

설계를 어렵게 하는 것

• 설계를 어렵게 하는것은 의존성이다.
• 해결방법
  1. 불필요한 의존성을 제거함으로써 객체 상의 결합도를 낮추는 것
  2. 세부사항을 객체 내부로 감춰 캡슐화를 하는 것

결론

• 불필요한 세부사항을 객체 내부로 캡슐화하고, 객체의 자율성을 높이고 응집도 높은 객체들의 공통체를 창조하여 낮은 결합도와 높은 응집도를 가지고 협력하도록 최소한의 의존성만을 남기는 것을 훌륭한 객체지향 설계라 할 수 있다.

*캡슐화

• 개념적이나 물리적으로 객체 내부의 세부적인 사항을 감추는 것
• 목적은 변경하기 쉬운 객체를 만드는 것

*인터페이스

• 클라이언트 프로그램에 어떤 매ㅔ서드를 제공하는지 알려주는 명세 또는 약속이다.
• 추상 메서드의 집합(추상메서드만 가지고 있음. 다른 그 외에는 아무것도 가지고 있지 않음)
• 상속, 구현
• 참고

*구현

• 계획, 아이디어, 모델, 설꼐, 사양, 표준, 알고리즘 또는 정책의 적용 또는 실행을 실현하는 것
• 참고

DB를 설계할 때 인덱스를 설정해야하는 상황이 있었습니다. 그래서 저는 2개의 컬럼을 각자 인덱스(Index)를 시켰습니다. 하지만, 2개의 조건을 같이 검색을 할 때 각자 인덱스(Index)를 지정해주는 것보다 결합인덱스로 지정해주는것이 더 효과적이라는 것을 알게 되어 단일인덱스를 복합인덱스로 바꾸어 설계하였습니다.

우선, 복합인덱스에 대해 들어가기전에 인덱스(Index)에 대해 개념을 알아보겠습니다.

1. 인덱스(Index)란?

인덱스(Index)는 테이블에 대한 검색 속도를 향상시켜주는 자료구조 입니다.

예시로 책에 있는 목차나 색인이라고 생각하시면 됩니다. 만약 책에서 원하는 내용을 찾고자 한다면, 책의 모든 페이지를 찾는 것은 시간이 오래걸립니다. 이처럼 인덱스(Index)는 원하는 내용을 빨리 찾을 수 있게해주는 자료구조입니다.

출처: https://mangkyu.tistory.com/96

2. 인덱스(Index) 장/단점

• 장점

  • 테이블을 조회하는 속도와 그에 따른 성능을 향상시킬 수 있다.
  • 전반적인 시스템의 부하를 줄일 수 있다.

• 단점

  • 인덱스(Index)를 관리하기 위해 DB의 약 10%에 해당하는 저장공간이 필요하다.
  • 인덱스를 관리하기 위해 추가 작업이 필요하다.
  • 인덱스를 잘못 사용할 경우 오히려 성능이 저하되는 역효과가 발생할 수 있다.

만약 CREATE, DELETE, UPDATE가 자주 일어나는 컬럼에 인덱스를 걸게되면 오히려 성능이 저하됩니다. 위와 같은 CREATE, DELETE, UPDATE는 기존의 인덱스를 삭제하지 않고 사용하지 않음으로 남겨두기 때문에 작업을 할 때 실제 데이터에 비해 인덱스(Index)가 과도하게 커지는 문제점이 발생할 수 있습니다.

3. 인덱스(Index)를 사용하면 좋은 경우

• 규모가 큰 테이블
• INSERT, UPDATE, DELETE 작업이 자주 발생하지 않는 컬럼
• WHERE, ORDER BY, JOIN 등 자주 사용되는 컬럼
• 데이터 중복도가 낮은 컬럼

4. 인덱스(Index)의 자료구조

1. Hash Table

해시 테이블은 (Key, Value)의 구조로 데이터를 저장하는 자료구조입니다. 시간 복잡도가 O(1)로 매우 빠른 데이터를 탐색 할 수 있습니다.

탐색은 빠르지만 실제로 인덱스로 잘 사용되지는 않습니다. 그 이유는 해시 테이블은 1이라도 달라지면 완전히 다른 해시 값을 생성합니다. 다른 말로는 등호(=) 연산에 최적화 되어있습니다. 하지만 DB 탐색할 때 범위 탐색(부등호(<,>)를 사용하는 탐색)을 자주 사용하기 때문에 정렬되어 있지 않은 해시테이블은 잘 맞지 않습니다.

2. B+Tree

B+Tree는 DB의 인덱스(Index)를 위해 자식 노드가 2개 이상인 B-Tree를 개선시킨 자료구조입니다.

B+Tree 특징 - 리프노드(데이터노드)만 인덱스(Index)와 함께 데이터를 가지고 있고, 나머지 노드(인덱스노드)들은 데이터를 위한 인덱스 key만을 가지고 있습니다. - 리프노드들은 LinkedList로 연결되어 있습니다. - 데이터노드 크기는 인덱스노드의 크기와 같지 않아도 됩니다.

위에서 말했듯이 DB 탐색할 때 부등호를 이용한 순차 검색이 자주 발생합니다. 이에 맞게 BTree의 리프노드들을 LinkedList로 연결시키므로써 보완하여 B+Tree를 만들어 인덱스에 맞게 최적화되었습니다.

• B+Tree는 무조건 리프노드까지 탐색해야한다는 단점이 있고, O(log2n)의 시간복잡도를 갖습니다.

지금까지 인덱스(Index)에 대해서 알아봤습니다. 이제 본 문제였던 결합인덱스에 대해서 알아보겠습니다.

1. 복합 인덱스란?

2개 이상의 컬럼을 합쳐서 인덱스를 만드는 것입니다. 하나의 컬럼으로보다 여러개의 컬럼을 합쳤을 때 효율이 좋은 경우 사용하며, WHERE절에서 OR조건이 아니라 AND 조건일 때 사용하는 것이 좋습니다.

2. 복합 인덱스 컬럼 선택

1. WHERE절에서 AND 조건으로 결합되어 사용되면서 각각 사용할 때보다 여러개 사용했을 때 더 효율적인 컬럼들
2. JOIN의 연결고리로 자주 사용되는 컬럼
3. ORDER BY에 자주 사용되는 컬럼
4. 단일 키 컬럼 조건이 아닌 한개 이상 키 컬럼조건으로 자주 조회되는 컬럼

3. 복합 인덱스의 컬럼 순서 결정

결합 인덱스에서 순서가 중요합니다. 순서에 따라 성능이 좋아질수도 오히려 나빠질 수도 있습니다. 비슷하게 저도 결합 인덱스를 설정했는데 인덱스가 안되는 경우가 있었습니다.

예를 들어, 결합 인덱스로 (A,B,C)를 걸었을 때 순차적으로 A 필터링, B 필터링, C 필터링을 받아야 좋은 결합인덱스라 할 수 있는데 저는 A를 무시한체 B와 C에 대해서만 검색을 했었습니다. 이럴 때 인덱스가 적용되지 않았습니다. 결합인덱스가 적용되려면 설정했던 선행 컬럼부터 사용해야합니다.

그래서 결합 인덱스를 설정할 때 순서가 중요한다는 것을 알게되었습니다. 그래서 아래와 같은 고려하여 우선순위를 설정하셔야합니다.

1. WHERE절 조건에 많이 사용되는 컬럼
2. "="로 사용되는 컬럼
3. 분포도가 좋은 컬럼
4. 자주 이용되는 순서

*인덱스(Index) 생성 방법

단일 인덱스 생성방법:
create index "인덱스명" on "테이블명"(컬럼)

복합 인덱스 생성방법:
create index "인덱스명" on "테이블명"(컬럼1, 컬럼2, 컬럼3,...)

위와 같이 복합 인덱스를 생성하려면 단일 인덱스 생성방법에서 컬럼만 추가해주시면 됩니다.

참고

https://mangkyu.tistory.com/96 https://rebro.kr/167 https://coding-factory.tistory.com/755

맞지 않은 내용이 있으면 말씀해주세요. 수정하겠습니다 ^&^

1. Key 발급

kakao developers 내 애플리케이션을 누릅니다. 로그인이 필요한 작업이기 때문에 카카오계정을 로그인을 하게되면 위와같은 화면이 나옵니다. 화면에 보이는 애플리케이션 추가하기를 클릭합니다.

앱 이름과, 사업자명을 입력하라고 나옵니다. 자신이 만들고자 하는 이름을 적고 서비스 이용의 동의 후 저장을 클릭합니다.

해당 애플리케이션이 생성되고 그곳으로 들어가면 키가 발급된것을 볼 수 있습니다. 저는 javaScript 키를 이용하여 진행하였습니다.

2. 플랫폼 설정

플랫폼 설정하기를 클릭합니다.

자신이 쓸 플랫폼의 종류를 선택하여 등록하면 됩니다. 저는 Web을 사용할 예정이므로 Web 플랫폼 등록을 하였습니다.

자신의 사이트 도메인을 추가해주면됩니다. 저는 local에서 진행하므로 위와 같이 http://localhost:8080 을 도메인 주소를 추가하였습니다.

저장을 하게되면 위와 같이 저가 등록한 Web 플랫폼이 정상적으로 등록된것을 볼 수 있습니다.

3. map 설정

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8"/>
    <title>Kakao 지도 시작하기</title>
</head>
<body>
    <div id="map" style="width:500px;height:400px;"></div>
    <script type="text/javascript" src="//dapi.kakao.com/v2/maps/sdk.js?appkey=발급받은 APP KEY를 넣으시면 됩니다."></script>
    <script>
        var container = document.getElementById('map');
        var options = {
            center: new kakao.maps.LatLng(33.450701, 126.570667),
            level: 3
        };

        var map = new kakao.maps.Map(container, options);
    </script>
</body>
</html>

위와 같은 html파일을 만들어서 appkey='발급받은 APP KEY를 넣으시면 됩니다.' 이부분에 위에서 발급받은 key를 넣으시면 됩니다. center: new kakao.maps.LatLng(33.450701, 126.570667) 위도,경도로 설정된 위치가 지도에 나오는 것을 볼 수 있습니다.

참고

https://apis.map.kakao.com/web/guide

잘못된 사실이 있으면 알려주시면 수정하겠습니다. ^&^

객체가 가지고 있는 날짜에서 3일전의 날짜를 구하고 싶었습니다. 그래서 저는 아래와 같이 설정하였습니다.

let date = $('#date).val(); // 2023-02-09
let endDate = new Date(date);
let startDate = new Date(); // 오늘 날짜 2023-04-04

startDate.setDate(endDate.getDate()-3);

원하는 값으로는 2023-02-06이 나와야하는데 2023-04-06이 나왔습니다.

🎈해결방안

let date = $('#date).val(); // 2023-02-09
let endDate = new Date(date);
let startDate = new Date(date); // 날짜 세팅 2023-02-09

startDate.setDate(endDate.getDate()-3);

위와 같이 startDate도 객체시간으로 할당하여 계산하였더니 원하는 값이 2023-02-06이 나왔습니다.

🎈이유!!

결론부터 말씀드리면, 1970 년 1 월 1 일 00:00:00 UTC와 주어진 날짜 사이의 밀리 초로 변경되서 계산 되기 때문입니다.

endDate.getDate()-3의 값은 6입니다.(9 - 3 = 6) 그래서 2023-04-04이 값인 객체에서 setDate(6)을 했을 때 2023-04-06으로만 바뀌게 됩니다.

그래서 2023-02-09인 같은 일수로 맞춰줬습니다. 다른 방법으로는

let startDate = new Date(endDate.getTime() - 3 * 24 * 60 * 60 * 1000);

이런식으로 설정해주면 됩니다.

🎈참고

https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Global_Objects/Date/setDate

⚠️틀린부분이 있으면 말씀해주세요!! 수정하겠습니다.

public interface CarRepository extends JpaRepository<Car, Long>{
    @Query("select c from Car c join fetch c.location where c.user.id = :userId and c.number like %:number")
    List<Car> findByLastFourNumbers(@Param("userId") Long userId, @Param("number") String number);

    @Query("select c from Car c join fetch c.location where c.user.id = :userId")
    List<Car> findByUserId(@Param("userId") Long userId);
}

🎈 2. CarRepositoryCustom 만들기

public interface CarRepositoryCustom{
    List<CarDto> search(CarSearchCondtion condition);
}

Query Dsl 를 작성과 유지보수를 쉽게하기 위해서 Custom을 만들어줍니다.

🎈 3. CarRepositoryImpl 만들기

⚠️주의. 이름 지을 때 해당하는 repository 이름+ Impl를 붙혀서 이름을 지어준다.

public class CarRepositoryImpl implements CarRepositoryCustom{
    // 쿼리문을 작성을 위해 선언
    private final JPAQueryFactory queryFactory;

    // 생성자 주입
    public CarRepositoryImpl(EntityManager em){
        this.queryFactory = new JPAQueryFactory(em);
    }

    @Override
    public List<CarDto> search(CarSearchCondition condition){


          return queryFactory
                .select(Projections.fields(CarDto.class,
                    car.id, //QCar.car(Qcar를 static 시킴)
                    car.number,
                    car.user.username,
                    car.address,
                    car.location.lat,
                    car.location.lng
               ))
               .from(car)
               .leftJoin(car.user, user)
               .where(
                           usernameEq(condition.getUsername()),
                        targetEq(condtion.getTarget())
               .fetch();
    }
    private BooleanExpression usernameEq(String username){
        return StringUtils.hasText(username) ? car.user.username.eq(username) : null;
    }

    private BooleanExpression targetEq(String target){
        return StringUtils.hasText(target) && target.length() >= 4 ? car.number.endWith(target) : null;
    }
}

동적쿼리 작성하는 방법은 2가지 방법이 있습니다.

1. BooleanBuilder
2. where 다중 파라미터 사용

* BooleanBuilder

public void BooleanBuilder() throws Exception{
     String usernameParam = "member1";
     Integer ageParam = 10;

BooleanBuilder builder = new BooleanBuilder();
  if(usernameCond != null){
      builder.and(member.username.eq(usernameCond));
  }
  if(ageCond != null){
      builer.and(member.age.eq(ageCond));
}
  List<Member> result = queryFactory
                          .selectFrom(member)
                          .where(builder)
                          .fetch();

}

> **where 다중 파라미터**는
  1. where 조건에 null 값은 무시되는 장점
  2. 메서드를 다른 쿼리에서도 재활용 할 수 있는 장점
  3. 쿼리 자체의 가독성이 높아지는 장점
  위와 같은 3가지 장점이 있어 선택하였습니다.

## 🎈 4. CarRepository 수정

 ```java
  public interface CarRepository extends JpaRepository<Car, Long>, CarRepositoryCustom{

  }

JPQL 작성한 코드는 삭제하고 인터페이스로 만든 CarRespositoryCustom을 상속받아줍니다.

🎈참고

링크 Inflearn의 김영한님 실전! Querydsl 강의입니다.

** 잘못된 내용이 있으면 알려주세요. 댓글 남겨주세요!! 수정하겠습니다!!**

1. 🎈version 설정

buildscript{
    ext{
        queryDslVersion = "5.0.0"
    }
}

dependencies 부분에 해당 version을 그대로 써도 되지만 버전 관리를 더 쉽게 하기위해서 위와 같은 방법으로 queryDslVersion을 선언하여 저장하였습니다.




## 2. 🎈plugin 설정
>```java
plugins{
...
    id "com.ewerk.gradle.plugins.querydsl" version "1.0.10"
...
}

아래 부분에 querydsl{..} 부분을 사용하기 위해서는 플러그인을 추가해주어야합니다.

3. 🎈dependency 추가

dependencies{
    ...
    implementation "com.querydsl:querydsl-jpa:${queryDslVersion}"
    implementation "com.querydsl:querydsl-apt:${queryDslVersion}"
}

위에서 설정한 Version을 담고 있는 변수 queryDslVersion을 ${queryDslVersion} 형식으로 넣어준다. 
>
***⚠️주의‼️***
" "가 아니라 ' '로 감싸면 ${queryDslVersion} 부분이 인식하지 못한다. ⚠️

## 4. 🎈추가 설정
```java
def querydslDir = "$buildDir/generated/querydsl"

querydsl{
    jpa = true
    querydslSourcesDir = querydslDir
}
sourceSets{
    main.java.srcDir querydslDir
}
compileQuerydsl{
    options.annotationProcessorPath = configurations.querydsl
}
configurations{
    conpileOnly{
        extendsFrom annotationProcessor
    }
    querydsl.extendsFrom compileClasspath
}

위에서 말한거처럼 플러그인을 설정한 이유는 추가 설정을 해주기 위해서입니다. querydslDir = "$buildDir/generated/querydsl" QType Entity들이 생길 주소 경로입니다. (* $buildDir은 project의 build 드렉토리 경로입니다.)

5. 🎈build 실행

compileQuerydsl를 통해서 빌드를 시켜서 Entity들에 대해서 QType의 클래스가 생깁니다. 생기지 않거나 이미 build를 했었더라면 clean을 먼저 실행시키고 compileQuerydsl를 실행시켜주세요

참고

링크 Inflearn의 김영한님 실전! Querydsl 강의입니다.

• key와 value이 하나의 쌍으로 연결되어 있어 키를 통해 값에 접근을 할 수 있도록 만들어진 자료 구조

🎉HashMap이란?

• 내부적으로 Entry<K,V>[] Entry 의 array로 되어 있으며, 해당 array에 index는 내부 해쉬 함수를 통해 계산된다.
• HashMap은 Map 인터페이스의 한 종류로 Key와 Value 한 쌍을 데이터로 가지고 있으며 Key를 통해 Value에 접근한다.
• HashMap은 그 안에 들어있는 데이터를 Set 구조 저장하기 때문에 Set의 원칙대로 중복된 데이터를 허락하지 않으면서 순서가 없다.
• hashing을 사용하기 때문에 많은양의 데이터를 검색하는데 뛰어난 성능을 가지고 있다.
• 시간복잡도 O(1)

*Set : 중복된 데이터 x, 순서 x

🎉TreeMap이란?

• key 값에 따라서 자동으로 Sort가 되는 방식
• 동기화(synchronized) 처리가 되어 있어 Thread-safe 하다.
• HashMap과는 다르게 Key 값으로 null을 허용하지 않는다.
• 내부적으로 RedBlack Tree로 저장되며, 키값에 대한 Comparator 구현으로 정렬 순서를 바꿀수 있음
• 시간복잡도 O(logN)
• RedBlack Tree : 자가 균형 이진 탐색 트리

🎉HashMap과 TreeMap의 차이

• HashMap은 key로 null 허용, TreeMap은 key로 null 허용하지 않음
• HashMap은 정렬되어 있지 않은 상태, TreeMap은 정렬된 상태
• HashMap 시간복잡도 O(1), TreeMap 시간복잡도 O(logN)

참고

Red Black Tree HashMap vs TreeMap

• GC(Garbage Collection)는 자바 애플리케이션에서 사용하지 않는 메모리를 자동으로 수거하는 기능

🎈JVM 메모리 영역

• 자바에서는 Young 영역과 Old 영역으로 나뉜다.
• Young 영역은 생성된지 얼마 되지 않은 객체들을 저장하는 장소. (Young 영역에서 시간이 지남에 다라서 우선 순위가 낮아지면 Old 영역으로 옮겨짐)
• Old 영역은 생성된지 오래된 객체를 저장하는 장소
• Perm 영역은 Class, Method 등의 코드가 저장되는 영역으로, JVM에 의해서 사용된다.

🎈Minor GC

• Young 영역을 Minor GC라고 부른다. Young 영역은 Eden/ survivor 이라는 두 영역으로 또 나뉜다.
• Eden 영역은 자바 객체가 생성되자마자 저장되는 곳
• 이렇게 생성된 객체는 Minor GC가 발생할 때 Survior 영역으로 이동하게 된다.
• Survivor 영역은 Survivor1과 Survivor2 두 영역으로 나뉘는데, Minor GC가 발생하면 Eden과 Survivor1에 활성 객체를 Survivor2로 복사한다.
• Survivor1과 Eden 영역을 클리어하여 Survivor2에 활성객체만 있도록 한다.
• 다음번 Minor GC가 발생하면 같은 원리로 Eden과 Survivor2 영역에서 활성객체를 Survivor1에 이동시킨다. 반복하면서 Minor GC 수행
• Survivor에 오래된 객체는 Old영역으로 옮긴다.
• 이러한 방식을 GC 알고리즘 Copy & Scavenge 라고 한다. 이 방식은 속도가 매우 빠르며 작은 크기의 메모리를 콜렉팅하는데 매우 효과적이다.
• Minor GC의 경우에는 자주 일어나기 때문에 GC에 걸리는 시간이 잛은 알고리즘을 사용하는것이 적합하다.

🎈FULL GC

• Old 영역의 가비지 컬렉션을 Full GC라고 부르며 Full GC에 사용되는 알고리즘을 Mark & compact 라고 한다.
• Mark & Compack 알고리즘은 객체들의 참조를 확인하면서 참조가 연결되지 않은 객체를 표시한다. 이 작업이 끝나면 사용되지 않는 객체를 모두 표시하고 이 표시된 객체를 삭제한다.
• Full GC는 속도가 매우 느리며, Full GC가 일어나는 도중에는 순간적으로 자바 애플리케이션이 멈춰버리기 대문에, Full GC가 일어나는 정도와 시간은 애플리케이션의 성능과 안정성에 아주 큰 영향을 미친다.

🎈GC가 중요한 이유

• 가비지 컬렉션 중에서 Minor GC의 경우에는 보통 0.5 이내에 끝나기 때문에 큰 문제가 되지 않지만, Full GC의 경우네는 자바 애플리케이션이 멈춰 버리기 때문에, 문제가 될 수 있다.
• 멈추는 동안 사용자의 요청이 큐에 들어있다가, 순간적으로 요청이 한꺼번에 들어오기 대문에 과부하에 의한 여러 장애를 만들 수 있다.
• 따라서 원활한 서비를 위해서는 GC가 어떻게 일어나게 하느냐가 시스템의 안정성과 성능에 큰 변수로 작용할 수 있다.

🎈Stop-the-world

• GC를 실행하기 위해 JVM이 애플리케이션 실행을 멈추는 것이다.
• stop-the-world가 발생하면 GC를 실행하는 스레드를 제외한 나머지 스레드는 모두 작업을 멈춘다.
• GC 작업을 완료한 이후에야 중단했던 작업을 다시 시작한다.
• 어떤 GC 알고리즘을 사용하더라도 stop-the-world가 발생한다.
• GC 튜닝이란 stop-the-world 시간을 줄이는 것이다.

참고

• 이동욱님 GC(Garbage Collection) 종류 및 내부 원리
• 발전 가능성이 있는 사람이 되자

Integer.toString("10진수", "변환하고 싶은 진수")

특정 진수를 변환할 때 쓰이는 함수들도 있다.

2진수 Integer.toBinaryString("원하는 값")

8진수 Integer.toOctalString("원하는 값")

16진수 Integer.toHexString("원하는 값")

N진수 -> 10진수

Integer.parseInt(값(String형태), N진수)

```

참고

https://cornarong.tistory.com/48https://cornarong.tistory.com/48

문제링크

🎉 입/출력 형식

🎉 접근방법

1. A~Z를 String 형태로 list에 저장한다.
2. 주어진 msg를 index 0부터 빈 스트링(s)에 붙히면서 list에 있는지 확인한다. 2-1 list에 존재하면 history에 s를 저장한다. 2-2 list에 없으면 history의 index 번호는 ans에 저장하고 s는 list에 넣어 준뒤 s = ""로 초기화하고 index를 -1를 해준다.
3. index가 msg 길이 만큼 2를 반복한다.
4. 마지막 history의 index 번호를 ans에 저장하고 반환한다.

🎉 코드

import java.util.*;
class Solution {
    public int[] solution(String msg) {
        int[] answer = {};
        List<Integer> ans = new ArrayList<>();
        List<String> list = new ArrayList<>();
        char temp = 'A';
        // 1. A~Z 넣기
        for(int i=0; i<26; i++){
            String str = String.valueOf((char)(temp+i));
            list.add(str);
        }
        String s = "";
        String history = "";
        for(int i=0; i<msg.length(); i++){
            // 1. list에 포함되는지 확인
            s += msg.charAt(i);
            if(list.contains(s)){
                history = s;
                continue;
            }
            ans.add(list.indexOf(history)+1);
            list.add(s);
            s = "";
            i--;
        }
        ans.add(list.indexOf(history)+1);
        return ans.stream().mapToInt(i->i).toArray();
    }
}

문제링크

🎈제한사항(입력형식)

🎈접근방법

1. 4칸으로 지워지는 블록을 이차원 boolean 배열(check)에 체크해준다.(바로 적용안하는 이유는 : 겹치는 부분도 있기 때문에 모든 경우를 구해야한다.)
2. check배열에서 true이면 map에 '.'으로 바꿔준다. (지우는 단계) 2-1. '.'으로 바꿔주면서 바꿔준 갯수를 새고 반환해준다. 2-2 개수가 0이면 종료하고 아니면 answer에 더해준다.
3. 지워진 블록을 채우기 위해서 블록들을 내려준다.
4. 2-2에 0이 나올 때까지 반복한다.

🎈코드

class Solution {
    static int[] dx ={1,0,1};
    static int[] dy ={0,1,1};
    static char[][] map;
    static int M,N;
    public int solution(int m, int n, String[] board) {
        int answer = 0;
        M = m; N = n;
        map = new char[m][n];
        for(int i=0; i<m; i++){
            map[i] = board[i].toCharArray();
        }
        while(true){
            boolean[][] check = new boolean[m][n]; 
            for(int i=0; i<m-1; i++){
                for(int j=0; j<n-1; j++){
                    if(map[i][j] == '.') continue;
                    blockCheck(check,i,j);
                }
            }
            int cnt = blockDelete(check);
            if(cnt==0) break;
            answer+=cnt;
            blockDown();
        }
        return answer;
    }
    // 블럭 내리기
    static void blockDown(){
        for(int c = 0 ; c < N ; c++) {
            for(int r = M - 1 ; r >= 0 ; r--) {
                if(map[r][c] == '.') {
                    for(int k = r - 1 ; k >= 0 ; k--) {
                        if(map[k][c] != '.') {
                            map[r][c] = map[k][c];
                            map[k][c] = '.';
                            break;
                        }
                    }
                }
            }
        }

    }
    // 블럭 지우기
    static int blockDelete(boolean[][] check){
        int cnt = 0;
        for(int i=0; i<M; i++){
            for(int j=0; j<N; j++){
                if(check[i][j]){
                    map[i][j] = '.';
                    cnt++;
                }
            }
        }   
        return cnt;
    }
    // 지워야할 블럭 찾기
    static void blockCheck(boolean[][] check,int x, int y){
        int cnt = 0;
        for(int i=0; i<3; i++){
            int px = x + dx[i];
            int py = y + dy[i];
            if(0<=px && px < M && 0<=py && py<N){
                if(map[x][y] == map[px][py]){
                    cnt++;
                }
            }
        }
        if(cnt==3){
            check[x][y] = true;
            check[x+1][y] = true;
            check[x][y+1] = true;
            check[x+1][y+1] = true;
        }
    }
}

2진수 변환을 아래와 같이 while문을 통해 지금까지 구해왔습니다.

public String binary(int num){
        String ans = "";
        while(num>0){
            ans = (num%2) + ans;
            num /= 2;
        }
        return ans;
    }

📖 새로 알게된 방법

Integer.toBinaryString(num); num에 원하는 int 값을 넣으면 그에 맞게 2진수로 변환해서 반환합니다.

문제링크

🎈 제한 사항

🎈 접근방법

1. DFS를 이용하였다.
2. DFS를 돌면서 깊이가 주어진 numbers의 길이 일때 종료 조건을 넣는다.
3. 종료조건이 만족할 때 sum이 target과 같으면 answer +1를 해준다.
4. sum에 해당 숫자를 더한 값 DFS, 뺀 값 DFS를 돌린다.

🎈 코드

class Solution {
    static int answer=0;
    public int solution(int[] numbers, int target) {
        dfs(0,0,target,numbers);
        return answer;
    }
    static void dfs(int depth, int sum, int target, int[] numbers){
        if(depth == numbers.length){
            if(sum == target){
                answer++;
            }
            return;
        }
        dfs(depth+1, sum+numbers[depth], target, numbers);
        dfs(depth+1, sum-numbers[depth], target, numbers);
    }
}

문제링크

🎈 제한사항

🎈 접근방법

두가지 경우를 나뉜다.

1. 첫번 째 집을 도둑질 할 경우
2. 첫번 째 집을 도둑질 안하고, 두번 째 집부터 도둑질 할 경우
3. 시작점을 정하고, index 2부터 주어진 money의 길이만큼 반복하면서 index-1과 index-2 + money[index]를 비교해 가면서 최댓값을 저장한다.

🎈 코드

import java.util.*;
class Solution {
    public int solution(int[] money) {
        int len = money.length;
        int[] dp0 = new int[len];
        int[] dp1 = new int[len];
        dp0[0] = dp0[1] =money[0];
        dp1[1] = money[1];
        for(int i=2; i<len; i++){
            dp0[i] = Math.max(dp0[i-1], dp0[i-2]+money[i]);
            dp1[i] = Math.max(dp1[i-1], dp1[i-2]+money[i]);
        }
        return Math.max(dp0[len-2],dp1[len-1]);
    }
}

문제링크

🎉 제한사항

🎉 접근방법

1. 구덩이를 -1로 먼저 표시를 해준다.
2. (1,1)부터 (n,m) 까지 돌면서 웅덩이일 경우 표시했던 웅덩이를 0으로 바꿔주고 continue해준다.
3. 첫행이 아닐 때와 첫열이 아닐 때 그전까지 왔던 수를 저장한다.
4. map[n][m]을 리턴한다.

🎉 코드

class Solution {
    static int[][] map;
    public int solution(int m, int n, int[][] puddles) {
        int answer = 0;
        map = new int[n+1][m+1];
        for(int i=0; i<puddles.length; i++){
            int x = puddles[i][0];
            int y = puddles[i][1];
            map[y][x] = -1;
        }
        map[1][1] = 1;
        for(int i=1; i<=n; i++){
            for(int j=1; j<=m; j++){
                if(map[i][j] == -1){
                    map[i][j] = 0;
                    continue;
                }
                if(i != 1){
                    map[i][j]  += map[i-1][j]%1000000007;
                }

                if(j != 1){
                    map[i][j] += map[i][j-1]%1000000007;
                }
            }
        }
        return map[n][m]%1000000007;
    }
}

문제링크

🎊 제한 사항

🎊 접근방법

위 모양처럼 생각하면 쉽게 접근할 수 있다.

1. 자신의 위에 있는 숫자와 왼쪽대각선의 숫자를 비교한 뒤 더 큰 숫자와 자신을 더하고 저장한다.
2. 마지막 행까지 1번을 반복한다.
3. 마지막 행을 반복할 때 Math.max를 이용하여 최댓값을 구한다.

🎊 코드

class Solution {
    public int solution(int[][] triangle) {
        int answer = 0;
        int[][] dp = new int[triangle.length][triangle.length];
        dp[0][0] = triangle[0][0];
        for(int i=1; i<triangle.length; i++){
            dp[i][0] = triangle[i][0]  + dp[i-1][0];

            for(int j=1; j<=i; j++){
                dp[i][j] = triangle[i][j] + Math.max(dp[i-1][j-1], dp[i-1][j]);
                if(i == triangle.length-1){
                    answer = Math.max(answer, dp[i][j]);
                }
            }
        }
        return answer;
    }
}

문제링크

🎉 제한사항

🎉 접근방법

1. DFS을 통해 +, -, /, * 를 통해 해당 값을 찾았을 때 cnt의 최솟값을 구한다.
2. 만약 처음 최솟값으로 설정한 Integer.MAX_VALUE라면 -1 리턴

🎉 코드

class Solution {
    static int answer = Integer.MAX_VALUE;
    static int n,num;
    public int solution(int N, int number) {
        n = N;
        num = number;
        dfs(0,0);
        return answer==Integer.MAX_VALUE?-1:answer;
    }
    static void dfs(int cnt, int cur){
        if(cnt > 8){
            return;
        }        
        if(cur == num){
            answer = Math.min(answer,cnt);
            return;
        }
        int temp = n;
        for(int i=0; i<8; i++){
            dfs(cnt+i+1, cur + temp);
            dfs(cnt+i+1, cur - temp);
            dfs(cnt+i+1, cur / temp);
            dfs(cnt+i+1, cur * temp);

            temp = temp * 10 + n;
        }
    }
}

링크텍스트

🧨 제한사항

🧨 접근방법

1. 끝나는 시간 기준으로 오름차순 정렬을 한다.
2. std를 Integer 최솟값을 지정해준다.
3. routes 조회하면서 시작지점이 std보다 클 경우 카메라 개수 +1 해주고 시작지점을 std로 지정한다.

🧨 코드

import java.util.*;
class Solution {
    public int solution(int[][] routes) {
        int answer = 0;
        Arrays.sort(routes, (o1,o2) -> o1[1]-o2[1]);

        int std = Integer.MIN_VALUE;
        for(int i=0; i<routes.length; i++){
            if(std < routes[i][0]){
                std = routes[i][1];
                answer++;
            }
        }
        return answer;
    }
}

문제링크

🧨 제한사항

🧨 접근방법

1. 크루스칼 알고리즘으로 Union & Find를 사용하였다.
2. 같은 부모일 경우 continue를 통해서 Union을 하지않는다.

-> Union을 할 경우 사이클이 생기므로 안된다.

🧨 코드

import java.util.*;
class Solution {
    static int[] group;
    public int solution(int n, int[][] costs) {
        int answer = 0;
        group = new int[n];
        // 그룹 초기화
        for(int i=0; i<n; i++){
            group[i] = i;
        }
        Arrays.sort(costs, (o1,o2)-> Integer.compare(o1[2],o2[2]));
        for(int i=0; i<costs.length; i++){
            int a = find(costs[i][0]);
            int b = find(costs[i][1]);
            int cost = costs[i][2];

            if(a == b) continue;
            union(a,b);
            answer += cost;
        }
        return answer;
    }
    public int find(int x){
        if(group[x] == x){
            return x;
        }
        return group[x]=find(group[x]);
    }
    public void union(int a, int b){
        int groupA = find(a);
        int groupB = find(b);

        if(groupA > groupB){
            group[groupA] = groupB;
        }else{
            group[groupB] = groupA;
        }
    } 
}

참고

https://velog.io/@qodlstjd12/%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%A8%B8%EC%8A%A4-%EC%84%AC-%EC%97%B0%EA%B2%B0%ED%95%98%EA%B8%B0-Java

문제링크

🎊 제한사항

🎊 접근방법

1. 오름차순정렬을 한다.
2. 투포인터를 사용하였다.
3. 작은 값들을 변경하면서 구한다.

🎊 코드

import java.util.*;
class Solution {
    public int solution(int[] people, int limit) {
        int answer = 0;
        Arrays.sort(people);
        int left = 0;
        int right = people.length-1;
        int sum = people[right--];
        while(left <= right){
            if(sum + people[left] <= limit){
                sum += people[left++];
            }else{
                answer++;
                sum = people[right--];
            }
        }
        if(sum <= limit) answer++;
        return answer;
    }
}