728x90

이글은 백기선님 스터디 할래? 스터디를 뒤늦게 따라간 기록입니다.

매년 혼자 자바 책한권씩 정리했었는데, 이 스터디 따라가는게 훨~~~씬 좋았습니다. 

어떻게 공부할지에 대한것을 많이 배웠습니다. 

누군가에게 도움이 되길 바라며 남김니다.  

 

유튜브 구독하시면 이전 스터디 수강가능합니다. 

백기선님 유튜브 >>https://www.youtube.com/user/whiteship2000

스터디할래 유튜브 >>https://youtu.be/peEXNN-oob4

스터디할래 링크 >> https://github.com/whiteship/live-study

 

[스터디할래? Java 01] JVM 이란 무엇인가?

[스터디할래? Java 02] 자바 데이터 타입, 변수 그리고 배열

[스터디할래? Java 03] 연산자 Operator

[스터디할래? Java 04] 제어문

[스터디할래? Java 05] 클래스_ BinrayTree_DFS,BFS

[스터디할래? Java 06]상속

[스터디할래? Java 07]패키지

[스터디할래? Java 08]인터페이스

[스터디할래? Java 09]예외처리

[스터디할래? Java 10]멀티쓰레드 프로그래밍

[스터디할래? Java 11]enum

[스터디할래? Java 12]애노테이션

[스터디할래? Java 13]I/O

[스터디할래? Java 14]제네릭

[스터디할래? Java 15]lamda

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

'JAVA > Basic' 카테고리의 다른 글

[스터디할래? Java] 목차  (0) 2021.05.17
[스터디할래? Java 15]lambda 람다  (0) 2021.05.15
[스터디할래? Java 14]제네릭  (0) 2021.05.15
[스터디할래? Java 13]I/O  (0) 2021.05.15
[스터디할래? Java 12]애노테이션  (0) 2021.05.15
[스터디할래? Java 11]enum  (0) 2021.05.15
728x90

[스터디할래? Java] 목차

이글은 백기선님 스터디 할래? 스터디를 뒤늦게 따라간 기록입니다.

스터디할래 링크 >> https://github.com/whiteship/live-study

이필기를 시작으로 공부했습니다 >>https://xxxelppa.tistory.com/207https://tourspace.tistory.com/6

여기 없는내용은 스터디 할래 강의 내용 혹은 제가 java Doc보고작성하거나 예제를 만들어 추가했습니다.

그외는 같이 출처가 써있습니다. 

람다식 lambda expression : 식별자 없이 실행 가능한 함수표현식
익명클래스를 함수표현식으로 처리할수 있음. 

식별자: 코드에 존재하는 변수, 자료형, 서브루틴 등을 가리키는 토큰이다.

+ java8 부터 람다식 가능하게한것은 함수형프로그램이 가능하게 하기위해. 
함수 자체가 first-class-function : 변수할당, 매개변수 전달, 리턴 전달 가능해짐. 
컬렉션 잘쓰려고 스트림 지원, 그를위해 함수형 프로그래밍 지원, 그를위해 람다 지원. 

+ 익명내부클래스는 XXXXXX$1.class 로 컴파일 됨. 
        람다는 invoke dynamic(jdk1.7, 인디) 이라는 opcode 사용. 바이트트 코드 확인가능
                 이런이유로 버전올라갈때 개선의 여지가 있다고함. 

invoke dynamic : (jdk1.7, 인디) 동적타입언어. 바이트 코드 셋.
-기존 4가지 invokevirtual(instance메소드 디스패치), invokestatic, invokeinterface, invokespecial
-메소드이름, 메소드시그니처, 메소드 정의 클래스, 메소드 실행 바이트 코드 가 명확히선언필요...
invoke dynamic  : https://tourspace.tistory.com/12

+ 람다를 지연연산으로 활용할수 있다.  
Variable Capture 변수 캡쳐

람다 외부 정의된 변수 : 자유변수 :Free Valiable
자유변수를 참조 : 람다 캡쳐링 :Lambda Capthuring
람다에서 지역변수 참조시 : 1. final, 2. final처럼 동작  ==> 재할당 안되야. 
원인 : 지역변수 스택생성 쓰레드끼리 공유 안된다. 인스턴스변수 힙영역생성, 쓰레드 공유가능. 
람다는 변수도 자신의 스택에 저장해서 쓰는데 변하면안된다는 제약조건 필요한이유. 
https://perfectacle.github.io/2019/06/30/java-8-lambda-capturing/

+ VariableCapture 클래스. 
run 메서드  안에 익명클래스는다른영역
                  -->(익명내부클래스 쉐도잉 = 새로운 scop 를 가짐, 동일변수선언가능). 
run 메서드 안에 람다는 같은 scope 같은 이름 변수 정의 불가. 
메소드 생성자 레퍼런스 :: "
1. static 메소드참조
클래스이름::메소드이름  System.out::println
2. 인스턴스메소드참조  
3. 람다식 매개변수로 접근가능 메소드참조
BiFunction<string,string,boolean> stringContain = String::contains;
System.out.println(stringContain.apply("apple","a"));
4. 생성자 참조
클래스이름 :: new
Supplier<Random> random = Random::new;
System.out.println(random.get().nextInt(10)+1);
타입추론 Predicate<String> isEmpty = s-> s==null || s.length()<0;
함수형 인터페이스
함수형 인터페이스
@FunctionalInterface
추상메서드가 하나뿐인인터페이스
Consumer,Runnable, Predicate,  supplier, functon.....
Runnable         Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("Run");
            }
        };

        Runnable lambdaRun = ()->{System.out.println("run");};
        new Thread(lambdaRun).start();
predicate<T> boolean test(T t);
        List<Integer> numbers = new ArrayList();
        numbers.add(3); numbers.add(1); numbers.add(0); numbers.add(2);
        Predicate<Integer> moreThen3 = (num) -> num >= 3;
        System.out.println(moreThen3.test(4));
        numbers.removeIf(moreThen3);
        String num = numbers.stream().map(Object::toString).collect(Collectors.joining(","));
        System.out.println(num);
https://zetcode.com/java/predicate/


List<VerseModel> verses =  chapter.getBibleVerse().stream().filter(verse -> verse.getBiblePublish().getPublishSn() ==publishesSn.get(0)).collect(Collectors.toList());





Consumer<T>



https://zetcode.com/java/consumer/
void accept(T t);
        List<Integer> numbers = new ArrayList();
        numbers.add(3); numbers.add(1); numbers.add(0); numbers.add(2);
Consumer<List> toStringList = (list) -> {
   System.out.println(list.stream().map(Object::toString).collect(Collectors.joining(",")));;
};
toStringList.accept(numbers);
ArrayList.forEach(Consumer<? super E> action)
        List<Integer> numbers = new ArrayList();
        numbers.add(3); numbers.add(1); numbers.add(0); numbers.add(2);
        numbers.forEach((num)->{System.out.println(String.valueOf(num));});
Consumer.andThen(Consumer<? super T> after)
        Consumer<List<String>> addRoom = (list) -> {
            for (int i = 0; i < list.size(); i++) {
                list.set(i,list.get(i).concat(" Room"));
            }
        };
        Consumer<List> toStringList = (list) -> {
            System.out.println(list.stream().map(Object::toString).collect(Collectors.joining(",")));;
        };
        List<String> strNum = new ArrayList<>();
        strNum.add("a"); strNum.add("B"); strNum.add("C"); strNum.add("d");
        addRoom.andThen(toStringList).accept(strNum);
Consumer<T>, BiConsumer<T,U>, DoubleConsumer, IntConsumer, LongConsumer, ObjDoubleConsumer, ObjIntConsumer, ObjLongConsumer
Supplier<T>




T get();
Supplier random10Supplier = ()-> new Random().nextInt(10)+1;

Stream.generate(random10Supplier).limit(5).forEach(System.out::println);
System.out.println(random10Supplier.get());
https://java2blog.com/java-8-supplier-example/#Java_8_Supplier_example
Supplier<T>, BooleanSupplier, DoubleSupplier, IntSupplier LongSupplier
Function<T,R> R apply(T t);
        Function<Integer,Integer> plus4 = (num)-> num + 4;
        System.out.println(plus4.apply(5));
Function<T,R>, BiFunction<T,U,R>, DoubleFunction<R>, IntFunction<R>, IntToDoubleFunction....

List<Integer> publishSnList = publishModelList.stream().map(TheBiblePublishModel::getPublishSn).collect(Collectors.toList())

List<String> verseList = verses.stream().map(verse -> verse.getVerse()).collect(Collectors.toList());
UnaryOperator<T> T apply(T t);
- Function<T,R> 같은타입일때. 
        UnaryOperator<Integer> UnaryPlus4 = (num)-> num + 4;
        System.out.println(UnaryPlus4.apply(5));
BinaryOperator - BiFunction<T,U,R>, UnaryOperator<T>, DoubleBinaryOperator.....
stream from https://futurecreator.github.io/2018/08/26/java-8-streams/
stream jdk8 람다 활용가능기술
1. 생성 :스트림인스턴스생성
2. 가공 : 필터링, 맵핑, 등 중간작업
3. 결과 
stream 생성 1. 배열 스트림
2. 컬렉션스트림
3. 비어있는스트림 Stream.empty()
4. 빌더스트림
Stream<String> builderStream 
= Stream.<String>builder().add("A").add("B").add("C").build();
5. Stream.generate()
Stream<String> genStream
                = Stream.generate(()->"gen").limit(3);
System.out.println(genStream.map(String::toString).collect(Collectors.joining()));//gengengen
6. Stream.iterate()
Stream<Integer> iterStream
       = Stream.iterate(1,n->n+1).limit(3);
System.out.println(iterStream.map(num-> String.valueOf(num)).collect(Collectors.joining()));//123
7.기본타입, 문자형 스트림. 파일, 병렬
IntStream, LongStream, DoubleStream, .paralleStream()
stream 가공 1. 연결
Stream.concat(stream1,stream2);
2. Filtering -> Stream<T> filter(Predicate<? super T> predicate)
Stream<String> stream = name.stream().filter(name-> name.contain("a"));
3. Mapping -> <R> Stream<R> map(Function<? super T, ? extends R> mapper);
4. flatMap -> <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
List<String> flatList = list.stream() .flatMap(Collection::stream) .collect(Collectors.toList()); // [a, b]
4. sorting()
sorted(Comparator.comparingInt(String::length))
5. peek : 그냥 확인해본다. 
stream 결과 1. 연산
스트림.count(), 스트림.sum(), 스트림.min();, 스트림.max()
2. reduce
        OptionalInt reduced =
                IntStream.range(1, 4) // [1, 2, 3]
                        .reduce((a, b) -> {
                            return Integer.sum(a, b);
                        });
        System.out.println(reduced.getAsInt());
3. Collecting  >> .collect(XXXXXX)
- Collectors.toList() 리스트 반환
-Collectors.joining(", ", "<", ">");
- Collectors.averageIngInt(Product::getAmount);  평균
- Collectors.summingInt() 합
- Collectors.summarizingInt(); 합, 평균
- Collectors.groupingBy()  그룹
- Collectors.partitioningBy() Predicate 함수.
- Collectors.of()  직접 Collector 만듬
3. Matching
.anyMatch(name -> name.contains("a"));
4. foreach : 최종과정의 peek
names.stream().forEach(System.out::println);


Map<Integer, String> map = list.stream().collect( Collectors.toMap(Item::getId, Item::getValue));
Map<Integer, Boolean> isUsedPublish = publishesSn.stream().collect(Collectors.toMap(Function.identity(), e -> true));

** random.nextInt(max - min + 1) + min

추천책 : 시작의 기술 ,

못하는건가... 안하는건가.....

 


+ 리플렉션. : 가장 빨리 getter를 읽는 방법은? 
https://dzone.com/articles/java-reflection-but-faster

  • Java Reflection is slow.
  • Java MethodHandles are slow too.   // MethodHandlers.lookup() jdk7   리플렉션과 별차이없음...
  • Generated code with javax.tools.JavaCompiler is fast.    //JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
  • LambdaMetafactory is pretty fast.      //MethodHandles.Lookup lookup = MethodHandles.lookup();
            CallSite site = LambdaMetafactory.metafactory(lookup,

제니퍼.

 

So, the devil is in the details. Let’s go through the implementations to confirm that I applied typical magical tricks, such as

So, the devil is in the details.  >>> (A를 B로 합시다)... 구현하면 일이 많아진다. 

 

 


String[] names = {"Z","B","C"};
Arrays.sort(names,String::compareToIgnoreCase);   //(this, o2) -> this.compareTo(o2)
Arrays.stream(names).forEach(System.out::print);

 

 

 

 

 

 

  • 람다식 사용법
  • 함수형 인터페이스
  • Variable Capture
  • 메소드, 생성자 레퍼런스

'JAVA > Basic' 카테고리의 다른 글

[스터디할래? Java] 목차  (0) 2021.05.17
[스터디할래? Java 15]lambda 람다  (0) 2021.05.15
[스터디할래? Java 14]제네릭  (0) 2021.05.15
[스터디할래? Java 13]I/O  (0) 2021.05.15
[스터디할래? Java 12]애노테이션  (0) 2021.05.15
[스터디할래? Java 11]enum  (0) 2021.05.15
728x90

[스터디할래? Java] 목차

이글은 백기선님 스터디 할래? 스터디를 뒤늦게 따라간 기록입니다.

스터디할래 링크 >> https://github.com/whiteship/live-study

이필기를 시작으로 공부했습니다 >>https://sujl95.tistory.com/73 ,  https://docs.oracle.com/javase/tutorial/java/generics/types.html

여기 없는내용은 스터디 할래 강의 내용 혹은 제가 java Doc보고작성하거나 예제를 만들어 추가했습니다.

그외는 같이 출처가 써있습니다. 

제네릭 data type을 클래스, 메소드에서 내부 데이터 타입을 제네릭으로 지정,
"컴파일과정에서 문제제거"
- jdk1.5 부터 도입 
- jdk 1.7 Diamond  <>: 타입안에 안써도됨, 타입추론
- 클래스나 메소드 내부에서 사용되는 객체의 타입을 컴파일과정에서 문제제거
- 반환값에 대한 타입변환 및 타입 검사에 들어가는 노력줄인다. 
- 타입국한 효과로 타입변환이 불필요해져 성능향상효과

A generic type is a generic class or interface that is parameterized over types. 
제네릭 타입은 타입에서 매개변수로 사용되는 클래스나 인터페이스
https://docs.oracle.com/javase/tutorial/java/generics/types.html 
제네릭 컴파일 ----- .java
        List<Integer> numbers = new ArrayList<>();
        numbers.add(3);
------.class
        List<Integer> numbers = new ArrayList();
        numbers.add(3);
컴파일할때 소거자에 대해 타입정보가 사라지는것 > 구체화타입ex) List
제네릭 사용법
제네릭 메소드 만들기
interface fruit<K,V>{                                           //클래스 
    public default K getKey() {return null;}
    public default V getValue() {return null;}
}
class Banana<K,V> implements fruit<K,V>{                // 상속시 

