📃 요약

자바는 웹 프로그램을 개발하는데 특화된 컴파일 언어이자 벡엔드 개발 전문 언어임. 플랫폼에 독립적이라서 어떤 운영체제(OS)에서도 실행이 가능하며 가상머신을 통해 실행됨

요소 기술 :

Basic : 자바

📃 기술 구현

스펙 :

 intellij
 java

📃 주요 자바API

    자바에서 코딩시에 활용할 수 있는 유용한 함수를 제공함. 이것을 API 함수라고 함

1) Object 클래스 :

• 자바의 최상위 부모 클래스, 모든 자바 객체에서 사용가능( 자동 상속되고, extends 키워드는 생략됨 ),
• 기본적인 함수들이 있음(.equals(), .hashCode(), .toString() 등)

(1) .equals() 함수 :

• 객체를 동등 비교 : 객체가 동등하다는 것은 2개의 속성이 같다라는 뜻
• String 객체를 제외한 모든 객체는 .equals() 함수르 쓰면 주소(방번호) 비교를 하기때문에 재정의해서 사용해야 함
• String 객체는 .equals() 값비교가 됨( String 에서 재정의 되어 있음 : 자바에서 미리 재정의함 )

Member.java

public class Member {
//    속성
    public String id;

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

//    Object : 객체의 최고 조상(부모) 클래스
//    객체의 .equals 함수 재정의
    @Override
    public boolean equals(Object obj) {
        if(obj instanceof Member) {
//            강제 형변환
            Member member =(Member)obj;
//            속성의 id 값 매개변수값 id를 비교해서 같은면 true
//            틀리면 false
            if(this.id.equals(member.id)) {
                return true;
            }
        }
        return false;
    }
}

MemberApplication.java

public class MemberApplication {
    public static void main(String[] args) {
        Member member = new Member("blue"); // 방번호(주소) 1
        Member member2 = new Member("blue"); // 방번호(주소) 2
        Member member3 = new Member("red");

//        객체 비교 시 .equals 방번호(주소) 비교
        if(member.equals(member2)) {
            System.out.println("member 와 member2는 같습니다.");
        } else {
            System.out.println("member 와 member2는 다릅니다.");
        }
    }
}

(2) .hashCode() 함수 :

• 객체를 식별하는 유일한 정수값
  1) 번호는 중복되면 안됨,
  2) 주로 방번호(주소값)으로 해쉬코드를 사용함
  3) 해쉬코드를 자동으로 만들어주는 해쉬함수에 의해 구해짐
• HashMap, HashSet 라는 자료구조는 해쉬코드로 객체 비교를 하기때문에 재정의해서 사용해야 함
• 해쉬코드 재정의 : 객제 2개가 같다라는 것을 정의하기 위해 사용.
  1) 주로 속성의 값이 항상 같도록 결과 내보내기함

Member.java

public class Member {
//    속성
    public String id;

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

//    Object : 객체의 최고 조상(부모) 클래스
//    객체의 .equals 함수 재정의
    @Override
    public boolean equals(Object obj) {
        if(obj instanceof Member) {
//            강제 형변환
            Member member =(Member)obj;
//            속성의 id 값 매개변수값 id를 비교해서 같은면 true
//            틀리면 false
            if(this.id.equals(member.id)) {
                return true;
            }
        }
        return false;
    }

//    해쉬코드 재정의
//    id속성이 2개가 같으면 해쉬코드도 같음
//    String 객체의 특징 : 문자열이 같으면 같은 방번호를 씀
    @Override
    public int hashCode() {
        return id.hashCode();
    }
}

(3) .toString() 함수 :

• 객체를 문자열로 변환하는 함수
• 객체만 출력함수에 매개변수(인자)로 넣어도 자동으로 .toString() 함수가 실행됨(생략가능)
• 객체의 속성(필드) 정보 출력하기.
  1) 객체의 핵심 정보는 속성(필드)임
  2) 재정의 않하면 객체 출력시 방번호(주소값)가 출력됨(배열과 같음)
  3) 재정의 대상 : 객체의 속성이 출력되도록 재정의함

