22.11.15 [Java 활용편]

어제공부한거 복습하다가 글이 지저분해서 분량을 나눴다...!

JAVA 활용

 

날짜 와 시간

 1.현재날짜와 시간 불러오기 .now

 2.내가 원하는 날짜 쓰기 .of

 3.형식을 내가 원하는 형식으로 Formatter 사용

  >>> enum 클래스... 정해진 것만 사용가능함!

  >>> ofPattern 내가 형식을 만들어 사용 yyyy년 MM 달 dd 일 

    >>>>String 클래스 써서 문자열로 반환시키기 !  

https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html 참조

오류나서 안될때는 걍 처음부터 다시시작하자  ;;; ㅜㅜㅜ

4.기간 계산

>period 함수이용

 

컬렉션  [복붙임]

• 이번 장에서는 자바에서 자료구조를 표현하는 인터페이스인 컬렉션(Collection), 그리고 구체적인 자료구조의 종류인 리스트(List), 스택(Stack) ,큐(Queue),셋(Set),맵(Map)의 개념과 예제 코드를 함께 배웁니다.
• 컬렉션의 개념과 클래스는 코딩을 하면서 숨쉬는 것처럼 계속 사용해야하는 것이니 이번 기회에 잘 배워두시기를 바랍니다.

• 1. 컬렉션 프레임워크란?
  • 다수의 데이터를 다루기 위한 자료구조를 표현하고 사용하는 클래스의 집합을 의미합니다!
  • 데이터를 다루는데 필요한 풍부하고 다양한 클래스와 기본함수를 제공하기 때문에 많이 유용합니다! 실제 자바 어플리케이션을 개발할 때 가장 많이 사용할 클래스와 함수를 이번에 배우게 됩니다.
  • 컬렉션 프레임워크의 모든 클래스는 Collection interface를 구현(implement)하는 클래스 또는 인터페이스 입니다.
  • 1. 컬렉션 인터페이스와 자료구조
    Collection 은 모든 자료구조가 구현(implement)하는 인터페이스입니다. 아래 배우는 모든 자료구조에 해당하는 클래스, 인터페이스는 언제나 Collection 인터페이스를 구현하고 있습니다.
    1. List : 순서가 있는 데이터의 집합이며 데이터의 중복을 허용합니다. → ArrayList, LinkedList, Stack 등
    2. Set : 순서를 유지하지 않는 데이터의 집합이며 데이터의 중복을 허용하지 않습니다. → HashSet, TreeSet 등
    3. Map : 키(key)와 값(value)의 쌍으로 이루어진 데이터의 집합입니다. 순서는 유지되지 않으며 키는 중복을 허용되지 않고 값은 중복을 허용합니다. → HashMap, TreeMap 등
    4. Stack : 마지막에 넣은 데이터를 먼저 꺼내는 자료구조입니다. LIFO(Last In First Out) → Stack, ArrayDeque 등
    5. Queue : 먼저 넣은 데이터를 먼저 꺼내는 자료구조입니다. FIFO(First In First Out) → Queue, ArrayDeque 등

list 정리

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

public class Main{
    public static void main(String[] args){
        List<Integer> integerList = new ArrayList<>(); // 숫자를 지정해 주지 않음
        integerList.add(1); //add하는 순간 그거에 맞춰서 사이즈가 정해짐
        integerList.add(5);
        integerList.add(6);
        integerList.add(6);
        integerList.add(4);
        integerList.add(10);

        System.out.println(integerList);

        Collections.sort(integerList); //기본 오름차순 정렬
        System.out.println(integerList);
        System.out.println(integerList.size()); //크기측정

        integerList.remove(4);//4번째 인덱스 제거
        System.out.println(integerList); // for문이용 하나하나 출력가능

        for(int current: integerList){
            System.out.println(current); //for-each문이면 더간결
        }
    }
}

set  정리

import java.util.*;