    public <T> boolean isBTime(List<T> list, T addvlaue) {  //메서드
        T value = list.get(0);
        V[] vArray =(V[]) new Object[2];                        // 배열 선언 
        if (value == addvlaue) return true;
        return false;
    }
}
와일드 카드 wild card 
-Unbounded WildCard
: List<?> :모든클래스
-Upper Bounded wildcard
: List<? extends Number>:특정타입자식클래스
-Lower Bounded Wildcard
: List<? super Number>: 특정타입 부모클래스


아무이름 컴파일은 문제없음 클래스, 메소드매개변수,반환값 가능

매개변수 명명 규약
E - Element (used extensively by the Java Collections Framework)
K - Key
N - Number
T - Type
V - Value
S,U,V etc. - 2nd, 3rd, 4th types
Erasure
Generics Type Erasure
List<Object> list = new ArrayList<Integer>();  >> 컴파일에러. 

메서드 수준

제네릭 특이점 - 원시타입 사용불가.
타입 파라메터 자리에 원시타입 사용안함>> 타입소거(Erasure)발생때문.. 명시안되면 Object로
>> Object클래스를 상속받으면서 하위호환성이지켜진다. >> Wrapper 클래스 사용. 

- 배열선언은 캐스팅이용
  V[] vArray =(V[]) new Object[2];            
new 연산자 동적메모리 할당영역 heap 영역에 생성한 객체 할당.
제네릭은 컴파일타임동작. Object 생성후 캐스팅하여 사용. 

- static 으로 사용불가. 
static 내부에선 제네릭사용가능
https://blog.naver.com/hsm622/222251602836
브리지 메서드 매개변수가 반환타입소거시 가끔 브리지메서드를 생성하는데 stackTrace에 가끔 나타나니 알아두기
public class A extends ArrayList<String>{
    public boolean add(String e){
        return super.add(e)
    }
}
A a = new A();
a.add("text"); 
https://rockintuna.tistory.com/102

Erasure 이레이저 삭제 말소

Conventions 규약

Unbounded  무한한

추천책 : 클라우드 네이티브 자바

 

 

리플렉션으로 볼수 있음.

 

 

  • 제네릭 사용법
  • 제네릭 주요 개념 (바운디드 타입, 와일드 카드)
  • 제네릭 메소드 만들기
  • Erasure

'JAVA > Basic' 카테고리의 다른 글

[스터디할래? Java] 목차  (0) 2021.05.17
[스터디할래? Java 15]lambda 람다  (0) 2021.05.15
[스터디할래? Java 14]제네릭  (0) 2021.05.15
[스터디할래? Java 13]I/O  (0) 2021.05.15
[스터디할래? Java 12]애노테이션  (0) 2021.05.15
[스터디할래? Java 11]enum  (0) 2021.05.15
728x90

[스터디할래? Java] 목차

이글은 백기선님 스터디 할래? 스터디를 뒤늦게 따라간 기록입니다. 

스터디할래 링크 >> https://github.com/whiteship/live-study

이필기를 시작으로 공부했습니다 >> https://www.notion.so/I-O-af9b3036338c43a8bf9fa6a521cda242

여기 없는내용은 스터디 할래 강의 내용 혹은 제가 java Doc보고작성하거나 예제를 만들어 추가했습니다.

그외는 같이 출처가 써있습니다. 

I/O Input & Ouput 입출력
java.io  // 데코레이션 패턴으로 만들어짐 : 
컴퓨터 내부 또는 외부장치와 프로그램간 데이터 주고받기. 
ex) 키보드 데이터 입력, System.out.println()
데코레이션패턴 객체의 타입, 메소드 그대로 유지하면서 새로운 책임을 추가할때 사용. 
탈부착가능한 책임. 
하기 코드 참고.
ex)
BufferedInputStream 담아 보내면 모아서 보내서 시스템 콜 횟수가 줄어서 성능이익
Stream 스트림이란 데이터를 운반하는데 사용되는 연결 통로. 
단방향 통신만 가능. 
먼저 보낸데이터 먼저, 중간에 건넘뜀없이 연속적
바이트 단위로 데이터 전송
AutoCloseable(1.7) <-Closeable(1.5) <- InputStream (1.0) <- FileInputStream (1.0)
                                               <- OutputStream (1.0) <- FileOutputStream (1.0)
InputStream/OutputStream 상속받은 클래스 종류

- FileInputStream / FileOutputStream : 파일
- ByteArrayInputStream / ByteArrayOutputStream
                                              : 메모리(Byte배열) > 메모리만써서 close필요없음
- PipedInputStream / PipedOutputStream : 프로세스간 통신
- AudioInputStream / AudioOutputStream :오디오 장치 

소스작성 흐름
1. FileInputStream : HDD에 존재하는 파일과 연결
2. InputStreamReader : 8bit Stream 16bit stream 연결, char변경(encoding)
3. BufferedReader : 스트림으로 연결된곳에서 줄단위로 읽음. readLine()
InputStream  InputStream 의 추상메서드 read()  --> reader

public abstract class InputStream implements Closeable {
    public abstract int read()  
* byte단위 전송, int값을 가져옴- 4byte중 1byte 이용 범위가 0~255 와 -1 이기때문.

    public int read(byte b[]) 
    public int read(byte b[], int off, int len) 
    public long skip(long n)               // 주어진길이만큼 건너뜀
    public int available()                    //스트림으로부터읽을수 있는 데이터 크기 반환
    public void close()                       // 닫고 사용하던자원반환
    public synchronized void mark(int readlimit) //현재 위치 표시. reset에의해 다시돌아감
    public synchronized void reset()     //스트림위치를 마지막 mark호출된위치 되돌림
    public boolean markSupported()    // mark reset 기능 제공하는지 확인

OutputStream  OutSteream 의 추상메서드 write()  --> writer

public abstract class OutputStream implements Closeable, Flushable {
    
    public abstract void write(int b)  주어진값출력소스에 쓴다. 
    public void write(byte b[])
    public void write(byte b[], int off, int len)
    public void flush()  : 스트림의 버퍼에 있는 모든 내용을 출력소스에 쓴다. 
    public void close()  : 입력소스 닫음으로써 사용하던 자원반납

}
보조 스트림 보조 스트림 : 기능향상, 새로운기능 추가.
각각 inputStream, OutputStream 상속
- FilterInputStream / FilterInputStream 
- BufferedInputStream / BufferedOutputStream
- DataInputStream/DataOutputStream
- SequenceInputStream /없음
- LineNumberInputStream/없음
- PushbackInputStream/없음
- 없음/PrintStream
표준입출력 콘솔을 통한 데이터 입력, 출력
System.in   : inputStream
System.out : PrintStream
System.err : printStream
FileReader /FileWriter FileReader(1.1) -> InputStreamReader(1.1)->Reader(1.1)--> Readable(1.5), Closerble(1.5)
Reader : 문자기반 스트림. byte배열대신 char 배열사용. 자동인코딩
4byte 중 2byte 사용해서 문자단위전송. 

FileReader fileReader = new FileReader("파일이름경로");
fileReader.read() ;
fileReader.close();
Byte스트림 vs Character스트림 Byte 스트림 : 8bit :한번에 전달하는양 작지만 속도빠름
InputStream - FileInputStream, ObjectInputStream, DataInpuStream
Char스트림: 16bit : 한번에 전달하는양 많지만 속도 느림. 
Reader : FileReader , InputStreamReader, BufferedReader
PipeReader /pipeWriter 입출력스트림을하나의 스트림으로 연결
직렬화 Serializable , 파일 읽을때쓸때, 웹에서 데이터 보내고 받을때 줄로보냄. 그때 사용. 
transient - 직렬화 제외
serialVersionUID = 버전관리,  
NIO New Input / Output 새로운 입출력(jdk1.4)
java.nio.channels : 파일채널, TCP, UDT 채널
java.nio.channels.spi java.nio.channels 위한 서비스 제공자. 
java.nio.charset 문자셋 인코더 디코더 API
java.nio.charset.spi
java.nio.file 파일 파일시스템 접근위한 서비스
java.nio.file.attribute 속성접근
java.nio.file.spi
java.nio.buffer
...
입출력방식은  IO는 스트림 NIO 는 채널방식  : 스트림은 매번 생성, 채널은 만들필요없음
버퍼 방식은   IO 넌버퍼,   NIO 는 버퍼 : IO는 넌버퍼라서 bufferedInputStream 연결사용
비동기방식   IO 지원안함 , NIO 지원   : 
프로킹/넌블로킹 IO 블로킹방식만 지원 : 동기, NIO 블로킹/넌블로킹 모두 지원
                                          블로킹(대기상태): IO는 인터럽트안되나 NIO는 가능    
                                          넌블로킹(쓰레드가 입출력시 블로킹안됨)
* NIO 전 FileReader 사용했음. FileWriter 사용 추천. 
Buffer 읽고 쓰기가 가능한 메모리 배열(일반)
데이터를 전송하는 상호간 장치에서 OS system core (저속)와 java api호출(고속) 장치간의 속도차이로 인해 저속 장치가 작업을 추리하는 동안 기다리는 현상 줄어짐
 buffer는 사이즈 지정이 가능, 효율관런 고려 가능

package java.nio;
public abstract class Buffer (1.4))
버퍼에 담았다 한번에 모아서 보냄. 입출력 횟수 줄어 성능이점
ByteBuffer, CharBuffer, DoubleBuffer, FloatBuffer, IntBuffer, LongBuffer, ShortBuffer
할당:
바이트버퍼.allocatedDirect(크기);
- 다이렉트    Direct      : 운영체제 관리 메모리공간 :생성시간 느림, 한번생성재사용, IMDG 참고
바이트버퍼.allocated(크기);
- 넌다이렉트 NonDirect : JVM 관리 힙 메모리 공간. :생성시간은빠름, 큰크기사용힘듬
https://docs.oracle.com/javase/7/docs/api/java/nio/Buffer.html
Channel 파일, 소켓, 데이터그램등과 같은 I/O소스로부터 데이터 블록을 버퍼로 쓰거나 읽음. 
- Socket과 연결, 입출력 역할 수행
- 입력과 출력을 동시 수행
- Selector와 연결, 하나Selector에 다수 채널 존재
- Blocking 스레드 깨우거나 다시 Blocking할수 있다. 
기존 IO 에서 쓰레드에 Reader, Writer만 존재해 Reader로 블로킹, Writer로 블로킹풀어줌
NIO 에서 Non-blocking방식, 쓰레드 -버퍼사이 터널을 만들어주는데 이것이 채널하는역할
package java.nio.channels;
public interface Channel extends Closeable {
https://adrian0220.tistory.com/150
selector java NIO에서 하나의 쓰레드에 여러개 연결이 있어
Selector를 이용해 어떤채널과 연결 선택, 
선택된 채널이 스레드와 버퍼 연결 진행하는게 NIO 매커니즘.  
NIO 파일 읽고 쓰기 package study;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class NIOReadeWrite {
    public static void main(String[] args) throws IOException {

        LocalDateTime localDateTime = LocalDateTime.now();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String contexts = localDateTime.format(formatter) +"  "+ "안녕하세요 \r\n";
        String path = "C:\\Users\\신미성\\Desktop\\test.txt";
        fileWrite(contexts, path);
        fileRead(path);
    }

    public static void fileWrite(String contents, String pathString) {
        Path path = Paths.get(pathString);
        try(FileChannel writeFileChannel
                    = FileChannel.open(path, StandardOpenOption.CREATE, StandardOpenOption.WRITE)){
            ByteBuffer byteBuffer =  Charset.defaultCharset().encode(contents);
            writeFileChannel.write(byteBuffer);
        }catch (IOException e){
            e.printStackTrace();
        }
    }

    private static void fileRead(String pathString) throws FileNotFoundException {
        Path path = Paths.get(pathString);
        if (!Files.exists(path))
            throw new FileNotFoundException("경로 없음");
        try(FileChannel readFileChannel = FileChannel.open(path, StandardOpenOption.READ)){
            ByteBuffer byteBuffer = ByteBuffer.allocate((int)Files.size(path));
            readFileChannel.read(byteBuffer);
            byteBuffer.flip();
            System.out.println(Charset.defaultCharset().decode(byteBuffer).toString());
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}


참고는 했으나.. 파일생성은 없었음.  : https://multifrontgarden.tistory.com/194
StandardOpenOption APPEND
CREATE                 없으면생성
CREATE_NEW         파일생성 있으면 에러남
DELETE_ON_CLOSE
DSYNC
READ
SPARSE
SYNC
TRUNCATE_EXISTING
WRITE

https://docs.oracle.com/javase/7/docs/api/java/nio/file/StandardOpenOption.html
IMDG IMDG(In Memory Data Grid)는 메인 메모리에 데이터를 저장
자바가 쓸수있는것보다 더큰메모리 저장가능

component 부품

decorate 꾸미다. 

책추천 : 유닉스의탄생

개발자취업  https://codesquad.kr/page/masters/curriculum.html

 

데코레이션패턴

package study;

public class CoffeDeco {
    public static void main(String[] args) {
        Latte latte = new Latte();
        System.out.println(latte);
    }
}

//component
abstract class Beans{
    protected String name="원두";
    public abstract double cost();
    public String getName() {return name; }
    public String toString(){return getName() +" : " +cost(); }
}
//deco
abstract class AddMilk extends Beans{
    public abstract String addMilk();
}
class Espresso extends Beans{
    Espresso(){name = "에스프레소"; }
    @Override
    public double cost() { return 1000;}
}
class Latte extends AddMilk{
    Latte(){name = "라떼"; }
    @Override
    public double cost() {return 3000;}
    @Override
    public String addMilk() {return "HALF"; }
    @Override
    public String toString() {
        return super.toString()+"(Milk:"+addMilk()+")";
    }
}

//참고사이트 : https://johngrib.github.io/wiki/decorator-pattern/
  • 스트림 (Stream) / 버퍼 (Buffer) / 채널 (Channel) 기반의 I/O
  • InputStream과 OutputStream
  • Byte와 Character 스트림
  • 표준 스트림 (System.in, System.out, System.err)
  • 파일 읽고 쓰기
728x90

[스터디할래? Java] 목차

이글은 백기선님 스터디 할래? 스터디를 뒤늦게 따라간 기록입니다.

스터디할래 링크 >> https://github.com/whiteship/live-study

이필기를 시작으로 공부했습니다 >> https://b-programmer.tistory.com/264 ,

                                                https://gowoonsori.site/java/annotation/

여기 없는내용은 스터디 할래 강의 내용 혹은 제가 java Doc보고작성하거나 예제를 만들어 추가했습니다.

그외는 같이 출처가 써있습니다. 

어노테이션 정의방법 @Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, MODULE, PARAMETER, TYPE})
public @interface Deprecated {

java.lang.Annotation 구현 from Bytecode
장점 : 유효성검사등 명시 , AOP 을 쉽게 구성할 수 있게해준다. 
용도 : 문서화, 컴파일러 체크, 코드 분석 자동생성, 런타임 프로세싱
완전히 정적이어야 한다. final. 
빌트인 어노테이션 Java에 내장되어 있는 어노테이션, 컴파일러를 위한 어노테이션
@Override
@Deprecated
@SuppressWarning
개발자가 의도를 가지고 만들었는데 컴파일이 알지못하고 경고를 띄울수있어 제거하는목적
@SafeVarargs
jdk7 제네릭 같은 가변인자 매개변수 사용시 경고 무시
@FunctionalInterface
메타 어노테이션 어노테이션 정의 하기 위해 사용
@Retention, @Target, @Documented, @Inherited, @Repeatable
@Retention 어노테이션 LIfe Time 적용범위
public enum RetentionPolicy {
    SOURCE,  // 소스파일에만 존재, 클래스파일존재 안함
    CLASS,    // 클래스파일에만 존재, 런타임유지 필요없음 
                // default : class
    RUNTIME // 클래스파일에도 존재하고 런타임에 VM에 의해 유지, ==> 리플렉션 정보읽기가능
}
// 정말 Runtime 설정이 필요한 정보인가? 
리플렉션
XXXController.class.getAnnotation();
XXXController.class.getDeclardAnnotations();//클래스에 정의되어 있는것만

@Target 어노테이션 적용대상
public enum ElementType {
    TYPE,   //Class, Interface, enum , recode(JDK14)
    FIELD,
    METHOD,
    PARAMETER,  // 매개변수
    CONSTRUCTOR,
    LOCAL_VARIABLE,
    ANNOTATION_TYPE,
    PACKAGE,
//1.8 이후 추가. 
    TYPE_PARAMETER,  //타입메개변수
//jdk 9이후
    TYPE_USE,
    MODULE,
//jdk 14
    RECORD_COMPONENT
}
@Documented 어노테이션 정보 javaDoc 작성된 문서에 포함. 생성된문서가 어노테이션인지 여부가 차이가남.
@Inherited 부모에 이설정이 있는 어노테이션이 있으면 
자식도 같이 씀.  (하기 예시참조)
@Repeatable 어노테이션을 반복적으로 선언할 수 있게 하는 어노테이션
애노테이션 프로세서 어노테이션을 프로세싱 하는기술.
컴파일타임에 어노테이션들을 프로세싱하는 javac에 속한 빌드 툴로 어노테이션
소스코드를 분석하고 처리하기 위해 사용되는 훅. 
- 보일러플레이트코드 제거하는데 도움이 된다. 
: AbstractProcessort 구현하여 만들고 getter/setter 컴파일타임에 만들어서 보일러 플레이트 코드 제거.
marker annotation 메서드 선언 없는 인터페이스
ex) Serializable, Cloneable
public interface Serializable {
}
   

어노테이션 에노테이션 에너테이션 어너테이션

 

책추천: 

아웃라이어... 1만시간....

부의 추월차선.....사업.  5일을 노예처럼일하고. 노예처럼일하기위해 2일을 쉰다. 

 

XDoclet 엑스닥렛 java5.... 에노테이션 전신

 

ServiceLoader : JAR 파일에 포함된 구성 파일을 읽어서 인터페이스 구현을 찾고, 구현을 선택한 오브젝트의 목록으로 사용. 

serviceLoader.load(XXXX.class)

 

@Inherited

package study;

import java.lang.annotation.Annotation;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface InheritedAnnotation {
}

@Retention(RetentionPolicy.RUNTIME)
@interface notInherit{
}
@InheritedAnnotation
class A {}
@notInherit
class B {}
class AA extends A {}
class BB extends B {}

class test{
    public static void main(String[] args) {
        Class AAClass = AA.class;
        Class BBClass = BB.class;

        Annotation[] AAAnnotations =AAClass.getAnnotations();

        for (int i = 0; i < AAAnnotations.length; i++) {
            System.out.println(AAAnnotations[i]);
        }
        Annotation[] BBAnnotations =BBClass.getAnnotations();

        for (int i = 0; i < BBAnnotations.length; i++) {
            System.out.println(BBAnnotations[i]);
        }
    }
}

 

728x90

[스터디할래? Java] 목차

이글은 백기선님 스터디 할래? 스터디를 뒤늦게 따라간 기록입니다.

스터디할래 링크 >> https://github.com/whiteship/live-study

이필기를 시작으로 공부했습니다 >> https://xxxelppa.tistory.com/204?category=858435 , 

여기 없는내용은 스터디 할래 강의 내용 혹은 제가 java Doc보고작성하거나 예제를 만들어 추가했습니다.

그외는 같이 출처가 써있습니다. 

 

enum정의 public enum TODAY {
    MORNING,
    AFTERNOON
}

public enum TODAY_TIME {
    MORNING(6, 11),
    AFTERNOON(12, 6);
    private int startTime;
    private int endTime;