SmartPhone.java

public class SmartPhone {
    private String company;
    private String os;

    public SmartPhone(String company, String os) {
        this.company = company;
        this.os = os;
    }

//    toString() 재정의
//    속성의 값을 볼수 있게 함수 재정의
    @Override
    public String toString() {
        return this.company + "," + this.os;
    }
}

SmartPhoneApplication.java

public class SmartPhoneApplication {
    public static void main(String[] args) {
        SmartPhone smartPhone = new SmartPhone("구글", "안드로이드");

//        .toString() 함수 : 객체를 문자열로 변환하는 함수
//        출력 : 패키지명+클래스명@16진수해쉬코드
//        개발자 기대하는 출력 : 속성의 값들을 보고 싶다.
        System.out.println(smartPhone.toString());
    }
}

2) Wrapper 클래스 :

• 기본 자료형 : byte, short, int, long, float, double, char, boolean
• 위의 자료형을 객체로 변환해야 할때가 있음
• 주로 표기할때 풀네임(Full Name)으로 사용하고 첫글자로 대문자를 사용함
  1) int -> Integer
  2) long. -> Long
  3) double -> Double
  4) boolean -> Boolean
  5) char -> Charater
  6) 기타 등등
• Boxing : 기본자료형 -> 객체 변환
• UnBoxing : 객체 -> 기본자료형
• 과거에는 특정 함수를 이용해서 Boxing/UnBoxing 했지만, 지금은 함수사용하지 않고 바로 사용가능

BoxingApplication.java

public class BoxingApplication {
    public static void main(String[] args) {
//        기본 자료형 : byte, short, int, long, float, double, char, boolean
//        위의 자료형을 객체로 변환해야 할때가 있음
//        int -> Integer 객체 있음
//        double -> Double 객체 있음
//        boolean -> Boolean 객체 있음

//        기본자료형 -> 객체 변환 : Boxing
        Integer obj1 = new Integer(100); // 객체 정수형(Wrapper Class), 옛날방식
        Integer obj2 = 100; // 기본자료형 -> 객체 자동변환(AutoBoxing), 요즘방식

//        객체 -> 기본자료형 : UnBoxing
        int value1 = obj1.intValue(); // 원복
        int value2 = obj2; // 자동 변환(객체 -> 기본자료형)

        System.out.println(value1);
        System.out.println(value2);
    }
}

📃 컬렉션(자료구조) 프레임워크

    널리 알려진 자료구조를 사용해서 만들어 놓은 클래스

1) 자료구조 :

• 자료(데이터)들을 효율적으로 사용하기 위한 구조(방)를 말함
• 배열이 가장 쉬운 자료구조이며 이것을 개선한 여러가지 자료구조가 있음

2) 컬렉션 프레임워크 :

• 널리 알려져 있는 자료구조를 사용해서 객체들을 효율적으로 추가, 삭제, 검색할 수 있도록 만들어 놓은 클래스들
• 대표적으로 List, Set, Map 이 있음

3) List :

• 배열을 개선한 자료구조(컬렉션)로 인덱스번호를 내부에 가지고 있음
• 추가/삭제/검색을 위한 다양한 함수들을 제공함
• 
  

  특징 :

  
  

  1) 순서가 있음(index 번호)
  2) 중복 저장 허용
  3) 구현 클래스는 ArrayList(*), LinkedList, Vector 가 있음
  4) ArrayList 는 순차적으로 추가/삭제 시 성능이 좋음
  5) LinkedList 는 중간에 추가/삭제 시 성능이 좋음
  6) Vector 는 멀티쓰레드 환경에서 사용하는 자료구조임

  
  

