wwwj_in.log https://velog.io/ Developer Record Wed, 23 Oct 2024 18:56:54 GMT https://validator.w3.org/feed/docs/rss2.html https://github.com/jpmonette/feed wwwj_in.log https://velog.velcdn.com/images/www_j/profile/99f3592b-c994-416f-ac8b-6b521f50d922/image.jpg https://velog.io/ Copyright (C) 2019. wwwj_in.log. All rights reserved. <![CDATA[[Javascript & Jquery] {} 와 [] 차이]]> https://velog.io/@www_j/Javascript-Jquery-var-test-%EC%99%80-var-test2-%EC%B0%A8%EC%9D%B4 https://velog.io/@www_j/Javascript-Jquery-var-test-%EC%99%80-var-test2-%EC%B0%A8%EC%9D%B4 Wed, 23 Oct 2024 18:56:54 GMT
  • var test = {} (객체):

    • 이는 객체를 생성합니다.

    • 객체는 키-값 쌍의 컬렉션으로, 각 키는 고유한 문자열(또는 심볼)로 값에 접근하는 데 사용됩니다.

    • 예시:

      var test = {
name: "John",
age: 30
};
console.log(test.name);  // 출력: "John"
console.log(test["age"]);  // 출력: 30
    1. var test2 = [] (배열):

    • 이는 배열을 생성합니다.

    • 배열은 값(항목)의 정렬된 목록으로, 각 항목은 인덱스를 통해 접근할 수 있습니다. 인덱스는 0부터 시작합니다.

    • 예시:

      var test2 = ["apple", "banana", "cherry"];
console.log(test2[0]);  // 출력: "apple"
console.log(test2.length);  // 출력: 3

      주요 차이점:

    1.** 객체 ({}):**

    • 데이터를 키-값 쌍으로 저장하는 데 사용됩니다.

    • 키는 일반적으로 문자열이며, 값은 어떤 데이터 타입이든 될 수 있습니다.

    • 키는 순서가 없습니다.

    2.** 배열 ([]):**

    • 항목의 목록을 저장하는 데 사용됩니다.

    • 항목은 인덱스(0부터 시작)에 의해 정렬됩니다.

    • 인덱스는 숫자로 되어 있으며 순차적입니다.

    사용 예시:

    // 객체
var person = {
  firstName: "Alice",
  lastName: "Smith",
  age: 25
};
console.log(person.firstName); // 키로 접근, 출력: "Alice"

// 배열
var fruits = ["apple", "banana", "cherry"];
console.log(fruits[1]); // 인덱스로 접근, 출력: "banana"

    요약하자면, 객체는 이름이 있는 데이터를 저장하는 데 사용되고, 배열은 순서가 있는 데이터를 저장하는 데 사용됩니다.

    ]]>         <![CDATA[[Web] HTTP 상태 코드]]> https://velog.io/@www_j/Web-HTTP-%EC%83%81%ED%83%9C-%EC%BD%94%EB%93%9C https://velog.io/@www_j/Web-HTTP-%EC%83%81%ED%83%9C-%EC%BD%94%EB%93%9C Fri, 18 Oct 2024 16:35:53 GMT

    등록, 조회, 수정, 삭제에 해당하는 HTTP 상태 코드


    등록 (Create):

    • 201 Created: 요청이 성공적으로 처리되어 새로운 리소스가 생성됨.

    • 400 Bad Request: 잘못된 구문으로 인해 서버가 요청을 이해할 수 없을 때 발생 (예: 잘못된 데이터 입력).

    • 409 Conflict: 서버의 현재 상태와 충돌이 발생할 때 (예: 중복된 리소스 등록).


    조회 (Read):

    • 200 OK: 요청이 성공적으로 처리되었고, 서버가 요청한 리소스를 반환함.

    • 204 No Content: 요청이 성공적으로 처리되었으나 반환할 콘텐츠가 없을 때 (예: 검색 결과가 없음).

    • 404 Not Found: 요청한 리소스를 찾을 수 없을 때.


    수정 (Update):

    • 200 OK: 요청이 성공적으로 처리되었으며, 리소스가 성공적으로 수정됨.

    • 204 No Content: 요청이 성공적으로 처리되었지만, 수정 후에 반환할 콘텐츠가 없을 때.

    • 400 Bad Request: 잘못된 데이터나 구문으로 인해 서버가 요청을 처리할 수 없을 때.

    • 404 Not Found: 수정하려는 리소스를 찾을 수 없을 때.


    삭제 (Delete):

    • 200 OK: 리소스가 성공적으로 삭제되었으며, 서버가 응답을 반환할 때.

    • 204 No Content: 리소스가 성공적으로 삭제되었고, 반환할 콘텐츠가 없을 때.

    • 404 Not Found: 삭제하려는 리소스를 찾을 수 없을 때.

    • 400 Bad Request: 요청이 잘못되었거나 필요한 데이터가 없을 때.


    이 상태 코드는 일반적인 RESTful API에서 사용

    공통 에러 코드

    • 400 Bad Request: 잘못된 요청 (예: 유효하지 않은 데이터)
    • 401 Unauthorized: 인증 필요
    • 403 Forbidden: 권한 없음
    • 404 Not Found: 요청한 리소스를 찾을 수 없음
    • 405 Method Not Allowed: 허용되지 않은 HTTP 메소드
    • 409 Conflict: 리소스의 현재 상태와 충돌 (예: 동시 업데이트)
    • 500 Internal Server Error: 서버 내부 오류
    ]]>         <![CDATA[[용어] 비니즈스 로직 의미와 사용]]> https://velog.io/@www_j/%EC%9A%A9%EC%96%B4-%EB%B9%84%EB%8B%88%EC%A6%88%EC%8A%A4-%EB%A1%9C%EC%A7%81-%EC%9D%98%EB%AF%B8%EC%99%80-%EC%82%AC%EC%9A%A9 https://velog.io/@www_j/%EC%9A%A9%EC%96%B4-%EB%B9%84%EB%8B%88%EC%A6%88%EC%8A%A4-%EB%A1%9C%EC%A7%81-%EC%9D%98%EB%AF%B8%EC%99%80-%EC%82%AC%EC%9A%A9 Mon, 23 Sep 2024 14:22:59 GMT 비즈니스 로직(Business Logic)은 소프트웨어 애플리케이션에서 비즈니스 규칙과 절차를 구현하는 부분입니다. 쉽게 설명하자면, 소프트웨어가 해야 하는 핵심 업무라고 생각하면 됩니다.

    비즈니스 로직의 역할

    비즈니스 로직은 애플리케이션의 핵심 기능을 정의하며, 보통 Service 계층에 위치합니다. 여기서 데이터베이스와 상호작용하는 Repository나 DAO와는 별개로, 데이터의 흐름과 처리에 관한 주요 결정을 내립니다

    예를 들어:

    1.온라인 쇼핑몰을 운영한다고 생각해보세요. 쇼핑몰에서 상품을 주문하고, 결제하고, 재고를 관리하는 것들이 핵심 업무입니다.

    • 비즈니스 로직은 주문을 처리하고, 재고가 충분한지 확인하며, 결제를 처리하는 규칙과 절차입니다.

    2.회원 가입을 예로 들면:

    • 사용자가 회원 가입을 할 때, 입력한 이메일이 이미 등록된 이메일인지 확인하는 것,

    • 비밀번호가 규칙에 맞는지 검사하는 것,

    • 이 모든 과정이 성공하면 사용자를 데이터베이스에 저장하는 것 등이 비즈니스 로직에 해당합니다.

    비즈니스 로직이 중요한 이유

    비즈니스 로직이 없다면 프로그램은 그냥 데이터를 주고받는 통로에 불과합니다. 비즈니스 로직이 있어야만 프로그램이 회사의 업무나 목표를 달성하는 진짜 일을 할 수 있습니다.

    쉽게 생각하면:

    • Controller는 마치 레스토랑의 웨이터 같아서, 고객의 요청(주문)을 받아오고, 그걸 주방에 전달합니다.

    • Service(비즈니스 로직을 담당하는 부분)는 주방으로, 요청을 받은 후 실제로 음식을 만드는 곳입니다. 주방에서는 요리법(비즈니스 로직)에 따라 음식을 만듭니다.

    주요 차이점 요약

    역할 Controller Service/ServiceImpl
    주요 목적 HTTP 요청을 처리하고, 요청을 서비스에 전달한 후 응답 반환. 비즈니스 로직을 처리하고, 데이터베이스와 상호작용.
    기능 요청 매핑, 요청 파라미터 처리, 응답 반환 (JSON, XML 등). 비즈니스 로직, 데이터 처리, 트랜잭션 관리, 데이터베이스 연동.
    구현 클라이언트 요청 처리 및 결과 응답 (HTTP 레벨). 인터페이스로 정의된 비즈니스 로직을 구현하고 DAO/Repository를 호출.
    구성 요소 @RestController, @RequestMapping, @GetMapping 등. @Service, @Transactional, @Autowired 등을 사용.

    • Controller는 클라이언트 요청을 받아서 어떤 서비스를 호출할지 결정하고, 결과를 HTTP 응답으로 반환합니다.

    • ServiceImpl은 실제 비즈니스 로직을 구현하는 곳으로, 데이터 처리, 외부 시스템 호출, 데이터베이스 연동 등을 담당합니다

    요약:

    • 비즈니스 로직은 프로그램이 실제 일을 처리하는 규칙과 절차입니다.

    • 예를 들어, 쇼핑몰에서 상품을 주문할 때, 주문을 처리하고 재고를 확인하는 과정이 비즈니스 로직입니다.

    • 프로그램의 핵심 기능을 담당하며, 이 기능을 제대로 설계해야만 프로그램이 목적을 달성할 수 있습니다.

    ]]>         <![CDATA[[Javascript & Jquery] DOM이란]]> https://velog.io/@www_j/Javascript-Jquery-DOM%EC%9D%B4%EB%9E%80 https://velog.io/@www_j/Javascript-Jquery-DOM%EC%9D%B4%EB%9E%80 Fri, 20 Sep 2024 12:22:03 GMT DOM (Document Object Model)은 웹 페이지의 구조를 표현하는 객체 기반의 트리 구조로, 브라우저가 HTML 문서를 읽고 각 요소를 객체로 변환해 구조화한 형태입니다. 즉, HTML 문서를 브라우저가 이해할 수 있도록 객체화한 버전이라고 보면 됩니다.

    브라우저가 HTML 문서를 로드하면 그 문서를 DOM 트리로 변환하며, 자바스크립트는 이 DOM을 통해 HTML 요소에 접근하고 조작할 수 있습니다.

    DOM 트리 예시

    만약 다음과 같은 HTML이 있다면:

    <!DOCTYPE html>