    TODAY_TIME(int startTime, int endTime) {
        this.startTime = startTime;
        this.endTime = endTime;
    }

    public int getStartTime() {
        return this.startTime;
    }

    public int getEndTime() {
        return this.endTime;
    }
}

내부 static
values() vs  valueOf() values : 선언 상수를 배열로 반환, 컴파일되며 생김
valueOf : enum 존재 상수를 가져올때. 상속 받음,  jdk8기준 없으면 illegalArgumentException
ordinal()  TODAY_TIME.AFTERNOON.ordinal()  //1
ordinal  서수 , enum 클래스에 나열된 상수가 몇번째 나열되어있는지. 
zero base 로 넘버링 한 위치를 반환. 
EnumSet, EnumMap 에서 사용.. 내부용
java.lang.Enum enum 은 java.lang.Enum 클래스 상속받음. - 아래 바이트 코드 참고. 
생성자 : Sole constructor : 컴파일러 사용, 사용자 직접 호출사용불가. 
  /**
     * Sole constructor.  Programmers cannot invoke this constructor.
     * It is for use by code emitted by the compiler in response to
     * enum type declarations.
     *
     * @param name - The name of this enum constant, which is the identifier
     *               used to declare it.
     * @param ordinal - The ordinal of this enumeration constant (its position
     *         in the enum declaration, where the initial constant is assigned
     *         an ordinal of zero).
     */
    protected Enum(String name, int ordinal) {
        this.name = name;
        this.ordinal = ordinal;
    }
EnumSet java.util
Set자료구조특징. 중복허용 안함. 
EnumSet<TODAY_TIME> todayTimeAllSet = EnumSet.allOf(TODAY_TIME.class);
EnumSet todayTimeSet = EnumSet.of(TODAY_TIME.AFTERNOON);
EnumSet todayTimeAt =todayTimeAllSet.complementOf(todayTimeSet);  //특정상수제외
System.out.println(todayTimeAllSet.range(TODAY_TIME.MORNING,TODAY_TIME.AFTERNOON));
// 출력 : [MORNING, AFTERNOON][MORNING, AFTERNOON]

EnumSet은 왜 생성자를 사용자가 호출할수있게만들었을까?
1. ReqularEnumSet 개수적을때  JumboEnumSet 많을때
개발한 사람이 구현 객체 발환해준다면.. 사용입장에서 접합한지 몰라도된다 
2. 사용자는 빈번하게 EnumSet초기화 진행가능
3. 확장성, 유지보수
EnumMap EnumMap<TODAY_TIME> enumMap = new EnumMap<>(TODAY_TIME.class)

enum 에넘, 이늄, 열거형

 

추천책 : 토비의 스프링.

하이버네이트 : java persistence ,> 번역서  하이버네이트 

                      JPA 프로그래밍

----------

type safey

- 타입에 안정적

- query DSR 각광.  http://www.querydsl.com/

------------

jpa 맵핑시

enum Fruit{

    kiwi, apple, banana

}

@Enumerated(EnumType.STRING)

Fruit fruit;

 

EnumType.STRING

EnumType.ORDINAL  

--------------------

private final static String hello = "/hello";

@GetMapping(hello)  << final 만 참조. "변하지않는값'

---------------------

순서 정의할때 1,2,3 보다는 10,20,30으로 정의 

---------------------

Enum 싱글톤으로 쓸수 있다. 

spring에서  @Component 하면 싱글톤을 사용할수 있다. 

---------

리플렉션 : 객체를 통해 클래스의 정보 분석해내는 기법

Calss c = Data.class;

 

 

 

바이트코드

// class version 52.0 (52)
// access flags 0x4031
// signature Ljava/lang/Enum<Lstudy/TODAY_TIME;>;
// declaration: study/TODAY_TIME extends java.lang.Enum<study.TODAY_TIME>
public final enum study/TODAY_TIME extends java/lang/Enum {

  // compiled from: TODAY_TIME.java

  // access flags 0x4019
  public final static enum Lstudy/TODAY_TIME; MORNING

  // access flags 0x4019
  public final static enum Lstudy/TODAY_TIME; AFTERNOON

  // access flags 0x2
  private I startTime

  // access flags 0x2
  private I endTime

