boolean add(Object o);  // (추가)
boolean add(Collection c);

boolean remove(Object o); // (삭제)
boolean removeAll(Collection c);
boolean retainAll(Collection c) ; //포함된 객체만 남기고 다른 객체 삭제
void clear(); // 전체 삭제

boolean contains(Object o); // 포함 여부 확인 (검색)
boolean contains(Collection c);

boolean isEmpty(); // 비어 있는지 확인 
int size(); // 저장된 객체수 확인

Iterator iteraotr(); // iterator 반환

Object[] toArray(); // 객체배열로 반환
Object[] toArray(Object[] a); // 지정된 배열에 Collection 객체를 저장해서 반환한다?

//추가
void add(int index, Object element);
boolean addAll(int index, Collection c);
Object set (int index, Object element);

//검색
Object get(int index); // 읽기
int indexOf(Object o);
int lastIndexOf(Object o);

//삭제
Object remove(int index);

//정렬
void sort(Comparator c);
List subList(int fromIndex, int toIndex);

boolean addAll(Collection c); // 합집합
boolean containsAll(Collection c); // 포함 확인 (부분 집합)
boolean removeAll(Collection c); // 차집합
boolean retailAll (Collection c); // 교집합 (포함된 객체만 남기고 나머지는 삭제) 

// 추가
Object put(Object key, Object value);
void putAll(Map t);

//삭제
Object remove(Object key);
void clear();

//검색
boolean containsKey(Object key);
boolean containsValue(Object value);
Object get(Object key);
boolean isEmpty();
int size();

Set entrySet(); // 저장된 모든 객체를 key, value 의 객체로 반환
Set keySet(); // Map 에 저장된 모든 key 객체를 반환
Collection values(); // Map 에 저장된 모든 value 객체를 반환

//생성자
ArrayList();
ArrayList(Collection c);
ArrayList(int initialCapacity);

// 추가
boolean add(Object o);
void add(int index, Object element);
boolean addAll(Collection c);
boolean addAll(int index, Collection c);

//삭제
boolean remove(Object o);
Object remove(int index);
boolean removeAll(Collection c);
void clear();

//검색
int indexOf(Object o); // 못 찾으면 -1
int lastIndexOf(Object o);
boolean contains(Object o);
Object get(int index); // 특정 위치 객체 읽기
Object set(int index, Object element); // 특정 위치 객체 변경

//이외
List subList(int fromIndex, int toIndex);
Object[] toArray();
Object[] toArray(Object[] a);
boolean isEmpty();
void trimToSize(); // 빈공간 제거
int size(); // 저장된 객체 반환

Stack s = new Stack();

boolean empty();
Object pop(); // 비었을때는 EmptyStackException 발생
Object push(Object item);
int search(Object o); // 못찾으면 -1, index가 1부터 시작
Object peek();

Queue q = new LinkedList();

boolean offer(Object o); // 추가
boolean add(Object o); // 저장 공간 부족하면 IllegalStateException 발생

Object poll(); // 꺼내기, 비어 있으면 null 반환
Object remove(); // 비어 있으면 NoSuchElementException 발생

Object peek(); // 비어 있으면 null 반환
Object element(); // peek 비어 있으면 NoSuchElementException 발생

public interface Collection {
    //...
    public Iterator iteartor();
    //...    
}

boolean hasNext(); // 읽어올 요소가 남아 있는지 확인
Object next(); // 다음 요소를 읽어 온다

List list = new ArrayList();
Iterator it = list.iterator();

while(it.hasNext()) {
    System.out.println(it.next());
}

Map map = new HashMap();
//...
Iterator it = map.entrySet().iterator();

int[] arr = new int[5];
Arrays.fill(arr, 9);
Arrays.setAll(arr, (i) -> (int) (Math.randome()*5)+1)

int[] arr = { 3, 2, 0, 1, 4};
int index = Arrays.binarySearch(arr, 2); // 정렬되어 있을때만 호출 가능, 아니면 잘못된 결과

Arrays.sort(arr);
int idx = Arrays.binarySearch(arr, 2);

public interface Comparator {
    int compare(Object o1, Object o2);  // o1, o2 두 객체를 비교 
                                        // 양수 왼쪽 큼, 0, 같음, 음수: 오른쪽 큼
    boolean equals(Object obj);         // equals를 오버라이딩 하라는 뜻
}

