Member <----> Team N:1 양방향

@Entity
@Getter
@Setter
public class Locker {

    @Id
    @GeneratedValue
    @Column(name="locker_id")
    private long id;
    private String name;

    @OneToOne(mappedBy="locker")
    private Member member;

    public Locker(String name) {
        this.name= name;
    }

    public void setMember(Member member) 
    {
        if(member.getLocker()!=this)
            member.setLocker(this);

    }


}

@Entity
@NoArgsConstructor
@Getter
@Setter

public class Member {
    @Id
    @GeneratedValue

    private long id;
    private String name;

    @ManyToOne
    @JoinColumn(name="TEAM_ID")
    private Team team;


    @OneToOne
    @JoinColumn(name="locker_id")
    private Locker locker;

    //무한 루프를 막는 로직
    public void setTeam(Team team) 
    {
        //양방향이라 맵핑 되는 부분을 서로 셋팅을 해줘야 하는데 .
        //일단 Member 의 team은 셋팅
         this.team = team;
         //Team에도 Member를 셋팅하기 전에 이미 member가 포함되어있지 않아야만 셋팅 해줄수있다 Team클래스도 마찬가지 
         if(!team.getMembers().contains(this)) 
         {
             team.getMembers().add(this);
         }
    }

    public void setLocker(Locker locker) 
    {
        this.locker= locker;
        if(locker.getMember() == null) 
        {
            locker.setMember(this);
        }
    }

    public Member(String name) {
        this.name= name;
    }
}

실행 로직

@Component
@Transactional 
public class JpaRunner implements ApplicationRunner{
    @PersistenceContext
    EntityManager entityManager;
     public void oneToOne() 
    {

        Member member1 = new Member("member1");
        Member member2 = new Member("member2");
        Member member3 = new Member("member3");
        entityManager.persist(member1);
        entityManager.persist(member2);
        entityManager.persist(member3);


        Locker locker1 = new Locker("locker4");
        Locker locker2 = new Locker("locker5");
        Locker locker3 = new Locker("locker6");
        entityManager.persist(locker1);
        entityManager.persist(locker2);
        entityManager.persist(locker3);

        member1.setLocker(locker1);
        member2.setLocker(locker2);
        member3.setLocker(locker3);
    }

    public void ManyToOne() 
    {

    }

    @Override
    public void run(ApplicationArguments args) throws Exception {
        oneToOne();
    }




}

참고 : 김영한님의 jpa 교재

밑에꺼 쓰면 에러나는데 아직 이유는 모르겠음 #spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5InnoDBDialect

통계 쿼리 뽑는 방법 :DECODE가 IF문 역할을 하는데 HIREDATE(채용일?)을 TO_CHAR로 바꿨을떄 0112로 나오는데 여기서 01끼리 합을 내면 01월의 통계가 된다 . 그렇게 0112월을 만들면 되는데 그게 왜 이렇게 이해가안된건지 ㅡ_ㅡ..

package examp;

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

public class CollectionEx {
    public static void main(String args[]) {
        Dto[] dtoArr = new Dto[10];
        String type="";
        for(int i=0;i<10;i++) 
        {
            int a= 1111;
            if(i%2==0) 
            {
                type="type1";

            }else 
            {
                type="type2";

            }
            dtoArr[i] = new Dto(a*i,String.valueOf(a*i),type);
        }
         System.out.println("람다");
         List<Dto> dtoList = Arrays.asList(dtoArr);
         RevolutionDto revolutionDto = dtoList.stream()
                                              .filter(s->s.getId()%2 == 0)
                                               .collect(
                                                       ()->new RevolutionDto(),
                                                       (r,t)->r.accumulated(t),
                                                       (r1,r2) ->r1.combine(r2));
         RevolutionDto revolutionDto1 = dtoList.stream().filter(s->s.getId()%2 ==0).collect(RevolutionDto::new,RevolutionDto::accumulated,RevolutionDto::combine);     
         System.out.println(revolutionDto);
         System.out.println(revolutionDto1);

     //type으로 group 하기

         Map<?,List<Dto>> dtoGroupingMap =dtoList.stream().collect(Collectors.groupingBy(Dto::getId));
         Map<?,List<Dto>> dtoGroupingMapOrderById =dtoList.stream().collect(Collectors.groupingBy(Dto::getId));
         System.out.println("dtoGroupingMap:::::"+dtoGroupingMap.toString().toString());  
         System.out.println("dtoGroupingMapOrderById:::::"+dtoGroupingMapOrderById.toString().toString());  

         //type으로  type1,2 각각의 id의 평균치를 계산 
         Map <String,Double> dtogroupingMapByType =  dtoList.stream().collect(Collectors.groupingBy(Dto::getType,Collectors.averagingDouble(Dto::getId)));
         System.out.println("dtogroupingMapByType::::::::"+dtogroupingMapByType.toString().toString());


         //type을 키로 하고 나머지 id를 쉼표로 가져오는 방법 
         Map<?,?> dtogroupingMapByTypeCombineSemiCol = dtoList.stream().collect(Collectors.groupingBy(Dto::getType,Collectors.mapping(Dto::getName,Collectors.joining(","))));
>          System.out.println("dtogroupingMapByTypeCombineSemiCol::::::::"+dtogroupingMapByTypeCombineSemiCol.toString().toString());
    }
}

    List<Example> examList = new ArrayList<Example>();
    examList.add(new Example(1, "1111"));
    examList.add(new Example(2, "2111"));
    examList.add(new Example(3, "3111"));
    examList.add(new Example(4, "4111"));

    Stream<Example> streamList = examList.stream();
    streamList.forEach(s -> {
        String name = s.getName();
        int id = s.getId();
        System.out.println("[name]:::::" + name);
        System.out.println("[id]:::::" + id);
    });
    // stream은 재사용이 안된다 .따라서 list에서 따로 다시 빼던가 해야됨

       //double average= streamList.mapToDouble(Example::getId).average().getAsDouble();

       //System.out.println("[평균]:"+average);

    IntStream intStream = IntStream.range(1, 100);
    int sumOne = intStream.sum();
    System.out.println("sumOne::::" + sumOne);
    streamList.close();

    Stream<Example> streamList12 = examList.stream();
    int sum = streamList12.filter(s -> "1111".equals(s.getName())).distinct()
                  .mapToInt(Example::getId).sum();
    System.out.println(sum);

    List<String> nameList = Arrays.asList("AAA", "BBB", "CCC", "AAA", "BBB", "DDD");
    Stream<String> nameStream = nameList.stream().distinct();
    nameStream.forEach(s -> {
        System.out.println(s);
    });
    nameStream.close();
    Stream<String> nameStream12 = nameList.stream();
    nameStream12.filter(s -> s.startsWith("A"))
                    .forEach(s -> System.out.println("startWith:[A]" + s)

    );

    nameList.stream().flatMap(d -> {
        String[] arr = d.split(",");
        return Arrays.stream(arr);
    }).forEach(s -> System.out.println(s));

    int[] intArray = { 1, 2, 3, 4, 5 };
    IntStream intStreams = Arrays.stream(intArray);
    intStreams.asDoubleStream().forEach(System.out::println);
    intStreams.close();
    intStreams = Arrays.stream(intArray);
    intStreams.boxed().forEach(System.out::println);
}

}