  // access flags 0x101A
  private final static synthetic [Lstudy/TODAY_TIME; $VALUES

  // access flags 0x9
  public static values()[Lstudy/TODAY_TIME;
   L0
    LINENUMBER 5 L0
    GETSTATIC study/TODAY_TIME.$VALUES : [Lstudy/TODAY_TIME;
    INVOKEVIRTUAL [Lstudy/TODAY_TIME;.clone ()Ljava/lang/Object;
    CHECKCAST [Lstudy/TODAY_TIME;
    ARETURN
    MAXSTACK = 1
    MAXLOCALS = 0

  // access flags 0x9
  public static valueOf(Ljava/lang/String;)Lstudy/TODAY_TIME;
    // parameter mandated  name
   L0
    LINENUMBER 5 L0
    LDC Lstudy/TODAY_TIME;.class
    ALOAD 0
    INVOKESTATIC java/lang/Enum.valueOf (Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
    CHECKCAST study/TODAY_TIME
    ARETURN
   L1
    LOCALVARIABLE name Ljava/lang/String; L0 L1 0
    MAXSTACK = 2
    MAXLOCALS = 1

  // access flags 0x2
  // signature (II)V
  // declaration: void <init>(int, int)
  private <init>(Ljava/lang/String;III)V
    // parameter synthetic  $enum$name
    // parameter synthetic  $enum$ordinal
    // parameter  startTime
    // parameter  endTime
   L0
    LINENUMBER 11 L0
    ALOAD 0
    ALOAD 1
    ILOAD 2
    INVOKESPECIAL java/lang/Enum.<init> (Ljava/lang/String;I)V
   L1
    LINENUMBER 12 L1
    ALOAD 0
    ILOAD 3
    PUTFIELD study/TODAY_TIME.startTime : I
   L2
    LINENUMBER 13 L2
    ALOAD 0
    ILOAD 4
    PUTFIELD study/TODAY_TIME.endTime : I
   L3
    LINENUMBER 14 L3
    RETURN
   L4
    LOCALVARIABLE this Lstudy/TODAY_TIME; L0 L4 0
    LOCALVARIABLE startTime I L0 L4 3
    LOCALVARIABLE endTime I L0 L4 4
    MAXSTACK = 3
    MAXLOCALS = 5

  // access flags 0x1
  public getStartTime()I
   L0
    LINENUMBER 17 L0
    ALOAD 0
    GETFIELD study/TODAY_TIME.startTime : I
    IRETURN
   L1
    LOCALVARIABLE this Lstudy/TODAY_TIME; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x1
  public getEndTime()I
   L0
    LINENUMBER 21 L0
    ALOAD 0
    GETFIELD study/TODAY_TIME.endTime : I
    IRETURN
   L1
    LOCALVARIABLE this Lstudy/TODAY_TIME; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x8
  static <clinit>()V
   L0
    LINENUMBER 6 L0
    NEW study/TODAY_TIME
    DUP
    LDC "MORNING"
    ICONST_0
    BIPUSH 6
    BIPUSH 11
    INVOKESPECIAL study/TODAY_TIME.<init> (Ljava/lang/String;III)V
    PUTSTATIC study/TODAY_TIME.MORNING : Lstudy/TODAY_TIME;
   L1
    LINENUMBER 7 L1
    NEW study/TODAY_TIME
    DUP
    LDC "AFTERNOON"
    ICONST_1
    BIPUSH 12
    BIPUSH 6
    INVOKESPECIAL study/TODAY_TIME.<init> (Ljava/lang/String;III)V
    PUTSTATIC study/TODAY_TIME.AFTERNOON : Lstudy/TODAY_TIME;
   L2
    LINENUMBER 5 L2
    ICONST_2
    ANEWARRAY study/TODAY_TIME
    DUP
    ICONST_0
    GETSTATIC study/TODAY_TIME.MORNING : Lstudy/TODAY_TIME;
    AASTORE
    DUP
    ICONST_1
    GETSTATIC study/TODAY_TIME.AFTERNOON : Lstudy/TODAY_TIME;
    AASTORE
    PUTSTATIC study/TODAY_TIME.$VALUES : [Lstudy/TODAY_TIME;
    RETURN
    MAXSTACK = 6
    MAXLOCALS = 0
}

 

 

 

 

 

 

  • enum 정의하는 방법
  • enum이 제공하는 메소드 (values()와 valueOf())
  • java.lang.Enum
  • EnumSet
728x90

[스터디할래? Java] 목차

이글은 백기선님 스터디 할래? 스터디를 뒤늦게 따라간 기록입니다.

스터디할래 링크 >> https://github.com/whiteship/live-study

이필기를 시작으로 공부했습니다 >> https://sujl95.tistory.com/63 

                                               , https://wisdom-and-record.tistory.com/48

여기 없는내용은 스터디 할래 강의 내용 혹은 제가 java Doc보고작성하거나 예제를 만들어 추가했습니다.

그외는 같이 출처가 써있습니다. 

 

프로세스 와 쓰레드 프로세스 : 자원(resources, 데이터+메모리) + 쓰레드 
쓰레드 : 프로세스의 자원을 이용해 셀제 작업을 수행하는것. 
 Runnable vs Thread Runnable : 함수형인터페이스
package java.lang;
public interface Runnable {       
    public abstract void run();
}
---------------
Thread : 클래스, 쓰레드 그룹등 사용가능 
package java.lang;
public class Thread implements Runnable {

--------------
run() 말고 다른것도 재정의가 필요하면 thread상속, run()만 수정하면 Runnble 사용. 
thread는 순서대로 실행되지 않는다. 
suspend(), resume(), stop()//쓰레드종료 안전성때문에 Deprecated
쓰레드는 코어수와 비례
Thread 종류 - 일반쓰레드 : 
- 데몬쓰레드 : 일반쓰레드 보조역할, GC.자동저장, 갱신등 사용. 
                   일반쓰레드 종료시 같이 종료. 보통무한루프로 구현.
                   쓰레드.setDaemon(True) 하면 데몬쓰레드 지정

- 메인쓰레드 : 프로그램 시작시 가장 먼저 실행 쓰레드, 
public static void main(Stringp[] args){}  메인 쓰레드의 시작점 선언
따로 쓰레드 실행하지 않고 main() 메소드만 실행하면 싱글 쓰레드 애플리케이션

JVM -> Other Daemon Threads(ex_ Gc)
       -> MainThread -> Child ThreadA
                            -> Child ThreadB -> child ThreadC
                            ->         ...
Thread 메서드 static void sleep(long millis) : 지정시간 쓰레드 일시정지 -> TIMED_WAITING
void join()   : (지정시간)실행, 호출한 쓰레드 일시정지 호출 실행 완료 후에 재개
void join(long millis)
void interrupt() : sleep(), join() 일시정지 -InterruptedException->  실행대기로 만듬
static void yield() : 실행중에 자신에게 주어진 실행시간 다른쓰레드 양보, 자신은실행대기
public synchronized void start() 호출
쓰레드의 상태     public enum State {
        NEW,                  //객체만 생성 start() 미호출
        RUNNABLE,          // start() 쓰래드 실행
        BLOCKED,            //쓰레드 실행중지, 락이 풀리는것 대기
        WAITING,            //쓰레드 대기중
        TIMED_WAITING,  //특정 시간만큼  대기중 
        TERMINATED;      //쓰레드가 종료
    }

New  -(start())----> Runnable              -> Terminated
                           --------------------
                          -> Blocked
                          -> Waiting           
                          -> Timed Wating 
쓰레드의 우선순위 쓰레드.setPriority(int newPriority)
    public final static int MIN_PRIORITY = 1;       //최소
    public final static int NORM_PRIORITY = 5;   //기본값
    public final static int MAX_PRIORITY = 10;    //최대
runnable vs callable  Runnable :어떤 객체도 리턴하지 않음 , Exception발생시키지 않음
Callable: 특정타입 객체 리턴 Exception 발생가능
public interface Callable<V> {
    V call() throws Exception;
}
https://codechacha.com/ko/java-callable-vs-runnable/
Object의
thread관련 메소드
wait() , wait(long timeout), wait(long timeout, int nanos)
: 동기화블록내  쓰레드를 해당객체 waiting pool에 넣는다. 
notify(), notifyAll()
: 동기화블록내 waitng pool 대기중인 쓰래드를 깨운다. 
synchronized 동기화 
: 여러개의 쓰레드가 한 개의 리소스를 사용하려고 할 때 사용 하려는 쓰레드를 제외한 나머지 접근못하게 함. (Thread-safe)

구현
- Synchronized 키워드 : 동기화블록, 메소드 선언시, 메소드내 특정 문장 감싸기
                                범위가 좁게 사용하는것을 추천. 그래서 동기화블록사용이 적합..
- Atomic 클래스: java.util.concurrent
: 여러쓰레드 접근해도 원자적 접근 데이터 구조 ,한쓰레드씩 접근사용.
- Volatile 키워드 : java 변수를 메인메모리 저장 명시, multi thread 환경 cpu cache값 불일치 문제 때문에 사용. ,한쓰레드씩 접근사용.

Lock  jdk1.5 락. : 상호 배재를 사용할수 있는 클래스 제공
package java.util.concurrent.locks;
public interface Lock {
    void lock();                  // 잠근다.
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();               //해지한다.
    Condition newCondition();
}
lock구현체
- ReentrantLock              : 재진입가능, 가장일반적임
- ReentrantReadWriteLock : 읽기공유가능 쓰기 lock
- StampedLock                 : ReentrantReadWriteLock 에 기능추가. 
DeadLock   교착상태 
둘 이상의 쓰레드가 lock 을 획득하기 위해 대기 하는데 
대기하는 쌍방이 우위를 가리수 없어 어느쪽도 진행되지 않는상태(block)

Thread 1 rocks A, waits for B
Thread 2 locks B, waits for A

동시성 vs 병렬성 concurrency programming model,
: 동시성 프로그래밍 모델 ex_자바쓰레드

Parallelism programing model
: 병렬성 프로그래밍 모델
- critical path : 동시 실행 하는것중 가장 긴거.. 이것을 줄여야 수행시간이 줄다.
----
-----------
---- 
              -----------------
              -----
              -------
                                  ---------
                                  -------------
                                  --------
race condition: 어떻게 접근하느냐에 따라 결과가 달라지는 경우. 

추천책 : 자바 병렬프로그래밍...이출판사 번역신경쓰니참고.

 

thread.. 서버 수준 구현 할때만 필요. ex) tomcat

톰캣 최종분석...톰캣을 만들어봄.... ㅋㅋㅋOTL

요즘 컨테이너는 NIO Connector 사용...

 

동시 프로그래밍 모델: concurrency programing model 

 - 예 자바 쓰레드, Actor Model -아카..., STM(Software Trancsaction memory)- closer

  당시 actor가 가장빠름. contention 이 없어서.. 자원충돌날것이 없음. 

동시성 vs 병렬성

free lunch is over 

: CPU 클럭속도 한계가 와서 더많은 코어를 잘쓸수있는 방향으로. >>멀티쓰레딩 패러다임이 바뀌고 있다. 

무어의 법칙이... 주춤해짐...년 혹은 18개월마다 반도체의 집적도는 2배가 된다

 

Volatile 볼레틸 휘발성 

 

Thread, runnable 구현

package study;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadExample  {
    public static void main(String[] args) {
        Thread byThread = new ThreadByThread();
        byThread.start();

        Runnable runnable  = new ThreadByRunnable();
        Thread byRunnable = new Thread(runnable);
        //byRunnable.run();

        byRunnable.start();
        Lock lock= new ReentrantLock();
    }

    public static void print(String threadInfo , int num){

        for (int i =0; i<100;i++)
            System.out.println(threadInfo + " | " + num);
    }
}

class ThreadByThread extends Thread{
    @Override
    public void run() {
        ThreadExample.print(Thread.currentThread().getName(), 1);
    }
}

class ThreadByRunnable implements Runnable{
    @Override
    public void run() {
        ThreadExample.print(Thread.currentThread().getName(),0);
    }
}

강사님 설명소스. 

package study;

public class ThreadExample  {
    public static void main(String[] args) {
        Thread byThread = new ThreadByThread();
        byThread.start();

        new Thread(()->ThreadExample.print(Thread.currentThread().getName(), 0)).start();
    }

    public static void print(String threadInfo , int num){

        for (int i =0; i<100;i++)
            System.out.println(threadInfo + " | " + num);
    }
}

class ThreadByThread extends Thread{
    @Override
    public void run() {
        ThreadExample.print(Thread.currentThread().getName(), 1);
    }
}

  • Thread 클래스와 Runnable 인터페이스
  • 쓰레드의 상태
  • 쓰레드의 우선순위
  • Main 쓰레드
  • 동기화
  • 데드락
728x90

[스터디할래? Java] 목차

 

이글은 백기선님 스터디 할래? 스터디를 뒤늦게 따라간 기록입니다.

스터디할래 링크 >> https://github.com/whiteship/live-study

이필기를 시작으로 공부했습니다 >>  https://www.notion.so/3565a9689f714638af34125cbb8abbe8

여기 없는내용은 스터디 할래 강의 내용 혹은 제가 java Doc보고작성하거나 예제를 만들어 추가했습니다.

그외는 같이 출처가 써있습니다. 

 

 

자바제공하는 예외 계층구조 Object <- Throwable <- Error :치명적 시스템오류 해결불가. 
                            <- Exception <- RuntimeException : unchecked Exception
                                              <- RE 아닌 Exception : checked Exception
Exception vs Error 오류 :Error : 시스템의 비정상적인 상황이 생겼을때. 시스템레벨, 심각한수준 오류.  예측불가
                개발자가 상속받지도, 사용할필요 없음. 
예외 :Exception : 개발자가 구현한로직에서 발생, 미리 예측 처리
RuntimeException vs RE가 아닌 Exception RuntimeException : Unchecked Exception
: 예외처리 하지 않아도 됨.
ex) IOException, SQLException

RE 아닌 Exception : checked Exception
: 반드시 예외 처리. 
NullPointException, IllegalArgumentException

https://cheese10yun.github.io/checked-exception/
throw vs throws throws 현재 메서드에서 호출한 "상위 메서드로 Exception 발생"
throw : 현재 메서드에  프로그래머가 일부러 에러를 발생시킬때  throw new XXXException();
예외 처리방법 1. 예외 복구 : 예외 발생시 다른작업 흐름유도
   : try -catch ~final
2. 예외처리 회피(전파) : 처리하지 않고 호출한 쪽으로 던짐
   : throw ~.. 
3. 예외 전환 : 호출한쪽으로 명확한 의미 전달하기위해 다른예외 전환던짐
    : try -catch( 특정예외 e ){throw 커스텀예외} ~final
from 토비의 스프링 3.1 Vol.1 4장 예외
(최종까지 예외 발생시 예외처리후 해당 쓰레드 종료. )
커스텀한 예외 만드는법.  커스텀예외 참고4가지
1. 항상 이익이 있어야 한다. jdk 있으면 ..있으면있는거 써라
2. 네이밍 규칙 따르기
3. 자바doc을 작성하세요. 
4. 커스텀 예외 던지기전 예외의 이유를 작성하자. 
    원래 발생한 에러가 있으면 같이 전달.  생성자에 Throwable cause 변수 추가. 
(참고. https://m.blog.naver.com/sthwin/221144722072, https://dzone.com/articles/implementing-custom-exceptions-in-java?fromrel=true)
 예외처리 비용.  예외 발생시 발생메서드의 Stack Trace를 모두 메모리에 담고있어야함>> 비용
예외처리로 비즈니스로직 처리 피하는 이유 
로직으로 할수 있는것은 예외던지는것보다 값을 리턴하는게 비용적으로 이득. 
try - catch - finally catch 여러 줄일때 상속관계 인지 주의 할것. 상위 상속관계가 뒤에 
finally 안에 return 을 쓰는 것은 anti 패턴.  finally에 리턴이 있음 try 리턴작동안함. 
e.printStackTrace 로그로 출력하면 안되는 정보들 주의 -개인정보
Multicatch블록 JDK 1.7, 역시 부모자식관계 주의 
try{         }catch(예외1 | 예외2 | 예외3 e) {         }
메서드체이닝 여러 메서드 호출을 연결해 하나의 실행문 표현. 
Init init = new Init();
init.set1(1); init.set2(2); init.set3(3);
메서드 체이닝 :  init.set1(1).set2(2).set3(3);
- setN메서드의 리턴값으로 this를 반환 해서 만듬. 
try-with-resource -알아서 close처리. finally 생략 가능해짐
--컴파일코드 보면 다중 try catch 문이 생기고 catch 블록에서 Throwble로 잡아 close를 해줌. 마지막에도 close()호출. (아래 컴파일 전후 확인)
메이븐 >라이프사이클>컴파일> 타켓 폴더 생성 해당 class파일 확인
@Cleanup -lombok close를 호출해줌.  알고만있고 try-with -resource.로~
   
   
   
   
   
트랜젝션 스프링 기본 트랜젝션 전략에서... 설정을 확인할필요. 
기본적으로 Checekd Exception은 Rollback 하지 않고
unchecked Exception 은 Rollback됨.
스택프레임 스택영역에서 함수 호출 끝난뒤에 돌아갈 정보들을 쌓아놓은곳을 스택프래임이라고한다. 
많이쓰는 기본예외 런타임아닌익셉션 계열 : checked 예외
ClassNotFoundException 
FileNotFoundException 
IOException 
InterruptedException : 특정쓰레드 작업 멈춰달라..
NoSuchMethodException 

RuntimeException계열 : unchecked예외
ArithmeticException : 산술(Arithmetic)연산
ArrayIndexOutOfBoundsException : 배열 인덱스 넘어갈때 
NullPointerException
NumberFormatException
StringIndexOutOfBoundsException
illegalargumentexception 값이 잘못들어옴. 

GoF의 다자인패턴. 

surrond with .. :ctrl alt T

리펙터링 책추천. http://www.yes24.com/Product/Goods/89649360

 

try-with-resource

package study;

import java.io.FileInputStream;
import java.io.InputStream;

public class TryCatchResource {



    public static void main(String[] args) {
        try(InputStream inputStream = new FileInputStream("없는파일.xml")){
            System.out.println(inputStream.toString());
        }catch (Exception e){

        }finally {

        }

    }
}





















package study;

import java.io.FileInputStream;
import java.io.InputStream;

public class TryCatchResource {
    public TryCatchResource() {
    }

    public static void main(String[] args) {
        try {
            try {
                InputStream inputStream = new FileInputStream("없는파일.xml");
                Throwable var2 = null;

                try {
                    System.out.println(inputStream.toString());
                } catch (Throwable var20) {
                    var2 = var20;
                    throw var20;
                } finally {
                    if (inputStream != null) {
                        if (var2 != null) {
                            try {
                                inputStream.close();
                            } catch (Throwable var19) {
                                var2.addSuppressed(var19);
                            }
                        } else {
                            inputStream.close();
                        }
                    }

                }
            } catch (Exception var22) {
            }

        } finally {
            ;
        }
    }
}

 

 

Q1 아래 소스 문제는?

답 : close에 try catch블록이 없다.in 닫을 때 예외 발생하면 out 못닫음 

출처 : 백기선의 스터디할래 강의

Q2 뭣이출력

답: 3

package study;

public class TryCatchFinal {

    public static void main(String[] args) {

       int num = onTryCatchFinally();
        System.out.println(num);
    }

    private static int onTryCatchFinally() {

        try {

            return 1;
        }catch (Exception e){
            return 2;
        }finally {
            return 3;
        }
    }
}

 

package study;

public class TryCatchFinal {

    public static void main(String[] args) {

       int num = onTryCatchFinally(100);
        System.out.println(num);
    }

    private static int onTryCatchFinally(int num) {

        try {
            if (num ==100){
                new RuntimeException();
            }
            return 1;
        }catch (Exception e){
            return 2;
        }finally {
            return 3;
        }
    }
}
728x90

[스터디할래? Java] 목차

이글은 백기선님 스터디 할래? 스터디를 뒤늦게 따라간 기록입니다.

스터디할래 링크 >> https://github.com/whiteship/live-study

이필기를 시작으로 공부했습니다 >> https://www.notion.so/4b0cf3f6ff7549adb2951e27519fc0e6

여기 없는내용은 스터디 할래 강의 내용 혹은 제가 java Doc보고작성하거나 예제를 만들어 추가했습니다.

그외는 같이 출처가 써있습니다. 

 

인터페이스 규약. : 개발기간 단축, 결합도 낮주기, 표준화 

구성
-상수
-추상메소드     : 재정의 하여 사용
-디폴트 메소드  jdk8  : 재정의 가능
-스테틱 메소드  jdk8  : 변경불가

구현방법
- 상속
- 익명클래스 

다중상속
- 동일 이름 메서드 있을때. 재정의 필요. 
@Overide
public void sameMethod(){
  AInterface.super.sameMethod();
  BInterface.super.sameMethod();
}
-동일 이름 static 메서드
재정의가 안됨. 
-동일 이름 메서드 부모 static, 자식 default
 호출방법이 다름. 
- 동일이름 메서드 무보 default 자식 static
  불가. 
추상클래스
vs 인터페이스
public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

링크드 리스트는 "추상 순차 목록"이다. "List, Deque, Cloneable, Serializable" 을 할수 있다.
해당 클래스는 "추상~~~클래스"이다. "인터페이스" 을 할수 있다. 
클래스타입레퍼런스
vs 인스턴스 레퍼런스
클래스타입레퍼런스 : CalssA  classA = new CallsA();
인스턴스타입레퍼런스 : List<String> stringList = new ArrayLIst<>();
강한결합 vs 느슨한결합 강한결합: 코드 변경필요 :빠르지만 변경불리
기존 : A -> B
추가 : A -> C ->B or A->B->C
느슨한 결합 :코드변경 필요없음: 느리지만 유연하고 변경 유리
기존 : A--->I , I->B
추가: C --->I
default Method java8
등장이유 : 하위 호환성, 오픈소스코드에서 메소드가 추가되었을때 오류가 발생할수있다. 
from 자바의 신
이전에는 Handler 기능이 필요하면 추상클래스 adoptor를상속받아 일부만 구현할수 있게했음

public interface HandlerInterceptor {
    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return true;
    }
static method java8
File의
 public static File[] listRoots() {
        return fs.listRoots();
    }
private method java9

1. private 메소드는 구현부를 가져야한다. 
2. 오직인터페이스 내부에서만사용가능
3. private static 메소드는 다른 static, static아닌 메소드에서 사용가능 ??? 아직모르겠다. 
4. static이 아닌 private메소드는 private static  메소드에서 상용불가
private static method java9
File의 
  private static String slashify(String path, boolean isDirectory) {
        String p = path;
        if (File.separatorChar != '/')
            p = p.replace(File.separatorChar, '/');
        if (!p.startsWith("/"))
            p = "/" + p;
        if (!p.endsWith("/") && isDirectory)
            p = p + "/";
        return p;
    }
자바 8 이후 추상클래스 자바8 , 9 기준 인터페이스 에서 못하는부분이 남아있음. 

public abstract class AbstractJoinMember {
   private String message  =""
   public void setMessage(String message){
   }
}

인터페이스 구현불가 : private 상수.  자바8기준 private 안됨. 
Constant Interface 안티패턴임. 사용하지 마세요~
1. 상수포함하여 모두 가져오고 계속가지고있음
2. 컴파일때 사용 런타임때 용도없음
3. 이진호환성을 필요로할때  계속유지
4. IDE가 없으면 상수 implement한 클래스에서 상수 사용할 때 네임스페이스 사용하지 않음 
    네임스페이스도 인터페이스 상수들로 오염
5. 인터페이스 구현해 클래스를 만드는 것은 클라이언트에게 알리는 행위... 혼동
6. 의도치 않은 현상 발생
https://jessyt.tistory.com/78
안티패턴 소프트웨어 공학 분야 용어이며, 실제 많이 사용되는 패턴이지만 비효율적이거나 비생산적인 패턴을 의미한다. 

 

 

extract method : 리펙토링메뉴. ????

https://spark.adobe.com/sp/design/page/new?_branch_match_id=623005067329261293 

로고, 아이콘만들때. 

비폭력 대화 

 

  • 인터페이스 정의하는 방법
  • 인터페이스 구현하는 방법
  • 인터페이스 레퍼런스를 통해 구현체를 사용하는 방법
  • 인터페이스 상속
  • 인터페이스의 기본 메소드 (Default Method), 자바 8
  • 인터페이스의 static 메소드, 자바 8
  • 인터페이스의 private 메소드, 자바 9
728x90

[스터디할래? Java] 목차

이글은 백기선님 스터디 할래? 스터디를 뒤늦게 따라간 기록입니다.

스터디할래 링크 >> https://github.com/whiteship/live-study

이필기를 시작으로 공부했습니다 >>  https://kils-log-of-develop.tistory.com/430

                                                https://sangwoobae.github.io/posts/java-livestudy-7week/

여기 없는내용은 스터디 할래 강의 내용 혹은 제가 java Doc보고작성하거나 예제를 만들어 추가했습니다.

그외는 같이 출처가 써있습니다. 

package 키워드 패키지 이름은 java로 시작하면안된다. 
소스 첫줄, 
폴더이름과 패키지 이름이 같아야
FQCN : Fully Qualified Class Name : 패키지이름과 정의된 클래스 모 표현되야 정확한 표현
ex) java.lang.String
FQCN  FQCN : Fully Qualified Class Name : 패키지이름과 정의된 클래스 모 표현되야 정확한 표현
패키지이름 규칙 java : 자바기본 패키지
javax : 자바 확장패키지
org : 비영리단체(오픈소스) 패키지
com : 영리단체(회사) 패키지

패키지 이름은 모두 소문자. 
자바 예약어 사용불가

빌트인 패키지 : 자바는 개발자들이 사용하는 패키지, 클래스 제공
ex) import java.lang.System, import java.lang.String
import 키워드 import 패키지*  사용가능. 
import static 

* import 하지 않아도 되는 패키지
java.lang, 같은패키지
접근제어자 public            누구나 접근
protected       같은패키지, 상속받은경우
private-package  = default  : 같은패키지내
private            해당클래스내 
클래스 패스 JVM이 프로그램 실행할때 클래스파일을 찾는데 기준되는 파일경로. 
- java runtime -classpath 
- javac -classpath
- 환경변수 CLASSPATH  안하는쪾으로..개발할때 라이브러리 꼬일수있음. 
CLASSPATH=
클래스 패스 옵션은 언제 쓸수 있나? 둘다 or javac or java   >> 둘다 쓸수 있다. 
cf)
maven pom.xml scop- runtime, provied.. 의존성설정 관련되어있다고함. 
클래스 로더.  java 에 3가지 기본 클래스 로더 존재
Bootstrap class loader
: 최상위 클래스 로더, jre/lib/rt.jar 에 담긴 JDK 클래스 파일 로딩
: 원시 클래스 로더 : Primordial ClassLoader
Extension class loader
: jre/lib/ext , java.ext.dirs 로 지정된 클래스파일 로딩. 
Application class loader
: classpath 나 jar 파일 안에 있는 Manifest파일의 class-path 속성값으로 지정된 폴더의 클래스 로딩
: 자가 애플리케이션 구동을 위해 직접 작성한 대부분클래스는 애플리케이션 클래스 로더에 의해로딩

동작 3원칙
1. 위임 : 클래스 로딩 작업을 상위 클래스 로더 위임
2. 가시범위 원칙 : 하위클래스 로더 상위클래스로더 볼수 있지만 상위는 하위클래스로더 로딩 볼수없음
3. 유일성 원칙 : 하위 클래스로더는 상위 클래스 로더가 로딩한 클래스를 다시로딩하지 못함

https://umanking.github.io/2019/06/25/java-class-loader/#:~:text=%E2%80%BB%20rt.jar%20%ED%8C%8C%EC%9D%BC%EC%9D%B4%EB%9E%80,%EC%8B%9C%EC%97%90%20%EB%A9%94%EB%AA%A8%EB%A6%AC%EC%97%90%20%EC%98%AC%EB%A6%B0%EB%8B%A4.
rt.jar RunTime
코어 자바클래스의 콜렉션, 
JVM 에서 rt.jar 파일에 담긴 클래스 파일을 런타임때 메모리에 올림. 
String, System 클래스가 rt.jar 안에 있음. 
Built-in 패키지 패키지 = 사용자정의패키지 + 빌트인패키지
java.lang : 프리미티브타입, String
java.io : 입출력
java.util : 자료구조  Linked, Dictionary Time, Date
java.applet : Applets 생성
java.awt :  GUI 컴포넌트를 구현하기 위한 클래스들을 포함하는 패키지
java.net : 네트워킹 지원 
https://ahnyezi.github.io/java/javastudy-7-package/
   
   

테스트 주도개발 저자 켄트 벡|역자 김창준, 강규영|인사이트

maven or gradle 반드시 공부할것. 

java9 부터 모듈화가 많이됨.

클래스로더 계층구조.

부트스트랩: 최상단 

1. 부모한테 있는가?

2. 부모한테 없으면 자기가 읽음. 

보통 최상단 rt.jar에 java.lang을 읽어둠. 

 

heap 사이즈는 기본적으로 다이나믹. min max... 똑같이 썼었다.....요즘도...

java실행중 max 조정하는방법? 메모리누수.....그걸고칩시다.>> 실행할때 정해짐. 

튜닝 : 애플리케이션이 최대한으로 쓸수있는 heap을 찾는 과정. 

 

https://www.geeksforgeeks.org/java/?ref=ghm

 

Constant Interface  >> 쓰지마세용...

---------------------------------------

public interface Constats{

  int NUMBER = 100;

  String NAME = "NAME";

}

public class myBook implements Constants{

  private static final String NAME ="";

]

}

-----------------------------------------

>> 1. anti patten. : 인터페이스가 존재하는 목적이 아님. 규약 정하는게 목적. 

>> 2. 상수를 갖고 인스턴스를 만들게됨. 

인터페이스는 기본적으로 public static 이 써있음. .

public class Constants{

  public static final int NUMBER=100;

   private Constants(){}  // 생성못하게 막음. 

}

!! ENUM >> 선택가능한값 고정할때!!!

JPA.. 쿼리 DSR 

--------------------------------------------

import를 구체적 or 포괄적 ... 설정...  java > import > Class.... 999 이렇게 넣으면 패키지.* 사용하지 않음(명시적)

 

  • package 키워드
  • import 키워드
  • 클래스패스
  • CLASSPATH 환경변수
  • -classpath 옵션
  • 접근지시자
728x90

[스터디할래? Java] 목차

이글은 백기선님 스터디 할래? 스터디를 뒤늦게 따라간 기록입니다.

스터디할래 링크 >> https://github.com/whiteship/live-study

이필기를 시작으로 공부했습니다 >>  https://leemoono.tistory.com/20 

여기 없는내용은 스터디 할래 강의 내용 혹은 제가 java Doc보고작성하거나 예제를 만들어 추가했습니다.

그외는 같이 출처가 써있습니다. 

자바상속 특징 다중상속 금지 : extends A, B   X
최상위 클래스 Object
디스패치  프로그램이 어떤 메소드를 호출할 것인가를 결정하여 그것을 실행하는 과정. 
- 동적 디스패치
- 정적 디스패치
Static Dispatch
정적 디스패치
어떤 메소드 실행될지 컴파일시점에서 알수 있음. 
static class Do{
void run(){}
void run(int number){}
}
Do.run();  <<<  정적디스패치는 ... 메소드 오버로딩의 경우. 
Dynamic Method Dispatch
동적 디스패치
컨파일타임에 알수 없는 메서드 의존성을 런타임에 늦게 바인딩
abstract class Do{
void run(){}
}
class MoningDo extends Do{
  @Overried
   void run(){ System.out.println("1"); }
}
class EveningDo extends Do{
  @Overried
   void run(){ System.out.println("2"); }
}
EveningDo ed = new EveningDo();
ed.run()  <<<<< 컨파일때는 알수 없고, 런타임때 알수 있다. 
바이트코드 : imvokvirtual : 동적디스패치
cf) 바이트코드 : imvorkspecial : 생성자 호출. 
더블 디스패치 동적 디스패치 두번 발생 
- 방문자 패턴: visitor partten 더블 디스패치 사용한 대표적 패턴.  
interface Post{
  void postOn(SNS sns);
}
class Text implements Post{
  public void postOn(Sns sns){ sns.post(this);}
}
class Picture implements Post{
  public void postOn(Sns sns){ sns.post(this);}
}
--------------------------- POST 구현하는클래스2개 postOn 생성. 
interface SNS{
  void post(Text text);
  void post(Picture picture);
}
class Facebook implements SNS{
   public void post(Text text){}
   public void post(Picture Picture){}
}
class Twitter implements SNS{
  public void post(Text text){}
   public void post(Picture Picture){}
}
--------------------------상기 상속받은 클래스를 매개변수로 쓰는 SNS 상속클래스 2개

public static void main(String[] args) {
     List<Post> posts = Arrays.asList(new Text(), new Picture()); 
     List<SNS> sns = Arrays.asList(new Facebook(), new Twitter());
     posts.forEach(p -> sns.forEach(s -> p.postOn(s)));
     //1. 어떤 구현체의 PostOn. 2. 어떤 SNS의 post  : 두번발생. 
}
출처 : https://blog.naver.com/swoh1227/222181505425
방문자 패턴 visitor pattern 
- SAX Parser  (cf _DOM Parser)



final class
variable
method
Object 클래스 clone: 해당객체 복제본생성
finalize()  해당객체 더는 아무도 참조지 않아 GC 호출함
notify()  해당객체 대기하고 있는 스레드 다시실행 할때 호출
wait()  notify, notifyall 메소드 호출전까지 현재 스레드 일시적 대기.  
varargs 가변인자, 변수의 마지막선언
내부적으로 배열로 받음. 
String... message  ==  String[] message
-------------------
void sum (String A, String...str){}
void sum (String...str){}
컴파일에러. 
------------------
var = variable
args = 아그 독립변수. 변수 독립변수. 
UML 상속 : 실선
구현 : 점선

- 클래스이름
- 필드내용
- 메소드 내용

객체지향의 사실과 오해, 오브젝트- 조영호저

dispatch : 보내다. 

 

 

웹 uml 툴 : https://app.diagrams.net/

public class Object {

    private static native void registerNatives();
    static {
        registerNatives();
    }
    public final native Class<?> getClass();
    public native int hashCode();
    public boolean equals(Object obj) {
        return (this == obj);
    }
    protected native Object clone() throws CloneNotSupportedException;

    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
    public final native void notify();
    public final native void notifyAll();
    public final native void wait(long timeout) throws InterruptedException;
    public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos > 0) {
            timeout++;
        }

        wait(timeout);
    }
    public final void wait() throws InterruptedException {
        wait(0);
    }
    protected void finalize() throws Throwable { }
}

학습할 것 (필수)