public class ArrayListApplication {
    public static void main(String[] args) {
//        다형성 : 인터페이스(부모) 변수명 = new 구현클래스();
//        list 객체 <- ArrayList , Vector, LinkedList
//        <제한할자료형> : 제네릭 , 객체 자료형을 제한하기 위해 사용
        List<String> list = new ArrayList<>();

//        개선된 배열 : ArrayList
//        객체.add(문자열) : 개선된 배열에 자료 생성하는 함수
        list.add("Java");
        list.add("JDBC");
        list.add("Servlet/JSP");
        list.add(2, "Database");
//        JPA/ myBatis : JPA(단순 질의) + myBatis(복잡한 질의)
        list.add("myBATIS"); // Springboot framework 데이터베이스 연결하기 위한 용도의 프레임워크
        System.out.println(list); // [Java, JDBC, Database, Servlet/JSP, myBATIS]

//        배열 크기 가져오기
        int size = list.size();
        System.out.println("총 객체수 :" + size);
        System.out.println("-------3번째 자료 가져오기");

//        3번째 자료 가져오기
        String skill = list.get(2);
        System.out.println("3번째 자료 : " + skill);
        System.out.println("----------모두 출력하기------------");

//        ArrayList 안의 자료 모두 출력하기
        for (int i = 0; i < list.size(); i++) {
//            객체.get(인덱스번호) : 인덱스번호에 해당하는 자료 조회하기(검색하기)
            String str = list.get(i);
            System.out.println(i + " : " + str);
        }
        System.out.println("-------수정하기--------------");

//       자료 수정하기
        list.set(0, "자바");
        System.out.println("수정된 값 : " + list.get(0));
        System.out.println("----------삭제하기--------------");

//        삭제하기
//      객체.remove(인덱스번호) : 배열의 인덱스번호에 해당하는 자료 삭제하기
//      ArrayList : 중간에 삭제되면 뒤에 자료가 그 공간으로 자동 당겨짐
//                  중간에 추가되면 뒤로 한칸씩 밀림
        list.remove(2);
        list.remove(2);
        list.remove("myBATIS");

        //        ArrayList 안의 자료 모두 출력하기
        for (int i = 0; i < list.size(); i++) {
//            객체.get(인덱스번호) : 인덱스번호에 해당하는 자료 조회하기(검색하기)
            String str = list.get(i);
            System.out.println(i + " : " + str);
        }

        System.out.println("-------------모두 삭제하기---------------");

//        모두 삭제하기
        list.clear();

        if(list.isEmpty() == true) {
            System.out.println("모두 삭제됨");
        }
    }
}

4) Set : 집합을 구현한 자료구조

• 
  

  특징 :

  
  

  1) 순서가 없음, 중복 저장 안됨
  2) 만약 중복 저장하면 나중값이 들어가지 않음
  3) 구현 클래스는 HashSet 이 있음

  
  

public class HashSetApplication {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();

//        .add(객체) : set 자료 추가
        set.add("Java");
        set.add("JDBC");
        set.add("Servlet/JSP");
        set.add("Java");
        set.add("myBATIS");
        System.out.println(set); // [Java, myBATIS, JDBC, Servlet/JSP]

//        자료 크기 보기
        int size = set.size();
        System.out.println("총 객체수 : " + size);

//        자료 출력
        for(String element : set) {
            System.out.println("\t" + element);
        }

//        자료 삭제하기
        set.remove("JDBC");
        set.remove("myBATIS");

        System.out.println("---------------------------");

        //        자료 출력
        for(String element : set) {
            System.out.println("\t" + element);
        }

        System.out.println("---------------------------");

//        모두 삭제
        set.clear();
//        set.isEmpty() : 집합에 자료가 있는지 없는지 검사 , 없으면 true, 있으면 false
        if(set.isEmpty() == true) {
            System.out.println("비워 있음");
        }
    }
}

5) Map : (키, 값) 으로 구성된 자료구조(1개를 Entry 라고 함)

• 
  

  특징 :

  
  

  1) 키는 중복 저장될 수 없지만, 값은 중복 저장될 수 있음
  2) 만약 (키, 값)을 중복 저장하면 기존의 값이 나중 값으로 대치됨
  3) 구현 클래스는 HashMap(*), HashTable(멀티쓰레드에서 사용) 등이 있음

  
  