public interface Comparable {
    int compareTo(Object o);            // 주어진 객체(o)를 자신과 비교
}

public final class Integer extends Number implements Comparable {
    //...
    public int compareTo(Integer anotherInteger) {
        int v1 = this.value;
        int v2 = anotherInteger.value;

        return (v1 < v2 ? -1 : (v1==v2? 0 : 1));
    }
}

Arrays.sort(strArr, String.CASE_INSENSITIVE_ORDER);

public static final Comparator<String> CASE_INSENSITIVE_ORDER = new CaseInsensitiveComparator();

Arrays.sort(strArr, new Descending());
class Descending implements Comparator {
    public int compare(Object o1, Object o2) {
        if( o1 instanceof Comparable && o2 instanceof Comparable) {
            Comparable c1 = (Comparable) o1;
            Comparable c2 = (Comparable) o2;
            return c1.compareTo(c2) * -1;
        }
        return -1;
    }
}

class Person {
    String name;
    int age;
    //..
}
public boolean equals(Object obj) {
    if(!(obj instanceof Person)) return false;
    Person tmp = (Person) obj;
    return name.equals(tmp.name) && age==tmp.age;
}
public int hashCode() {
    return Objects.hash(name, age);
}

TreeSet(); // 기본 생성자
TreeSet(Collection c);
TreeSet(Comparator comp); // 주어진 정렬 기준으로 TreeSet 생성

Object first();
Object last();

Object ceiling(Object o);
Object floor(Object o);
Object higher(Object o);
Object lower(Object o);

SortedSet subSet(Object fromElement, Object toElement); // 범위 검색
SortedSet headSet(Object toElement); // 지정 된 객체보다 작은 것을 반환
SortedSet tailSet(Object fromElement); // 지정된 객체보다 큰것을 반환

HashMap(); 
HashMap(int initialCapacity);
HashMap(int initialCapacity, float loadFactor);
HashMap(Map m);

Set entrySet();
Set keySet();
Collection values();

Object put(Object key, Object value);
void putAll(Map m);
Object remove(Object key);
Object replace(Object key, Object value);
boolean replace(Object key, Object oldValue, Object newValue);

// 동기화 버전
static Collection synchronizedCollection(Collection c);
static List       synchronizedList(List list);
static Set        synchronizedSet(Set s);
static Map        synchronizedMap(Map s);
static SortedSet  synchronizedSortedSet(SortedSet s);

List syncList = Collections.synchronizedList(new ArrayList(...)); // 동기화 되지 않은

// 변경 불가 (readonly) 버전
static Collection unmodifiedCollection(Collection c); 
//....

// 싱글톤 컬렉션 만들기 
static List singletonList(Object o); // 객체 1개만 저장
static Set singleton(Object o);
static Map singletonMap(Object key, Object value);

// 한 종류의 객체만 저장 하는 컬렉션 만들기
static Collection checkedCollection(Collection c, Class type);
static List       checkedList(List list, Class type);
static Set        checkedSet(Set s, Class type);
//....

List list = new ArrayList();
List checkedList = checkedList(list, String.class);
checkedList.add("abc");
checkedList.add(new Integer(3)); // 에러

// 여러 메서드 등
import static java.util.Collections.*;
List list = new ArrayList();
addAll(list, 1,2,3,4,5);
rotate(list,2);
swap(list,0,2);
shuffle(list);
sort(list);
binarySearch(list,3);
max(list);
min(list);
fill(list,9);
nCopies(list.size(), 2);

List newList = nCopies(list.size(), 2);
disjoint(list, newList); // 공통 요소가 없으면 true
copy(list, newList);
replaceAll(list, 2, 1);

Enumeration e = enumeration(list);
ArrayList list2 = list(e);

@Controller
public class IndexController {

  @GetMapping("/")
  String index()
  {
    return "index";
  }
}

@GetMapping("/posts/save")
String postsSave() {
  return "posts-save";
}

import org.springframework.data.jpa.repository.Query;

public interface PostsRepository extends JpaRepository<Posts, Long> {

  @Query("SELECT p FROM Posts p ORDER BY p.id DESC")
  List<Posts> findAllDesc();

}

@Transactional(readOnly = true)
public List<PostsListResponseDto> findAllDesc()
{
  return postsRepository.findAllDesc().stream()
      .map(PostsListResponseDto::new)
      .collect(Collectors.toList());
}