  • 자바 상속의 특징
  • super 키워드
  • 메소드 오버라이딩
  • 다이나믹 메소드 디스패치 (Dynamic Method Dispatch)
  • 추상 클래스
  • final 키워드
  • Object 클래스

 

728x90

[스터디할래? Java] 목차

이글은 백기선님 스터디 할래? 스터디를 뒤늦게 따라간 기록입니다.

스터디할래 링크 >> https://github.com/whiteship/live-study

이필기를 시작으로 공부했습니다 >> https://www.notion.so/Live-Study-5-75f857b63e524d33914a8b3ec6e1e894

여기 없는내용은 스터디 할래 강의 내용 혹은 제가 java Doc보고작성하거나 예제를 만들어 추가했습니다.

그외는 같이 출처가 써있습니다. 

LinkedList vs ArrayList Vactor: Java1.0 시작 생성시 capacity 10로 정해져 10개씩 늘어남.
           thread에 대한 접근 동기화 보장 성능이슈
Java1.2 : List 인터페이스 대체
Collections.synchronizedList(List<T> list);   // Thread-safe 가필요할 때사용. 
ArrayList :내부적으로 데이터를 배열에서 관리, 추가 삭제를 위해 임시배열을 생성 데이터 복사
             *** 대량의 자료를 추가/삭제 하는 경우 그만큼 데이터의 복사가 많이 일어나 성능저하
             *** 반면 각 데이터는 인덱스를 가지고 있기 때문에 한번에 참조가 가능 검색에는 유리
LinkedList: 데이터를 저장하는 각 노드가 이전 노드와 다음 노드의 상태만 알고 있다. 
             ***추가 삭제 유리하지만 검색시 처음부터 노드를 순회해야함 성능상 불리 
접근제어자 public       동일클래스, 동일패키지, 자손클래스, 그외의 영역
protected  동일클래스 , 동일패키지, 자손클래스
(default)    동일클래스, 동일 패키지  >>자바파일안 클래스 동등두개 선언시 파일명 다른것. 
private      동일클래스
초기화블럭 vs 생성자 public class Init {
    private int number;
    private static int staticNum;
    {System.out.println("초기"); }
    static {System.out.println("정적초기");}
    public Init(){ System.out.println("생성");}
    public static void main(String[] args) {
        Init init = new Init();
    }
}   // 정적초기 > 초기 > 생성
this() 생성자에서 다른생성자 호출. 
public Init(){}
public Init(String start){ this(); }
-  this() 는 숨어있지않음, super()만 숨어있음
- this() 호출은 첫줄에서
기본생성자 선언하지 않아도 기본생성자 자동생성
변수가 들어간 생성자가 생기면 기본생성자를 자동 생성하지 않음
final public final class String :: 상속 막을 때 
상속이 적절하지 않을때  :: 특수한 String이 생겨버림. 
abstract public abstract class Init ::인스턴스 생성막을 떄 
Nested Class 중첩클래스 : 클래스 내부 다른클래스  
1. static nested class
2. inner class 
static nested class public class Outer {
  public static class Nested {
  }
}
InnerClass inner class >> Outter 호출후 사용. 
public class OuterClass{
    static class StaticNestedCalss{}
    class InnerClass{   
        class InnerInnerClass{}
    }
}
>>컴파일시 클래스파일 각각 3개 생성
OuterClass$InnerClass$InnerInnerClass.class
OuterClass$InnerClass.class
OuterClass.class
Local class 코드블럭 안에 정의된 클래스.  특정메소드 내에서만 필요한 객체가 필요할때 
public class Main{
 public static boolean methodExample(String... values){
   Class Value{
   }   
 }
}
Anonymous class 익명클래스= 이름없는 클래스
클래스의 정의와 인스턴스화를 한번에 작성.  인스턴스 구현, 추상클래스상속한 처리 부분적이용. 
만약 런타임시 클래스의 정보를 알고싶다면? Reflection API >
구체적 클래스 타입을 알지 못해도 클래스정보(생성자,필드,메서드) 접근할수 있게 해주는 자바 API, 상황에 따라 인스턴스 유동적 생성
https://woowacourse.github.io/javable/post/2020-07-16-reflection-api/#:~:text=Reflection%20API%EB%9E%80%3F,%EC%9E%88%EA%B2%8C%20%ED%95%B4%EC%A3%BC%EB%8A%94%20%EC%9E%90%EB%B0%94%20API%EB%8B%A4.
Java Reflection API 상기링크 참조
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method
Class carClass = Car.class;
Method move = carClass.getMethod("move");
move.invoke(obj, null);
import java.lang.reflect.Field; Field[] fields = Class.forName("java.com.whiteship.demo.Init").getDeclaredFields();
리플렉션을 사용하기 때문에 실제 Exception이 일어날 수 없어 Exception 처리를 용이하기 위함입니다.
>>리플렉션 사용예 .https://woowabros.github.io/experience/2020/10/08/excel-download.html
Heap 메모리 Heap 자료구조를 쓰기 때문. _ 완전이진트리. 항상 위의값이 아랫값보다 큼. 
min Heap , max Heap

java8 변화 추상클래스가 없어지고 인터페이스+디폴트메소드로 옮겨가고 있음. 
인터페이스 : 규약. 토비스프링3. ..참고. 

capacity 수용력

Nested 내포반복. 

Reflection 반영, 비추다. 

invoke 들먹이다 언급하다. 

http://tutorials.jenkov.com/java/nested-classes.html#:~:text=In%20Java%20a%20static%20nested,instance%20of%20the%20enclosing%20class.]

 

Java의 LinkedList와 ArrayList에 대한 비교 https://www.holaxprogramming.com/2014/02/12/java-list-interface/

 

객체지향의 사실과 오해.. 책 찾아볼것. 

 

 

package com.whiteship.demo;

import com.sun.xml.internal.ws.api.ha.StickyFeature;

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/*int 값을 가지고 있는 이진 트리를 나타내는 Node 라는 클래스를 정의하세요.
int value, Node left, right를 가지고 있어야 합니다.
BinrayTree라는 클래스를 정의하고 주어진 노드를 기준으로 출력하는 bfs(Node node)와 dfs(Node node) 메소드를 구현하세요.
DFS는 왼쪽, 루트, 오른쪽 순으로 순회하세요.*/
class Node_Binary{