<html>
<head>
    <title>DOM Example</title>
</head>
<body>
    <h1>Welcome to DOM</h1>
    <p>This is a paragraph.</p>
</body>
</html>

    이 HTML은 다음과 같은 트리 구조로 표현됩니다:

    Document
 ├── html
 │   ├── head
 │   │   └── title (DOM Example)
 │   └── body
 │       ├── h1 (Welcome to DOM)
 │       └── p (This is a paragraph.)

    위 트리 구조에서,Document는 최상위 객체(문서 전체)이고, 그 아래에 html, head, body와 같은 노드들이 있습니다. 각 노드는 그 안에 다른 요소들을 포함할 수 있습니다.

    DOM 예시

    DOM은 HTML 요소에 접근하고, 변경할 수 있도록 해줍니다. 예를 들어, 자바스크립트를 사용해 <h1> 태그의 텍스트를 변경하는 것은 DOM을 통해 이루어집니다.

    HTML:

    <!DOCTYPE html>
<html>
<head>
    <title>DOM Example</title>
</head>
<body>
    <h1 id="heading">Welcome to DOM</h1>
    <button id="changeTextButton">Change Text</button>

    <script>
        // 자바스크립트를 통해 DOM의 요소에 접근하여 텍스트 변경
        document.getElementById('changeTextButton').addEventListener('click', function() {
            // DOM을 통해 h1 요소에 접근하여 텍스트 변경
            document.getElementById('heading').textContent = 'DOM Changed!';
        });
    </script>