public class Main{
    public static void main(String[] args){
        Set<Integer> integerSet = new HashSet<>();
        integerSet.add(1);
        integerSet.add(1);
        integerSet.add(9);
        integerSet.add(3);
        integerSet.add(8);

        System.out.println(integerSet);//중복x 순서유지x

        Set<String> stringSet = new HashSet<>();
        stringSet.add("가");
        stringSet.add("파");
        stringSet.add("규");
        stringSet.add("호");
        stringSet.add("하");

        System.out.println(stringSet);
        stringSet.remove("규"); //한개삭제
        System.out.println(stringSet);

        List<String> target = new ArrayList<>();//여러개삭제 밑밥
        target.add("호");
        target.add("하");

        stringSet.removeAll(target); //콜렉션 타입이면 모두가능
        System.out.println(stringSet);

        System.out.println("가 포합되어 있나요?"+ stringSet.contains("가"));
        System.out.println("하 포합되어 있나요?"+ stringSet.contains("하"));

        System.out.println(stringSet.size());
        stringSet.clear();
        System.out.println(stringSet);
    }
}

  map 정리 key :value

import java.util.HashMap;
import java.util.Map;

public class Main{
    public static void main(String[] args){
        Map<Integer,String> map = new HashMap<>();
        map.put(1,"apple");
        map.put(2,"berry");   //add 대신에 put을 사용
        map.put(3,"cherry");

        System.out.println(map );
        System.out.println("첫번째 값 " + map.get(1)); // 주의할점은 인덱스값이 아닌 key값을 받고 value를 리턴

        map.remove(1);
        System.out.println(map);
        System.out.println(map.containsKey(1)+"  " +map.containsKey(2));
        System.out.println(map.containsValue("cherry"));

        map.clear();
        System.out.println(map);
    }
}

스택

  public class Main{
   public static void main(String[] args){
        Stack<Integer> stack = new Stack<>();
        stack.push(1);
        stack.push(2);
        stack.push(8);
        stack.push(7);

        System.out.println(stack);

        System.out.println(stack.peek());  //확인만한다면
        System.out.println(stack.size());
        System.out.println(stack.pop());   // 꺼내는것이다
        System.out.println(stack.size());

        //추가로  java에서 contaions..사용가능
        System.out.println(stack.empty()); // 비어있나 확인
        stack.clear();
        System.out.println(stack.isEmpty()); // empty랑 동일
    }
}

 큐

import java.util.LinkedList;
import java.util.Queue;

public class Main{
    public static void main(String[] args){
        Queue<Integer> queue = new LinkedList<>(); //큐는 인터페이스이기 때문에 구현체가 필요... 그중 링크드리스트 썻다
        queue.add(1);
        queue.add(5);
        queue.add(3);
        System.out.println(queue);
        System.out.println(queue.poll());
        System.out.println(queue);
        System.out.println(queue.peek());
        System.out.println(queue);
        
        //이외에도  ..~ clear  empty 모두 존재  
   
    }
}

 

어레이디큐!  장점만 짬뽕한 느낌

ArrayDeque에 대해서 알아보겠습니다. 실무에서는 단순히 Stack, Queue 클래스 대신에 ArrayDeque 많이 사용합니다! 기본 Stack, Queue의 기능을 모두 포함하면서도 성능이 더 좋기 때문이죠.

• 우리가 앞서 배운 큐는 한쪽에서만 값이 삽입되고 다른 한쪽에서만 값을 반환하는 자료구조였습니다. 하지만 deque의 경우 양 끝에서 삽입과 반환이 가능합니다.

import java.util.ArrayDeque;

public class Main {
    public static void main(String[] args) {
        ArrayDeque<Integer> arrayDeque = new ArrayDeque<>();
        arrayDeque.addFirst(1);
        arrayDeque.addFirst(2);
        arrayDeque.addFirst(3);
        arrayDeque.addFirst(4);
        arrayDeque.addFirst(5);

        System.out.println(arrayDeque); //앞자리에 넣은것이 계속 밀려남
        arrayDeque.addLast(0);
        System.out.println(arrayDeque); //마지막칸에 추가됨
        arrayDeque.offerFirst(10);  //크기에 문제가 생길시... 불린값 반환
        System.out.println(arrayDeque);//[10, 5, 4, 3, 2, 1, 0]

        arrayDeque.offerLast(-1);
        System.out.println(arrayDeque);//[10, 5, 4, 3, 2, 1, 0, -1]

        arrayDeque.push(22);//스택에 있는기능     // 큐에있는 poll,,pollLast,pollfrist도 지원
        System.out.println(arrayDeque);  //[22, 10, 5, 4, 3, 2, 1, 0, -1]

        System.out.println(arrayDeque.pop());//22
        System.out.println(arrayDeque);//[10, 5, 4, 3, 2, 1, 0, -1]
        System.out.println(arrayDeque.peek());//10
        System.out.println(arrayDeque.size());//8
        arrayDeque.clear();  //
        System.out.println(arrayDeque.isEmpty());  //true

    }
}

 