    private int value;
    private Node_Binary left;
    private Node_Binary right;

    public Node_Binary(int value, Node_Binary left, Node_Binary right){
        this.value=value;
        this.left = left;
        this.right=right;
    }
    public Node_Binary(int value){
        this.value=value;
    }

     public int getValue() {
         return value;
     }

     public void setValue(int value) {
         this.value = value;
     }

     public Node_Binary getLeft() {
         return left;
     }

     public void setLeft(Node_Binary left) {
         this.left = left;
     }

     public Node_Binary getRight() {
         return right;
     }

     public void setRight(Node_Binary right) {
         this.right = right;
     }
 }
public class BinaryTree {
    private Node_Binary root;
    public BinaryTree(Node_Binary root){
        this.root=root;
    }
    public Node_Binary getRoot() {
        return root;
    }

    public void getDFS (Node_Binary node, List<String> resultDfs){
        if (node == null) return;
        resultDfs.add(String.valueOf(node.getValue()));
        getDFS(node.getLeft(), resultDfs);
        getDFS(node.getRight(), resultDfs);
    }

    public List<String> getBFS (Node_Binary node, List<String> resultBfs){
        Queue<Node_Binary> queue  = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()){
            node = queue.poll();
            resultBfs.add(String.valueOf(node.getValue()));
            if (node.getLeft() !=null){
                queue.offer(node.getLeft());
            }
            if (node.getRight() != null){
                queue.offer(node.getRight());
            }
        }

        return resultBfs;
    }
}
package com.whiteship.demo;

import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collector;
import java.util.stream.Collectors;

import static org.junit.jupiter.api.Assertions.*;

class BinaryTreeTest {

    private List<String> resultDfsList = Collections.EMPTY_LIST;
   // 1 - 2 -4,5
   //   - 3-6,7
    private BinaryTree getUpBinaryTreeValue(){
        Node_Binary node4 = new Node_Binary(4);
        Node_Binary node5 = new Node_Binary(5);
        Node_Binary node6 = new Node_Binary(6);
        Node_Binary node7 = new Node_Binary(7);
        Node_Binary node2 = new Node_Binary(2,node4,node5);
        Node_Binary node3 = new Node_Binary(3,node6,node7);
        Node_Binary root = new Node_Binary(1,node2,node3);

        return new BinaryTree(root);
    }
    @Test
    void TEST_DFS (){
        BinaryTree binaryTree = getUpBinaryTreeValue();
        binaryTree.getDFS(binaryTree.getRoot(), resultDfsList);
        String resultDFS = String.join("",resultDfsList);
        assertEquals("1245367", resultDFS);
    }

    @Test
    void TEST_BFS(){
        BinaryTree binaryTree = getUpBinaryTreeValue();
        List<String> resultBfsList = binaryTree.getBFS(binaryTree.getRoot(), new ArrayList<>());
        String resultBfs = String.join("",resultBfsList);
        assertEquals("1234567",resultBfs);
    }
}

목표

자바의 Class에 대해 학습하세요.

학습할 것 (필수)

  • 클래스 정의하는 방법
  • 객체 만드는 방법 (new 키워드 이해하기)
  • 메소드 정의하는 방법
  • 생성자 정의하는 방법
  • this 키워드 이해하기

마감일시

2020년 12월 19일 토요일 오후 1시까지.

과제 (Optional)

  • int 값을 가지고 있는 이진 트리를 나타내는 Node 라는 클래스를 정의하세요.
  • int value, Node left, right를 가지고 있어야 합니다.
  • BinrayTree라는 클래스를 정의하고 주어진 노드를 기준으로 출력하는 bfs(Node node)와 dfs(Node node) 메소드를 구현하세요.
  • DFS는 왼쪽, 루트, 오른쪽 순으로 순회하세요.

 

728x90

[스터디할래? Java] 목차

 

이글은 백기선님 스터디 할래? 스터디를 뒤늦게 따라간 기록입니다.

스터디할래 링크 >> https://github.com/whiteship/live-study

이필기를 시작으로 공부했습니다 >> kils-log-of-develop.tistory.com/349

여기 없는내용은 스터디 할래 강의 내용 혹은 제가 java Doc보고작성하거나 예제를 만들어 추가했습니다.

그외는 같이 출처가 써있습니다. 

 

내가한 과제주소

>> blog.1028web.com/entry/JUnit

>>http://study/src/test/java/com/web1028/study/whiteship/javaBasic/ : 테스트

>>study/src/main/java/com/web1028/study/whiteship/javaBasic/ : 소스 위치

 

수업중 코멘트 

JUnit5 테스트는 public 생략가능.. Junit4 에서는 써야했음.  

일관성 : consistency : 일관적으로 예외를 던기거나 or null

더보기
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        // 예외를 던지는것 or null
        // 일관적 선택을 하 것.
        // 추가는 예외 , 뺄 때는 null??? 비추.

        queue.offer(1);
        queue.add(1);

        queue.poll();
        queue.remove();

        queue.peek();
        queue.element();

    }

데이터 사이언스에서 일관성은

데이터의 Replication (복제) 동일한 데이터셋.

레플리케이션(Replication)- 마스터/슬레이브 관계를 갖는 원본과 복사본 사이를 다룬다. 마스터는 변경 사항을 기록하고 그 결과는 슬레이브에게 전달된다-

@DisplayName("이름 바꾸기 \uD83D\uDE31")

목업테스트 >> 모키토. 