@RequiredArgsConstructor
@Controller
public class IndexController {

  private final PostsService postsService;

  @GetMapping("/")
  String index(Model model) {
    model.addAttribute("posts", postsService.findAllDesc());
    return "index";
  }

@Getter
@NoArgsConstructor
@Entity
public class Posts {

  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  @Column(length = 500, nullable = false)
  private String title;

  @Column(columnDefinition = "TEXT", nullable = false)
  private String content;

  private String author;

  @Builder
  public Posts(String title, String content, String author) {
    this.title = title;
    this.content = content;
    this.author = author;
  }

  public void update(String title, String content) {
    this.title = title;
    this.content = content;
  }
}

public interface PostsRepository extends JpaRepository<Posts, Long> {

}

@RunWith(SpringRunner.class)
@SpringBootTest
public class PostsRepositoryTest {

  @Autowired
  PostsRepository postsRepository;

  @After
  public void cleanup() {
    postsRepository.deleteAll();
  }

  @Test
  public void 게시글저장_불러오기() {
    //given
    String title = "테스트 게시글";
    String content = "테스트 본문";

    postsRepository.save(Posts.builder()
        .title(title)
        .content(content)
        .author("miromike@gmail.com")
        .build());

    //when
    List<Posts> postsList = postsRepository.findAll();

    //then
    Posts posts = postsList.get(0);
    assertThat(posts.getTitle()).isEqualTo(title);
    assertThat(posts.getContent()).isEqualTo(content);
  }
}

@RequiredArgsConstructor
@RestController
public class PostsApiController {

  private final PostsService postsService;

  @PostMapping("/api/v1/posts")
  public Long save(@RequestBody PostsSaveRequestDto requestDto)
  {
    return postsService.save(requestDto);
  }
}

@RequiredArgsConstructor
@Service
public class PostsService {
  private final PostsRepository postsRepository;

  @Transactional
  public Long save(PostsSaveRequestDto requestDto) {
    return postsRepository.save(requestDto.toEntity()).getId();

  }

}

@Getter
@NoArgsConstructor
public class PostsSaveRequestDto {
  private String title;
  private String content;
  private String author;

  @Builder
  public PostsSaveRequestDto(String title, String content, String author) {
    this.title = title;
    this.content = content;
    this.author = author;
  }

  public Posts toEntity() {
    return Posts.builder()
        .title(title)
        .content(content)
        .author(author)
        .build();
  }
}

@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class PostsApiControllerTest {

  @Autowired
  private TestRestTemplate restTemplate;

  @Autowired
  private PostsRepository postsRepository;

  @LocalServerPort
  private int port;

  @After
  public void cleanup() throws Exception
  {
    postsRepository.deleteAll();
  }
  
  @Test
  public void 등록_테스트() throws Exception
  {
    //given
    String url = "http://localhost:" + port + "/api/v1/posts";
    String title = "test title";
    String content = "test content";

    PostsSaveRequestDto requestDto = PostsSaveRequestDto.builder()
        .title(title)
        .content(content)
        .author("test author")
        .build();

    //when
    ResponseEntity<Long> responseEntity = restTemplate.postForEntity(url, requestDto, Long.class);

    //then
    assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
    assertThat(responseEntity.getBody()).isGreaterThan(0L);

    List<Posts> all = postsRepository.findAll();
    assertThat(all.get(0).getTitle()).isEqualTo(title);
    assertThat(all.get(0).getContent()).isEqualTo(content);
  }
}

@RequiredArgsConstructor
@RestController
public class PostsApiController {

  private final PostsService postsService;

  @PostMapping("/api/v1/posts")
  public Long save(@RequestBody PostsSaveRequestDto requestDto)
  {
    return postsService.save(requestDto);
  }

  @PutMapping("/api/v1/posts/{id}")
  public Long update(@PathVariable Long id, @RequestBody PostsUpdateRequestDto requestDto) {
    return postsService.update(id, requestDto);
  }

  @DeleteMapping("/api/v1/posts/{id}")
  public Long delete(@PathVariable Long id) {
    postsService.delete(id);
    return id;
  }

  @GetMapping("/api/v1/posts/{id}")
  public PostsResponseDto findById(@PathVariable Long id) {
    return postsService.findById(id);
  }