</body>
</html>

    설명:

    1. 브라우저가 HTML을 읽고 DOM 트리를 구성합니다.

    2. document.getElementById('heading')는 DOM 트리에서 <h1 id="heading"> 요소에 접근합니다.

    3. textContent 속성을 사용해 <h1> 태그의 텍스트를 변경합니다.

    4. 버튼을 클릭하면 DOM을 통해 h1 요소의 텍스트가 "DOM Changed!"로 바뀝니다.

    DOM의 주요 개념

    • 노드 (Node): DOM 트리의 각 요소를 말합니다. <html>, <head>, <body> 등 모든 HTML 요소는 노드입니다.

    • 부모/자식 관계: DOM 트리에서 상위에 있는 노드는 부모 노드, 하위에 있는 노드는 자식 노드입니다.

    • 속성: 각 노드는 다양한 속성을 가지고 있으며, 자바스크립트를 통해 이 속성들을 조작할 수 있습니다.

    DOM을 통해 자주 사용되는 조작들

    1. HTML 요소 접근: document.getElementById(), document.querySelector()

    2. 속성 변경: element.textContent, element.innerHTML

    3. 클래스 추가/제거: element.classList.add(), element.classList.remove()

    4. 이벤트 바인딩: element.addEventListener()

    DOM은 자바스크립트와 HTML이 상호작용하는 핵심적인 부분입니다.

    ]]>         <![CDATA[[Javascript & Jquery] propertychange, change, keyup, paste, input]]> https://velog.io/@www_j/Javascript-Jquery-propertychange-change-keyup-paste-input https://velog.io/@www_j/Javascript-Jquery-propertychange-change-keyup-paste-input Fri, 20 Sep 2024 11:53:45 GMT propertychange, change, keyup, paste, input는 모두 JavaScript/jQuery에서 특정 이벤트를 처리하기 위한 이벤트 타입입니다. 각 이벤트는 사용자가 웹 페이지나 애플리케이션과 상호작용할 때 발생하며, 주로 폼 요소나 입력 필드에서 자주 사용됩니다. 주요 차이점은 어떤 종류의 사용자 입력을 감지하는지에 따라 다릅니다.

    1. propertychange

    • 설명: IE에서 사용되는 이벤트로, HTML 요소의 속성이 변경되었을 때 발생합니다. 특히, <input> 요소의 값이 변경될 때 감지할 수 있습니다.

    • 특징: 모든 속성의 변경을 감지하며, IE8부터 IE11까지 사용되었습니다. 다른 브라우저에서는 거의 사용되지 않습니다.

    • 사용 예시:

      $('#input-field').on('propertychange', function() {
  console.log('Property changed!');
});

    2. change

    • 설명: <input>, <textarea>, <select> 같은 폼 요소의 값이 변경된 후 포커스가 벗어났을 때 발생합니다.

    • 특징: 값이 변경된 뒤에 요소에서 포커스를 잃거나 enter 키로 제출할 때 트리거됩니다.

    • 사용 예시:

      $('#input-field').on('change', function() {
  console.log('Input value changed!');
});

    3. keyup

    • 설명: 키보드를 눌렀다가 뗄 때 발생하는 이벤트입니다.

    • 특징: 입력 중인 키보드의 키가 릴리즈될 때 발생합니다. 이를 통해 사용자가 입력한 내용을 실시간으로 확인할 수 있습니다.

    • 사용 예시:

      $('#input-field').on('keyup', function() {
  console.log('Key released!');
});

    4. paste

    • 설명: 요소에 붙여넣기(paste) 작업이 일어날 때 발생하는 이벤트입니다.

    • 특징: 사용자가 복사한 텍스트나 콘텐츠를 붙여넣었을 때 트리거됩니다.

    • 사용 예시:

      $('#input-field').on('paste', function() {
  console.log('Content pasted!');
});

      5. input

    • 설명: <input> 또는 <textarea> 요소에서 값이 변경될 때마다 발생하는 이벤트입니다.

    • 특징: 값이 변경될 때마다 실시간으로 트리거됩니다. 키보드로 입력, 붙여넣기, 드래그 앤 드롭 등 모든 방식의 입력을 감지할 수 있습니다. 가장 일반적으로 사용되는 이벤트 중 하나입니다.

    • 사용 예시:

      $('#input-field').on('input', function() {
  console.log('Input changed!');
});

      이벤트들의 차이점:

    • propertychange: 특정 속성의 변화(주로 IE에서 사용).

    • change: 값이 바뀌고 포커스가 벗어났을 때 발생.

    • keyup: 키를 눌렀다가 뗐을 때 발생.

    • paste: 복사한 내용을 붙여넣을 때 발생.

    • input: 입력 내용이 실시간으로 변할 때마다 발생 (가장 범용적).

    실시간으로 사용자 입력을 감지하려면 주로 input 이벤트를 사용하고, 특정 상황에서는 다른 이벤트들과 함께 사용하여 더 나은 사용자 경험을 제공할 수 있습니다.

    언제 무엇을 사용하는 것이 더 좋을까?

    1. HTML에서 직접 onchange를 사용하는 경우:

      • 작고 간단한 프로젝트: 프로젝트가 작고, 복잡하지 않다면 HTML 내에서 직접 이벤트를 설정하는 것이 빠르고 효율적일 수 있습니다.

      • 빠른 프로토타이핑: 빠르게 화면을 구성하거나 프로토타입을 만들 때 유용할 수 있습니다.

    2. JavaScript에서 이벤트 핸들러를 사용하는 경우:

      • 중대형 프로젝트: 프로젝트 규모가 크고, 유지보수와 코드의 확장성이 중요하다면 JavaScript로 이벤트를 관리하는 것이 좋습니다.

      • 재사용성: 여러 요소에서 동일한 이벤트를 처리해야 할 때 유리합니다.

      • 동적 요소: 동적으로 생성되는 요소들에도 이벤트를 쉽게 연결할 수 있습니다.

      • 복잡한 이벤트 관리: 여러 이벤트를 관리하거나 하나의 요소에 여러 이벤트 핸들러가 필요할 때 더 효율적입니다.

    결론

    • 작은 프로젝트나 빠르게 개발할 때는 HTML에서 onchange를 사용하는 것이 간편하고 빠를 수 있습니다.

    • 큰 프로젝트나 유지보수성을 고려해야 하는 경우에는 JavaScript/jQuery에서 이벤트 핸들러를 사용하는 것이 더 효율적입니다.

    ]]>         <![CDATA[[Javascript & Jquery] .html() 과 .text()]]> https://velog.io/@www_j/Javascript-Jquery-.html-%EA%B3%BC-.text https://velog.io/@www_j/Javascript-Jquery-.html-%EA%B3%BC-.text Fri, 20 Sep 2024 11:29:47 GMT jQuery의 .html()과 .text() 메서드는 요소의 콘텐츠를 가져오거나 설정하는 데 사용되지만, 주요 차이점은 다음과 같습니다:

    1. .html()

    • 설명: HTML 콘텐츠를 가져오거나 설정합니다.

    • 특징: 요소 내부에 있는 HTML 태그와 함께 콘텐츠를 처리합니다. 즉, HTML 태그를 포함하여 콘텐츠를 가져오거나 설정할 수 있습니다.

    • 사용 예시:

      <div id="example"><strong>Hello</strong> World</div>
      // .html() 사용 예시

    // HTML을 가져오기 var content = $('#example').html(); console.log(content); // 출력: Hello World

    // HTML을 설정하기 $('#example').html('Goodbye World'); // 결과:

    Goodbye World

    
### 2. .text()
* **설명:** 텍스트 콘텐츠를 가져오거나 설정합니다.

* **특징:** HTML 태그를 제외한 순수 텍스트만 처리합니다. 요소 내부의 모든 HTML 태그를 무시하고 텍스트만을 가져오거나 설정합니다.