public class HashMapApplication {
    public static void main(String[] args) {
//        Map 자료 구조 생성
        Map<String, Student> map = new HashMap<>();

//      map객체.put(키, 값) : 객체 추가
        map.put("신용권", new Student(1,"신용권")); // 1st Entry
        map.put("홍길동", new Student(1,"홍길동")); // 2nd Entry
        map.put("동장군", new Student(1,"동장군"));
        map.put("홍길동", new Student(1,"홍길동"));
        System.out.println(map); // {홍길동=Student{sno=1, name='홍길동'}, 신용권=Student{sno=1, name='신용권'}, 동장군=Student{sno=1, name='동장군'}}

//      map.size() : map 객체 크기 보기
        System.out.println("총 Entry 수 :" + map.size());
        System.out.println("----------키에 해당하는 값보기----------");

//      map.get(키) : 키에 해당하는 값을 보기
        System.out.println("홍길동 :" + map.get("홍길동"));
        System.out.println();
        System.out.println("----------키만 있는 집합 변경 : 값 출력----------");

// Map -> Set 변환 : 키만 있는 집합
        Set<String> keySet = map.keySet();
        System.out.println(keySet);
        System.out.println("----------향상된 for 문으로 출력:키/값-----------");

//        향상된 for문으로 출력
        for (String key:keySet) {
            Student student = map.get(key); // 키로 값을 조회
            System.out.println(key + " : " + student);
        }

        System.out.println("---------자료 삭제----------"); // 줄바꿈

//        자료 삭제
        map.remove("홍길동");
        System.out.println("홍길동: " + map.get("홍길동"));
        System.out.println("----------모두 삭제-----------");

//        자료 모두 삭제
        map.clear();

        if(map.isEmpty() == true) {
            System.out.println("모두 삭제되었습니다.");
        }
    }
}

📃 LIFO 와 FIFO 컬렉션(자료구조)

• 널리 알려진 자료구조 중 자료추가 및 꺼낼 때 순서가 달라지는 자료구조가 있음
• 대표적으로 Stack(스택) / Queue(큐) 가 위와 같이 구조를 가짐

1) Stack(스택) :

• LIFO(Last In First Out, 후입선출) 을 구현한 클래스
• 마지막에 들어간 자료가 먼저 나옴

Coin.java

public class Coin {
    private int value;

//  생성자 : alt+insert
    public Coin(int value) {
        this.value = value;
    }

//    getter : 속성의 값을 조회하는 함수 (alt + insert)
    public int getValue() {
        return value;
    }

//    setter : 속성의 값을 저장하는 함수 (alt + insert)
    public void setValue(int value) {
        this.value = value;
    }
}

StackApplication.java

public class StackApplication {
    public static void main(String[] args) {
//        스택 객체 생성
        Stack<Coin> coinStack = new Stack<>();

//        Coin 객체가 Stack 4개가 들어감
        coinStack.push(new Coin(100));
        coinStack.push(new Coin(50));
        coinStack.push(new Coin(500));
        coinStack.push(new Coin(10)); // 먼저 나옴

//        스택객체.isEmpty() : 스택에 자료가 있는지 없는지 확인, 하나도 없으면 true,
//                           하나라도 있으면 false
        while (!coinStack.isEmpty()) {
            Coin coin = coinStack.pop(); // 스택에서 한개(Coin 객체) 꺼내기
//            coin.getValue() : Coin 객체의 getter 함수 ( 명명법 : get속성명() )
            System.out.println("꺼낸 동전 : " + coin.getValue() + "원");
        }
    }
}

2) Queue(큐) :

• FIFO(First In First Out, 선입선출) 을 구현한 인터페이스
• 먼저 들어간 자료가 먼저 나옴
• 구현 클래스는 주로 LinkedList를 사용함

Message.java

public class Message {
//    속성
    public String command;
    public String to;

//    생성자
    public Message(String command, String to) {
        this.command = command;
        this.to = to;
    }
}

MessageApplication.java