  @GetMapping("/api/v1/posts/list")
  public List<PostsListResponseDto> findAll() {
    return postsService.findAllDesc();
  }

}

@RequiredArgsConstructor
@Service
public class PostsService {
  private final PostsRepository postsRepository;

  @Transactional
  public Long save(PostsSaveRequestDto requestDto) {
    return postsRepository.save(requestDto.toEntity()).getId();
  }

  @Transactional
  public Long update(Long id, PostsUpdateRequestDto requestDto)
  {
    Posts post = postsRepository.findById(id)
        .orElseThrow(()-> new IllegalArgumentException("해당 사용자가 없습니다. id=" + id));

    post.update(requestDto.getTitle(), requestDto.getContent());

    return id;
  }

@Test
public void 업데이트_테스트() throws Exception
{
  //given
  Posts post = postsRepository.save(Posts.builder()
      .title("test title")
      .content("test content")
      .author("test author")
      .build());
  Long id = post.getId();
  String updatedTitle = "updated Title";
  String updatedContent = "updated Content";

  PostsUpdateRequestDto requestDto = PostsUpdateRequestDto.builder()
      .title(updatedTitle)
      .content(updatedContent)
      .build();

  String url = "http://localhost:" + port + "/api/v1/posts/" + id;

  HttpEntity<PostsUpdateRequestDto> requestEntity =
      new HttpEntity<>(requestDto);

  //when
  ResponseEntity<Long> responseEntity =
      restTemplate.exchange(url, HttpMethod.PUT, (HttpEntity<?>) requestEntity, Long.class);

  //then
  assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
  assertThat(responseEntity.getBody()).isGreaterThan(0L);

  List<Posts> all = postsRepository.findAll();
  assertThat(all.get(0).getTitle()).isEqualTo(updatedTitle);
  assertThat(all.get(0).getContent()).isEqualTo(updatedContent);
}

@Getter
@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
public abstract class BaseTimeEntity {

  @CreatedDate
  private LocalDateTime createdDate;

  @LastModifiedDate
  private LocalDateTime modifiedDate;

}

@Test
public void BaseTimeEntity_테스트() {
  //given
  LocalDateTime now = LocalDateTime.of(2022, 5, 15, 0, 0, 0);
  postsRepository.save(Posts.builder()
      .title("title")
      .content("content")
      .author("author")
      .build());
  //when
  List<Posts> postsList = postsRepository.findAll();

  //then
  Posts posts = postsList.get(0);

  System.out.println(">>>>>>>>> createDate=" + posts.getCreatedDate() + ", modifiedDate=" + posts.getModifiedDate());

  assertThat(posts.getCreatedDate()).isAfter(now);
  assertThat(posts.getModifiedDate()).isAfter(now);
}

try {
    //
} catch (ArithmeticException e1) {
    //
} catch (Exception e2) { // 모든예외의 조상
    //
} finally {

}

try {
    System.out.println(0/0);
} catch (ArithmeticException ae) {
    ae.printStackTrace();
    System.out.println(ae.getMessage());
} catch (Exception e) {
    ...
}

catch (ExceptionA | ExceptionB e) { // 이런 식으로 멀티 구성 가능

    // Exception 의 메서드 함수 호출시 instanceof 사용 하면 된다.

    if( e instanceof ExceptionA ) {
        ExceptionA e1 = (ExceptionA) e;
        e1.methodA();
    } else {
        // ...
    }

}

Exception e = new Exception("고의 발생");
throw e;

public static void main(String[] args) {
    throw new Exception();
}

// 컴파일시 에러 > java.lang.Exception; must be caught or declared to be thrown 이라고 나옴

public static void main(String[] args) {
    throw new RuntimeException(); // 런타임 에러 발생, 컴파일 에러는 안나옴
}

void method() throws Exception1, Exception2, ... ExceptionN {
    // 메서드의 내용
}

// method()에서 Exception과 그 자손 예외 발생 가능
void method() throws Exception { // 모든 예외의 최고 조상, 모든 예외가 발생 가능
    // 메서드의 내용
}

static void startInstall() throws SpaceException, MemoryException {
    if(!enoughSpace())
        throw new SpaceException("공간 부족");
    if(!enoughMemory())
        throw new MemoryException("메모리 부족");
    //...
}

public final void waits() throws InterruptedException { 
    //... 
}
/* 
Throws : 
1. IllegalMonitorStateException
2. InterruptedException

함수 보면 Interrupted Exception 만 예외 선언 중이다.
IllegalMonitorStateException은 RuntimeException의 자손임이다 (즉 예외처리가 선택적)
*/

class MyException extends Exception {
    MyException (String msg) { // 문자열을 매개변수로 받는 생성자
        super(msg);// 조상인 Exception 클래스의 생성자를 호출 한다.
    }
}

Throwable initCause(Throwable cause) : 지정한 예외를 원인 예외로 등록
Throwable getCAuse() : 원인 예외를 반환

public class Throwable implements Serializable { // Exception과 Error 의 조상 클래스
    //...
    private Throwable cause = this; // 원인 예외를 저장 하기위한 iv
    //...
    public synchronized Throwable initCause(Throwable cause) {
        this.cause = cause;
        return this;
    }
}

void install() throws InstallException {

    try {
        startInstall();
        copyFiles();
    } catch (SpaceException e) {
        InstallException ie = new InstallException("설치 중 예외발생"); 
        ie.initCause(e); // 원인을 새로 만든 예외에 넣고
        throw ie; // 새로 만든 예외로 던짐
    } catch (MemoryException me) {
        //...
    }
}

class Person {
    long id;