제네릭

• 다양한 타입의 객체들을 다루는 메소드나 컬렉션 클래스에 컴파일 시의 타입 체크를 해주는 기능을 의미합니다.(이미 컬렉션을 배울때 한번 만나본적있습니다!)
• 제네릭스를 왜 사용해야할까?
• → 객체의 타입을 컴파일 시에 체크하기 때문에 안정성이 높아집니다. (의도하지 않은 타입의 객체가 저장되는 것을 막고 잘못된 형변환을 막을 수 있기 때문입니다!)

public class 클래스명<T> {...}
public interface 인터페이스명<T> {...}

자주 사용되는 타입인자 약어

- <T> == Type

- <E> == Element

- <K> == Key

- <V> == Value

- <N> == Number

- <R> == Result

..흠 열혈자바 제네릭 문법 공부하기  + 콜렉션에서 자주나오는데 ... 명세서 확인하면서 공부하면 도움됨...

}import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class Main {
    public static void main(String[] args) {

        List<String> list = new ArrayList(); //인터페이스..? 리스트타입
        list.add("String")
        Collection<String> collection = list;  //리스트를 리스트보다 상위 인터페이스인 콜렉션에 할당

        List<Exception> exceptionList = new ArrayList<>();
        Collection<Exception> exceptionCollection = exceptionList;
        //exceptionCollection.addAll(list); //불가능
        List<IllegalAccessException> exceptions = new ArrayList<>();
        exceptionCollection.addAll(exceptions);  //가능 exception의 자식클래스중 하나가 illgalAccessException이기때문..함수의 명세서를 봐야함!

        
    }
}

 

람다

함수를 좀더 쉽게 표현하자..! 

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("korea");
        list.add("japan");
        list.add("france");  //스트림형태..?  리스트에 있는걸 하나씩 꺼내주는 형태...?
        Stream<String> stream = list.stream();
        stream.map(str->str.toUpperCase())     //map이라는 함수.. 내가 앞에있는 값을 ~ 내가 어떤 값으로 바꿀께
                .forEach(it ->System.out.println(it))); //Function을 매개변수=파라미터 로 받는다..~ 람다식을 쓸수잇따
    }               //forEach는 각각 하나마다 실행해줘  여러줄로 작성시 중괄호+return써줘야함\
}                       //.forEach(it ->System.out.println(it))=.forEach(System.out::println) 같은뜻이다.

 

스트림

하나의 데이터의 흐름... 컬렉션을 통해서 스트림을 만들어내는 것.. 

원본을 변형시키는건 아니다...!

리턴타입이... void 인경우는 추가 함수를 호출할수 없다..?

>예시로는 .forEach   ... 스트림이 닫혔다..

예시1

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("서울");
        list.add("대구");
        list.add("광주");
        list.add("부산");

        System.out.println(list);

        List<String> result = list.stream()      //stream + transformation
                .limit(2)                    //두개만 필요해
                .collect(Collectors.toList());      //그 모인걸로 모아서 또 리스트 만들꺼야
        System.out.println(result);

        Set<String> set = list.stream()
                .filter(it ->"서울".equals(it))     //set은 중복을 허용하지 않는구조
                .collect(Collectors.toSet());
        System.out.println(set);
    }
}

예시2

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        String[] arr={"SQL","Java", "Python"};    //컬렉션이 아니라도 스트림가능
        Stream<String> stringStream = Arrays.stream(arr);
        stringStream.forEach(System.out::println);
    }
}

예시 3은 외부 라이브러리추가했다 추가하고 나서는 gradle 최신화..? 돌려주기

implementation 'org.apache.commons:commons-lang3:3.0'

스트림이용 계산