public class MessageApplication {
    public static void main(String[] args) {
//        큐 객체 생성 : 다형성
//        부모인터페이스 변수 = new 자식클래스();
        Queue<Message> messageQueue = new LinkedList<>();

//        큐에 자료 저장
//        new Message(명령어, Who)
        messageQueue.offer(new Message("sendMail", "홍길동"));
        messageQueue.offer(new Message("sendSMS", "신용권"));
        messageQueue.offer(new Message("sendKakaotalk", "홍두깨"));

//        큐에 내용 출력
//        큐객체.isEmpty() : 큐안에 자료가 있는지 없는지 확인 함수(없으면:true, 있으면:false)
        while(!messageQueue.isEmpty()) {
//            자료 한개 꺼내기(Message 객체)
            Message message = messageQueue.poll();
            switch (message.command) {
                case "sendMail":
                    System.out.println(message.to + "님에게 메일을 보냅니다.");
                    break;
                case "sendSMS":
                    System.out.println(message.to + "님에게 SMS를 보냅니다.");
                    break;
                case "sendKakaotalk":
                    System.out.println(message.to + "님에게 카카오톡을 보냅니다.");
                    break;
            }

        }

    }
}

📃 Arrays / Collections

• Arrays : 고전적 배열에 관련된 유용한 함수들이 있는 클래스
• Collections : 컬렉션 프레임워크(List, Set, Map)에 있는 유용한 함수들이 있는 클래스
• 주로 코딩테스트나 프로젝트 시 활용가능함

1) Arrays :

• Arrays : 고전적 배열에 관련된 유용한 함수들이 있는 클래스

(1) Arrays.toString(배열) / Arrays.deepToString(배열)

    사용법 : Arrays.toString(배열)     : 1차원 배열의 모든값 문자열로 내보내기(리턴)
    사용법 : Arrays.deepToString(배열) : 2차원 배열의 모든값 문자열로 내보내기(리턴)

public class ArraysApplication {
    public static void main(String[] args) {
        int[] arr = {0,1,2,3,4};
        int[][] arr2D = { {11,12,13}, {21,22,23}};

//        사용법 : Arrays.toString(배열) -> 배열의 값이 보임
        System.out.println("arr=" + Arrays.toString(arr)); // 1차원 배열 값 보기
        System.out.println("arr2D=" + Arrays.deepToString(arr2D)); // 2차원 배열 값 보기        

    }
}

(2) Arrays.fill(배열, 값)

    사용법 : Arrays.fill(배열, 값); 배열의 모든원소를 특정값으로 채우기

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

        int[] arr7 = new int[5];

//      사용법 : Arrays.fill(배열, 값); 배열의 모든원소를 특정값으로 채우기
        Arrays.fill(arr7, 9); // arr7=[9,9,9,9,9]
        System.out.println("arr7=" + Arrays.toString(arr7));      

    }
}

(3) Arrays.sort(배열, Collections.reverseOrder()) / Arrays.sort(배열)

    사용법 : Arrays.sort(배열); 배열의 모든원소를 오름차순 정렬
    사용법 : Arrays.sort(배열, Collections.reverseOrder()); 배열의 모든원소를 내림차순 정렬
    - 듀얼피봇 퀵정렬 알고리즘 사용 : 변형된 퀵정렬 알고리즘, 이리 정렬된 데이터를 정렬할 경우를 제외하고 
                               빠른 알고리즘 중 1개  

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

        Character[] chArr = {'A', 'D', 'C', 'B', 'E'};         // char(정렬시 기본자료형 사용못함)

        Arrays.sort(chArr, Collections.reverseOrder());        // 내림차순 정렬
        System.out.println("chArr=" + Arrays.toString(chArr)); // 정렬된 배열 출력 

        Arrays.sort(chArr);                                    // 오름차순 정렬
        System.out.println("chArr=" + Arrays.toString(chArr)); // 정렬된 배열 출력   

    }
}