    public boolean equals(Object obj) {
        if(obj instanceof Person) 
            return id == ((Person) obj).id;
        else
            return false;
    }
}

public class Object {
    //...
    public native int hashCode();
}

public int hashCode() {
    // hash 함수는 가변 인자를 받을수 있다.
    // 통상 iv을 쭈욱 넣어 준다.
    return Objects.hash(kind, number); 
}

public String toString() {
    return getClass().getName()+"@"+Integer.toHexString(hashCode());
}

public final class String implements java.io.Serializable, Comparable {
    private char[] value;
    //...

String a = "a";
String b = "b";
a = a + b;

String str1 = "abc";  // "abc" 0x100, str1은 0x100 바라봄
String str2 = "abc";  // str2은 0x100 바라봄
String str3 = new String("abc");  // "abc" 0x200, str3은 0x200 바라봄
String str4 = new String("abc");  // "abc" 0x300, str4은 0x300 바라봄

String str = ""; // str을 빈 문자열로 초기화

char[] chArr = new char[0]; // 길이가 0인 char 배열
int[] iArr = {}; // 길이가 0 인 int 배열

String(String s); // 생성자
String s = new String("Hello");

String(char[] value); // 문자열로 생성
    char[] c = {'H', 'e', 'e'};
    String s = new String(c);

String(StringBuffer buf); // String buffer 활용
    StringBuffer sb = new StringBuffer("Hello");
    String s = new String(sb);

char charAt(int index); // index 위치에 문자 반환
    s.charAt(1);

int compareTo(String str); // 문자열과 사전 순서로 비교, 0 같ㅇㅁ, 이전 음수, 이후 양수
    int i1 = "aaa".compareTo("aaa"); // 0
    int i2 = "aaa".compareTo("bbb"); // -1 // 왼쪽 작음
    int i3 = "bbb".compareTo("aaa"); // 1 //  왼쪽 큼

String concat(String str);

boolean contain(CharSequence s); // 포함 인지 확인

boolean endsWith(String suffix);
boolean equals(Object obj);
boolean equalsIgnoreCase(String str);

int indexOf(int ch); // 못찾으면 -1
int indexOf(int ch, int pos);
int indexOf(String str);
int lastIndexOf(int ch);
int lastIndexOf(String str)

int length(); 

String[] split(String regex); // 정규식(Regular Expression)
    String animals = "dog,cat,bear";
    String[] arr = animals.split(",");

String[] split(String regex, int limit); // limit 숫자 만큼 나눈다
    String animals = "dog,cat,bear";
    String[] arr = animals.split(",", 2);  // arr[0]="dog", arr[1]="cat,bear";

boolean startsWith(String prefix); // prefix로 시작 하는지 확인

String subString(int begin);
String subString(int begin, int end);

String toLowerCase(); 
String toUpperCase();

String trim();

static String valueOf(boolean b); 
static String valueOf(char b); 
static String valueOf(int b); 
static String valueOf(long b); 
static String valueOf(float b); 
static String valueOf(double b); 
static String valueOf(Object b); // toString()을 호출한 결과를 반환

String animals = "dog, cat, bear";
String[] arr = animals.split(",");
String str = String.join("-", arr);

//기본형 -> 문자형
static String.valueOf(boolean b);
static String valueOf(char b); 
static String valueOf(int b); 
static String valueOf(long b); 
static String valueOf(float b); 
static String valueOf(double b); 

//문자형 -> 기본형
boolean Boolean.parseBoolean(String s); // 요즘 Boolean.valueOf(String s)
char Char.parseChar(String s);
//.... 등등 등 

boolean b = Boolean.valueOf("true");
int i = Integer.valueOf("1000");

public final class StringBuffer implements java.io.Serializable {
    private char[] value;
    //...
}

public StringBuffer(int length) { // 이렇게 길이를 잡아 줄수 있다.
    value = new char[length];
    shared = false;
}