* **사용 예시:**
```html
<div id="example"><strong>Hello</strong> World</div>
    // .text() 사용 예시

// 텍스트를 가져오기
var content = $('#example').text();
console.log(content);  // 출력: Hello World

// 텍스트를 설정하기
$('#example').text('Goodbye World');
// 결과: <div id="example">Goodbye World</div>

    주요 차이점:

    • .html(): HTML 태그와 함께 콘텐츠를 가져오거나 설정할 수 있습니다.

    • .text(): 순수 텍스트만 처리하며, HTML 태그는 무시됩니다.

    이 차이점에 따라 HTML 태그를 포함해서 처리해야 하는 경우에는 .html()을, 순수 텍스트만 다루고 싶을 때는 .text()를 사용하면 됩니다.

    ]]>         <![CDATA[[용어] 매개변수 (Parameter), 인자 (Argument)]]> https://velog.io/@www_j/%EC%9A%A9%EC%96%B4-%EB%A7%A4%EA%B0%9C%EB%B3%80%EC%88%98-Parameter-%EC%9D%B8%EC%9E%90-Argument https://velog.io/@www_j/%EC%9A%A9%EC%96%B4-%EB%A7%A4%EA%B0%9C%EB%B3%80%EC%88%98-Parameter-%EC%9D%B8%EC%9E%90-Argument Mon, 16 Sep 2024 07:48:33 GMT

    함수 호출 시 인자(argument)와 매개변수(parameter)는 함수 호출과 함수 정의에서 사용되는 용어입니다. 둘은 서로 연관이 있지만, 맥락에 따라 구분됩니다.


    매개변수 (Parameter):

    • 함수가 정의될 때 사용되는 변수입니다. 함수가 어떤 값을 입력받아야 하는지 지정하는 변수이며, 함수 내부에서 사용됩니다.

    • 매개변수는 함수 선언 시에 그 함수가 처리할 입력의 이름을 지정하는 부분입니다.

    • 예:

      void printName(String name) {
  System.out.println(name);
}

      여기서 name은 매개변수입니다. 이 함수는 호출될 때 어떤 String 값을 받아서 출력합니다.


    인자 (Argument):

    • 함수가 실제로 호출될 때 함수에 전달되는 값입니다. 즉, 매개변수에 전달되는 실제 데이터를 인자라고 부릅니다.

    • 함수가 호출될 때 사용자가 넘기는 값이 인자입니다.

    • 예:

      printName("Alice");

      여기서 "Alice"가 인자입니다. 함수가 호출될 때 매개변수 name에 이 값이 전달됩니다.


    예시로 설명:

    void greet(String message) {  // 여기서 'message'는 매개변수
    System.out.println(message);
}

greet("Hello, World!");  // 여기서 'Hello, World!'는 인자
    • 매개변수는 함수가 정의될 때 사용되는 변수 이름이고,
    • 인자는 함수가 호출될 때 매개변수로 전달되는 실제 값입니다.
    ]]>         <![CDATA[[Spring] @Builder 어노테이션]]> https://velog.io/@www_j/Spring-Builder-%EC%96%B4%EB%85%B8%ED%85%8C%EC%9D%B4%EC%85%98 https://velog.io/@www_j/Spring-Builder-%EC%96%B4%EB%85%B8%ED%85%8C%EC%9D%B4%EC%85%98 Sat, 14 Sep 2024 18:03:08 GMT @Builder는 Lombok 라이브러리에서 제공하는 어노테이션으로, 빌더 패턴(Builder Pattern)을 쉽게 구현할 수 있도록 도와줍니다. 빌더 패턴은 복잡한 객체를 생성할 때 유연하고 가독성 좋은 방식으로 객체를 생성할 수 있게 해줍니다. @Builder는 주로 객체 생성 시 필드가 많거나 선택적으로 값을 설정해야 할 때 유용합니다.

    1. @Builder의 역할

    @Builder는 다음과 같은 역할을 수행합니다:

    • 빌더 패턴을 자동으로 생성하여, 객체의 필드를 자유롭게 설정하고 객체를 생성할 수 있게 합니다.

    • 가독성을 높여, 필드가 많은 객체를 생성할 때 생성자나 setter를 사용하지 않고, 명시적인 방식으로 객체를 구성할 수 있습니다.

    • 불변 객체(Immutable Object)나 값 객체(Value Object)를 생성하는 데도 유용합니다. 객체를 생성한 후 값이 변경되지 않도록 설계할 수 있습니다.


    2. 빌더 패턴의 장점

    • 가독성: 각 필드를 명시적으로 설정할 수 있어, 코드의 가독성이 향상됩니다.

    • 선택적 필드 설정: 필요 없는 필드는 설정하지 않고, 필요한 필드만 설정하여 객체를 생성할 수 있습니다.

    • 유연한 객체 생성: 다양한 방법으로 객체를 유연하게 생성할 수 있습니다.

    • 불변성: 생성 후 변경되지 않는 객체를 쉽게 만들 수 있습니다.


    3. @Builder 사용 예시

    간단한 예시

    import lombok.Builder;
import lombok.ToString;

@Builder
@ToString
public class User {
    private String name;
    private int age;
    private String email;
}

// 사용법
public class Main {
    public static void main(String[] args) {
        // User 객체를 빌더 패턴으로 생성
        User user = User.builder()
                        .name("John Doe")
                        .age(30)
                        .email("john@example.com")
                        .build();

        System.out.println(user);
    }
}

    위 코드에서는 @Builder를 사용하여 User 객체를 생성할 때 빌더 패턴을 적용했습니다. 필드가 많거나 일부 필드만 설정하고 싶은 경우, 빌더 패턴은 유용하게 사용할 수 있습니다.

    @Builder로 생성된 빌더 메서드 @Builder는 클래스 내에 빌더 클래스와 메서드를 자동으로 생성해줍니다. 위 예시에서 User.builder()는 UserBuilder라는 클래스를 생성하고, name(), age(), email() 같은 메서드로 각 필드를 설정할 수 있게 합니다. build() 메서드를 호출하면 설정된 값들로 User 객체가 생성됩니다.

    4. 빌더 패턴이 필요한 경우

    1. 매개변수가 많은 생성자 대신 사용:
      • 필드가 많거나 선택적으로 설정해야 할 필드가 있을 때, 생성자나 setter를 사용하는 -- 것보다 빌더 패턴을 사용하는 것이 훨씬 더 깔끔하고 안전합니다.

    User user = new User("John Doe", 30, "john@example.com"); // 가독성 떨어짐

    
대신 빌더 패턴을 사용하면:

```java

User user = User.builder()
                .name("John Doe")
                .age(30)
                .email("john@example.com")
                .build(); // 가독성 향상

    1. 불변 객체 생성:

      • 객체를 생성할 때 값을 설정한 후, 더 이상 값이 변경되지 않도록 하기 위해 빌더 패턴을 사용합니다. 필드를 final로 설정하면 객체가 불변이 됩니다.
    @Builder
public class ImmutableUser {
    private final String name;
    private final int age;
    private final String email;
}

    1. 선택적 필드:

      • 필드 중 일부는 선택적일 수 있으며, 빌더 패턴은 이러한 필드를 생략하거나 선택적으로 설정할 수 있게 해줍니다.

    5. @Builder와 함께 자주 사용되는 Lombok 어노테이션

    • @Getter / @Setter: 빌더로 생성된 객체의 필드에 접근할 수 있게 합니다.

    • @ToString: 객체를 문자열로 표현할 때 사용합니다.

    • @AllArgsConstructor, @NoArgsConstructor: 생성자와 함께 사용할 수 있습니다.


    6. 복잡한 객체 구성 예시

    빌더 패턴은 복잡한 객체를 구성할 때 특히 유용합니다. 예를 들어, 객체 내에 리스트나 중첩된 객체가 있는 경우에도 쉽게 객체를 생성할 수 있습니다.

    
import lombok.Builder;
import lombok.ToString;

import java.util.List;

@Builder
@ToString
public class Order {
    private String orderId;
    private List<String> itemList;
    private double totalAmount;
}