자바 if switch 안쓰는걸 권장.  if 문없이 효과 낼수 있음.  >> 상속(다형성) 이용.  

refactoring.guru/replace-conditional-with-polymorphism

 

@TestInstance(TestInstance.Lifecycle.PER_METHOD

   >>  이게 기본값, 인스턴스를 매서드기준생성 내부 알고리즘 순서로 랜덤으로 실행됨. 

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)  >> @Order(1)  .. 순서대로 실행 

 

TDD 테스트 주도 개발(Test-driven development)

보통.. 테스트코드를 짜고. 개발 진행..을말함. 

 

스팍 spock  groovy 테스트 코드..  주관적으로 JUnit4(이름 뛰어쓰기 불가,한글가능) < spock < JUnit5 .. 가 나았다. 

>> 참고링크 blog.naver.com/varkiry05/221377431778woowabros.github.io/study/2018/03/01/spock-test.html

d2.naver.com/helloworld/568425

groovy  > A domain-specific language (DSL) 

 

차주수업 소개, 재귀. 작성시. 종료조건 유의.

팩토리얼 구현. 

시간복잡도,  O(N)

공간복잡도.  O(N).. 꼬리재귀 ??.>>최적화. 스칼라로는. O(1). 더 낮음. >> 스택까지 고려해야함. 

스택. 메서드 호출시 스택이 생김. 

재귀호출 호출할때마다 스택이 추가됨. 그만큼 메모리 사용. 

꼬리재귀.. 자기자신 스택을 재사용함. ... 지원하는 언어가 

java 기본적으로. 콜스텍 갯수 카운트에 의존하는 코드가 있어. 꼬리 재귀 기능을 추가하지 못함. 

O(N)까지는 고려할만하나... O(N^2) 은 수용가능한 범위인지 고려해봐야함. 

꾸준히 실행하세요!!

 

 

 

수업소감. 

테스트 코드를.... 진짜.. 처음 써봄.. 스터디로.. 이전까지.. 공부하면서 써먹지를 못해서.. 답답한애였는데. 

큐를 쓰면서... 제네릭을 생각보다 모르는것같다. 더 공부합시다~

모키토까지.. 공부해야하나봄.. 목업테스트에는 그걸하라고. 

이런생각을 하고 싶었는데.. 행복하네요.. 봅시다. 너무늦은건없다는거.

 

과제 0. JUnit 5 학습하세요.

  • 인텔리J, 이클립스, VS Code에서 JUnit 5로 테스트 코드 작성하는 방법에 익숙해 질 것.
  • 이미 JUnit 알고 계신분들은 다른 것 아무거나!
  • 더 자바, 테스트 강의도 있으니 참고하세요~

과제 1. live-study 대시 보드를 만드는 코드를 작성하세요.

  • 깃헙 이슈 1번부터 18번까지 댓글을 순회하며 댓글을 남긴 사용자를 체크 할 것.
  • 참여율을 계산하세요. 총 18회에 중에 몇 %를 참여했는지 소숫점 두자리가지 보여줄 것.
  • Github 자바 라이브러리를 사용하면 편리합니다.
  • 깃헙 API를 익명으로 호출하는데 제한이 있기 때문에 본인의 깃헙 프로젝트에 이슈를 만들고 테스트를 하시면 더 자주 테스트할 수 있습니다.
  •  
더보기

불러내기까지만 테스트

과제 2. LinkedList를 구현하세요.

  • LinkedList에 대해 공부하세요.
  • 정수를 저장하는 ListNode 클래스를 구현하세요.
  • ListNode add(ListNode head, ListNode nodeToAdd, int position)를 구현하세요.
  • ListNode remove(ListNode head, int positionToRemove)를 구현하세요.
  • boolean contains(ListNode head, ListNode nodeTocheck)를 구현하세요.

과제 3. Stack을 구현하세요.

  • int 배열을 사용해서 정수를 저장하는 Stack을 구현하세요.
  • void push(int data)를 구현하세요.
  • int pop()을 구현하세요.

과제 4. 앞서 만든 ListNode를 사용해서 Stack을 구현하세요.

  • ListNode head를 가지고 있는 ListNodeStack 클래스를 구현하세요.
  • void push(int data)를 구현하세요.
  • int pop()을 구현하세요.

과제 5. Queue를 구현하세요.

  • 배열을 사용해서 한번
  • ListNode를 사용해서 한번.
728x90

[스터디할래? Java] 목차

 

이글은 백기선님 스터디 할래? 스터디를 뒤늦게 따라간 기록입니다.

스터디할래 링크 >> https://github.com/whiteship/live-study

이필기를 시작으로 공부했습니다 >> blog.naver.com/hsm622/222150928707,

                                                swich operator  catch-me-java.tistory.com/31

여기 없는내용은 스터디 할래 강의 내용 혹은 제가 java Doc보고작성하거나 예제를 만들어 추가했습니다.

그외는 같이 출처가 써있습니다. 

 


연산 : Operations : 프로그램에서 데이터 처리 결고 산출

연산자 : Operator : 연산사용 표시 기호

피연산자: Operand:연산대상이되는 데이터

연산식 : expressions: 연산자 피연산자로 연산의 과정기술

 

연산자 우선 순위

https://blog.naver.com/hsm622/222150928707

(optional) Java 13. switch 연산자

int result = switch (day){

   case "MON" ->2;

   case "FRI" ->3;

   case "NOT" ->43;

}

yield 사용가능

 

 

산술 연산자

비트 연산자

int num = 8;  

~num            : -9: 보수        

num << 1      : 16:곱하기2  , 쉬프트연산자

num >> 1      : 4:나누기2, 쉬프트 연산자

 

진리표(truth table)



 

관계 연산자
논리 연산자

Q1.

int i  =0;

int j =0;

if (i++ == 0 || j++ == 0){

   Hello 출력

}

i, j 값은?

답: i 출력 :1, j 출력 : 0 

 

Q2.

int i  =0;

int j =0;

if (i++ == 0 | j++ == 0){

   Hello 출력

}

i, j 값은?

답: i 출력 :1, j 출력 : 1

 

 

Q3. 중간값 구하기. 

int start = 0;

int end = 10;

int mid= (start + end)/2;

오버플로우 가능성. >> 이상한값이 나온다. 

 

int mid = start + (end-start)/2;

int mid = (start + end) >>>1;  비트연산자.. 

 

 


instanceof
assignment(=) operator

 

 

 

화살표(->) 연산자
3항 연산자

Q numbers라는 int라는 배열이 있다. 

해당 배열이 들어있는 숫자들은 오직 한숫자를 제외하고 모두 두번씩들어있다. 

오직 한번만 등장하는 숫자 찾는 코드를 작성하라. 

 

public class Hello{

    Hello hello = new Hello();

    int result  = hello.solution(new int[] {5,2,3,1,2,4,5,});

    출력 결과

}

 

private int solution(int[] numbers){

    //xor 논리적 배타합. 다르면 1 같으면 0

   // 5  ^ 0 = 5     

  // 5 ^5 =0   => (5^5)^1 = 0^1 =1     

 

  // 101

 //  101

 //-------

// 000

 

// 101

// 000

//-------

// 101

//인텔리제이 for ita   or iter

int result =0;

for (int number : numbers){

    result ^=result;

}

 

return result;

 

}

 

 

 

 

3주차 과제: 연산자 #3

  • 산술 연산자
  • 비트 연산자
  • 관계 연산자
  • 논리 연산자
  • instanceof
  • assignment(=) operator
  • 화살표(->) 연산자
  • 3항 연산자
  • 연산자 우선 순위
  • (optional) Java 13. switch 연산자

 

자바의 객체지향 디자인패턴

 

클린아키텍처..

www.yes24.com/Product/Goods/77283734

 

 

ListNode : 링크드리스트 기본구조. 

 

 

 

728x90

[스터디할래? Java] 목차

이글은 백기선님 스터디 할래? 스터디를 뒤늦게 따라간 기록입니다.

스터디할래 링크 >> https://github.com/whiteship/live-study

여기 없는내용은 스터디 할래 강의 내용 혹은 제가 java Doc보고작성하거나 예제를 만들어 추가했습니다.

그외는 같이 출처가 써있습니다. 

 


타입추론, var

1. 개발자가 명시하지 않아도 컴파일러가 변수의 타입을 대입된 리터럴로 추론하는것. java10

2. 초기화 값이 있는 지역변수 로만 선언이 가능

 

 

자료형 (Data Type)

기본자료형

= Primitive type= 원시타입

1. 8가지 기본자료형

정수: byte, short, int, long

실수: float, double

문자: char

참거짓:boolean

2. 기본값이 있어 Null 존재 안함, Null이 필요하면 래퍼클래스사용

3. 실제값 저장 하는 공간  Stack

1. 1byte는 8it

2. 1bit당 한가지씩 표현가능.

2byte = 16진수

0000 0000 0000 0000

숫자형은 맨 앞 1bit 를 가지고 음수 or 양수   : singed   // 1.8 이전까지 unsinged는 없다. 

 

문자 char형은 예외

char 1111 1111 1111 1111  10진수값 65535

자바  유니코드 지원. 

shot 1111 1111 1111 1111  10진수값 -1

 

float

1bit : 부호 8bit: 지수 23비트 : 가수

부동소수점(浮動小數點, floating point) 또는 떠돌이 소수점 방식은 실수를 컴퓨터상에서 근사하여 표현할 때 소수점의 위치를 고정하지 않고 그 위치를 나타내는 수를 따로 적는 것

float number = 0f;

for(int i =0;i<10;i++){

  number +=0.1f

}

출력 number

1.0000001  

>> 돈계산 할때 float, double 하면안되는이유.  2의 배수가 아닌이상 근사치로 계산하기 때문

BigDecimal 사용. 

BigDecimal number = BigDecimal.ZERO;

for(int i =0;i<10;i++){

  number = number.add(BigDecimal.valueOf(0.1));    //<< 사실상 2줄.. 멀티쓰레드.. 레이스컨디션..주의

}

출력 number

 

3. JVM 스택이 4Byte 단위로 저장 (2^8 =  8*4 =32bit)

int 보다 작은 자료형 값 계산시 int형으로 형변환 되서 연산 수행

 

 

cf) 멀티스레드 레이스컨디션 .. : 멀티스레드 동시 접근

싱글톤.. 더블체크드 락킹. ..

public class App{

  private static App app;

 

  public static App getInstance(){

    if(this.app =null){

       this.app = new App();    // 두번 만들수 있다. ....

     }

    return app;

  }

}

 

오버플로우 overflow 

int 21억....  22억 안됨

int million = 100000000;

int a = 21 * million

int b = a + million;   // 나타낼수 있는 범위 넘어감. -2094967296   한바뀌돌아요~

cf)

Integer.toUnsignedString(unsigned);  //22억   //unsinged로 취급한다. 

BigInteger bigInteger = new BigInteger(a + million); //biginteger 사용. 

 

 

참조형타입

 Reference Type

1. 기본형 제외

2. stack 에는 주소, 데이터는 heap에 저장

 변수명 작명규칙

1. 대소문자 구분

2. 숫자로 시작안됨

3. $, _ 이외 특수문사 사용불가

4. 키워드는 변수 사용불가

 

배열

int[] odds = {1, 3, 5, 7, 9};

int[][] arrays;

arrays = new int[1][5]

int[][][][] a = new int[2][2][2][3];

크기는 2*2*2*3 = 24

 

배열 참고. b-programmer.tistory.com/225

리터럴

"문자 그대로", 고정된 값을 갖는 소스코드 표현형태

실수 리터럴 : 소수점 형태나 지수 형태로 표현한 값

double f =0.1234f;

double g = 1234E-4d;

16진수 0x

2진수 

문자리터럴 : '' 로 문자를 표현한다. 

char a = 'H';

int a = 1_000_000;

숫자표현시 언더바 로 단위표현가능(1.8)

 

 

프로모션 과 캐스팅

byte < short < int < long < float < double < String

<----정수형 변수----> <-실수형 변수->

 

프로모션 : 자동형편환

int a = 10;

float b = a;

 

출력 : a = 10, b = 10.0  >> 더큰자료형에 더 작은 자료형을 넣음. 

 

캐스팅 : 명시적 형편환

float a = 10;

int b = a;   << 컴파일에러  

int b  = (int)a;

출력 : a=10.0, b=10

 

Boxing, Unboxing

Boxing   : 프리미티브 -> Wrapper 클래스로 바꿔줌   

Unboxing : Wrapper->프리미티브 

묵시적 boxing : 프리미티브 -> Wrapper 명시 묵시

 

int data = 4;

Integer boxing = new Integer(data);

int unboxing = data.intValue();

Integer Implied boxing = data;

스코프와 라이프타임

스코프 : 변수에 접근할수 있는영역

인스턴스 변수 클래스변수 로컬변수
클래스 내부, 인스턴스 생성시 생성
- int x, y;
클래스내부, 클래스 메모리 올라갈때 생성
- final static int a = 4
변수 선언문 수행시
- 메서드, 생성자, 초기화블럭 내부
scope:정적메서드 제외 인스턴스 전체 클래스 전체 선언된 블록내
lifetime: 객체 메모리 남아있을떄 클래스가 메모리 로드되는 동안 컨트롤이 선언된 블록 떠날때 까지

 

 

 

프리미티브 레퍼런스 비교 :  gbsb.tistory.com/6

리터럴 : mine-it-record.tistory.com/100

프로모션, 캐스팅 : m.blog.naver.com/PostView.nhn?blogId=haejoon90&logNo=220781157092&proxyReferer=https:%2F%2Fwww.google.com%2F 

스코프, 라이프타임: league-cat.tistory.com/411

타입추론catch-me-java.tistory.com/19

원시타입 이론설명 : velog.io/@gillog/%EC%9B%90%EC%8B%9C%ED%83%80%EC%9E%85-%EC%B0%B8%EC%A1%B0%ED%83%80%EC%9E%85Primitive-Type-Reference-Type

박싱, 언박싱  m.blog.naver.com/PostView.nhn?blogId=highkrs&logNo=220530396617&proxyReferer=https:%2F%2Fwww.google.com%2F

 

 


2주차 과제: 자바 데이터 타입, 변수 그리고 배열 #2

목표

자바의 프리미티브 타입, 변수 그리고 배열을 사용하는 방법을 익힙니다.