    // 기본 생성 하면 길이를 16으로 잡는다.
    // String 넣어서 생성 하면 문자열 길이 + 16으로 잡는다.

Stringbuffer sb = StringBuffer("abc");
sb.append("123");
sb.append("ZZ");

sb.append("123").append("ZZ");

StringBuffer sb1 = new StringBuffer("abc");
StringBuffer sb2 = new StringBuffer("abc");

// (sb1 == sb2)     // false
// sb1.equals(sb2); // false

StringBuffer append(/* 각종 타입 인자 가능*/);

int capacity();
char charAt(int index);
StringBuffer delete(int start, int end);
StringBuffer deleteCharAt(int index);

StringBuffer insert(int pos, /*각종 타입 */ boolean b);

int length();
StringBuffer replace(int start, int end, String str);
StringBuffer reverse();

void setCharAt(int index, char ch);
void setLength(int newLength);
String toString();
String substring(int start);
String substring(int start, int end);

static double abs(double a); // 절대값 반환
// float, int, long 버전 존재

static double ceil(double a); // 올림 반환
static double floor(double a); // 버림

static double max(double a, double b); // 둘중 큰거 반환
// float, int, long 버전 존재

static double min(double a, double b);
static double randome();

static double rint (double a);  // 짝수 반올림
static double round(double a);  // 일반 반올림

Integer.MAX_VALUE; 
Integer.MIN_VALUE;
Integer.SIZE;
Integer.BYTES;
Integer.TYPE;

public abstract class Number implements java.io.Serializable {
    public abstract int intValue();
    public abstract long longValue();
    public abstract float floatValue();
    public abstract double doubleValue();

    ..
    ..
    // 래퍼 객체 -> 객체형으로 변경해주는 메서드를 가지고 있음
}

Calendar cal = new Calendar(); // 생성 안됨, Calendar는 추상화 클래스
Calendar cal = Calendar.getInstance(); // 환경 변수를 참고 해서 생성
Calendar cal = new GregorianCalendar(); // 특정 Calendar의 생성

Calendar cal = Calendar.getInstance(); // 현재 날짜와 시간
int thisYear = cal.get(Calendar.YEAR); // 올해 가져오기
int lastDayOfMonth = cal.getActualMaximum(Calendar.DATE); // 이날의 마지막 날짜

long difference = date1.getTimeInMillis() - date2.getTimeInMillis();

final int[] TIME_UNIT = {3600, 60, 1};
final String[] TIME_UNIT_NAME = {"시간 ", "분 ", "초 " };

String tmp="";

for(int i=0; i< TIME_UNIT.length;i++) {
    tmp += difference/TIME_UNIT[i] + TIME_UNIT_NAME[i];
    difference %= TIME_UNIT[i];
}

System.out.println(tmp);

Calendar date = Calendar.getInstance();
date.clear();
date.set(2020, 7, 31); // 2020년 8월 31일 설정

date.add(Calendar.DATE, 1); // 날짜에서 1을 더한다 // 9월 1일이 된다
data.add(Calendar.MONTH, -8); // 월에서 8 을 뺀다// 1월 1일이 된다

double number = 1234567.89;
DecimalFormat df = new DecimalFormat("#.#E0");
String result = df.format(number); // result = "1.2E6"

DecimalFormat df = new DecimalFormat("#,###.##");
Number num = df.parse("1,234,567.89");
double d = num.doubleValue(); // 1234567.89

Date today = new Date();
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
String result = df.format(today);

SimpleDataFormat df2 = new SimpleDataFormat("yyyy년 MM월 dd일");
Date d = df2.parse("2015년 11월 23일");  // 문자열을 Date 객체로

String result = df2.format(d); // 객체를 문자열로