(4) Arrays.binarySearch(배열, 값)

    사용법 : Arrays.binarySearch(배열, 값); 배열에서 갑을 찾은 후에 인덱스번호를 내보내기함(리턴)
    사용 전에 미리 오름차순 정렬되어 있어야함

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

        Character[] chArr = {'A', 'D', 'C', 'B', 'E'};         // char(정렬시 기본자료형 사용못함)

        Arrays.sort(chArr);                                    // 오름차순 정렬
        System.out.println("B의 인덱스번호 : " + Arrays.binarySearch(chArr, 'B'));

    }
}

(5) Arrays.asList(배열)

    사용법 : Arrays.asList(배열) : 배열을 리스트로 변환

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

        List list = new ArrayList(Arrays.asList(1,2,3,4,5)); // 배열을 리스트로 변환
        System.out.println(list);                            // List 의 값 보기

    }
}

2) Collections :

• Collections : 컬렉션 프레임워크(List, Set, Map)에 있는 유용한 함수들이 있는 클래스

(1) Collections.addAll(향상된배열, 배열값)

    사용법 : Collections.addAll(향상된배열, 배열값) : 배열값이 향상된배열에 들어감

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

        List list = new ArrayList();

        Collections.addAll(list, 1,2,3,4,5);
        System.out.println(list);      

    }
}

(2) Collections.rotate(향상된배열, 오른쪽칸이동)

    사용법 : Collections.rotate(향상된배열, 오른쪽칸이동) : 배열값을 오른쪽으로 두 칸씩 이동

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

        List list = new ArrayList();
        Collections.addAll(list, 1,2,3,4,5);

//        사용법 : Collections.rotate(향상된배열, 오른쪽칸이동)
        Collections.rotate(list, 2);
//        [4,5,1,2,3]
        System.out.println(list);   

    }
}

(3) Collections.swap(향상된배열, 원본요소, 바꿀요소)

    사용법 : Collections.swap(향상된배열, 원본요소, 바꿀요소) : 원본요소에서 바꿀요소로 값 교환(swap)

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

        List list = new ArrayList();
        Collections.addAll(list, 1,2,3,4,5);     

//        사용법 : Collections.swap(향상된배열, 원본요소, 바꿀요소)
        Collections.swap(list, 0, 2);
        System.out.println(list);

    }
}

(4) Collections.sort(향상된배열) / Collections.sort(향상된배열, reverseOrder())

    사용법 : Collections.sort(향상된배열)                 : 향상된배열을 오름차순 정렬
    사용법 : Collections.sort(향상된배열, reverseOrder()) : 향상된배열을 내림차순 정렬
    - Tim 정렬 알고리즘 사용 : 삽입(Insertion) 정렬과 합병(Merge) 정렬을 결합하여 만든 정렬
            빠른 알고리즘 중 1개

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

        List list = new ArrayList();
        Collections.addAll(list, 2,4,3,1,5);  

        Collections.sort(list, reverseOrder()); // 내림차순
        System.out.println(list);

        Collections.sort(list);                 // 오름차순
        System.out.println(list);

    }
}

(5) Collections.binarySearch(향상된배열, 검색할값)

    사용법 : Collections.binarySearch(향상된배열, 검색할값) : 값을 찾아서 그 위치의 인덱스번호 내보내기(리턴)
    - 사용 전 오름차순 정렬되어 있어야 함

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

        List list = new ArrayList();
        Collections.addAll(list, 2,4,3,1,5);        

        Collections.sort(list);                 // 오름차순
        int idx = Collections.binarySearch(list, 3); // 3의 값이 있는 인덱스 위치가 리턴
        System.out.println("3의 위치 : " + idx);        

    }
}

(6) Collections.fill(향상된배열, 채울값)

    사용법 : Collections.fill(향상된배열, 채울값) : 값으로 향상된배열을 채움

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

        List list = new ArrayList();
        Collections.addAll(list, 2,4,3,1,5);        

//        사용법 : Collections.fill(향상된배열, 채울값)
        Collections.fill(list, 9);
        System.out.println("list=" + list);      

    }
}