학습할 것

  • 프리미티브 타입 종류와 값의 범위 그리고 기본 값
  • 프리미티브 타입과 레퍼런스 타입
  • 리터럴
  • 변수 선언 및 초기화하는 방법
  • 변수의 스코프와 라이프타임
  • 타입 변환, 캐스팅 그리고 타입 프로모션
  • 1차 및 2차 배열 선언하기
  • 타입 추론, var
728x90

[스터디할래? Java] 목차

 

이글은 백기선님 스터디 할래? 스터디를 뒤늦게 따라간 기록입니다.

스터디할래 링크 >> https://github.com/whiteship/live-study

여기 없는내용은 스터디 할래 강의 내용 혹은 제가 java Doc보고작성하거나 예제를 만들어 추가했습니다.

그외는 같이 출처가 써있습니다. 

 

Error : A JNI error has occurred,   ....(중략)....   version of the Java Runtime (class file version 53.0), this version of the Java Runtime only recognizes class file versions up to 52.0 at java.lang

>> 컴파일버전과 실행버전이 다를때. 


JAVA

1995년 SUN에서 발표한 제임스 고슬링의 프로그램 언어, 컴퓨팅 플랫폼. 

OS에 독립적

JAVAC

javac Hello.java

java Hello.class

java -c Hello.class

더보기

C:\Program Files\Java\jdk1.8.0_144\bin>javac -version
javac 1.8.0_144

 

Client Compiler, Server Compiler >> JAVA 1.6  자바실행할때 쓰는 옵션 Client일수록 빠름

레이어드 >> JAVA 1.8 부터 알아서 실행해줌

 

Q. java 14 로 컴파일 후 java 8로 실행하면?

 

더보기

실행이 안된다. 

 

JAVA14  -> class file version 58

JAVA8  -> class file version 52

 

- 상위버전 클래스파일은 하위버전이 실행안됨.

해결방법 :  옵션을 준다. 

javac Hello.java -source 1.8 - target

C:\Program Files\Java\jdk1.8.0_144\bin>javac
Usage: javac <options> <source files>
where possible options include:
  -g                         Generate all debugging info
  -g:none                    Generate no debugging info
  -g:{lines,vars,source}     Generate only some debugging info
  -nowarn                    Generate no warnings
  -verbose                   Output messages about what the compiler is doing
  -deprecation               Output source locations where deprecated APIs are used
  -classpath <path>          Specify where to find user class files and annotation processors
  -cp <path>                 Specify where to find user class files and annotation processors
  -sourcepath <path>         Specify where to find input source files
  -bootclasspath <path>      Override location of bootstrap class files
  -extdirs <dirs>            Override location of installed extensions
  -endorseddirs <dirs>       Override location of endorsed standards path
  -proc:{none,only}          Control whether annotation processing and/or compilation is done.
  -processor <class1>[,<class2>,<class3>...] Names of the annotation processors to run; bypasses default discovery process
  -processorpath <path>      Specify where to find annotation processors
  -parameters                Generate metadata for reflection on method parameters
  -d <directory>             Specify where to place generated class files
  -s <directory>             Specify where to place generated source files
  -h <directory>             Specify where to place generated native header files
  -implicit:{none,class}     Specify whether or not to generate class files for implicitly referenced files
  -encoding <encoding>       Specify character encoding used by source files
  -source <release>          Provide source compatibility with specified release
  -target <release>          Generate class files for specific VM version
  -profile <profile>         Check that API used is available in the specified profile
  -version                   Version information
  -help                      Print a synopsis of standard options
  -Akey[=value]              Options to pass to annotation processors
  -X                         Print a synopsis of nonstandard options
  -J<flag>                   Pass <flag> directly to the runtime system
  -Werror                    Terminate compilation if warnings occur
  @<filename>                Read options and filenames from file
C:\Program Files\Java\jdk1.8.0_144\bin>java
사용법: java [-options] class [args...]
           (클래스 실행)
   또는  java [-options] -jar jarfile [args...]
           (jar 파일 실행)
여기서 options는 다음과 같습니다.
    -d32          사용 가능한 경우 32비트 데이터 모델을 사용합니다.
    -d64          사용 가능한 경우 64비트 데이터 모델을 사용합니다.
    -server       "server" VM을 선택합니다.
                  기본 VM은 server입니다..

    -cp <디렉토리 및 zip/jar 파일의 클래스 검색 경로>
    -classpath <디렉토리 및 zip/jar 파일의 클래스 검색 경로>
                  클래스 파일을 검색할 ;(으)로 구분된 디렉토리,
                  JAR 아카이브 및 ZIP 아카이브 목록입니다.
    -D<name>=<value>
                  시스템 속성을 설정합니다.
    -verbose:[class|gc|jni]
                  상세 정보 출력을 사용으로 설정합니다.
    -version      제품 버전을 인쇄한 후 종료합니다.
    -version:<value>
                  경고: 이 기능은 사용되지 않으며
                  이후 릴리스에서 제거됩니다.
                  실행할 버전을 지정해야 합니다.
    -showversion  제품 버전을 인쇄한 후 계속합니다.
    -jre-restrict-search | -no-jre-restrict-search
                  경고: 이 기능은 사용되지 않으며
                  이후 릴리스에서 제거됩니다.
                  버전 검색에서 사용자 전용 JRE를 포함/제외합니다.
    -? -help      이 도움말 메시지를 인쇄합니다.
    -X            비표준 옵션에 대한 도움말을 인쇄합니다.
    -ea[:<packagename>...|:<classname>]
    -enableassertions[:<packagename>...|:<classname>]
                  세분성이 지정된 검증을 사용으로 설정합니다.
    -da[:<packagename>...|:<classname>]
    -disableassertions[:<packagename>...|:<classname>]
                  세분성이 지정된 검증을 사용 안함으로 설정합니다.
    -esa | -enablesystemassertions
                  시스템 검증을 사용으로 설정합니다.
    -dsa | -disablesystemassertions
                  시스템 검증을 사용 안함으로 설정합니다.
    -agentlib:<libname>[=<options>]
                  <libname> 고유 에이전트 라이브러리를 로드합니다(예: -agentlib:hprof).
                  -agentlib:jdwp=help 및 -agentlib:hprof=help도 참조하십시오.
    -agentpath:<pathname>[=<options>]
                  전체 경로명을 사용하여 고유 에이전트 라이브러리를 로드합니다.
    -javaagent:<jarpath>[=<options>]
                  Java 프로그래밍 언어 에이전트를 로드합니다. java.lang.instrument를 참조하십시오.
    -splash:<imagepath>
                  이미지가 지정된 스플래시 화면을 표시합니다.
자세한 내용은 http://www.oracle.com/technetwork/java/javase/documentation/index.html을 참조하십시오.

바이트코드 Bytecode

특정 하드웨어가 아닌 가상 컴퓨터에서 돌아가는 실행 프로그램을 위한 이진 표현법이다.

클래스파일 안에 들어있음. 

컴파일러에 의해 변환되는 코드명령어(opcode, operator code) 크기가 1바이트

JIT Compiler(Just In Time Compiler)

JAVA 실행시 실행 : JIT Compiler + Interpreter 

JRE 안에 포함됨

얼마나 자주 수행되는지 체크하고 일정정도를 넘을 때만 컴파일 수행

JDK

JAVA 9 부터는 JRE가 더이상 없음.

JDK
JRE + javac, jar, debugging tools, javap
JVM + java, javaw, lib, rt.jar
Class Loader
Execution Engine
Runtime Data Area

 
Interpreter JIT Compiler Garbage
Collector

JVM(Java Virtual Machine)

1. Java 코드, 에플리케이션 구동 위한 실행환경 제공하는엔진

2. Java 바이트 코드를 기계언어로 변환

3. JAVA는 독립적이고 JVM은 OS버전마다 의존적임

JVM Architecture

JJVM 아키 출처 :  dzone.com/articles/jvm-architecture-explained

 

Hello.java

-- Compiler -->  Hello.class(자바 바이트 코드: JVM에서 실행됨)

----------------------------------------------JVM----------------------------------------------------

ClassLoader 

-------------------------------:로드, 연결, 초기화------------------------------------

- 로딩

부트 스트랩 클래스 로더

: <JAVA_HOME> / jre / lib 디렉토리에있는 핵심 Java 라이브러리 로드
확장 클래스 로더

: <JAVA_HOME> / jre / lib / ext 또는 java.ext.dirs 시스템특성에 지정된 라이브러리로드
시스템 클래스 로더

: CLASSPATH 환경 변수에 매핑되는 java.class.path에있는 코드를로드

- 링크 : 레퍼런스 연결 : 로딩이 끝나면 class 객체 생성  Heap 영역에 저장

Verfiy

: .class 파일 유효한지 확인, 바이트 코드가 조작될 경우 JVM 에러 발생

Prepare

: 메모리 준비 과정 클래스의 static 변수, 기본값에 필요한 메모리 준비

Resolve

:  Symbolic Memory Reference를 실제 Reference로 교체

- 초기화 : static 값 초기화, 변수 할당

JVM Memory (Runtime Data Area)

------------------- : 프로그램 실행 메모리------------------

1. Stack Area 

: LIFO: 호출 시마다 생성 수행 후 삭제, 메서드 작성값(매개번수, 지역변수, 리턴값, 연산시 임시값) 저장. 

2. Heap Area

: Heap Space = Young Generation + Old Generation

Young Generation = Eden + Survivor1, Survivor2 + (virtual, 가상공간)

Old Generation = Old + (virtual, 가상공간)

- young Generation: Minor GC 발생

- Eden : 새로 생성된 대부분 객체가 처음 위치하는 영역, GC 발생후 살아남은 객체는 Survivor1 or Survivor2 이동

- Old Generation : Major GC(Full GC)발생

- Old : Survivor에서 살아남은 객체만이 Old 영역이동, Old영역은 Young영역보다 크게 할 당. 

- Xms : 최소 힙공간(Eden+Survivor+Old), Xmx : 최대 Heap 공간(Eden+Survivor+Old+virtual)
- XX:NewSize : 최소 Young 공간(Eden+Survivor), XX:MaxNewSize : 최대 Young공간( Eden + suvivor +virtual)
- XX:SurvivorRatio : Eden(new)/Survivor 영역비율, XX: NewRatio : Young(Eden + Survivor)/Old

3. Method Area

(= class Area, code area, static area)  Permanent Generation , heap 영역에서 메타스페이스로 )

( Permanent Generation , heap 영역 JDK 1.8에서는 Metaspace로 대체됨, 최대를 지정하지 않으면 서버 메모리전체를 사용할수 있으니 주의 필요.)

Permanent Generation = Runtime Constant Pool + fild & Method Data + code +(virtual)

- 클래스, 인터페이스에 대한 런타임 상수, 멤버변수(필드), 클래스변수(Static), 생성자 메서드 저장

-XX:PermSize   초기 Perm크기 , -XX:MaxPermSize 
(XX:MaxMetaspaceSize  cf)JDK1.8이후 )

4. Native Area

: Code Cashe :JIT 방식 변환 시간 절약위해 많이 쓰는 코드 기계어로 변환시켜 저장해둠. 

5. PC Register

: 현재 수행중인 JVM 명령과 주소 저장, CPU 내의 기억장치, Thread가 생성될 때마다 생성

Execution Engine

------------------- (Runtime Engine) : 실행 엔진------------------

1. Interpreter

: 바이트 코드를 한줄씩 해석, 초기방식, 속도가 느림

2. JIT Compiler

: 같은 코드를 매번 해석하지 않고 실행할 때 컴파일을 하면서 해당 코드 캐싱 

3. Garbage Collector

: Heap 메모리 영역에 생성된 객체들 중에 참조되지 않은 객체들을 제거

------> 실행 완료. 

 


백기선님 1주차 강의 내용 :

JVM은 무엇이며 자바 코드는 어떻게 실행하는 것인가. #1

  • JVM이란 무엇인가
  • 컴파일 하는 방법
  • 실행하는 방법
  • 바이트코드란 무엇인가
  • JIT 컴파일러란 무엇이며 어떻게 동작하는지
  • JVM 구성 요소
  • JDK와 JRE의 차이

Java News : www.whiteship.me/java-news-2020-11-13/

1. Spring Boot 2.4.0 정식버전 출시

- 새로운  Java15 지원

- 스프링프레임워크 5.3

- 설정 파일 4가지 : 한파일안에서 여러 도큐먼트 설정가능.. 꼬이는 부분해결.. 

- 도커/빌드팩 : Publishing image, Authetication,

2. 스프링 인증 서버 0.0.3

 OAuth 2.0 Refresh token

 

PubSub 방식 

Publisher -> Redis PubSub 쌓아둠-> subscriber

Jokes api : jokeapi.dev/

 

카카오 컨퍼런스  : if(kakao)2020  : if.kakao.com/

 

네이버 컨퍼런스 : 네이버 데뷰 : deview.kr/2020

 

Java 16 EA 버전 출시

 

Project Loom : 프로젝트 Loom에서는 자바의 Thread를 개선해서 Virtual Thread라는 것을 제공할 것으로 보이며 Structured 동시성(Concurrency) (코드의 구조 자체가 컨커런시를 제어하는 시작과 끝을 나타내는 것) 를 제공하는게 목표라고 하네요.

 

LinkedIn에서 공개한 머신 러닝 Java 오픈 소스

 

JSON 자바 클래스 변환기 >> instantwebtools.net/json-to-java

 

www.reddit.com/r/java/<< 자바 뉴스 참고


 

교재 : java in a nutshell 

www.dblab.ntua.gr/~gtsat/collection/Java%20books/O%27Reilly%20-%20JAVA%20in%20a%20Nutshell.pdf

 

O'Reilly - JAVA in a Nutshell.pdf
4.58MB

lombok >> projectlombok.org/

the java 참고. 

 

현재 Java 8  80%.. 현재 .. 11로 넘어가고 있음.

 

피드백 >> 이미지는 직접 그릴것. 글은 이해한대로 적을것. 

 

 

설문조사.

strawpoll.com/create/

 

컴파일타임과 런타임의 구분하는걸 원했다. 

컴파일타임 : javac 실행시간

런타임: java 실행시간

 

 

 

 

 

 

 

 

 

 

 

+ Recent posts