https://ict-nroo.tistory.com/43 참조

public class innerClassExample {

    public static int test(MathInterface mathInterface) {
        return mathInterface.cal(4, 5);
    }

    public static void main(String args[]) {
        MathInterface mathInterface  = new MathClass() 
        {

            @Override
            public int cal(int a, int b) {
                System.out.println("run implments[Not] lamdaType");
                return a + b;
            }
        };
        int result = test(mathInterface);
        System.out.println(result);


       MathInterface mathInterface1 = (a,b)->{return a*b;};    
       int AA = mathInterface1.cal(1, 2);
       System.out.println("결과값은 "+AA);
    }

}

참고자료 : https://nowonbun.tistory.com/499?category=636956

그냥 대충 만든 코드 제네릭이 뭔지 알기위한 그런 코드니 참고용으로만 봐주세요

1 . 제네릭 class

public class GenericSource<T> {
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

}



public class GenericSource2<T> {

    private int test2;
    private int test3;

    public int getTest2() {
        return test2;
    }

    public void setTest2(int test2) {
        this.test2 = test2;
    }

    public int getTest3() {
        return test3;
    }

    public void setTest3(int test3) {
        this.test3 = test3;
    }

    @Override
    public String toString() {
        return "GenericSource2 [test2=" + test2 + ", test3=" + test3 + "]";
    }

}

2. 인터페이스의 경우

 interface InterFaceExample <T1,T2>{
    T1 testMethod12(T2 t);
    T2 testMethod13(T1 t);
}

public class TestInterface implements InterFaceExample<String, Integer>{

    @Override
    public String testMethod12(Integer t) {
        return String형태;
    }

    @Override
    public Integer testMethod13(String t) {
        return Integer형태;
    }
} 

3.메소드를 사용할시에

//메소드의 파라미터 T 이 선언되어 있다면, 리턴타입 바로앞에 제너릭 타입을 선언해주어야한다.

public class TestGenericMethod {

 public static <T> List<T> methodEx(List<T> list,T item)
 {
     list.add(item);
     return list;
 }

-->T를 String 클래스 타입으로 바꿔봐도 OK

 public static <String> List<String> methodEx12(List<String> list,String item)
 {
     list.add(item);
     return list;
 }

 public static <Integer> List<Integer> methodEx12(List<Integer> list,String item)
 {
     list.add(item);
     return list;
 } 

//parameter에서 형태의 List가 들어가니 리턴도 그걸로 해주겠다라는거 같다

}

4. Main함수나 실행 클래스에서 제네릭 클래스 테스를 해봤다

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

          GenericSource<Integer> test = new GenericSource<Integer>();
        GenericSource<String> test1 = new GenericSource<String>();
        test.setT(10);


          test.setT("test123"); error[test에는 문자열이 들어올수없다 위에 이미 선언을 해놔서]

        test.setT(123);// integer으로 했을떄 정상

        test1.setT(123); error[test1 변수는 String 클래스만 들어오게 설정해놔서 int형은 들어올수 없다]
        // String 으로 했을 경우는 정상 
        test1.setT("test123"); 

        String paramStr = "1";
        Integer paramint =0;

        List<String> strList = new ArrayList<String>();
        List<Integer> intList = new ArrayList<Integer>();

        TestMethod.methodEx(strList, paramStr);(O);
        TestMethod.methodEx(strList, paramint);(X);
    }
}

5.다음으로 WildCard라는게 있다

  1. Generic 타입에는 <?>도 존재한다.
  2.?는 알수없는 타입이며, 사용법으로는 아래와같다
  3.<?> : 모든 객체 자료형, 내부적으로는 Object로 인식
  4.<? super 객체형> : 명시된 객체자료형의 상위 객체, 내부적으로는 Object로 인식
5.<? extends 객체자료형> : 명시된 객체자료형을 상속한 하위객체, 내부적으로는 명시된     객체 자료형으로 인식