// 사용법
public class Main {
    public static void main(String[] args) {
        Order order = Order.builder()
                           .orderId("ORD12345")
                           .itemList(List.of("item1", "item2", "item3"))
                           .totalAmount(150.75)
                           .build();

        System.out.println(order);
    }
}

    7. @Builder의 다양한 활용

    • 필드 초기화: 특정 필드를 빌더 패턴에서 기본 값으로 설정할 수 있습니다.

    • 다중 생성 패턴: @Builder를 생성자와 함께 사용하여 객체 생성 방법을 다변화할 수 있습니다.

    @Builder public class Person { private final String firstName; private final String lastName; private final int age;

    @Builder.Default
private final String country = "Unknown"; // 기본값 설정

    }

    <br/>

### 8. @Builder와 상속
`@Builder`는 상속 관계에서 사용할 때 다소 주의가 필요합니다. Lombok은 상속받은 필드에 대해 빌더를 자동으로 생성하지 않기 때문에, 상속 관계에서 빌더 패턴을 사용하려면 하위 클래스에서 빌더를 다시 정의하거나, `@SuperBuilder`를 사용할 수 있습니다.

```java

import lombok.experimental.SuperBuilder;

@SuperBuilder
public class Parent {
    private String parentField;
}

@SuperBuilder
public class Child extends Parent {
    private String childField;
}

    결론 @Builder는 복잡한 객체를 쉽게 생성하고, 선택적으로 필드를 설정할 수 있게 해주는 강력한 도구입니다. 특히 가독성, 유연성, 불변성을 강조하는 상황에서 빌더 패턴을 적용하면 코드 유지보수가 쉬워지고, 객체 생성 로직이 간결해집니다. @Builder를 사용하면 빌더 패턴을 수동으로 구현할 필요 없이 Lombok이 이를 자동으로 처리해주므로, 더 적은 코드로 동일한 기능을 구현할 수 있습니다.

    ]]>         <![CDATA[[용어] 매핑(mapping), 바인딩(binding)]]> https://velog.io/@www_j/Spring-%EB%A7%A4%ED%95%91mapping-%EB%B0%94%EC%9D%B8%EB%94%A9binding https://velog.io/@www_j/Spring-%EB%A7%A4%ED%95%91mapping-%EB%B0%94%EC%9D%B8%EB%94%A9binding Fri, 13 Sep 2024 08:53:45 GMT 매핑(mapping)과 바인딩(binding)은 비슷한 개념이지만, 미묘한 차이가 있습니다. 둘 다 어떤 데이터를 다른 데이터와 연결하는 과정에 사용되지만, 주로 쓰이는 맥락과 의미에 따라 다르게 사용됩니다.

    매핑 (Mapping):

    두 개의 서로 다른 데이터 구조를 서로 연결하는 작업을 말합니다. 예를 들어, 데이터베이스의 테이블과 자바 객체 간의 필드를 연결하는 작업을 "매핑"이라고 합니다. MyBatis나 Hibernate와 같은 ORM(Object Relational Mapping) 프레임워크에서는 데이터베이스의 필드와 자바 객체의 속성을 매핑합니다. ex) SQL 쿼리 결과를 자바 객체의 필드에 매핑하는 작업.

    바인딩 (Binding):

    변수를 특정 값이나 객체에 연결하거나, 함수 호출 시 인자와 매개변수를 연결하는 행위를 주로 말합니다. 주로 메모리상에서 변수를 특정 데이터에 연결하거나, UI 컴포넌트와 데이터를 연결할 때 "바인딩"이라고 많이 말합니다. ex) JDBC에서 SQL 쿼리의 파라미터에 값을 바인딩하는 작업.

    정리하면, 매핑은 주로 구조적인 연결을 의미하고, 바인딩은 주로 변수나 값과의 직접적인 연결을 의미하는 경우가 많습니다.

    ]]>         <![CDATA[[LeetCode] Check If N and Its Double Exist]]> https://velog.io/@www_j/LeetCode-Check-If-N-and-Its-Double-Exist https://velog.io/@www_j/LeetCode-Check-If-N-and-Its-Double-Exist Sun, 08 Sep 2024 13:36:49 GMT Probelm

    정수 배열이 주어졌을 때 , i와 j두 개의 인덱스 가 arr존재하는지 확인합니다.

    • i != j
    • 0 <= i, j < arr.length
    • arr[i] == 2 * arr[j]

    Soulution

    class Solution {
    public boolean checkIfExist(int[] arr) {
        Set<Integer> set = new HashSet<>();

        for(int num: arr){
            if(set.contains(num*2) || (num % 2 == 0 && set.contains(num/2))){
                return true;
            }
             set.add(num);
        }
        return false;
    }
}

    1. 해시셋 사용:

    • set이라는 해시셋을 사용하여 배열을 순회하면서 각 숫자를 기록합니다.

    • 현재 숫자의 두 배가 이미 해시셋에 있는지, 또는 현재 숫자가 짝수이며 그 절반이 해시셋에 있는지를 확인합니다.

    • 이 조건이 만족되면 true를 반환합니다.

    2. 시간 복잡도:

    • 이 방법은 배열을 한 번 순회하면서 각 요소를 상수 시간 내에 해시셋에서 검색할 수 있으므로, 전체 시간 복잡도는 O(n)입니다.

    3. 음수, 0 처리:

    • 이 방법은 음수, 0, 양수 모두 적절히 처리합니다. 0이 두 번 들어가면 두 번째 0을 만나면 바로 true를 반환합니다.

    결론:

    • 해시셋을 사용한 방법이 더 효율적이고, 코드가 직관적이며 다양한 경우를 보다 잘 처리합니다.
    ]]>         <![CDATA[[DB] Oracle 테이블스페이스 생성 스크립트 추출]]> https://velog.io/@www_j/DB-Oracle-%ED%85%8C%EC%9D%B4%EB%B8%94%EC%8A%A4%ED%8E%98%EC%9D%B4%EC%8A%A4-%EC%83%9D%EC%84%B1-%EC%8A%A4%ED%81%AC%EB%A6%BD%ED%8A%B8-%EC%B6%94%EC%B6%9C https://velog.io/@www_j/DB-Oracle-%ED%85%8C%EC%9D%B4%EB%B8%94%EC%8A%A4%ED%8E%98%EC%9D%B4%EC%8A%A4-%EC%83%9D%EC%84%B1-%EC%8A%A4%ED%81%AC%EB%A6%BD%ED%8A%B8-%EC%B6%94%EC%B6%9C Thu, 05 Sep 2024 19:32:57 GMT

    DB 구축시에 기존에 있던 테이블스페이스를 동일하게 구축하고자 할때 사용하는 방법

    SELECT tablespace_name, DBMS_METADATA.GET_DDL('TABLESPACE',tablespace_name)||';' SCRIPT
FROM dba_tablespaces
WHERE tablespace_name IN ('TEMP','USERS');

    ]]>         <![CDATA[[DB] Oracle 테이블스페이스 및 유저 생성부터 등록 ]]> https://velog.io/@www_j/DB-Oracle-%ED%85%8C%EC%9D%B4%EB%B8%94%EC%8A%A4%ED%8E%98%EC%9D%B4%EC%8A%A4-%EB%B0%8F-%EC%9C%A0%EC%A0%80-%EC%83%9D%EC%84%B1%EB%B6%80%ED%84%B0-%EB%93%B1%EB%A1%9D https://velog.io/@www_j/DB-Oracle-%ED%85%8C%EC%9D%B4%EB%B8%94%EC%8A%A4%ED%8E%98%EC%9D%B4%EC%8A%A4-%EB%B0%8F-%EC%9C%A0%EC%A0%80-%EC%83%9D%EC%84%B1%EB%B6%80%ED%84%B0-%EB%93%B1%EB%A1%9D Thu, 05 Sep 2024 16:35:13 GMT Oracle에서 테이블스페이스를 생성하고 사용자를 등록하는 과정은 다음 단계로 나누어 설명할 수 있습니다. 각 단계는 데이터베이스 저장소의 구조를 정의하고, 사용자에게 데이터를 저장할 권한을 부여하는 작업입니다.

    1. 테이블스페이스 생성

    Oracle에서 테이블스페이스는 데이터베이스 객체(테이블, 인덱스 등)가 물리적으로 저장되는 논리적 저장소입니다. 테이블스페이스는 하나 이상의 데이터 파일을 포함하며, 데이터 파일은 실제로 데이터가 저장되는 물리적 파일입니다.

    테이블스페이스 생성 명령:

    CREATE TABLESPACE 테이블스페이스_이름
DATAFILE '경로/파일이름.dbf'
SIZE 크기M
AUTOEXTEND ON
NEXT 증가크기M MAXSIZE 최대크기M;

    예제: 아래는 SHOP이라는 이름의 테이블스페이스를 생성하는 예제입니다.

    CREATE TABLESPACE SHOP
DATAFILE '/u01/oracle/oradata/SHOP.dbf'
SIZE 100M
AUTOEXTEND ON
NEXT 10M MAXSIZE 500M;
    • DATAFILE: 테이블스페이스에 속하는 물리적 데이터 파일의 경로와 파일 이름.
    • SIZE: 데이터 파일의 초기 크기.
    • AUTOEXTEND ON: 데이터 파일이 자동으로 확장되도록 설정.
    • NEXT: 테이블스페이스가 다 차면 추가할 크기.
    • MAXSIZE: 데이터 파일이 확장될 수 있는 최대 크기.

    2. 사용자 생성 및 테이블스페이스 할당

    다음 단계는 새로운 사용자를 생성하고, 그 사용자에게 테이블스페이스를 할당하는 것입니다. 사용자는 데이터를 저장할 테이블스페이스가 필요합니다.

    사용자 생성 명령:

    CREATE USER 사용자_이름 IDENTIFIED BY 비밀번호
DEFAULT TABLESPACE 테이블스페이스_이름
QUOTA 크기M ON 테이블스페이스_이름;

    예제: USER1이라는 사용자를 생성하고, 그 사용자의 기본 테이블스페이스를 SHOP으로 설정하며, 할당량을 200MB로 설정합니다.

    CREATE USER USER1 IDENTIFIED BY password123
DEFAULT TABLESPACE SHOP
QUOTA 200M ON SHOP;
    • DEFAULT TABLESPACE: 사용자가 데이터를 생성할 때 기본으로 사용할 테이블스페이스를 지정.
    • QUOTA: 사용자가 해당 테이블스페이스에 데이터를 저장할 수 있는 최대 크기를 지정.

    3. 사용자에게 권한 부여

    생성한 사용자에게 데이터베이스 내에서 객체를 생성하고 접근할 수 있는 권한을 부여해야 합니다. 보통 아래와 같은 권한을 부여합니다.

    권한 부여 명령:

    GRANT CONNECT, RESOURCE TO 사용자_이름;

    예제:

    GRANT CONNECT, RESOURCE TO USER1;
    • CONNECT: 기본 연결 권한.
    • RESOURCE: 테이블, 인덱스와 같은 데이터베이스 객체를 생성할 수 있는 권한.

    또한, DBA 권한을 부여하고 싶다면:

    GRANT DBA TO USER1;

    4. 테이블스페이스 확인

    테이블스페이스가 정상적으로 생성되었는지 확인하려면 아래 명령을 사용할 수 있습니다.

    SELECT TABLESPACE_NAME, FILE_NAME, BYTES, MAXBYTES
FROM DBA_DATA_FILES
WHERE TABLESPACE_NAME = 'SHOP';

    이 명령은 테이블스페이스 SHOP의 파일 경로, 크기 등을 보여줍니다.


    5. 테이블스페이스 할당량 확인

    사용자가 테이블스페이스에서 사용할 수 있는 공간을 확인하려면 다음 쿼리를 사용할 수 있습니다.

    SELECT TABLESPACE_NAME, BYTES, MAX_BYTES FROM DBA_TS_QUOTAS WHERE USERNAME = 'USER1';

    6. 테이블 생성 및 사용

    이제 USER1로 로그인하고 SHOP 테이블스페이스에 테이블을 생성할 수 있습니다.

    예제:

    CREATE TABLE MY_TABLE (
    ID NUMBER PRIMARY KEY,
    NAME VARCHAR2(50)
) TABLESPACE SHOP;

    이 명령은 SHOP 테이블스페이스에 MY_TABLE이라는 테이블을 생성합니다.


    요약:

    1. 테이블스페이스 생성: CREATE TABLESPACE 명령을 사용하여 테이블스페이스를 생성.

    2. 사용자 생성: CREATE USER 명령을 통해 사용자를 생성하고 테이블스페이스를 할당.

    3. 사용자 권한 부여: GRANT 명령을 통해 사용자가 테이블스페이스에서 객체를 생성할 수 있도록 권한을 부여.

    4. 테이블 생성: 테이블스페이스에 테이블 등의 데이터베이스 객체를 생성.

    이 단계를 완료하면 Oracle DB에서 테이블스페이스를 생성하고 사용자를 등록한 후, 해당 테이블스페이스에서 데이터를 저장하고 관리할 수 있습니다.

    ]]>         <![CDATA[[LeetCode] Remove Element]]> https://velog.io/@www_j/LeetCode-Remove-Element https://velog.io/@www_j/LeetCode-Remove-Element Tue, 27 Aug 2024 01:14:40 GMT Probelm

    주어진 nums 에서 val 원소를 지우는 문제 nums 인덱스 요소를 변화시키고, 리턴 값은 배열의 길이

    Soulution

    val 값이 일치하지 않을때 값을 넣어주고, 인덱스를 증가시킨다

    class Solution {  
    public int removeElement(int[] nums, int val) {  
       int length = 0;
        for(int i = 0; i < nums.length; i++){
            if(nums[i] != val){
                nums[length++] = nums[i];
            }
        }
        return length;
    }  
}
    ]]>         <![CDATA[[LeetCode] Merge Sorted Array]]> https://velog.io/@www_j/LeetCode-Merge-Sorted-Array https://velog.io/@www_j/LeetCode-Merge-Sorted-Array Mon, 19 Aug 2024 04:17:03 GMT 두 개의 배열 nums1, nums2 를 nums1 에 하나로 합치는 문제입니다.

    두 배열은 오름차순 정렬되어있고, 합쳐진 nums1 도 정렬되어야 합니다.

    nums1 은 nums2 의 길이인 n 만큼의 추가 공간이 있으며 해당 공간은 0 으로 채워져 있습니다.

    ✍풀이

    import java.util.Arrays;

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        // nums2의 요소를 nums1의 뒤쪽에 복사
        for (int i = 0; i < n; i++) {
            nums1[m + i] = nums2[i];
        }
        // 전체 nums1 배열을 정렬
        Arrays.sort(nums1);
        // System.out.println(Arrays.toString(nums1));
    }
}

    이 코드는 두 개의 정렬된 배열 nums1과 nums2를 병합하는 작업을 수행합니다. nums1 배열의 크기는 m + n이며, 처음 m개의 요소는 nums1에 저장된 값이고, 나머지 n개의 요소는 0으로 초기화된 상태로 남아있습니다. nums2는 n개의 요소를 가진 배열입니다.

    class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {

        int p1 = m - 1;
        int p2 = n - 1;
        int p = m + n - 1;

        // nums1과 nums2의 요소를 비교하여 큰 요소부터 nums1의 뒤쪽에 채움
        while(p1 >= 0 && p2 >= 0){
            // System.out.println("p1, p2, index : " + p1 + ", " + p2);
            // System.out.println("p1, p2, array = " + nums1[p1] + ", " + nums2[p2]);
            // System.out.println("배열 길이 : " + p); 
            if(nums1[p1] > nums2[p2]){
                nums1[p--] = nums1[p1--];
            }else{
                nums1[p--] = nums2[p2--];
            }
        }

        // nums2에 남은 요소가 있다면 채워넣음
        // nums1의 남은 요소들은 이미 제자리에 있기 때문에 따로 처리할 필요가 없습니다.
        while(p2 >= 0){
            nums1[p--] = nums2[p2--];
        }
    }
}

    배열의 뒤에서부터 큰 요소를 하나씩 채우는 방법을 사용하면 정렬 없이도 효율적으로 병합할 수 있습니다.

    배열의 뒤부터 비교해가며 넣어줍니다.

    p1 또는 p2 가 0 이 되고 나면 나머지 하나가 0 이 될때까지 배열을 채워야 합니다.

    p1 은 이미 배열에 채워져 있기 때문에 p2 가 0 이 될 때까지만 값을 넣어주면 됩니다

    ]]>         <![CDATA[[LeetCode] Duplicate Zeros]]> https://velog.io/@www_j/LeetCode-Duplicate-Zeros https://velog.io/@www_j/LeetCode-Duplicate-Zeros Wed, 14 Aug 2024 02:59:44 GMT Given a fixed-length integer array arr, duplicate each occurrence of zero, shifting the remaining elements to the right.

    Note that elements beyond the length of the original array are not written. Do the above modifications to the input array in place and do not return anything.

    Example 1:

    Input: arr = [1,0,2,3,0,4,5,0] Output: [1,0,0,2,3,0,0,4] Explanation: After calling your function, the input array is modified to: [1,0,0,2,3,0,0,4]

    Example 2:

    Input: arr = [1,2,3] Output: [1,2,3] Explanation: After calling your function, the input array is modified to: [1,2,3]

    Constraints:

    1 <= arr.length <= 104 0 <= arr[i] <= 9

    ✍풀이

    class Solution {
    public void duplicateZeros(int[] arr) {
        for(int i = 0; i < arr.length; i++){
            if(arr[i] == 0){
            // 0을 발견하면
            // 배열의 끝에서부터 현재 위치까지 요소를 오른쪽으로 한 칸씩 이동
                for(int j = arr.length - 1; j > i; j--){
                    arr[j] = arr[j - 1];
                }
                i++; // 복제된 0을 건너뛰기 위해 인덱스를 증가
            }
        }
    }
}
}

    작동 방식

    • 0의 발견: 배열을 처음부터 끝까지 순회하며 0을 찾습니다.

    • 배열 요소 이동: 0을 발견하면, 배열의 끝에서부터 현재 위치까지 모든 요소를 오른쪽으로 한 칸씩 이동합니다. 이는 복제된 0을 추가하기 위한 공간을 만듭니다.

    • 0 복제: 0을 복제한 후, 다음 0을 건너뛰기 위해 인덱스 i를 한 칸 더 증가시킵니다.

    ** 코드의 문제점 및 개선 가능성 ** 이 방법은 간단하지만, 중복 0을 처리할 때마다 배열 요소를 모두 한 칸씩 이동해야 하므로, 최악의 경우 시간 복잡도는 O(N^2)입니다. 배열의 크기가 크면 비효율적일 수 있습니다.

    더 효율적인 방법은 두 번의 패스를 사용하는 것입니다. 첫 번째 패스에서는 배열을 순회하며 복제된 0이 포함된 배열의 크기를 계산하고, 두 번째 패스에서는 실제로 0을 복제하며 배열을 뒤에서부터 채워나갑니다. 이를 통해 시간 복잡도를 O(N)으로 줄일 수 있습니다.

    class Solution {
    public void duplicateZeros(int[] arr) {
        int zeros = 0;
        int length = arr.length - 1;

        // 첫 번째 패스: 복제될 0이 포함된 배열의 크기 계산
        for(int i = 0; i <= length - zeros; i++) { 
            if(arr[i] == 0) {
                // 끝에서 0을 복제하는 경우를 고려하여 크기 조정
                if(i == length - zeros) {
                    arr[length] = 0;    // 마지막 위치에 0을 복제
                    length--;           // 배열의 크기를 하나 줄임
                    break;              // 0의 개수 추가 되는 것 방지
                }
                zeros++;    //0의 개수 증가
            }
        }

        // 두 번째 패스: 뒤에서부터 배열 채우기
        for(int j = length - zeros; j >= 0; j--){
            if(arr[j] == 0){
                arr[j + zeros] = 0; // 첫 번째 0 복제
                zeros--;
                arr[j + zeros] = 0; // 두 번째 0 복제
            }else{
                arr[j + zeros] = arr[j];    // 일반 요소 이동
            }
        }
    }
}

    작동 방식

    • 첫 번째 패스 (0의 개수 계산): 배열을 처음부터 순회하며, 배열 내에서 0이 등장하는 횟수를 세어 zeros 변수에 저장합니다. 만약 배열의 끝에 0이 있을 경우, 이를 복제할 공간이 있는지 확인하고, 마지막 위치에 0을 추가하고 종료합니다.

    • 두 번째 패스 (배열 재구성): 배열을 뒤에서부터 순회하며, 현재 요소가 0인 경우, 0을 두 번 복제하고, 그렇지 않은 경우에는 해당 요소를 그대로 이동시킵니다. 이 과정을 통해 배열 내에서 0이 복제되며, 복제된 결과는 배열 내에서 적절하게 반영됩니다.

    • 이 개선된 접근 방법은 배열을 한 번만 이동시키기 때문에 훨씬 효율적입니다.

    ]]>         <![CDATA[[LeetCode] Squares of a Sorted Array]]> https://velog.io/@www_j/LeetCode-Squares-of-a-Sorted-Array https://velog.io/@www_j/LeetCode-Squares-of-a-Sorted-Array Thu, 08 Aug 2024 15:49:01 GMT Given an integer array nums sorted in non-decreasing order, return an array of the squares of each number sorted in non-decreasing order.

    Example 1:

    Input: nums = [-4,-1,0,3,10] Output: [0,1,9,16,100] Explanation: After squaring, the array becomes [16,1,0,9,100]. After sorting, it becomes [0,1,9,16,100].

    Example 2:

    Input: nums = [-7,-3,2,3,11] Output: [4,9,9,49,121]

    Constraints:

    1 <= nums.length <= 104 -104 <= nums[i] <= 104 nums is sorted in non-decreasing order.

    Follow up: Squaring each element and sorting the new array is very trivial, could you find an O(n) solution using a different approach?

    ✍풀이

    import java.util.Arrays;
class Solution {
    public int[] sortedSquares(int[] nums) {

        int[] result = new int[nums.length];
        for(int i = 0; i < nums.length; i++){
            nums[i] *= nums[i];
            result[i] = nums[i];
        }
        Arrays.sort(result);
        return result;
    }
}
    class Solution {
    public int[] sortedSquares(int[] nums) {

        //결과를 저장할 배열 생성
        int[] res = new int[nums.length];

        // 두 포인터 초기화
        int left = 0;
        int right = nums.length - 1;

        //4,3,2,1,0 감소하며 인덱스에 저장
        //큰 값부터 차례대로 제곱된 값을 res배열에 저장
        for(int i = nums.length - 1; i >= 0; i--){
            //절대값을 비교하여 더 큰 값을 저장
            if(Math.abs(nums[left]) > Math.abs(nums[right])){
                res[i] = nums[left] * nums[left];
                left++;
            }else{
                res[i] = nums[right] * nums[right];
                right--;
            }
        }
        return res;
    }
}

    작동 방식

    • 포인터 초기화: left 포인터는 배열의 시작에서, right 포인터는 배열의 끝에서 시작합니다.

    • 제곱 값 비교: for 루프를 사용하여 배열의 끝에서부터 시작하여 채워나갑니다. nums[left]와 nums[right]의 절대값을 비교하여 더 큰 값을 제곱하여 결과 배열 res에 저장합니다.

    • 포인터 이동: 더 큰 값을 제곱하여 저장한 후, 해당 포인터를 이동합니다 (left++ 또는 right--).

    • 반복: 배열의 모든 요소에 대해 위 과정을 반복하여 결과 배열을 채웁니다.

    예제 입력 배열: [-4, -1, 0, 3, 10]

    left = 0, right = 4 비교: |nums[0]| = 4, |nums[4]| = 10 nums[4]가 더 크므로 res[4] = 10 * 10 = 100, right--

    left = 0, right = 3 비교: |nums[0]| = 4, |nums[3]| = 3 nums[0]가 더 크므로 res[3] = 4 * 4 = 16, left++

    left = 1, right = 3 비교: |nums[1]| = 1, |nums[3]| = 3 nums[3]가 더 크므로 res[2] = 3 * 3 = 9, right--

    left = 1, right = 2 비교: |nums[1]| = 1, |nums[2]| = 0 nums[1]가 더 크므로 res[1] = 1 * 1 = 1, left++

    left = 2, right = 2 비교: |nums[2]| = 0, |nums[2]| = 0 nums[2]가 같으므로 res[0] = 0 * 0 = 0, right--

    결과 배열: [0, 1, 9, 16, 100]

    ]]>         <![CDATA[[LeetCode] Find Numbers with Even Number of Digits]]> https://velog.io/@www_j/LeetCode-Find-Numbers-with-Even-Number-of-Digits https://velog.io/@www_j/LeetCode-Find-Numbers-with-Even-Number-of-Digits Mon, 05 Aug 2024 09:07:43 GMT Given an array nums of integers, return how many of them contain an even number of digits.

    Example 1

    Input: nums = [12,345,2,6,7896] Output: 2 Explanation: 12 contains 2 digits (even number of digits). 345 contains 3 digits (odd number of digits). 2 contains 1 digit (odd number of digits). 6 contains 1 digit (odd number of digits). 7896 contains 4 digits (even number of digits). Therefore only 12 and 7896 contain an even number of digits.

    Example 2

    Input: nums = [555,901,482,1771] Output: 1 Explanation: Only 1771 contains an even number of digits.

    Constraints

    1 <= nums.length <= 500 1 <= nums[i] <= 105

    Hint

    How to compute the number of digits of a number ? Divide the number by 10 again and again to get the number of digits.

    ✍풀이

    1. 숫자 추출

    class Solution {
    public int findNumbers(int[] nums) {

       int result = 0;
        for(int i = 0; i < nums.length; i++){
            int count = 0;

            while(nums[i] != 0){
                nums[i] = nums[i] / 10;
                count = count + 1;
            }

            if(count % 2 == 0){
                result++;
            }
        }

        return result;

    }
}

    2. 문자열 변환

    class Solution {
    public int findNumbers(int[] nums) {

        int count = 0;
        for(int num : nums){
            int length = String.valueOf(num).length();

            if(length % 2 == 0){
                count++;
            }
        }
    return count;
    }
}
    ]]>         <![CDATA[[LeetCode] Max Consecutive Ones]]> https://velog.io/@www_j/LeetCode-Max-Consecutive-Ones https://velog.io/@www_j/LeetCode-Max-Consecutive-Ones Mon, 05 Aug 2024 09:05:39 GMT Example 1.

    Input: nums = [1,1,0,1,1,1] Output: 3 Explanation: The first two digits or the last three digits are consecutive 1s. The maximum number of consecutive 1s is 3.

    Example 2.

    Input: nums = [1,0,1,1,0,1] Output: 2

    Constraints.

    1 <= nums.length <= 105 nums[i] is either 0 or 1.

    ✍풀이

    1. 최대 연속의수

    2. 배열에 담겨있어 for문을 length만큼 돌린후 if문을 통해 nums[i]가 1일 경우 count를 더해주고,아닐경우 0으로 초기화

    3. Math.max(a, b) - a, b 중에 큰 값을 사용

    class Solution {
    public int findMaxConsecutiveOnes(int[] nums) {


        int count = 0;
        int max = 0;

        for(int i = 0; i < nums.length; i++){

            if(nums[i] == 1){
                count++;
            }else{
                count = 0;
            }

            max = max > count ? max : count;
            // System.out.println(max);

        }

        return max;
    }
}
    class Solution {
    public int findMaxConsecutiveOnes(int[] nums) {

        int count = 0;
        int max = 0;
        for(int i : nums){
            System.out.println(i);
            if(i == 1){
                count++;
            }else{
                count = 0;
            }
            max = max > count ? max : count;
        }

        return  max;
    }

}
    ]]>