import org.apache.commons.lang3.tuple.Pair;

import java.util.Arrays;
import java.util.List;

class Sale {
    String fruitName;
    int price;
    float discount;

    public Sale(String fruitName, int price, float discount) {
        this.fruitName = fruitName;
        this.price = price;
        this.discount = discount;
    }
}

public class Main {
    public static void main(String[] args) {
        List<Sale> sales = Arrays.asList(
                new Sale("Apple",5000,0.05f),
                 new Sale("Orange",4000,0.02f),
                new Sale("Grape",2000,0)
        );
        sales.stream()
                .map(sale -> Pair.of(sale.fruitName, sale.price*(1-sale.discount))) 
                .forEach(pair -> System.out.println(pair.getLeft()+"실구매가 :" + pair.getRight() + "원 입니다." ));
    }
}

 

예제 4 reduce

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        System.out.println(list.stream().reduce(0,Integer::sum));  //처음엔 0으로시작해서 하나씩 오른쪽 함수를 실행할꺼야~
    }
}

 스트림퀴즈(내풀이)

import com.sun.org.apache.xpath.internal.SourceTree;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("김정우", "김호정", "이하늘", "이정희", "박정우", "박지현", "정우석", "이지수");

        List<String> strings = names.stream()
                .filter(it->it.startsWith("이"))
                .collect(Collectors.toList());

        System.out.println(strings.stream().count());
    }
}

강사님 풀이

import com.sun.org.apache.xpath.internal.SourceTree;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("김정우", "김호정", "이하늘", "이정희", "박정우", "박지현", "정우석", "이지수");

       System.out.println("이씨성을 가진 친구들 : " + names.stream().filter(name -> name.startsWith("이"))
                                                            .count());
    }
}

강사님의 경우... 따로 리스트 안만들고 바로 하나씩 꺼내고 필터하고 갯수까지 한번에 해결..! 대단하시다!

 

네트워킹-Retrofit,OpenAPI

리트로핏 라이브러리 ...!

 

네트워크...?두대이상의 컴퓨터를 물리적 or무산적으로 연결...

 

서버: 요청받는사람 요청응답

클라이언트:서비스요청하는

 

IP ~ 컴퓨터 주민번호

URL ~ 각 홈페이치의...개개의 방같은 느낌..

포트번호 ...어떤 프로그랩에 접속할 것인지를 식별하는 ,,,역할... http는 80번 https는 443번

http는 통신을 하기 위한 약속

https는 보안이 강화됨...!

API  ...는.. 요청/응답 데이터를 주고받는 형식에 대한 약속

 

리트로핏...라이브러리 쓰기 위해서는...

implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
implementation 'com.google.code.gson:gson:2.8.5'

요거 추가해줘야함

 

솔직히 사용법은 모르겠다 ㅋㅋ...

그냥 이런게 있구나 ... 수준임...

 

완전따라서 쳤는데 뭐한거지 이해가 안감

import retrofit2.Call;
import retrofit2.http.GET;
import retrofit2.http.Query;

public interface RetrofitSevice {
    @GET("/api/users/")
    Call<Object> getUsers(@Query("page")int page);
}

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;

public class RetrofitClient {
    private static final String BASE_URL = "http://reqres.in";

    public  static  RetrofitSevice getApi(){
        return getInstance().create(RetrofitSevice.class);
    }

    private static Retrofit getInstance(){
        Gson gson = new GsonBuilder().setLenient().create();
        return new Retrofit.Builder().baseUrl(BASE_URL)
                .addConverterFactory(GsonConverterFactory.create(gson))
                .build();
    }
}

import retrofit2.Call;

import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        Call<Object> result =RetrofitClient.getApi().getUsers(2);

        try{
            System.out.print(result.execute().body());
        }catch (IOException e){
            System.out.print(e.getMessage());
        }
    }
}

 

 

알고리즘 문풀 사이트와 깃허브 연동했다

이제 좀더 정리를 편하게 할수 있겠다고 생각한다

https://nomoreft.tistory.com/73

백준, 프로그래머스에서 문제풀고, 자동으로 GitHub 잔디 심자(BaekjoonHub)

내가 참고한 글..!

이제 잔디심기 알아서 된다..!!