class Student implements Comparable<Student>{
    private int num;
    private String name;
    private int kor;
    private int eng;
    private int math;
    private int score;
    private int rank;

    public Student(int num, String name, int kor, int eng, int math){
        this.num = num;
            this.name = name;
            this.kor = kor;
            this.eng = eng;
            this.math = math;
            this.score = kor + eng + math;
            this.rank = 1;
    }

    public int getNum() {
            return num;
    }

    public void setNum(int num) {
            this.num = num;
      }    

       public String getName() {
              return name;
       }

       public void setName(String name) {
              this.name = name;
       }

       public int getKor() {
              return kor;
       }

       public void setKor(int kor) {
              this.kor = kor;
       }

       public int getEng() {
              return eng;
       }

       public void setEng(int eng) {
              this.eng = eng;
       }

       public int getMath() {
              return math;
       }

       public void setMath(int math) {
              this.math = math;
       }

         public int getScore() {
              return score;
       }

       public void setScore(int score) {
              this.score = score;
       }

       public int getRank() {
              return rank;
       }

       public void setRank(int rank) {
              this.rank = rank;
       }

    @Override
       public String toString() {
        return "Student [num=" + num + ", name=" + name + ", kor=" + kor
                    + ", eng=" + eng + ", math=" + math + ", score=" + score
                    + ", rank=" + rank + "]";
       }
}

이 Student 객체는 List에 저장하여 관리한다.

public static void main(String[] args) {
    ArrayList<Student> list = new ArrayList<>();

    list.add(new Student(1, "홍길동", 50, 30, 80));
      list.add(new Student(10, "이순신", 80, 50, 90));
     list.add(new Student(3, "변학도", 50, 65, 56));
      list.add(new Student(8, "김철수", 80, 75, 42));
      list.add(new Student(6, "김영희", 15, 85, 42));
      list.add(new Student(5, "강감찬", 58, 56, 55));
      list.add(new Student(7, "이세종", 58, 56, 55));
      list.add(new Student(4, "이덕재", 59, 95, 56));
     list.add(new Student(9, "장희빈", 60, 80, 81));
      list.add(new Student(2, "김지희", 89, 88, 95));
}

List에 저장된 데이터들을 학번의 오름차순으로 정렬할 수 있는 내부 정렬 기준을 구현하고,

class Student implements Comparable<Student>{
    @Override
      public int compareTo(Student stu) {
        return Integer.compare(this.num, stu.getNum());
      }
}

public static void main(String[] args) {
    //학번의 오름차순(내부 정렬 기준)
      Collections.sort(list);

     System.out.println("학번 오름차순");
      for(Student stu : list){
             System.out.println(stu);
    }
    //학번 오름차순
    //Student [num=1, name=홍길동, kor=50, eng=30, math=80, score=160, rank=9]
    //Student [num=2, name=김지희, kor=89, eng=88, math=95, score=272, rank=1]
    //Student [num=3, name=변학도, kor=50, eng=65, math=56, score=171, rank=6]
    //Student [num=4, name=이덕재, kor=59, eng=95, math=56, score=210, rank=4]
    //Student [num=5, name=강감찬, kor=58, eng=56, math=55, score=169, rank=7]
    //Student [num=6, name=김영희, kor=15, eng=85, math=42, score=142, rank=10]
    //Student [num=7, name=이세종, kor=58, eng=56, math=55, score=169, rank=7]
    //Student [num=8, name=김철수, kor=80, eng=75, math=42, score=197, rank=5]
    //Student [num=9, name=장희빈, kor=60, eng=80, math=81, score=221, rank=2]
    //Student [num=10, name=이순신, kor=80, eng=50, math=90, score=220, rank=3]
}

총점의 역순(내림차순)으로 정렬하는데 총점이 같으면 이름의 오름차순으로 정렬되는 외부 정렬 기준 클래스를 작성하여 정렬된 결과를 출력하시오.

class scoreDesc implements Comparator<Student> {

    @Override
      public int compare(Student stu1, Student stu2) {
        if(stu1.getScore() > stu2.getScore()){
                return -1;
            }else if(stu1.getScore() < stu2.getScore()){
                  return  1;
            }else{
                  if(stu1.getName().compareTo(stu2.getName()) > 0){
                      return -1;
                  }else if(stu1.getName().compareTo(stu2.getName()) < 0){
                    return 1;
            }else{
                    return 0;
                }
        }
    }
}

public static void main(String[] args) {
    //총점의 내림차순(외부 정렬 기준 클래스), 총점이 같으면 이름의 오름차순
      Collections.sort(list, new scoreDesc());
      System.out.println("총점 내림차순...");
      for(Student stu : list){
          System.out.println(stu);
      }
}
//총점 내림차순...
//Student [num=2, name=김지희, kor=89, eng=88, math=95, score=272, rank=1]
//Student [num=9, name=장희빈, kor=60, eng=80, math=81, score=221, rank=2]
//Student [num=10, name=이순신, kor=80, eng=50, math=90, score=220, rank=3]
//Student [num=4, name=이덕재, kor=59, eng=95, math=56, score=210, rank=4]
//Student [num=8, name=김철수, kor=80, eng=75, math=42, score=197, rank=5]
//Student [num=3, name=변학도, kor=50, eng=65, math=56, score=171, rank=6]
//Student [num=5, name=강감찬, kor=58, eng=56, math=55, score=169, rank=7]
//Student [num=7, name=이세종, kor=58, eng=56, math=55, score=169, rank=7]
//Student [num=1, name=홍길동, kor=50, eng=30, math=80, score=160, rank=9]
//Student [num=6, name=김영희, kor=15, eng=85, math=42, score=142, rank=10]

(등수는 List 전체 데이터가 추가된 후에 저장되도록 한다.)

public static void main(String[] args) {
    rank(list);
}

private static void rank(ArrayList<Student> list) {
    //석차
      for (int i = 0; i < list.size(); i++) {
          for (int j = 0; j < list.size(); j++) {
                if (list.get(i).getScore() < list.get(j).getScore()) {
                      int rank = list.get(i).getRank();
                    rank += 1;
                    list.get(i).setRank(rank);
                  }
            }
      }
}

샘풀이

학번, 이름, 국어점수, 영어점수, 수학점수, 총점, 등수를 멤버로 갖는 Student클래스를 작성한다. 이 클래스의 생성자에서는 학번, 이름, 국어점수, 영어점수, 수학점수만 매개변수로 받아서 초기화 처리한다.

class Student implements Comparable<Student>{
    private int num;
    private String name;
    private int kor;
    private int eng;
    private int math;
    private int score;
    private int rank;

    public Student(int num, String name, int kor, int eng, int math){
        this.num = num;
            this.name = name;
              this.kor = kor;
            this.eng = eng;
            this.math = math;
            this.score = kor + eng + math;
    }

    public int getNum() {
            return num;
    }

    public void setNum(int num) {
            this.num = num;
      }

       public String getName() {
              return name;
       }

       public void setName(String name) {
              this.name = name;
       }

       public int getKor() {
              return kor;
       }

       public void setKor(int kor) {
              this.kor = kor;
       }

       public int getEng() {
            return eng;
       }    

       public void setEng(int eng) {
              this.eng = eng;
       }

       public int getMath() {
              return math;
       }

       public void setMath(int math) {
              this.math = math;
       }

       public int getScore() {
              return score;
       }

       public void setScore(int score) {
              this.score = score;
       }

       public int getRank() {
              return rank;
       }

       public void setRank(int rank) {
              this.rank = rank;
       }

    @Override
       public String toString() {
           return "Student [num=" + num + ", name=" + name + ", kor=" + kor
                    + ", eng=" + eng + ", math=" + math + ", score=" + score
                    + ", rank=" + rank + "]";
       }
}

이 Student 객체는 List에 저장하여 관리한다.

public static void main(String[] args) {
    StudentSam t = new StudentSam();

    List<Students> stdList = new ArrayList<>();

    stdList.add(new Students(1, "홍길동", 90, 95, 80));
    stdList.add(new Students(3, "성춘향", 90, 75, 70));
    stdList.add(new Students(7, "강감찬", 95, 95, 80));
    stdList.add(new Students(5, "변학도", 80, 95, 90));
    stdList.add(new Students(2, "일지매", 100, 85, 80));
    stdList.add(new Students(4, "이순신", 60, 65, 70));
    stdList.add(new Students(6, "이몽룡", 90, 100, 90));
}

List에 저장된 데이터들을 학번의 오름차순으로 정렬할 수 있는 내부 정렬 기준을 구현하고,

class Student implements Comparable<Student>{
    @Override
    public int compareTo(Students std) {
        return Integer.compare(this.num, std.getNum());
    }
}

public static void main(String[] args) {
    System.out.println("정렬전...");
    for(Students std : stdList){
        System.out.println(std);
    }
    System.out.println("-------------------------------------------------------------------------");
    System.out.println();

    //학번의 오름차순으로 정렬하기
    Collections.sort(stdList);

    System.out.println("학번의 오름차순 정렬 후...");
    for(Students std : stdList){
        System.out.println(std);
    }
}
//정렬전...
//Student2 [num=1, name=홍길동, kor=90, eng=95, mat=80, tot=265, rank=3]
//Student2 [num=3, name=성춘향, kor=90, eng=75, mat=70, tot=235, rank=6]
//Student2 [num=7, name=강감찬, kor=95, eng=95, mat=80, tot=270, rank=2]
//Student2 [num=5, name=변학도, kor=80, eng=95, mat=90, tot=265, rank=3]
//Student2 [num=2, name=일지매, kor=100, eng=85, mat=80, tot=265, rank=3]
//Student2 [num=4, name=이순신, kor=60, eng=65, mat=70, tot=195, rank=7]
//Student2 [num=6, name=이몽룡, kor=90, eng=100, mat=90, tot=280, rank=1]
//-------------------------------------------------------------------------

//학번의 오름차순 정렬 후...
//Student2 [num=1, name=홍길동, kor=90, eng=95, mat=80, tot=265, rank=3]
//Student2 [num=2, name=일지매, kor=100, eng=85, mat=80, tot=265, rank=3]
//Student2 [num=3, name=성춘향, kor=90, eng=75, mat=70, tot=235, rank=6]
//Student2 [num=4, name=이순신, kor=60, eng=65, mat=70, tot=195, rank=7]
//Student2 [num=5, name=변학도, kor=80, eng=95, mat=90, tot=265, rank=3]
//Student2 [num=6, name=이몽룡, kor=90, eng=100, mat=90, tot=280, rank=1]
//Student2 [num=7, name=강감찬, kor=95, eng=95, mat=80, tot=270, rank=2]

총점의 역순(내림차순)으로 정렬하는데 총점이 같으면 이름의 오름차순으로 정렬되는 외부 정렬 기준 클래스를 작성하여 정렬된 결과를 출력하시오.

class SortByTotal implements Comparator<Students>{

    @Override
    public int compare(Students std1, Students std2) {
        if(std1.getTot() == std2.getTot()){
            return std1.getName().compareTo(std2.getName());
            //String 클래스는 내부 정렬 기준이 구현되어 있다.(default 오름차순)
        }else{
            return Integer.compare(std1.getTot(), std2.getTot()) * -1;
        }
    }

}

public static void main(String[] args) {
    // 총점의 역순으로 정렬하기
    Collections.sort(stdList, new SortByTotal());

    System.out.println("총점의 역순으로 정렬 후....");
    for(Students std : stdList){
        System.out.println(std);
    }
}
//총점의 역순으로 정렬 후....
//Student2 [num=6, name=이몽룡, kor=90, eng=100, mat=90, tot=280, rank=1]
//Student2 [num=7, name=강감찬, kor=95, eng=95, mat=80, tot=270, rank=2]
//Student2 [num=5, name=변학도, kor=80, eng=95, mat=90, tot=265, rank=3]
//Student2 [num=2, name=일지매, kor=100, eng=85, mat=80, tot=265, rank=3]
//Student2 [num=1, name=홍길동, kor=90, eng=95, mat=80, tot=265, rank=3]
//Student2 [num=3, name=성춘향, kor=90, eng=75, mat=70, tot=235, rank=6]
//Student2 [num=4, name=이순신, kor=60, eng=65, mat=70, tot=195, rank=7]

(등수는 List 전체 데이터가 추가된 후에 저장되도록 한다.)

//등수를 구하는 메서드
public void setRanking(List<Students> stdList){
//for(int i = 0; i < stdList.size(); i++){ //기준 데이터를 구하기위한 반복문
//  int rank = 1; //처음에는 1등으로 설정해 놓고 시작한다.
//        for(int j = 0; j < stdList.size(); j++){ //비교 대상을 나타내는 반복문
//            //기준보다 큰 값을 만나면 rank값을 증가시킨다.
//            if(stdList.get(i).getTot() < stdList.get(j).getTot()){
//                rank++;
//                }
//            } //for - j
//            //구해진 등수를 Student 객체의 rank변수에 저장한다.
//            stdList.get(i).setRank(rank);
//            
//        } //for - i

    for(Students std1 : stdList){ //기준 대상
        int rank = 1;

        for(Students std2 : stdList){ //비교 대상
            if(std1.getTot() < std2.getTot()){
                rank++;
            }
        }
        std1.setRank(rank);
    }
}

정렬과 관련된 interface는 Comparable, Comparator 이렇게 두 가지가 있다.

1. Comparable

• Comparable은 Collection에 추가되는 데이터 자체에 정렬기준을 넣고 싶을 때(내부 정렬 기준) 구현하는 interface이다.
• Comparable에서는 compareTo( ) 메서드를 재정의 한다.
• String 클래스, Wrapper 클래스, Date 클래스, File 클래스에는 내부 정렬 기준이 구현되어 있다.(내부 정렬 기준은 보통 오름차순으로 처리되도록 구현되어 있다.)

2. Comparator

• Comparator는 외부에 별도로 정렬 기준을 구현하고 싶을 때 구현(외부 정렬 기준)하는 interface이다.
• Comparator에서는 compare( ) 메서드를 재정의 해야 한다.

public class ListSortTest {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("일지매");
        list.add("홍길동");
        list.add("성춘향");
        list.add("변학도");
        list.add("이순신");

        System.out.println("정렬 전 : " + list);
        //정렬 전 : [일지매, 홍길동, 성춘향, 변학도, 이순신]    
    }
}

Collection의 정렬은 Collections.sort( ) 메서드를 이용한다.

형식1) Collections.sort(리스트);

 =⇒ 내부 정렬 기준이 구현되어 있는 데이터 일 경우에 사용 가능

public static void main(String[] args) {
    Collections.sort(list); //default 오름차순
    System.out.println("정렬 후 : " + list);
    //정렬 후 : [변학도, 성춘향, 이순신, 일지매, 홍길동]

    Collections.shuffle(list); //데이터 섞기
    System.out.println("자료 섞기 후 : " + list);
    //자료 섞기 후 : [일지매, 이순신, 변학도, 성춘향, 홍길동]
}

형식2) Collections.sort(리스트, 외부 정렬 기준 객체의 인스턴스);

       =⇒ 외부 정렬 기준에 맞게 정렬한다.

compare( ) 메서드

1. compare( ) 메서드를 이용해서 정렬 기준을 정해 준다.
2. compare( ) 메서드의 반환값의 역할

• 반환값이 0이면 두 값이 같다.
• 반환값이 양수이면 앞, 뒤의 순서를 바꾼다.
• 반환값이 음수이면 앞, 뒤의 순서를 바꾸지 않는다.

ex) 오름차순일 경우 =⇒ 앞의 값이 크면 양수, 같으면 0, 앞의 값이 작으면 음수를 반환하도록 구현하면 된다.

public static void main(String[] args) {
    // 외부 정렬 기준을 지정해서 정렬하기
    //Desc dd = new Desc();
    //Collections.sort(list, dd);
    Collections.sort(list, new Desc());
    // 객체 생성해도 다른 곳에 쓸 일이 없으므로 현재식이 효율적이다.
    System.out.println("내림차순 정렬 후 : " +  list);
    //내림차순 정렬 후 : [홍길동, 일지매, 이순신, 성춘향, 변학도]
}

//정렬 방식을 외부에서 정해주는 class 작성하기
//즉, 외부 정렬 기준 클래스 작성하기 ==> Comparator 인터페이스를 구현해야 한다.
class Desc implements Comparator<String> {
    @Override
    public int compare(String str1, String str2){
        //내림차순으로 정렬되도록 구현하기
        if(str1.compareTo(str2) > 0){ //내림차순인 상태
            return -1; //음수 반한하면 내림차순 상태
        }else if(str1.compareTo(str2) < 0){
            return 1;
        }else{
            return 0;
        }
    }
}

class Browser{
    private LinkedList<String> back; //이전 방문 내역이 저장될 스택
    private LinkedList<String> forward; //다음 방문 내역이 저장될 스택
    private String currentURL; //현재 페이지

    //생성자
    public Browser(){
        back = new LinkedList<>();
        forward = new LinkedList<>();
        currentURL = "";
    }

    //사이트를 방문하는 메서드 ==> 매개변수에 방문한 url이 저장
    public void goURL(String url){
        System.out.println(url + "사이트로 접속합니다.");
        if(currentURL != null && !"".equals(currentURL)){
            back.push(currentURL);
        }
        currentURL = url;
    }

    //뒤로가기
    public void goBack(){
        //isEmpty() ==> list가 비어있으면 true, 그렇지 않으면 false
        if(!back.isEmpty()){ // 비어있지 않으면
            // 현재 URL을 forward 스택에 추가하고
            forward.push(currentURL);
            // back 스택에서 꺼내온 값을 현재 URL로 한다.
            currentURL = back.pop();
        }
    }

    //앞으로 가기
    public void goForward(){
        if(!forward.isEmpty()){
            // 현재 URL을 back에 추가
            back.push(currentURL);
            // forward에서 꺼내온 값을 현재 URL로 한다.
            currentURL = forward.pop();
        }
    }

    //방문 기록 확인하기
    public void history(){
        System.out.println();
        System.out.println("----------------------");
        System.out.println("    방  문  기  록");
        System.out.println("----------------------");
        System.out.println("back     ==> " + back);
        System.out.println("현재     ==> " + currentURL);
        System.out.println("forward  ==> " + forward);
        System.out.println();
    }
}

//-----------------------------------------------------

public class StackTest {

    public static void main(String[] args) {
        Browser b = new Browser();

        b.goURL("1. 네이버");
        b.history();

        b.goURL("2. 야후");
        b.history();

        b.goURL("3. 구글");
        b.history();

        b.goURL("4. 다음");
        b.history();

        System.out.println("뒤로가기 후...");
        b.goBack();
        b.history();

        System.out.println("뒤로가기 후...");
        b.goBack();
        b.history();

        System.out.println("앞으로 가기 후...");
        b.goForward();
        b.history();

        System.out.println("새로운 사이트 접속 후...");
        b.goURL("5. 네이트");
        b.history();
    }

}

Console

1. 네이버사이트로 접속합니다.

----------------------
    방  문  기  록
----------------------
back     ==> []
현재     ==> 1. 네이버
forward  ==> []

2. 야후사이트로 접속합니다.

----------------------
    방  문  기  록
----------------------
back     ==> [1. 네이버]
현재     ==> 2. 야후
forward  ==> []

3. 구글사이트로 접속합니다.

----------------------
    방  문  기  록
----------------------
back     ==> [2. 야후, 1. 네이버]
현재     ==> 3. 구글
forward  ==> []

4. 다음사이트로 접속합니다.

----------------------
    방  문  기  록
----------------------
back     ==> [3. 구글, 2. 야후, 1. 네이버]
현재     ==> 4. 다음
forward  ==> []

뒤로가기 후...

----------------------
    방  문  기  록
----------------------
back     ==> [2. 야후, 1. 네이버]
현재     ==> 3. 구글
forward  ==> [4. 다음]

뒤로가기 후...

----------------------
    방  문  기  록
----------------------
back     ==> [1. 네이버]
현재     ==> 2. 야후
forward  ==> [3. 구글, 4. 다음]

앞으로 가기 후...

----------------------
    방  문  기  록
----------------------
back     ==> [2. 야후, 1. 네이버]
현재     ==> 3. 구글
forward  ==> [4. 다음]

새로운 사이트 접속 후...
5. 네이트사이트로 접속합니다.

----------------------
    방  문  기  록
----------------------
back     ==> [3. 구글, 2. 야후, 1. 네이버]
현재     ==> 5. 네이트
forward  ==> [4. 다음]

$*$ LIFO : Last In First Out

Stack의 명령

1. 자료 입력 : push(입력값)
2. 자료 출력 :

• pop( ) : 자료를 꺼내온 후 꺼내온 자료를 Stack에서 삭제한다.

• peek( ) : 삭제 없이 자료를 꺼내온다.(주로 자료 확인용으로 사용)

  3. 데이터의 입구와 출구가 같다.

LinkedList<String> stack = new LinkedList<>();

stack.push("홍길동");
stack.push("일지매");
stack.push("강감찬");
stack.push("변학도");
//제일 먼저 들어간 데이터가 아래부터 채워지기 때문에 출력시 최근 데이터가 0번 인덱스

System.out.println("현재 stack값 : " + stack);
//현재 stack값 : [변학도, 강감찬, 일지매, 홍길동]

String data = stack.pop();
System.out.println("꺼내온 값 : " + data);
System.out.println("꺼내온 값 : " + stack.pop());
//꺼내온 값 : 변학도
//꺼내온 값 : 강감찬

System.out.println("현재 stack값 : " + stack);
//현재 stack값 : [일지매, 홍길동]

stack.push("성춘향");
System.out.println("추가 후 stack값 : " +  stack);
//추가 후 stack값 : [성춘향, 일지매, 홍길동]

System.out.println("꺼내온 값 : " + stack.pop());
//꺼내온 값 : 성춘향

System.out.println("삭제없이 꺼내온 값 : " + stack.peek());
System.out.println("현재 stack 값 : " + stack);
//삭제없이 꺼내온 값 : 일지매
//현재 stack 값 : [일지매, 홍길동]

Queue의 명령

1. 자료 입력 : offer(입력값)
2. 자료 출력 :

• poll( ) : 자료를 꺼내온 후 Queue에서 꺼내온 자료를 삭제한다.

• peek( ) : 삭제 없이 자료를 꺼내온다.

  3. 데이터의 입구와 출구가 다르다.

LinkedList<String> queue = new LinkedList<>();

queue.offer("홍길동");
queue.offer("일지매");
queue.offer("강감찬");
queue.offer("변학도");

System.out.println("현재 queue값 : " + queue);
//현재 queue값 : [홍길동, 일지매, 강감찬, 변학도]

String temp = queue.poll();
System.out.println("꺼내온 값 : " + temp);
System.out.println("꺼내온 값 : " + queue.poll());
System.out.println("현재 queue값 : " + queue);
//꺼내온 값 : 홍길동
//꺼내온 값 : 일지매
//현재 queue값 : [강감찬, 변학도]

queue.offer("성춘향");
System.out.println("현재 queue값 : " + queue);
//현재 queue값 : [강감찬, 변학도, 성춘향]

System.out.println("꺼내온 값 : " + queue.poll());
System.out.println("현재 queue값 : " + queue);
//꺼내온 값 : 강감찬
//현재 queue값 : [변학도, 성춘향]

System.out.println("삭제 없이 꺼내온 값 : " + queue.peek());
System.out.println("현재 queue값 : " + queue);
//삭제 없이 꺼내온 값 : 변학도
//현재 queue값 : [변학도, 성춘향]

public class ArrayListTest02 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        ArrayList<String> names = new ArrayList<>();

        for(int i = 0; i < 5; i++){
            System.out.println("이름을 입력하세요.");
            String name = sc.nextLine();
            names.add(name);
        }

        ArrayList<String> kim = new ArrayList<>();
        for(int i = 0; i < 5; i++){
            String firstName = names.get(i).substring(0,1);
            if(firstName.equals("김")){
                kim.add(names.get(i));
            }
        }

        System.out.println(kim.toString());

        //샘풀이
        Scanner scan = new Scanner(System.in);

        ArrayList<String> nameList = new ArrayList<>();

        for(int i = 1; i <= 5; i++){
            System.out.println(i + "번째 사람의 이름을 입력하세요.");
            String name = scan.nextLine();
            nameList.add(name);
        }

        System.out.println();
        System.out.println("김씨 성을 가진 사람들...");

        for(int i = 0; i < nameList.size(); i++){
//            if(nameList.get(i).charAt(0) == '김'){
                  //charAt은 반환값이 character이기 때문에 ' '
//                System.out.println(nameList.get(i));
//            }

//            if(nameList.get(i).substring(0,1).equals("김")){
//                System.out.println(nameList.get(i));
//            }

//            if(nameList.get(i).indexOf("김") == 0){
//                System.out.println(nameList.get(i));
//            }

            if(nameList.get(i).startsWith("김")){
              //"김"으로 시작하면 true
                System.out.println(nameList.get(i));
            }
        }
    }

}

5명의 별명을 입력 받아 ArrayList에 저장하고 이들 중 별명의 길이가 제일 긴 별명을 출력하시오. (단, 각 별명의 길이는 모두 다르게 입력한다.)

public class ArrayListTest03 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        ArrayList<String> names = new ArrayList<>();

        for(int i = 1; i <= 5; i++){
            System.out.println(i + "번째 사람의 별명을 입력하시오.");
            String name = sc.nextLine();
            int lang = name.length();
            if(i > 1){
                for(int j = 0; j < i-1; j++){
                    if(names.get(j).length() == lang){
                        System.out.println("별명의 길이는 같을 수 없습니다. 다시 입력하세요.");
                        name = sc.nextLine();
                    }
                }
            }

            names.add(name);
        }

        int max = 0;
        for(int i = 0; i < names.size(); i++){
            if(names.get(max).length() < names.get(i).length()){
                max = i;
            }

        }

        System.out.println("제일 긴 별명...");
        System.out.println(names.get(max));
//        
        //샘풀이
        ArrayList<String> aliasList = new ArrayList<>();

        System.out.println("서로 다른 길이의 별명을 5번 입력하시오.");
        for(int i = 1; i <= 5; i++){
            System.out.println(i + "번째 별명 : ");
            String alias = sc.next();
            aliasList.add(alias);
        }

        //제일 긴 별명이 저장될 변수를 선언하고 이 변수에는 List의 첫번째 데이터로 초기화 한다.
//        String maxAlias = aliasList.get(0);
        //제일 긴 별명이 저장된 index값이 저장될 변수를 선언하고 0으로 초기화 한다.
        int maxIndex = 0;

        for(int i = 1; i < aliasList.size(); i++){
//            if(maxAlias.length() < aliasList.get(i).length()){
//                maxAlias = aliasList.get(i);
//            }

            if(aliasList.get(maxIndex).length() < aliasList.get(i).length()){
                maxIndex = i;
            }
        }

//        System.out.println("제일 긴 별명 : " + maxAlias);
        System.out.println("제일 긴 별명 : " + aliasList.get(maxIndex));
    }

}

위 문제에서 별명의 길이가 같은 것을 입력할 수 있는 경우를 처리하시오.

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    ArrayList<String> names2 = new ArrayList<>();
    for(int i = 1; i <= 5; i++){
        System.out.println(i + "번째 사람의 별명을 입력하시오.");
        String name = sc.nextLine();

        names2.add(name);
    }

    int max2 = 0;
    for(int i = 0; i < names2.size(); i++){
        if(names2.get(max2).length() < names2.get(i).length()){
            max2 = i;
        }
    }

    for(int i = 0; i < names2.size(); i++){
        if(names2.get(max2).length() == names2.get(i).length()){
            System.out.println(names2.get(i));
        }
    }

    //샘풀이
    ArrayList<String> aliasList = new ArrayList<>();

    System.out.println("별명을 5번 입력하시오.");
    for(int i = 1; i <= 5; i++){
        System.out.println(i + "번째 별명 : ");
        String alias = sc.next();
        aliasList.add(alias);
    }

    //제일 긴 별명의 길이가 저장될 변수를 선언하고 이 변수는 List의 첫번째 데이터의 길이로 초기화한다.
    int maxLength = aliasList.get(0).length();

    for(int i = 1; i < aliasList.size(); i++){
        if(maxLength < aliasList.get(i).length()){
            maxLength = aliasList.get(i).length();
        }
    }

    System.out.println("제일 긴 별명들...");
    for(int i = 0; i < aliasList.size(); i++){
        if(aliasList.get(i).length() == maxLength){
            System.out.println(aliasList.get(i));
        }
    }
}

List 인터페이스를 상속받은 클래스로 크기가 가변적으로 변하는 선형리스트로 배열과 같은 순차리스트이며 인덱스로 내부의 객체를 관리한다. 객체들이 추가되어 저장 용량을 초과한다면 자동으로 부족한 크기만큼 저장 용량이 늘어나는 특징을 가지고 있다.

ArrayList는 기본적인 사용법이 Vector와 같다.

1. 객체생성 ArrayList 사용하기

데이터 추가

• add()메서드를 이용하여 추가한다.

ArrayList list1 = new ArrayList();

list1.add("aaa");
list1.add("bbb");
list1.add(123);
list1.add('k');
list1.add(false);
list1.add(123.45);

System.out.println("size => " + list1.size());
System.out.println("list1 => " + list1.toString());
//size => 6
//list1 => [aaa, bbb, 123, k, false, 123.45]

데이터 꺼내오기

• get()메서드로 데이터를 꺼내온다.

System.out.println("1번째 데이터 : " + list1.get(1));
//1번째 데이터 : bbb

데이터 끼워넣기

list1.add(3, "zzz");
System.out.println("list1 => " + list1);
//list1 => [aaa, bbb, 123, zzz, k, false, 123.45]

데이터 변경

• set(index, 변경할 데이터)

String temp = (String)list1.set(3, "yyy");
System.out.println("temp => " + temp);
System.out.println("list1 => " + list1);
//temp => zzz
//list1 => [aaa, bbb, 123, yyy, k, false, 123.45]

데이터 삭제

• remove(index)

list1.remove(3); //index가 3번째인 데이터 삭제
System.out.pritnln("list1 => " + list1);
//list1 => [aaa, bbb, 123, k, false, 123.45]

2. 제네릭 타입 ArrayList 사용하기

데이터 추가

ArrayList<String> list2 = new ArrayList<>();
list2.add("AAAAA");
list2.add("BBBBB");
list2.add("CCCCC");
list2.add("DDDDD");
list2.add("EEEEE");

for(int i = 0; i < list2.size(); i++){
    System.out.println(i + " ==> " + list2.get(i));
}
//0 ==> AAAAA
//1 ==> BBBBB
//2 ==> CCCCC
//3 ==> DDDDD
//4 ==> EEEEE

for(String str : list2){
    System.out.println(str);
}
//AAAAA
//BBBBB
//CCCCC
//DDDDD
//EEEEE

데이터 비교

• contains(비교객체)

→ 리스트에 '비교객체'가 있으면 true, 없으면 false를 반환한다.

System.out.println("DDDDD값 존재 여부 : " + list2.contains("DDDDD");
System.out.println("ZZZZZ값 존재 여부 : " + list2.contains("ZZZZZ");
//DDDDD값 존재 여부 : true
//ZZZZZ값 존재 여부 : false

• IndextOf(비교객체)

→ 리스트에 '비교객체'가 있으면 '비교객체'가 위치한 index값을 반환하고 '비교객체'가 없으면 -1을 반환한다.

System.out.println("DDDDD의 위치 값 : " + list2.indexOf("DDDDD"));
System.out.println("ZZZZZ의 위치 값 : " + list2.indexOf("ZZZZZ"));
//DDDDD의 위치 값 : 3
//ZZZZZ의 위치 값 : -1

데이터 반환

• toArray()

→ 리스트 안의 데이터를 배열로 변환하여 반환한다.

→ 기본적으로는 Object형 배열로 반환한다.

Object[] strArr = list2.toArray();
System.out.println("배열의 개수 : " + strArr.length);
//배열의 개수 : 5

for(int i = 0; i < strArr.length; i++){
    System.out.println(i + " ===> " + strArr[i]);
}
//0 ===> AAAAA
//1 ===> BBBBB
//2 ===> CCCCC
//3 ===> DDDDD
//4 ===> EEEEE

• toArray(new 제네릭타입[0])

→ 제네릭 타입의 배열로 변환해서 반환한다.

String[] strArr2 = list2.toArray(new String[0]);
for(String str : strArr2){
    System.out.println(str);
}
//AAAAA
//BBBBB
//CCCCC
//DDDDD
//EEEEE

1. Connection 생성
2. Statement 생성(쿼리)
3. Query 실행
4. ResultSet에서 결과 추출(select인 경우)
5. ResultSet, Statement, Connection 닫기

SELECT 문

//데이터베이스 접속 정보
String url = "jdbc:oracle:thin:@localhost:1521:xe";
String user = "계정명";
String password = "java";

Connection con = null;
PreparedStatement ps = null;
ResultSet rs = null;

//기본 세팅
con = DriverManager.getConnection(url, user, password);
//컴파일에러 -> try-catch

try {
    con = DriverManager.getConnection(url, user, password);

    String sql = "select * from member";
    ps = con.prepareStatement(sql);

    //select
    rs = ps.executeQuery(); 

    //insert, update, delete
     //int result = ps.executeUpdate(); //영향받은 행(row)의 수를 리턴

    while(rs.next()){//rs의 다음행이 있는지 없는지 확인하는 메서드
        String memId = rs.getString(1); //인덱스로 값을 가져오기(인덱스는 1부터 시작)
        String memPass = rs.getString("MEM_PASS"); //컬럼명으로 값을 가져오기
        System.out.println("MEM_ID : " + memId + " / MEM_PASS : " + memPass);
    }

    String sql2 = "select * from departments";
    ps = con.prepareStatement(sql2);

    rs = ps.executeQuery();

    while(rs.next()){ //다음 행이 있을때까지 실행
        int deptId = rs.getInt(1);
        String deptName = rs.getString(2);
        int parentId = rs.getInt(3);
        int managerId = rs.getInt(4);
        Date createDate = rs.getDate(5);
        Date updateDate = rs.getDate(6);
        System.out.println("DEPARTMENT_ID :" + deptId + " / DEPARTMENT_NAME : " + deptName 
                                    +  " / PARENT_ID : " + parentId + " / MANAGER_ID : " + managerId
                                    + " / CREATE_DATE : " + createDate + " / UPDATE_DATE : " + updateDate);
        System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------");
    }
} catch (SQLException e) {
    e.printStackTrace();
}finally{
    if(rs != null) try { rs.close(); } catch(Exception e) {}
    if(ps != null) try { ps.close(); } catch(Exception e) {}
    if(con != null) try { con.close(); } catch(Exception e) {}
       //open한 순서 반대로 close
    }
}

메타데이터 : 데이터에 대한 데이터

한 행의 여러 컬럼을 불러올 때 for문을 돌려서 불러올 수 있다.

try {
    con = DriverManager.getConnection(url, user, password);

    String sql = "select * from member where mem_id = ?";
    ps = con.prepareStatement(sql);
    ps.setString(1, "a001"); //?의 인덱스, 넣을 값
//    ps.setInt(parameterIndex, x);
//    ps.setObject(parameterIndex, x);

    rs = ps.executeQuery(); 

//    rs.getMetaData(); //메타데이터 : 데이터에 대한 데이터 ctr + 1 -> local variable
//      ↓
    ResultSetMetaData md = rs.getMetaData(); //메타데이터 : 데이터에 대한 데이터

    int columnCount = md.getColumnCount();//컬럼 갯수

    String result = md.getColumnName(1);//컬럼 이름
    System.out.println(result); //1번 컬럼인 mem_id 출력

    while(rs.next()){ //row의 값은 while이 확인
        for(int i = 1; i <= columnCount; i++){
            System.out.print(rs.getObject(i) + "\t");
        }
        System.out.println();
    }
} catch (SQLException e) {
        e.printStackTrace();
}finally{
    if(rs != null) try { rs.close(); } catch(Exception e) {}
    if(ps != null) try { ps.close(); } catch(Exception e) {}
    if(con != null) try { con.close(); } catch(Exception e) {}
}

INSERT, UPDATE, DELETE 문

try {
    con = DriverManager.getConnection(url, user, password);

    String sql = "insert into lprod values(?, ?, ?)";
    ps = con.prepareStatement(sql);

    ps.setInt(1, 11);
    ps.setString(2, "P601");
    ps.setString(3, "식품"); //?에 들어갈 데이터

    int result = ps.executeUpdate();
    System.out.println("영향받은 행의 수 : " + result);

} catch (SQLException e) {
    e.printStackTrace();
}finally{
    if(rs != null) try { rs.close(); } catch(Exception e) {}
    if(ps != null) try { ps.close(); } catch(Exception e) {}
    if(con != null) try { con.close(); } catch(Exception e) {}
}

ArrayList와 동일한 내부구조를 가지고 있으며, 값이 추가되면 자동으로 크기가 조절된다. 하지만 Vector는 동기화된 메서드로 구성되어 있기 때문에 멀티 스레드가 동시에 이 메소드들을 실행할 수 없고, 하나의 스레드가 실행 완료해야만 다른 스레드들이 실행할 수 있다.

$*$ 멀티 스레드 환경에서 안전하게 객체를 추가하고 삭제할 수 있다.

1. 객체생성해서 Vector 사용하기

Vector v1 = new Vector();
//객체생성
//예전방식 : 모든 데이터를 저장할 수 있지만 꺼내올 때는 형변환 필요               

System.out.println("처음 크기 : " + v1.size()); // 0

데이터 추가

• add(추가할 데이터)

→ 반환값 : 추가 성공(true), 실패(false)

v1.add("aaaa");
v1.add(new Integer(111));
v1.add(123);

$*$ 오토박싱(기본자료형 → 랩퍼클래스형으로 자동변환)

$*$ 오토언박싱(랩퍼클래스형 → 기본자료형으로 자동변환)

v1.add('a'); //' '로 저장되는 데이터는 문자가 아닌 코드값으로 저장
v1.add(true);
boolean chk = v1.add(3.14);

System.out.println("현재크기 : " + v1.size()); // 6
System.out.println("반환값 : " + chk); // true

• addElement(추가할 데이터)

→ add와 똑같은 기능을 하는 메서드(이전 버전의 프로그램에서도 사용 가능하도록 하기위해 남아 있는 메서드)

v1.addElement("CCC");

System.out.println("v1 ==> " + v1.toString());
System.out.println("v1 ==> " + v1); //toString() 생략

//v1 ==> [aaaa, 111, 123, a, true, 3.14, CCC]
//v1 ==> [aaaa, 111, 123, a, true, 3.14, CCC]

• add(index, 추가할 데이터)

→ index번째에 '추가할 데이터'를 끼워 넣는다.( index는 0부터 시작한다.)

→ 반환값은 없다.

v1.add(1, "kkk");
System.out.println("v1 ==> " + v1);

//v1 ==> [aaaa, kkk, 111, 123, a, true, 3.14, CCC]

데이터 수정

• set(index, 새로운 데이터)

→ index번째의 데이터를 '새로운 데이터'로 덮어쓴다.

→ 반환값 : 원래의 데이터

String temp = (String)v1.set(1, "zzz");
System.out.println("v1 ==> " + v1);
System.out.println("반환값 : " + temp);

//v1 ==> [aaaa, zzz, 111, 123, a, true, 3.14, CCC]
//반환값 : kkk

데이터 꺼내오기

• get(index)

→ index번째의 데이터를 반환한다.

int data = (int)v1.get(2);
System.out.println("2번째 자료 : " + data);

//2번째 자료 : 111

데이터 삭제

• remove(index)

→ index번째의 데이터를 삭제한다.

→ 반환값 : 삭제된 데이터

v1.remove(0);
System.out.println("v1 ==> " + v1);

temp = (String)v1.remove(0);
System.out.println("v1 ==> " + v1);
System.out.println("삭제된 데이터 : " + temp);

//v1 ==> [zzz, 111, 123, a, true, 3.14, CCC]
//v1 ==> [111, 123, a, true, 3.14, CCC]
//삭제된 데이터 : zzz

• remove(삭제할 데이터)

→ '삭제할 데이터'를 찾아서 삭제한다.

→ '삭제할 데이터'가 여러개이면 앞에서부터 삭제된다.

→ 반환값 : 삭제 성공(true), 삭제 실패(false)

→ 삭제할 데이터가 '정수형'이거나 'char형'일 경우에는 반드시 객체로 변환해서 지정해 주어야 한다.

v1.remove("CCC");
System.out.println("삭제 후 v1 = " + v1);
// 삭제 후 v1 = [111, 123, a, true, 3.14]

//v1.remove(123);
//데이터 123을 삭제하는 것이 아니라 123번째 자료를 삭제하는 것으로 해석하여 컴파일 에러발생
v1.remove(new Integer(123);
System.out.println("삭제 후 v1 = " + v1);
//삭제 후 v1 = [111, a, true, 3.14]

//v1.remove('a'); 객체변환 필요
v1.remove(new Character('a'));
System.out.println("삭제 후 v1 = " + v1);
//삭제 후 v1 = [111, true, 3.14]

v1.remove(true);
v1.remove(3.14);
System.out.println("삭제 후 v1 = " + v1);
//삭제 후 v1 = [111]

2. 제네릭 타입으로 Vector 사용하기

제네릭 타입(Generic Type)

• 클래스 내부에서 사용할 데이터 타입을 외부에서 지정하는 기법을 말한다.
• 객체를 선언할 때 괄호(<>) 안에 그 클래스 내부에서 사용할 데이터의 타입을 정해주는 것을 말한다. 이런식으로 선언하게 되면 그 데이터 타입 이외의 다른 데이터를 저장할 수 없게 된다.
• 제네릭으로 선언될 수 있는 데이터 타입은 '클래스형'이어야 한다. 즉, Integer, boolean은 Boolean, char는 Character등으로 대체해서 사용해야 한다.
• 제네릭 타입으로 선언하게 되면 데이터를 꺼내올 때 형변환이 필요없다.

Vector<String> v2 = new Vector<>();
Vector<String> v22 = new Vector<>();

Vector<Integer> v3 = new Vector<>();
//Vector<int> v33 = new Vector<>();
//제네릭 타입은 반드시 '클래스형'으로 지정해야 한다.

데이터 추가

• add(추가할 데이터)

v22.add("안녕하세요");
//v22.add(123); //에러 : 다른 종류의 데이터를 저장할 수 없다.

String temp2 = v22.get(0);
System.out.println("temp2 = " + temp2);
//temp2 = 안녕하세요

전체 데이터 삭제하기

• clear()

v1.clear();
System.out.println("v1의 개수 : " + v1.size());
//v1의 개수 : 0

데이터 삭제

• removeAll(Collection 객체)

→ 'Collection 객체'가 가지고 있는 데이터를 모두 삭제한다.

→ 반환값 : 삭제 성공(true), 삭제 실패(false)

v2.add("AAAA");
v2.add("BBBB");
v2.add("CCCC");
v2.add("DDDD");
v2.add("EEEE");

Vector<String> v4 = new Vector<>();
v4.add("BBBB");
v4.add("EEEE");

System.out.println("v2 = " + v2);
System.out.println("v4 = " + v4);
//v2 = [AAAA, BBBB, CCCC, DDDD, EEEE]
//v4 = [BBBB, EEEE]

v2.removeAll(v4);
System.out.println("v2 = " + v2);
//v2 = [AAAA, CCCC, DDDD]

모든 데이터 가져오기

• Vector에 저장된 데이터를 순서대로 모두 가져와 사용하고 싶으면 반복문을 사용하면 된다. → 보통 for문을 많이 사용

//현재 v2 = [AAAA, BBBB, CCCC, DDDD, EEEE]
for(int i = 0; i < v2.size(); i++){
    System.our.println(i + "번째 자료 : " + v2.get(i));
}
//0번째 자료 : AAAA
//1번째 자료 : BBBB
//2번째 자료 : CCCC
//3번째 자료 : DDDD
//4번째 자료 : EEEE

$*$ 향상된 for문

• 형식) for(자료형명 변수명 : 배열이나 List 또는 Set형 객체 변수) { 처리할 내용들...}

for(String str : v2){
    System.out.pritnln(str);
}
//AAAA
//BBBB
//CCCC
//DDDD
//EEEE

제네릭 타입의 장점

• 객체생성의 방법에서 데이터 타입 형변환 시 문법적으로는 에러가 없지만, 실행과정에서 에러가 발생하는 경우가 있다.

→ 제네릭 타입은 코딩 작성 과정에서 그 오류를 해결할 수 있다.

• 사용 틀을 만들고 사용단계에서 데이터 타입을 결정할 수 있다.

Vector<Vector> vv = new Vector<>();
Vector<Vector<Vector>> vvv = new Vector<>();

관계형 데이터베이스의 Relation 구조

릴레이션은 데이터들을 표(Table)형태로 표현한 것으로 구조를 나타내는 릴레이션 스키마와 실제 값들인 릴레이션 인스턴스로 구성

** 릴레이션 인스턴스 : 데이터 개체를 구성하고 있는 속성들에 데이터 타입이 정의되어 구체적인 데이터 값을 갖고 있는 것

튜플(Tuple)

• 릴레이션을 구성하는 각각의 행
• 속성의 모임
• 파일 구조의 레코드와 같은 구조
• 튜플의 수 = 카디널리티 = 기수 = 대응수

속성(Attribute)

• 데이터베이스를 구성하는 가장 작은 논리적 단위
• 파일 구조상의 데이터 항목 또는 데이터 필드
• 개체의 특성
• 속성의 수 = 디그리 = 치수

도메인(Domain)

• 속성 하나가 취할 수 있는 같은 타입의 원자값들의 집합
• 값의 합법 여부를 시스템이 검사하는데도 이용 ex) 성별의 도메인은 남, 여로 그 이외의 값을 입력될 수 없다.

릴레이션의 특징

• 한 릴레이션에는 똑같은 튜플이 포함될 수 없으므로 튜플들은 모두 상이하다.
• 한 릴레이션에 포함된 튜플 사이에는 순서가 없다.
• 시간에 따라 변한다. -> 튜플의 삽입, 삭제
• 스키마의 속성 순서는 중요하지 않다.
• 속성의 명칭은 유일해야 하지만, 속성을 구성하는 값은 동일할 수 있다.
• 튜플을 유일하게 식별하기 위해 속성들의 부분집합을 키로 설정
• 속성의 값은 논리적으로 더 이상 쪼갤 수 없는 원자값만 저장

관계형 데이터베이스의 제약 조건

키(Key)의 개념 및 종류

키는 데이터베이스에서 조건에 만족하는 튜플을 찾거나 순서대로 정렬할 때 튜플들을 서로 구분할 수 있는 기준이 되는 속성을 말한다.

후보키(Candidate Key)

• 릴레이션을 구성하는 속성들 중에서 튜플을 유일하게 식별하는 기본키로 사용할 수 있는 속성
• 중복된 튜플들이 있을 수 없으므로 모든 릴레이션에는 반드시 하나 이상의 후보키가 존재
• 유일성 : 하나의 키 값으로 하나의 튜플만을 유일하게 식별
• 최소성 : 모든 레코드들을 유일하게 식별하는 데 꼭 필요한 속성으로만 구성

ex) <학생> 릴레이션 -> 학번, 주민번호

기본키(Primary Key)

• 후보키 중에서 선택한 주키
• 특정 튜플을 유일하게 구별할 수 있는 속성
• Null 값을 가질 수 없다.
• 중복값을 가질 수 없다.

대체키(Altermate Key)

• 후보키가 둘 이상일 때 기본키를 제외한 나머지 후보키
• 보조키라고도 한다.

외래키(Foreign Key)

• 참조되는 릴레이션의 기본키와 대응되어 릴레이션 간에 참조 관계를 표현하는데 중요한 도구
• 외래키로 지정되면 참조 릴레이션의 기본키에 없는 값은 입력할 수 없다.

무결성

1) 개체 무결성

• 릴레이션에서 기본키를 구성하는 속성은 널 값이나 중복값을 가질 수 없다.

2) 참조 무결성

• 외래키 값은 널이거나 참조 릴레이션의 기본키 값과 동일해야 한다. 즉 릴레이션은 참조할 수 없는 외래키 값을 가질 수 없다.
• 외래키와 참조하려는 테이블의 기본키는 도메인과 속성 개수가 같아야 한다.

관계대수 및 관계해석

관계대수의 개요

• 관계형 데이터베이스에서 원하는 정보와 그 정보를 검색하기 위해서 어떻게 유도하는가를 기술하는 절차적인 언어
• 피연산자가 릴레이션이고 결과도 릴레이션
• 순수 관계 연산자 : Select, Project, Join, Division
• 일반 집합 연산자 : 합집합, 교집합, 차집합, 교차곱

순수 관계 연산자

• 관계 데이터베이스에 적용할 수 있도록 특별히 개발한 관계 연산자

1) Select

• 릴레이션에 존재하는 튜플 중에서 선택 조건을 만족하는 튜플의 부분집합을 구하여 새로운 릴레이션을 만든다.
• 수평연산
• 표기형식 : σ<조건>(릴레이션) ex) 성적평균이 90점 이상인 사람을 성적 릴레이션에서 추출

2) Project

• 주어진 릴레이션에서 속성 list에 제시된 속성만 추출
• 수직연산
• 표기형식 : π<속성리스트>(릴레이션) ex) 성적 릴레이션에서 이름, 평균 리스트를 추출

3) Join

• 공통 속성을 중심으로 두 개의 릴레이션을 하나로 합쳐서 새로운 릴레이션을 만드는 연산자
• 표기형식 : 릴레이션⋈키속성r=키속성s 릴레이션 ex) 성적과 학적부 릴레이션을 학생no 속성을 기준으로 합쳐라

4) Division

• X ⊃ Y인 두개의 릴레이션이 있을 때 R의 속성이 S의 속성값을 모든 가진 튜플에서 S가 가진 속성을 제외한 속성만을 구하는 연산
• 표기형식 : R [속성r ÷ 속성s] S

일반 집합 연산자

• 합집합, 교집합, 차집합은 합병 조건이 가능해야 한다.
• 합병조건 : 합병하려는 두 릴레이션 간에 속성 수가 같고, 각 속성이 취할 수 있는 도메인의 범위가 같아야 한다.

관계해석

• 관계 데이터의 연산을 표현하는 방법으로 원하는 정보를 정의할 때는 계산 수식을 사용한다.
• 원하는 정보가 무엇이라는 것만 정의하는 비절차적 특성
• 튜플 관계해석, 도메인 관계해석
• 관계해석과 관계대수는 관계 데이터베이스를 처리하는 기능과 능력 면에서 동등
• 관계대수로 표현한 식은 관계해석으로 표현할 수 있다.
• 질의어로 표현

정규화

정규화의 개요

• 잘못 설계된 관계형 스키마를 더 작은 속성의 세트로 쪼개어 바람직한 스키마로 만들어 가는 과정
• 논리적 설계 단계에서 수행

정규화의 목적

• 데이터 구조의 안정성
• 효과적인 검색 알고리즘
• 중복 배제

Anomaly(이상)의 개념 및 종류

$*$ 원인 : 정규화(Normalization)를 거치지 않으면 데이터베이스 내에 데이터들이 불필요하게 중복되어 릴레이션 조작 시 예기치 못한 곤란한 현상이 발생 ** 1) 삽입 이상** : 릴레이션에 데이터를 삽입할 때 의도와는 상관없이 원하지 않은 값들도 함께 삽입되는 현상 2) 삭제 이상 : 릴레이션에서 한 튜플을 삭제할 때 의도와는 상관없는 값들도 함께 삭제되는 연쇄 삭제 현상이 일어나는 현상 3) 갱신 이상 : 릴레이션에서 튜플에 있는 속성값을 갱신할 때 일부 튜플의 정보만 갱신되어 정보에 모순이 생기는 현상

$*$ 불필요하게 중복되어 저장되면 릴레이셔 조작 시 예기치 못한 이상 현상이 발생할 가능성이 높아진다. -> 정규화는 이상을 제거하기 위해서 중복성 및 종속성을 배제시키는 방법으로 사용

정규화의 원칙

• 정보의 무손실
• 분리의 원칙
• 데이터의 중복성 감소

정규화 과정

1) 1NF(제1정규형)

• 릴레이션에 속한 모든 도메인이 원자값만으로 되어 있는 릴레이션
• 모든 속성이 단순 영역에서 정의

2) 2NF(제2정규형)

• 릴레이션이 R이 1NF이고, 키가 아닌 모든 속성이 기본키에 대하여 완전 함수적 종속 관계를 만족

$*$ 함수적 종속 관계 / 완전 함수적 종속 관계

• 함수적 종속 관계 학번에 따라 읾이 결정될 때 이름을 학번에 함수 종속적이라고 하며 '학번 -> 이름'과 같이 쓴다.
• 완전 함수적 종속 관계 수강(학번, 과목명, 성적) 일 때 성적은 (학번, 과목명)에는 함수 종속이지만, 학번이나 과목명에는 함수 종속이 아니다.

3) 3NF(제3정규형)

• 릴레이션 R이 2NF이고, 키가 아닌 모든 속성이 기본키에 대해 이행적 종속 관계를 이루지 않도록 제한한 관계형 ex) A -> B이고, B -> C일 때 A -> C를 만족하는 관계
• 무손실 조인 또는 종속성 보존을 저해하지 않고도 항상 얻을 수 있다.

4) BCNF(Boye-Codd 정규형)

• 릴레이션 R에서 결정자가 모두 후보키인 관계형
• 3NF에서 후보키가 많고 서로 중첩되는 경우에 적용하는 강한 제3정규형이라고도 한다.
• 모든 BCNF가 종속성을 보존하는 것은 아니다.
• 제약 조건 가. 키가 아닌 모든 속성은 각 키에 대하여 완전 종속 나. 키가 아닌 모든 속성은 그 자신에 부분적으로 들어가 있지 않은 모든 키에 대하여 완전 종속 다. 어떤 속성도 키가 아닌 속성에 대해서는 완전 종속할 수 없다.

5) 4NF(제4정규형)

• 릴레이션 R에 A ->> B가 성립하는 경우 R의 모든 속성이 A에 함수적 종속이다.

6) 5NF(제5정규형, PJ/NF)

• 릴레이션 R의 모든 조인 종속성(JD)의 만족이 R의 후보키를 통해서만 만족될 때

$*$ 정규화 단계 도메인의 원자값 -> 부분적 함수 종속 제거 -> 이행적 함수 종속 제거 -> 결정자이면서 후보키가 아닌 것 제거 -> 다치 종속 제거 -> 조인 종속성 이용

SQL의 개념

SQL(Structured Query Language)의 개요

• 관계대수와 관계해석을 기초로 한 혼합 데이터 언어
• 질의어지만 질 의 기능만 있는 것이 아니라 데이터 구조의 정의, 데이터 조작, 데이터 제어 기능을 모두 갖추고 있다.(비절차어의 일종)

SQL의 분류

1) DDL(데이터 정의어)

• 스키마, 도메인, 테이블, 뷰, 인덱스를 정의하거나 변경 또는 삭제
• 논리적 데이터 구조와 물리적 데이터 구조의 사상을 정의
• 데이터베이스 관리자나 설계자가 사용
• 데이터 정의어의 세 가지 유형

2) DML(데이터 조직어)

• 데이터베이스 사용자가 응용 프로그램이나 질의어를 통하여 저장된 데이터를 실질적으로 처리하는 데 사용되는 언어
• 사용자와 관리 시스템 간의 인터페이스를 제공
• 데이터 조작어(DML)의 네 가지 유형

3) DCL(데이터 제어어)

• 데이터의 보안, 무결성, 회복, 병행 수행 제어 등을 정의하는 데 사용되는 언어
• 관리자가 데이터 관리를 목적으로 사용
• 데이터 제어어의 종류

DDL

DDL로 정의된 내용은 Meta-data가 되어, 시스템 카탈로그에 저장

데이터 정의문에서 사용하는 테이블 종류

CREATE

• 스키마, 도메인, 테이블, 인덱스 정의하는 명령문

  참조 무결성의 CASCADE법칙

  참조 무결성 제약이 설정된 기본 테이블의 어떤 데이터를 삭제하는 경우 그 데이터와 밀접하게 연관되어 있는 다른 테이블의 데이터들도 도미노처럼 자동으로 삭제된다. 이러한 법칙을 '계단식', '연속성'이라는 사전적 의미를 가진 CASCADE 법칙이라 한다.

ALTER

테이블에 대한 정의를 변경하는 명령문

DROP

스키마, 도메인, 테이블, 뷰, 인덱스 등을 삭제하는 명령문

• CASCADE 옵션 : 삭제할 요소를 참조하는 다른 모든 개체를 함께 삭제한다. 즉 테이블 데이터 삭제 시 각 외래키에 부합되는 모든 데이터를 삭제하는 참조 무결성의 법칙을 설정
• RESTRICT 옵션 : 삭제할 요소를 다른 개체가 참조중일 때는 삭제를 취소한다.

DML - SELECT

테이블을 구성하는 튜플(행)들 중에서 전체 또는 조건을 만족하는 튜플을 검색하여 주기억장치 상에 임시 테이블로 구성하는 명령문

일반형식

• 두 개 이상의 테이블을 대상으로 검색할 때는 '테이블명.속성명'으로 표현
• Predicate : 불러올 튜플 수를 제한할 명령어를 기술(ALL, DISTINCT, DISTINCTROW) $*$ 조건 연산자
• IN : 포함되어 있다.
• $*$ 또는 % : 모든 문자를 대표
• ? 또는 _ : 한 자리 문자를 대표
• $#$ : 한자리 숫자를 대표

DML - INSERT, DELETE, UPDATE

삽입문(INSERT INTO~)

기본 테이블에 새로운 튜플을 삽입할 때 사용

• 대응하는 속성과 데이터는 개수와 data-type이 일치
• 기본 테이블의 모든 속성을 사용할 때는 속성명 생략
• SELECT문을 사용하여 다른 테이블의 검색 결과를 삽입

삭제문(DELETE FROM~)

기본 테이블에 있는 튜플들 중에서 특정 튜플(행)을 삭제할 때 사용

갱신문(UPDATE~ SET~)

기본 테이블에 있는 튜플들 중에서 특정 튜플의 내용을 변경할 때 사용

내장 SQL

내장 SQL(Embedded SQL)의 정의

응용 프로그램 내에 데이터베이스에서 사용하는 테이터를 정의하거나 질의하는 SQL 문장을 내포하여 프로그램이 실행될 때 함께 실행되도록 호스트 프로그램 언어로 만든 프로그램에 삽입된 SQL

내장 SQL의 특징

• 호스트 언어에서 실행문이 나타날 수 있는 곳이면 프로그램의 어디서나 사용
• 단 하나의 튜플만을 반환

호스트 언어의 실행문과 구분시키는 방법

1) 명령문의 구분

• C/C++에서 내장 SQL문은 $와 세미클론(;) 문자 사이에 기술
• Visual BASIC에서는 내장 SQL문 앞에 'EXEX SQL'을 기술

2) 변수의 구분 내장 SQL에서 사용하는 호스트 변수는 변수 앞에 클론(:) 문자를 붙인다.

커서(Cursor)

• 내장 SQL문의 수행 결과로 반환될 수 있는 복수의 튜플들을 액세스할 수 있도록 해주는 개념
• 질의 수행 결과로 반환되는 첫 번째 튜플에 대한 포인터로 생각할 수 있다.
• 튜플들을 한 번에 하나씩 차례로 처리할 수 있다.

커서 관련 명령어

• DECLARE : 커서를 정의하는 등 커서에 관련된 선언
• OPEN : 커서가 질의 결과의 첫 번째 튜플을 포인트 하도록 설정
• FETCH : 질의 결과의 튜플들 중 현재의 다음 튜플로 커서를 이동
• CLOSE : 질의 수행 결과에 대한 처리 종료 시 커서를 닫는다.

뷰(View)

뷰(View)의 개요

• 사용자에게 접근이 허용된 자료만을 제한적으로 보여주기 위해 하나 이상의 기본 테이블로부터 유도된, 이름을 가지는 가상 테이블
• 저장장치 내에 물리적으로 존재하지 않지만, 사용자에게는 있는 것처럼 간주
• 데이터 보정작업, 처리과정 시험 등 임시적인 작업을 위한 용도로 활용
• 조인문의 사용 최소화로 사용상의 편의성을 최대화

뷰(View)의 특징

• 기본 테이블로부터 유도된 테이블이기 때문에 기본 테이블과 같은 형태의 구조를 사용하며, 조작도 기본 테이블과 거의 같다.
• 가상 테이블이기 때문에 물리적으로 구현되어 있지 않다.
• 데이터의 논리적 독립성 제공
• 필요한 데이터만 뷰로 정의해서 처리할 수 있기 때문에 관리가 용이하고 명령문이 간단해진다.
• 뷰를 통해서만 데이터에 접근하게 하면 뷰에 나타나지 않는 데이터를 안전하게 보호하는 효율적인 기법으로 사용
• 기본키를 포함한 속성 집합으로 뷰를 구성해야만 삽입, 삭제, 갱신 연산이 가능
• 정의된 뷰는 다른 뷰의 정의에 기초가 될 수 있다.
• 정의 테이블을 삭제하면 그 테이블이나 뷰를 기초로 정의된 다른 뷰도 자동으로 삭제

뷰(View)의 장, 단점

장점

• 논리적 데이터 독립성 제공
• 동일 데이터에 대해 동시에 여러 사용자의 상이한 응용이나 요구를 지원
• 사용자의 데이터 관리를 간단하게 해준다.
• 접근 제어를 통한 자동 보안 제공

단점

• 독립적인 인덱스를 가질 수 없다.
• ALTER VIEW문을 사용할 수 없다. 즉, 뷰의 정의를 변경할 수 없다.
• 뷰로 구성된 내용에 대한 삽입, 삭제, 갱신 연산에 제약이 따른다.

뷰(View)의 정의문

• 부질의어로서의 SELECT문에는 UNION이나 ORDER BY절을 사용 할 수 없다.
• 속성 이름을 기술하지 않으면 SELECT문의 속성 이름이 자동으로 사용

뷰(View) 삭제문

• RESTRICT : 뷰를 다른 곳에서 참조하고 있으면 삭제 취소
• CASCADE : 뷰를 참조하는 다른 뷰나 제약 조건까지 모두 삭제

시스템 카탈로그

시스템 카탈로그의 의미

• 시스템 그 자체에 관련이 있는 다양한 객체에 관한 정보를 포함하는 시스템 데이터베이스
• 각 테이블은 사용자를 포함하여 DBMS에서 지원하는 모든 데이터 객체에 대한 정의나 명세에 관한 정보를 유지 관리
• 데이터베이스 구조 및 통계 정보 저장
• 카탈로그들이 생성되면 자료 사전(Data Dictionary)에 저장
• 카탈로그에 저장된 정보를 메타 데이터라고 한다.

카탈로그의 특징

• 카탈로그 자체도 시스템 테이블로 구성 - > 검색 가능
• INSERT, DELETE, UPDATE문으로 카탈로그를 갱신하는 것은 허용되지 않는다.
• 데이터베이스 시스템에 따라 상이한 구조를 갖는다.
• DBMS가 스스로 생성하고 유지
• 카탈로그의 갱신 : 사용자가 SQL문을 실행시켜 기본 테이블, 뷰, 인덱스 등에 변화를 주면 시스템이 자동으로 갱신
• 분산 시스템에서의 카탈로그 : 위치 투명성 및 중복 투명성을 제공하기 위해 필요한 모든 제어 정보를 가져야 한다.

카탈로그/데이터 사전을 참조하기 위한 DBMS 내의 모듈 시스템

• *데이터 정의어 변역기 *: DDL을 메타 데이터를 갖는 테이블(카탈로그)로 변환하여 데이터 사전에 저장
• 데이터 조작어 번역기 : 응용 프로그램에 삽입된 DML문을 주 언어로 표현한 프로시저 호출로 변환하여 질의 처리기와 상호 통신
• Data Directory : 데이터 사전에 수록된 데이터를 실제로 접근하는 데 필요한 정보를 관리 유지하는 시스템으로 시스템 카탈로그는 사용자와 시스템 모두 접근할 수 있지만 데이터 디렉터리는 시스템만 접근할 수 있다.
• 질의 최적화기
• 트랜잭션 처리기 : 복수 사용자 환경에서 평행으로 동시에 일어나는 트랜잭션 문제를 해결하여, 각각의 사용자가 데이터베이스 자원을 배타적으로 이용할 수 있도록 한다.

$*$ 년 월 일이 다 있어야 날짜 타입이다.

1) SYSDATE

• 시스템이 제공하는 기본 날짜형
• 년, 월, 일, 시, 분, 초 정보제공
• '+'와 '-' 연산의 대상
• 단순 연산이 아닌 일수를 더하고 뺀다. (윤달까지도 계산)

예)

SELECT SYSDATE, SYSDATE+10, SYSDATE-200 FROM DUAL;

![] (https://images.velog.io/images/amuse_on_01/post/2c88ae10-241d-47cf-9fc0-486964016503/image.png)

2) ADD_MONTHS(d, n)

• 'd'로 주어진 날짜에서 'n' 월 수를 더한 날짜 반환

예) 회원테이블에서 MEM_MEMORIALDAY 컬럼이 가입일이라고 가정했을 때, 모든 회원의 유효기간이 3개월이며 모두 재등록할 경우 재등록 날자 10일전에 문자데이터를 전송하고자 한다. 각 회원의 문자전송 시작일을 구하시오.

Alias 회원번호, 회원명, 가입일, 종료일, 문자전송일
SELECT MEM_ID AS 회원번호,
       MEM_NAME AS 회원명,
       MEM_MEMORIALDAY AS 가입일,
       ADD_MONTHS(MEM_MEMORIALDAY,3) AS 종료일,
       ADD_MONTHS(MEM_MEMORIALDAY,3) - 10 AS 문자전송일
  FROM MEMBER;

3) NEXT_DAY(d, char)

• 주어진 날짜 'd' 이후 처음 만나는 char요일 날짜

SELECT NEXT_DAY(SYSDATE,'금') FROM DUAL;
SELECT NEXT_DAY(SYSDATE,'목요일') FROM DUAL;

4) LAST_DAY(d)

• 주어진 날짜 'd'의 월에 해당하는 마지막 일자 반환

SELECT LAST_DAY(SYSDATE), LAST_DAY('2000210') FROM DUAL;

5) MONTHS_BETWEEN(d1, d2)

• 두 날짜 자료 'd1'과 'd2' 사이의 개월 수를 반환

SELECT ROUND(MONTHS_BETWEEN(TRUNC(SYSDATE), '00010101')) FROM DUAL;

6) EXTRACT(fmt FROM d)

• 주어진 날짜데이터 'd'에서 fmt로 정의된 값을 추출하여 반환

• fmt는 YEAR, MONTH, DAY, HOUR, MINUTE, SECOND

• 반환 데이터 타입은 숫자형식

• 예) 매입테이블에서 2005년도 월별 매입정보를 조회하시오.

Alias 월, 매입수량, 매입금액
SELECT EXTRACT(MONTH FROM BUY_DATE) AS 월,
       COUNT(*) AS 건수,
       SUM(BUY_QTY) AS 매입수량,
       SUM(BUY_QTY*BUY_COST) AS 매입금액
  FROM BUYPROD
 WHERE EXTRACT(YEAR FROM BUY_DATE)=2005
 GROUP BY EXTRACT(MONTH FROM BUY_DATE)
 ORDER BY 1;

예) 사원테이블에서 이번달에 입사한 사원정보를 조회하시오.

SELECT EMPLOYEE_ID 사원번호,
       EMP_NAME AS 사원명,
       DEPARTMENT_ID AS 부서코드,
       HIRE_DATE AS 입사일,
       EMAIL AS 이메일
  FROM EMPLOYEES
 WHERE EXTRACT(MONTH FROM HIRE_DATE)=EXTRACT(MONTH FROM SYSDATE)
 ORDER BY 3;

형 변환 함수

1) CAST(expr AS 타입[(크기)]

• 'expr'로 제공되는 자료를 '타입[(크기)]' 형식으로 형변환
• 형변환은 CAST가 사용된 위치에서 일시적 변환

예) 사원테이블에서 부서코드 50에 속한 사원들의 근속년수를 조회하시오.

Alias 사원번호, 사원명, 입사일, 근속년수 (근속년수는 'xx년' 형식의 문자열로 변환 출력하시오.)
SELECT EMPLOYEE_ID AS 사원번호,
       EMP_NAME AS 사원명,
       HIRE_DATE AS 입사일,
       CAST(EXTRACT(YEAR FROM SYSDATE)-EXTRACT(YEAR FROM HIRE_DATE) AS CHAR(2)) || '년' AS 근속년수
  FROM EMPLOYEES
 WHERE DEPARTMENT_ID=50;

2) TO_CHAR(char)

• CHAR, CLOB 타입을 VARCHAR2 타입의 문자열로 변환
• TO_CHAR(d [ , fmt] ) : 날짜 자료 'd'를 fmt 형식의 문자열로 변환
• TO_CHAR(n [ , fmt] ) : 숫자 자료 'n'을 fmt 형식의 문자열로 변환

날짜 형식 지정 문자열

(사용형식)

SELECT TO_CHAR(MEM_BIR),
       TO_CHAR(MEM_BIR, 'YYYY-MM-DD DAY'
  FROM MEMBER;

숫자 형식 지정 문자열

예)2005년 2월 제품별 매입현황을 조회하시오. Alias 제품코드, 매입수량, 매입금액

SELECT BUY_PROD AS 제품코드,
       TO_CHAR(SUM(BUY_QTY), '99,999') AS 매입수량,
       TO_CHAR(SUM(BUY_QTY*BUY_COST),'L99,999,999') AS 매입금액
  FROM BUYPROD
 WHERE BUY_DATE BETWEEN '20050201' AND LAST_DAY('20050201')
 GROUP BY BUY_PROD
 ORDER BY 1;

3) TO_NUMBER(c [ , fmt ])

• 숫자형식으로 제공된 문자열을 숫자형으로 변환
• 사용되는 fmt는 TO_CHAR에서 사용하는 형식 저장 문자열과 동일

4) TO_DATE(c [ , fmt ])

• 날짜 형식의 문자열을 날짜 타입으로 변환
• 형식 지정 문자열은 TO_CHAR의 형식 지정 문자열과 동일

예) 2005년 6월 13일 판매일보를 작성하시오

Alias 날짜, 상품코드, 판매수량, 구매자
SELECT TO_DATE(SUBSTR(CART_NO,1,8)) AS 날짜,
       CART_PROD AS 상품코드,
       CART_QTY AS 판매수량,
       CART_MEMBER  AS 구매자
  FROM CART
 WHERE SUBSTR(CART_NO,1,8)='20050613';

1) 수학적 함수

• ABS(n) : n의 절대값 반환
• SIGN(n) : n의 부호에 다라 0인 경우 0, 양수이면 1, 음수이면 -1을 반환
• SQRT(n) : n의 평방근(ROOT)
• POWER(n1, n2) : n1의 m2승 값을 반환

예) 상품테이블에서 상품의 매입단가와 할인판매단가를 비교하여 이익정도를 나타낼 수 있도록 조회하시오. (이익여부는 이익이 발생되면 '정상', 이익이 없으면 '원가판매상품', 손해가 발생되면 '재고처분상품' 이라고 출력하시오.)

SELECT PROD_ID AS 상품코드,
    PROD_NAME AS 상품명,
        PROD_COST AS 매입단가,
        PROD_SALE AS 할인판매가,
        CASE WHEN SIGN(PROD_SALE - PROD_COST) = 1 THEN '정상제품'
             WHEN SIGN(PROD_SALE - PROD_COST) = 0 THEN '원가판매상품'
             ELSE '재고처분상품' END AS 비고
  FROM PROD;

$*$ 표현식(CASE WHEN THEN ~ END)

• 조건을 판단하여 처리할 명령을 다르게 선택할 때 사용( IF문과 비슷한 기능)
• SELECT 절에서 사용

예) 회원테이블에서 주민번호를 이용하여 성별을 구분하시오. 단, 대전지역에 거주하는 회원정보만 조회하시오.

Alias 회원번호, 회원명, 주소, 성별

SELECT MEM_ID AS 회원번호,
    MEM_NAME AS 회원명,
         MEM_ADD1||' '||MEM_ADD2 AS 주소,
    CASE WHEN SUBSTR(MEM_REGNO2,1,1)='2' OR
                  SUBSTR(MEM_REGNO2,1,1)='4' THEN 
                  '여성회원'
             WHEN SUBSTR(MEM_REGNO2,1,1)='1' OR
                  SUBSTR(MEM_REGNO2,1,1)='3' THEN
                  '남성회원'
             ELSE 
                  '데이터 오류' END AS 성별
 FROM MEMBER
WHERE MEM_ADD1 LIKE '대전%';

2) GREATEST(n1, n2 [ , n3,...]), LEAST(n1, n2 [ , n3,...])

• GREATEST : 주어진 수 n1, n2 [ , n3, ...] 중 제일 큰 수를 반환
• LEAST : 주어진 수 n1, n2 [ , n3,...] 중 제일 작은 수를 반환

예)

SELECT GREATEST(20, -15, 70), LEAST('오성님', '오성순', '정은실')
  FROM DUAL; --DUAL : 시스템이 제공해주는 가상의 테이블
--가나다순이 빠른 '오성님'이 제일 작다.

• 예) 회원테이블에서 마일리지가 1000미만인 회원들의 마일리지를 1000으로 부여하려 한다. 이를 구현하시오. (GREATEST 사용)

Alias 회원번호, 회원명, 마일리지
SELECT MEM_ID AS 회원번호,
       MEM_NAME AS 회원명,
       MEM_MILEAGE AS 마일리지,
       GREATEST(MEM_MILEAGE,1000) AS 마일리지
  FROM MEMBER;

3) ROUND(n [ , 1] ) , TRUNC(n [ , 1])

• ROUND : 주어진 자료 n을 1+1 번째 자리에서 반올림하여 1자리까지 표현
• TRUNC : 주어진 자려 nDMF 1+1 번째 자리에서 자리버림하여 1자리까지 표현
• 1이 음수이면 정수부분 1자리에서 반올림(ROUND), 자리버림(TRUNC)
• 1이 생략되면 0으로 간주

예) 사원테이블에서 각 부서별 평균임금을 조회하시오. 평균임금은 소수 2자리까지 출력하시오.

Alias 부서코드, 부서명, 평균임금
SELECT A.DEPARTMENT_ID AS 부서코드,
       DEPARTMENTS.DEPARTMENT_NAME AS 부서명,
       ROUND(AVG(A.SALARY),2) AS 평균임금   
  FROM EMPLOYEES A, DEPARTMENTS
 WHERE A.DEPARTMENT_ID=DEPARTMENTS.DEPARTMENT_ID
 GROUP BY A.DEPARTMENT_ID,DEPARTMENTS.DEPARTMENT_NAME
 ORDER BY 1;

예제) 사원테이블을 이용하여 사원들의 이번달 급여를 지급하려한다. 지급액은 보너스+급여-세금이고 보너스는 영업실적*급여이다. 또, 세금은 보너스+급여의 3%이다.

Alias 사원번호, 사원명, 부서코드, 급여, 보너스, 세금, 지급액 (소수 첫자리까지 나타내시오)
SELECT EMPLOYEE_ID AS 사원번호,
       EMP_NAME AS 사원명,
       DEPARTMENT_ID AS 부서코드,
       SALARY AS 급여,
       ROUND(NVL(COMMISSION_PCT*SALARY,0),1) AS 보너스,
       TRUNC((SALARY+NVL(COMMISSION_PCT*SALARY,0)) * 0.03,1) AS 세금,
       SALARY+ROUND(NVL(COMMISSION_PCT*SALARY,0),1) -TRUNC((SALARY+NVL(COMMISSION_PCT*SALARY,0)) * 0.03,1) AS 지급액
  FROM EMPLOYEES;

4) MOD(n, c)

• n을 c로 나눈 나머지
• 내부에서 서로 다른 함수를 사용하여 나머지를 구함

MOD : n - c * FLOOR(n / c)

REMAINDER : n - c * ROUND(n / c)

$*$ FLOOR(n) : n과 같거나 작은쪽에서 제일 큰 정수(n을 초과하지 않는 최대 정수)

SELECT MOD(10,3),REMAINDER(10,3) FROM DUAL; -- 1 , 1
SELECT MOD(11,3),REMAINDER(11,3) FROM DUAL; -- 1, -1

//내부 연산
MOD(10,3) : 10 - 3*FLOOR(10/3)
            10 - 3*FLOOR(3.33333)
            10 - 3*3 => 10 - 9 => 1
REMAINDER(10,3) : 10 - 3*ROUND(10/3)
                  10 - 3*ROUND(3.3333)
                  10 - 3*3 => 10 - 9 => 1

MOD(11,3) : 11 - 3*FLOOR(11/3)
            11 - 3*FLOOR(3.6666)
            11 - 3*3 => 11 - 9 => 2
REMAINDER(11,3) : 11 - 3*ROUND(11/3)
                  11 - 3*ROUND(3.6666)
                  11 - 3*4 => 11 - 12 => -1

5) FLOOR(n), CEIL(n)

• FLOOR : n을 초과하지 않는 최대 정수

• CEIL : n과 같거나 n보다 큰 제일 작은 정수 (n이 정수일 경우 같고, 실수일 경우 제일 작은 정수)

  → 소숫점이 허용되지 않는 컬럼에 정수 데이터가 입력 된 경우 소숫점을 무조건 반올림하여 정수자료만 저장하는 경우 주로 사용 ex) 급여, 세금 등의 계산 항목에 주로 사용

예)

SELECT FLOOR(-10), FLOOR(-10.234), CEIL(-10), CEIL(-10.001) FROM DUAL;

SELECT FLOOR(10), FLOOR(10.234), CEIL(10), CEIL(10.001) FROM DUA

6) WIDTH_BUCKET(n, min, max, b)

• min과 max 사이를 b개의 구간으로 나누었을 경우 주어진 수 n이 어느 구간에 속하는지를 반환

예) 사원테이블에서 급여 2000~3000 사이의 값을 3개의 구간으로 나눌때 각 사원의 급여가 속한 구간값을 구하고, 그 값이 1인 경우 '낮은 급여', 2인 경우 '중간 급여', 3인 경우 '고 임금' 이라는 메시지를 비고난에 출력하시오.

Alias 사원번호, 사원명, 부서코드, 급여, 구간값, 비고
SELECT EMPLOYEE_ID AS 사원번호,
       EMP_NAME AS 사원명,
       DEPARTMENT_ID AS 부서코드,
       SALARY AS 급여,
       WIDTH_BUCKET(SALARY,2000,30000,3) AS 구간값,
       CASE WHEN WIDTH_BUCKET(SALARY,2000,30000,3)='1' THEN
                 '낮은 급여'
            WHEN WIDTH_BUCKET(SALARY,2000,30000,3)='2' THEN
                 '중간 급여'
            ELSE '고 임금' END AS 비고
  FROM EMPLOYEES;

• Object put(Object key, Object value) : 지정된 키와 값을 저장한다.
• Object remove(Object key) : 지정된 키로 저장된 값을 제거한다.
• Object get(Object key) : 지정된 키의 값(없으면 null)을 반환한다.
• Set KeySet( ) : 저장된 모든 키를 Set으로 반환한다.

put()

HashMap<String, Object> map = new HashMap<>( ); //제네릭 두개를 지정

map.put("a", 10);
map.put("b", "홍길동");
map.put("c", new Scanner(System.in));
//Object 타입은 모든 타입을 저장할 수 있다.

$*$ key는 임의로 지정하기 때문에 순서라는 개념이 없다.

map.put("b", "이순신"); 
//덮어쓰기 -> 하나의 key는 하나의 값만 저장할 수 있다.

remove()

map.remove("c");

get()

Object value = map.get("b");
//타입에 맞는 변수를 만들어서 출력

int value1 = (Integer)map.get("a");
String value2 = (String)map.get("b");

KeySet()

Set<String> keys = map.keySet(); //저장된 모든 키

for(String key : keys){ //타입에 맞는 변수 선언
//향상된 for문 : keys라는 set을 String key라는 변수에 넣는다.
    System.out.println(key + " : " + map.get(key));
}

ArrayList랑 같이 쓰기 😂

//회원테이블
//아이디, 비밀번호, 이름, 전화번호
HashMap<String, String> user = new HashMap<>(); //테이블의 한 행
user.put("id", "admin");
user.put("password", "admin123");
user.put("name", "관리자");
user.put("tel", "010-1234-5678");

ArrayList<HashMap<String, String>> table = new ArrayList<>();
//여러개의 행을 하나의 묶음으로 저장하는 table
table.add(user);

user = new HashMap<>();
ser.put("id", "admin2");
user.put("password", "admin1234");
user.put("name", "관리자2");
user.put("tel", "010-1234-5679");

table.add(user);

//출력하기
for(int i = 0; i < table.size(); i++){
    HashMap<String, String> hashmap = table.get(i);
    //접근을 줄이기 위해 for문 안에서 hashmap 선언
    Set<String> keySet = hashmap.keySet();
    for(String key : keySet){
        System.out.println(key + " : " + hashmap.get(key));
    }
    System.out.println("--------------------------------");
}

ArrayList<String> students = new ArrayList<>();

students.add("학생1");
students.add("학생2");
students.add("학생3");
students.add("학생4");
students.add("학생5");
students.add("학생6");
students.add("학생7");
students.add("학생8");
students.add("학생9");
students.add("학생10");
students.add("학생11");
students.add("학생12");
students.add("학생13");
students.add("학생14");
students.add("학생15");
students.add("학생16");
students.add("학생17");
students.add("학생18");
students.add("학생19");
students.add("학생20");
students.add("학생21");
students.add("학생22");
students.add("학생23");
students.add("학생24");
students.add("학생25");

ArrayList<String> subjects = new ArrayList<>();

subjects.add("국어");
subjects.add("영어");
subjects.add("수학");
subjects.add("사회");
subjects.add("과학");
subjects.add("Oracle");
subjects.add("Java");

//점수발생
ArrayList<ArrayList<Integer>> scores = new ArrayList<>();

for(int i = 0; i < scores.size(); i++){
    ArrayList<Integer> score = new ArrayList<>();
    for(int j = 0; j < subjects.size(); j++){
        score.add((int)(Math.random() * 101));
    }
    scores.add(score);
}

//합계 / 평균
ArrayList<Integer> sums = new ArrayList<>();
ArrayList<Double> avgs = new ArrayList<>();

for(int i = 0; i < scores.size(); i++){
    int sum = 0;
    for(int j = 0; j < subjects.size(); j++){
        sum += scores.get(i).get(j);
    }
    double avg = Math.random((double) sum / subjects.size() * 100) / 100.0;
    sums.add(sum);
    avgs.add(avg);
}

//석차구하기
ArrayList<Integer> ranks = new ArrayList<>();

for(int i = 0; i < sums.size(); i++){
    ranks.add(1);
    for(int j = 0; j < sums.size(); j++){
        if(sums.get(i) < sums.get(j)){
            ranks.set(i, ranks.get(i) + 1);
        }
    }
}

//정렬
for(int i = 0; i < scores.size()-1 i++){
    int min = i;
    for(int j = i+1; j < scores.size(); j++){
        if(ranks.get(j) < ranks.get(min)){
            min = j;
        }
    }
    String name = stdents.get(i);
    student.set(i, students.get(min));
    student.set(min, name);

    ArrayList<Integer> list = scores.get(i);
    scores.set(i, scores.get(min));
    scores.set(min, list);

    Integer sum = sums.get(i);
    sums.set(i, sums.get(min));
    sums.set(min, sum);

    Double avg = avgs.get(i);
    avgs.set(i, avgs.get(min));
    avgs.set(min, avg);

    int rank = ranks.get(i);
    ranks.set(i, ranks.get(min));
    ranks.set(min, rank);
}

//출력
for(int i = 0; i < subjects.size(); i++){
    System.out.println("\t" + subjects.get(i));
}
System.out.println("\t합계\t평균\t석차");

for(int i = 0; i < students.size(); i++){
    System.out.print(students.get(i) + "\t");
    for(int j = 0; j < subjects.size(); j++){
        System.out.print(scores.get(i).get(j) + "\t");
    }
    System.out.print(sums.get(i) + "\t");
    System.out.print(avgs.get(i) + "\t");
    System.out.print(ranks.get(i) + "\t");
    System.out.println();
}

//과목합계, 과목평균 출력
ArrayList<Integer> subjectSums = new ArrayList<>();
ArrayList<Double> subjectAvgs = new ArrayList<>();
for(int i = 0; i < subjects.size(); i++){
    int sum = 0;
    for(int j = 0; j < students.size(); j++){
        sum += scores.get(j).get(i);
    }
    double avg = Math.round((double)sum / students.size() * 100) / 100.0;
    subjectSums.add(sum);
    subjectAvgs.add(avg);
}

System.out.print("과목합계");
for(int i = 0; i < subjectSums.size(); i++){
    System.out.print("\t" + subjectSums.get(i));
}
System.out.println();
System.out.print("과목평균");
for(int i = 0; i < subjectAvgs.size(); i++){
    System.out.print("\t" + subjectAvgs.get(i));
}
System.out.println();

• boolean add(Object obj) : 마지막 위치에 객체를 추가 후 성공여부를 반환한다.
• void add(int index, Object obj) : 지정된 위치에 객체를 추가한다.
• Object set(int index, Object obj) : 지정된 위치에 객체를 저장 후 기존 객체를 반환한다.
• Object get(int index) : 지정된 위치의 객체를 반환한다. (값을 가져오기 위한 메서드)
• int size() : 지정된 객체의 수를 반환한다.
• boolean remove(int index) : 지정된 위치의 객체를 제거한다.

add

ArrayList sample = new ArrayList();

sample.add("abc");
sample.add(100);
sample.add(new Scanner(System.in));
//ArrayList의 타입이 정해져있지 않다면 다른 타입을 넣을 수 있다.

제네릭 : ArrayList<제네릭>

• 제네릭을 지정하지 않으면 넣을 때는 편하나 타입을 예측하기 힘들다. 따라서 제네릭의 사용이 권장된다.
• 제네릭에는 객체만 저장할 수 있다.(참조형타입) / 기본형 타입은 저장할 수 없다. ex) int, double 등

set(), get()

ArrayList<Integer> list = mew ArrayList<>();
list.add(10);
//list.add("abc"); //컴파일 에러 : 타입이 맞지 않는다.
list.add(20);
System.out.println(list.add(30)); // true 출력 : 정상적으로 추가
System.out.println(list); // [10, 20, 30] 출력

list.add(1, 40) //1번 인덱스부터 뒤로 밀고 값을 저장한다.
//[10, 40, 20, 30] 출력

list.add(5, 50) //컴파일 에러 : 해당 인덱스가 없다.

Integer before = list.set(2, 50);
//2번 인덱스에 값을 저장하고 기존 값을 반환한다.
System.out.println("before : " + before);
//before : 20 출력
System.out.println("after : " + list.get(2));
//after : 50 출력

size(), remove()

//값을 제거 할 때는 뒤에서부터 제거해야 한다.
for(int i = list.size()-1; i >= 0; i--){
    System.out.println(i + " : " + list.get(i));
    list.remove(i);
}
System.out.println(list);

Wrapper 클래스

• 기본형 타입을 객체로 사용해야 할 때 대신 사용하는 클래스
• boolean : Boolean
• char : Character
• byte : Byte
• short : Short
• int : Integer
• long : Long
• float : Float
• double : Double

오토박싱

기본형 타입이 wrapper 클래스로 자동 변환

ArrayList<Integer> li = new ArrayList<>();

li.add(new Integer(10));
li.add(10);

언박싱

wrapper 클래스가 기본형 타입으로 자동 변환

Integer _integer = li.get(0);
int _int = li.get(0);

• 예제) list에 1~100 사이의 랜덤값을 10개 저장하시오.

    for(int i = 0; i < 10; i++){
        int random = (int)(Math.random() * 100 + 1);
        list.add(random);
    }

    System.out.println(list);

• 예제) list에 저장된 값을 합계와 평균을 구하시오.

    int sum = 0;
    double avg = 0.0;

    for(int i = 0; i < 10; i++){
        sum += list.get(i);
    }
    avg = (double)sum / list.size();
    System.out.println("합계 : " + sum + " / 평균 : " + avg);

• 예제) list에서 최소값과 최대값을 구하시오.

    int max = list.get(0);
    int min = list.get(0);
    for(int i = 0; i < list.size(); i++){
        if(list.get(i) < min){
            min = list.get(i);
        }

        if(list.get(i) > max){
            max = list.get(i);
        }
    }

    System.out.println("최소값 : " + min + " / 최대값 : " + max);

• 예제) list를 오름차순으로 정렬하시오.

    for(int i = 0; i < list.size()-1; i++){
        int min = i;
        for(int j = i+1; j > list.size(); j++){
            if(list.get(j) < list.get(min)){
                min = j;
            }
        }
        int temp = list.set(i, list.get(min));
        list.set(min, temp);
    }

2차원 ArrayList

ArrayList<ArrayList<Integer>> list2 = new ArrayList<>();

ArrayList<Integer> _list = new ArrayList<>();
_list.add(10);
_list.add(20);
_list.add(30);

list2.add(_list);

_list = new ArrayList<>();
_list.add(40);
_list.add(50);

list2.add(_list);
System.out.println(list2);

for(int i = 0; i < list2.size(); i++){
    ArrayList<Integer> templist = list2.get(i);
    for(int j = 0; j < templist.size(); j++){
        System.out.print(templist.get(j) + "\t");
    }
    System.out.println();
}

에러

• 컴파일 에러 : 컴파일 시에 발생되는 에러(빨간줄)
• 논리적 에러 : 실행은 되지만, 의도와 다르게 동작하는 것(버그)
• 런타임 에러 : 실행 시에 발생되는 에러

런타임 에러

• 런타임 에러 발생 시 발생한 위치에서 프로그램이 비정상적으로 종료된다.
• 에러 : 프로그램 코드에 의해 수습될 수 없는 심각한 오류(처리 불가)
• 예외 : 프로그램 코드에 의해서 수습될 수 있는 다소 미약한 오류 (처리 가능)

예외

• 모든 예외는 Exception 클래스의 자식 클래스이다.
• RuntimeException 클래스와 그 자식들은 예외처리가 강제되지 않는다.
• [RuntimeException 클래스와 그 자식들을 제외한]
• Exception 클래스의 자식들은 예외처리가 강제된다.

예외처리(try-catch)

• 예외처리를 통해 프로그램이 비정상적으로 종료되는 것을 방지할 수 있다.
• try { } catch(Exception e) { } → 블럭안의 내용과 파라미터의 타입이 같아야 한다.
• try 블럭 안의 내용을 실행 중 예외가 발생하면 catch로 넘어간다.
• catch의 ( )안에는 처리할 예외를 지정해줄 수 있다.
• 여러 종류의 예외를 처리할 수 있도록 catch는 하나 이상 올 수 있다.
• 발생한 예외와 일치하는 catch 블럭안의 내용이 수행된 후 try-catch를 빠져나간다.
• 발생한 예외와 일치하는 catch가 없을 경우 예외는 처리되지 않는다.

예외

int result = 10 / 0; //정수를 0으로 나눌 수 없다.(실수의 경우 가능)
System.out.print(result);

예외처리

try{
    int result = 10 / 0; //정수를 0으로 나눌 수 없다. (실수의 경우 가능)
    System.out.println(result);
}catch(ArithmeticException | IndexOutOfBoundsException e){
    e.printStackTrace(); //에러 메시지를 출력한다.
}catch(NullPointerException e){    

}catch(Exception e){
    //모든 예외 처리
}

//파라미터가 여러개일 경우 , 가 아닌 |로 구분한다

$*$ Console 창에서 컴파일 에러 원인 확인

대표적인 예외

//IndexOutOfBoundsException -> 배열의 인덱스를 벗어났다.
int[] arr = new int[5];
System.out.println(arr[5]);

//NullPointerException -> null에서 참조했다.
String str = null;
System.out.println(str.charAt(1));

$*$ CallStack | test2 | | test1 |
| main |

• 위에서 들어가고 위에서 나가는 구조
• 제일 마지막 데이터는 그 위에 쌓인 데이터가 나가야 나갈 수 있다.

finally

• 필요에 따라 try-catch 뒤에 finally를 추가할 수 있다.
• finally는 예외의 발생 여부와 상관없이 가장 마지막에 수행된다.

public static void main(String[] args) {
    FileInputStream fis null;

    fis = new FileInputStream("d:file.txt"); // 컴파일 에러
    //컴파일에러 Ctrl + 1
    //Surround with try/catch
}

public static void main(String[] args) {
    FileInputStream fis = null;

    try {
        fis = new FileInputStream("d:file.txt");
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    }finally{ //finally
        fis.close(); //컴파일에러
    }
}

 // ↓

public static void main(String[] args) {

    FileInputStream fis = null;

    try {
        fis = new FileInputStream("d:file.txt");
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    }finally{
        try {
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

$*$ 예외 발생 : try → catch → finally / 예외 미발생 : try → finally

자동 자원 반환(JDK1.7)

try(FileOutputStream fos = new FileOutputStream("d:/file.txt")){
    String str = "아무내용이나 써보자...";

    byte[] bytes = str.getBytes();

    for(int i = 0; i < bytes.length; i++){
        fos.write(bytes[i]);
    }
}catch(Exception e){
    e.printStackTrace();
}

예외 발생시키기

• throw new Exception( );
• throw 예약어와 예외 클래스의 객체로 예외를 고의로 발생시킬 수 있다.

IOException ioe = new IOException( );

try {
    throw ioe;
}catch (IOException e) {
    e.printStackTrace();
} //이런게 있다 그냥 알아만두자

throw new NullPointerException(); //예외처리를 하지 않아도 된다.

메서드에 예외 선언하기

• 메서드 호출시 발생할 수 있는 예외를 선언해줄 수 있다.
• void method( ) throws IOException { }
• 매서드의 구현부 끝에 throws 예약어와 예외 클래스명으로 예외를 선언할 수 있다.
• 예외를 선언하면 예외처리를 하지 않고 자신을 호출한 메서드로 예외처리를 남겨준다.

public static void main(String[] args) {
    try {
        method();
    }catch (IOException e) {
        e.printStackTrace();
    }
}

private static void method() throws IOException {
    throw new IOException();
}

• 산술연산자 (+, -, *, /)
• 관계연산자 (>, <, >=, <=, =, !=(<>)) : 대소 관계를 비교할 때 사용하는 연산자
• 논리연산자(AND, OR, NOT)

함수(FUNCTION)

• 특정 기능을 수행하여 하나의 결과를 반환하도록 설계된 모듈
• 컴파일되어 실행 가능한 상태로 제공
• 문자열, 숫자, 날짜, 변환, 집계함수의 형태로 제공

기타 연산자

1) IN 연산자

• 질의 탐색을 위해 2개 이상의 표현식(항목)을 지정
• OR 연산자로 변환 가능

(사용형식) 컬럼명 IN(표현식1, 표현식2,...)

• '컬럼명'에 저장된 값이 ( ) 안에 기술된 표현식 중 어느 하나와 일치하면 전체조건이 참

예)사원테이블에서 부서코드가 20, 60, 80번 부서에 속한 사원을 검색하시오.

(IN 연산자를 사용하지 않는 경우)
SELECT EMPLOYEE_ID AS 사원번호,
       EMP_NAME AS 사원명,
       DEPARTMENT_ID AS 부서코드,
       SALARY AS 급여
  FROM EMPLOYEES
 WHERE DEPARTMENT_ID=20 OR DEPARTMENT_ID=60 OR DEPARTMENT_ID=80
 ORDER BY DEPARTMENT_ID ASC;

(IN 연산자를 사용하는 경우)
SELECT EMPLOYEE_ID AS 사원번호,
       EMP_NAME AS 사원명,
       DEPARTMENT_ID AS 부서코드,
       SALARY AS 급여
  FROM EMPLOYEES
 WHERE DEPARTMENT_ID IN(20, 60, 80)
 ORDER BY 3; --SELECT 절에 나온 세번째 컬럼

2) SOME, ANY 연산자

• 기본 기능은 IN 연산자와 동일

(사용형식) 컬럼명 관계연산자 ANY|SOME (표현식1, 표현식2,...)

• IN 연산자는 동일성만 판단
• ANY, SOME은 크기 비교도 가능

(ANY 연산자 사용)
SELECT EMPLOYEE_ID AS 사원번호,
       EMP_NAME AS 사원명,
       DEPARTMENT_ID AS 부서코드,
       SALARY AS 급여
  FROM EMPLOYEES
 WHERE DEPARTMENT_ID=ANY(20, 60, 80)
 ORDER BY 3;

 (SOME 연산자 사용)
 SELECT EMPLOYEE_ID AS 사원번호,
       EMP_NAME AS 사원명,
       DEPARTMENT_ID AS 부서코드,
       SALARY AS 급여
  FROM EMPLOYEES
 WHERE DEPARTMENT_ID=SOME(20, 60, 80)
 ORDER BY 3;

예)회원테이블에서 직업이 공무원인 회원이 가진 마일리지보다 더 많은 마일리지를 보유한 회원을 조회하시오. Alias 회원번호, 회원명, 직업, 마일리지

(직업이 공무원인 회원의 마일리지)
SELECT MEM_NAME, MEM_MILEAGE
  FROM MEMBER
 WHERE MEM_JOB='공무원'
 ORDER BY MEM_MILEAGE DESC;

SELECT MEM_ID AS 회원번호,
       MEM_NAME AS 회원명,
       MEM_JOB AS 직업,
       MEM_MILEAGE AS 마일리지
  FROM MEMBER
 WHERE MEM_MILEAGE > ANY (SELECT MAX(MEM_MILEAGE)
                            FROM MEMBER
                WHERE MEM_JOB='공무원')
-- IN : ( )안의 절과 같은 조건일 때 출력
-- ANY : ( )안의 절에서 제일 작은값보다 클때 출력

예)사원테이블에서 부서번호가 30,50,80부서에 속하지 않은 사원을 조회하시오. Alias 사원번호, 사원명, 부서번호, 입사일

SELECT EMPLOYEE_ID AS 사원번호,
       EMP_NAME AS 사원명,
       DEPARTMENT_ID AS 부서번호,
       HIRE_DATE AS 입사일
  FROM EMP
--WHERE DEPARARTMENT_ID NOT IN(30, 50, 80) --IN
 WHERE NOT DEPARTMENT_ID = ANY(30, 50, 80) --ANY
 ORDER BY 3;

3) ALL 연산자

• 질의 탐색을 위해 2개 이상의 표현식(항목)을 지정
• 모든 표현식의 평가 결과가 참이어야 WHERE 절이 참이되는 연산자(거의 사용되는 경우가 없다)
• AND 연산자로 변환 가능

(사용형식) 컬럼명 ALL(표현식1, 표현식2,...)

4) EXISTS 연산자

• 반드시 뒤에 서브쿼리가 나와야 함
• 서브 쿼리의 결과가 한 건이라도 존재하면 참

(사용형식) WHERE EXISTS (서브쿼리)

예)사원테이블에서 전체 사원의 평균급여보다 많은 급여를 수령하는 사원이 근무하는 부서코드를 조회하시오.

(전체 사원의 평균급여)
SELECT ROUND(AVG(SALARY))
  FROM EMPLOYEES;

SELECT DISTINCT DEPARTMENT_ID --DISTINCT 중복제거
  FROM EMPLOYEES
 WHERE EXISTS(SELECT 1
                FROM EMPLOYEES
               WHERE SALARY > (SELECT ROUND(AVG(SALARY))
                                 FROM EMPLOYEES))
 ORDER BY 1; 

5) BETWEEN 연산자

• 범위를 지정하여 조건을 구성하는 경우 사용

(사용형식) 컬럼명 BETWEEN 값1 AND 값2

• 컬럼명의 값이 값1에서 값2 사이의 값이면 참을 반환

예)회원테이블에서 마일리지가 1000~3000사이인 회원정보를 조회하시오. Alias 회원번호, 회원명, 마일리지

(AND 연산자 사용)
SELECT MEM_ID AS 회원번호,
       MEM_NAME AS 회원명,
       MEM_MILEAGE AS 마일리지
  FROM MEMBER
 WHERE MEM_MILEAGE >= 1000 AND MEM_MILEAGE <= 3000;

 (BETWEEN 연산자 사용)
SELECT MEM_ID AS 회원번호,
       MEM_NAME AS 회원명,
       MEM_MILEAGE AS 마일리지
  FROM MEMBER
 WHERE MEM_MILEAGE BETWEEN 1000 AND 3000;

6) LIKE 연산자 **문자열에만 사용**

• 패턴을 비교하는 경우 사용하는 연산자
• 와일드카드(패턴문자열)로 '%'와 '_'가 사용
• '%' : '%'가 사용된 위치에서 그 이후에 나오는 모든 문자열과 대응 ex) '김%' : '김'으로 시작하는 모든 문자열과 대응 ㅤㅤ'%김' : '김'으로 끝나는 모든 문자열과 대응 ㅤㅤ'%김%' : '김'이 존재하는 모든 문자열과 대응
• ' _ ' : ' _ '가 사용된 위치에서 하나의 문자와 대응 ex) '김_' : '김'으로 시작하고 2글자로 구성되며 두번째 글자는 어느글자든 상관없음 ㅤㅤ'_김' : '김'으로 끝나는 2글자로 구성된 문자열과 대응

문자열 함수

• 문자열 조작한 결과를 반환 * 문자열 연산자 '||' : 자바의 문자열 연산자 '+'와 같이 두 문자열을 결합하여 하나의 문자열을 반환

예)회원테이블에서 회원번호, 회원명, 주민번호를 조회하시오. 단, 주민번호는 'xxxxxx-xxxxxxx' 형식으로 출력하시오.

SELECT MEM_ID AS 회원번호,
       MEM_NAME AS 회원명,
       MEM_REGNO1 || '-' || MEM_REGNO2 AS 주민번호
  FROM MEMBER;

1) CONCAT

• 주어진 두 개의 문자얄을 결합하여 하나의 문자열을 반환
• '||' 연산자와 같은 기능

(사용형식) CONCAT(C1, C2)

• C1과 C2를 결합하여 결과를 반환

예)회원테이블에서 회원번호, 회원명, 주민번호를 조회하시오. 단, 주민번호는 'XXXXXX-XXXXXXX' 형식으로 출시하되, CONCAT 함수 사용

 SELECT MEM_ID AS 회원번호,
        MEM_NAME AS 회원명,
        CONCAT(CONCAT(MEM_REGNO1, '-'), MEM_REGNO2) AS 주민번호
   FROM MEMBER; --위의 결과와 동일

2) INITCAP

• 단어의 선두문자만 대문자로 출력
• 보통 이름 출력시 사용

(사용형식) INITCAP(C1)

• C1에 포함된 단어의 첫 글자를 대문자로 변환

  SELECT EMP_NAME FROM EMPLOYEES;
  

SLECT INITCAP(EMP_NAME) FROM EMPLOYEES;

![](https://images.velog.io/images/amuse_on_01/post/2741b88e-60b1-4d03-941a-6f6d884d0a4d/image.png)

#### 3) UPPER, LOWER
- 주어진 문자열에 포함된 글자를 대문자(UPPER) 또는 소문자(LOWER)로 변환하여 반환

(사용형식)
UPPER(col), LOWER(col)

#### 4) ASCII, CHR
- ASCII : 주어진 문자자료를 ASCII 코드값으로 변환
- CHR : 주어진 숫자(정수, 1~65535)에 대응하는 문자 반환

(사용형식)
ASCII(col), CHR(col)

#### 5) LPAD, RPAD
- 특정문자열(패턴)을 삽입할 때 사용

(사용형식)
LPAD(c, n [,pattern])
RPAD(c, n [,pattern])
- 주어진 문자열 'c'를 길이 'n'의 기억공간에 왼쪽부터 채우고(RPAD) | 오른쪽부터 채우고(LPAD) 남는공간에 'pattern'으로 정의된 문자열을 채움
- 'pattern'이 생략되면 공백으로 채워짐

**예)매입테이블에서 2005년 2월 매입현황을 조회하시오. 단, 매입단가는 9자리에 출력하되 남은 왼쪽공간에 '*'을 삽입하여 출력하시오. Alias 날짜, 매입상품코드, 수량, 단가**
```sql
SELECT BUY_DATE AS 날짜,
       BUY_PROD AS 매입상품코드,
       RPAD(BUY_QTY,5) AS 수량, --뒤에 패턴이 공백이고 싶으면 생략하면 된다.
       LPAD(BUY_COST,9,'*') AS 단가
  FROM BUYPROD
 WHERE BUY_DATE BETWEEN '20050201' AND '20050228';

6) LTRIM, RTRIM, TRIM

• 주어진 문자열에서 왼쪽(LTRIM) 또는 오른쪽(RTRIM)에 존재하는 문자열을 찾아 삭제할 때 사용
• 양쪽에 존재하는 공백을 제거할때는 TRIM 사용

(사용형식) LTRIM(c1 [,c2]), RTRIM(c1 [,c2]), TRIM(c1) -c2가 생략되면 공백을 삭제

예)상품테이블에서 '대우'로 시작하는 상품명중 '대우'를 삭제하고 출력하시오. Alias 상품코드, 상품명, 분류코드, 거래처코드

SELECT PROD_ID AS 상품코드,
       PROD_NAME AS 상품명1,
       LTRIM(PROD_NAME,'대우 ') AS 상품명2,
       PROD_LGU AS 분류코드,
       PROD_BUYER AS 거래처코드
  FROM PROD
 WHERE PROD_NAME LIKE '대우%';

7) SUBSTR(c, n1[,n2])

• 주어진 문자열에서 n1에서 시작하여 n2(갯수)만큼의 부분 문자열을 추출하여 반환
• n2가 생략되면 n1 이후의 모든 문자열을 추출하여 반환
• n1이 음수이면 뒤에서 부터 처리됨
• n1은 1부터 counting

  SELECT SUBSTR('IL POSTINO', 3, 4),
       SUBSTR('IL POSTINO', 3),
       SUBSTR('IL POSTINO', -3, 4)
  FROM DUAL;

  

8) REPLACE(c1, c2[,c3])

• 주어진 문자열 c1에서 c2를 c3으로 대치(치환) 시킴
• c3가 생략되면 c2를 제거함

예)상품테이블에서 상품명 중 '대우'를 찾아 'Apple'로 변경하시오.

SELECT PROD_ID,
       PROD_NAME,
       REPLACE(PROD_NAME, '대우','Apple')
  FROM PROD
 WHERE PROD_NAME LIKE '%대우%';

9) LENGTH(c), LENGTHB(c)

• 주어진 문자열에서 글자수(LENGTH) 또는 기억공간의 크기(BYTE수, LENGTHB)를 반환

오라클에서 제공하는 데이터 타입은 문자열, 숫자, 날짜, 2진 자료형이 있다.

문자열 자료형

• ' '로 묶인 자료를 문자열 자료라 한다.
• CHAR, VARCHAR, VARCHAR2, NVARCHAR, NCHAR, LONG, RAW, CLOB 등이 존재

1) CHAR

• 고정길이 문자열을 취급
• 최대 2000BYTE 저장 가능 (약 666글자)
• 기억장소가 남으면 오른쪽에 공백이 삽입
• 기억공간보다 큰 데이터는 저장 오류
• 한글 한 글자는 3BYTE로 저장됨 (한글을 제외한 공백, 숫자는 1BYTE)
• 기본키 등에 사용

(사용형식) 컬럼명 CHAR(크기[BYTE|CHAR])

• 크기[BYTE|CHAR] : 기억공간의 크기(BYTE)나 글자수(CHAR) 정의 (2000BYTE 초과 불가)

CREATE TABLE TEMP01(
    COL1 CHAR(20),
        COL2 CHAR(20 BYTE),
        COL3 CHAR(20 CHAR)); --테이블 생성

INSERT INTO TEMP01(C0L1, COL2, COL3)
    VALUES('대한민국', 'IL POSTIONO', '대전광역시 중구 대흥동 500번지'); --데이터삽입

2) VARCHAR2

• 가변길이 문자열 처리
• 최대 4000BYTE 처리 가능
• 정의된 기억공간에서 데이터의 길이 만큼 사용하고 남는 공간은 시스템에 반납
• VARCHAR와 같은 기능(오라클은 VARCHAR2 사용 권고)

(사용형식) 컬럼명 VARCHAR2(크기[BYTE|CHAR]) -[BYTE|CHAR] : 생략되면 BYTE로 취급

CREATE TABLE TEMP02(
    COL1 VARCHAR2(20),
        COL2 VARCHAR2(20 CHAR));

INSERT INTO TEMP02
    VALUES('대전시', '대한민국은');

3) LONG 데이터 타입

• 가변길이 문자열을 저장
• 최대 2GB까지 저장가능
• LONG 타입은 하나의 테이블에서 1개만 사용 가능
• CLOB로 대체(기능 업그레이드 중단)
• SELECT문의 SELECT절, UPDATE문의 SET절, INSERT문의 VALUES절에서 사용 가능

(사용형식) 컬럼명 LONG

CREATE TABLE TEMP03(
    COL1 LONG,
    COL2 VARCHAR2(2000));

SELECT SUBSTR(COL2,2,5) FROM TEMP03;

4) CLOB(Character Large OBjects) 데이터 타입

• 대용량 문자열 자료를 처리하기 위한 데이터 타입
• 최대 4GB까지 처리 가능
• 가변길이 문자 자료형
• 한 테이블에서 사용될 수 있는 CLOB의 갯수에 제한이 없음
• 일부 기능들은 DBMS_LOB API의 지원을 받아야 한다. -> LANGTHB의 경우 제한

(사용형식) 컬럼명 CLOB

CREATE TABLE TEMP04(
    COL1 CLOB,
    COL2 CLOB,
    COL3 CLOB);

SELLECT LENGTHB(COL2) FROM TEMP04; --제한

SELECT DBMS_LOB.SUBSTR(COL1,5,3),
       DBMS_LOB.GETLENGTH(COL2),
       LENGTH(COL3)
  FROM TEMP04;

5) NCLOB, NVARCHAR2

• 다국어 지원 형태로 문자 자료 저장
• UTF-8, UTF-16 형식의 ENCODDING
• 나머지 기능은 CLOB, VARCHAR2와 동일

숫자 자료형

• 정수와 실수 데이터 저장
• NUMBER 타입 제공

(사용형식) NUMBER[(정밀도|*[ , 스케일])]

• 표현할 수 있는 값의 범위 : 1.0e-130 ~ 9.999..9e125
• 정밀도 : 전체 자리수(1~38)
• 스케일 : 소숫점이하의 자리수

ex)NUMBER(5,2) : 전체 5자리가 확보(정수 부분 3자리, 소숫점이하 3자리에서 반올림하여 2번째 자리까지 표현)

• 정밀도 대신 '*'를 사용하여 38자리 이내에서 자동할당(정수부분)

ex)NUMBER(*,2) : 소숫점이하 3자리에서 반올림하여 2번째 자리까지 표현 단, 정수부분은 38자리 이내에서 크기 만큼 자동할당

• 스케일이 생략되면 0으로 간주
• 스케일이 음수이면 정수 부분에서 반올림

** 정밀도 < 스케일 인경우

• 정밀도는 0이 아닌 유효숫자의 수
• (스케일-정밀도) : 소숫점이하에 존재해야할 0의 갯수
• 스케일 : 소숫점 이하의 데이터의 수

날짜 자료형

• 날짜자료(년, 월, 시, 분, 초)를 저장하기 위한 데이터 타입
• 기본형은 DATE, 시간대(TIMEZONE) 정보와 10억분의 1초단위의 시각정보를 제공하는 데이터 타입으로 TIMESTAMP가 제공

1) DATE 타입

• 기본 날짜형
• '+', '-' 연산의 대상
• • SYSDATE : 시스템이 제공하는 날짜정보를 제공하는 함수

(사용형식) 컬럼명 DATE

INSERT INTO TEMP VALUES(SYSDATE, '20101029', SYSDATE+30);

2) TIMESTAMP 타입

• 시간대 정보와 정교한 시각정보를 필요할 때 사용

(사용형식) 컬럼명 TIMESTAMP - 시간대 정보 없음 컬럼명 TIMESTAMP WITH TIME ZONE - 시간대정보(대륙명/도시명) 포함 컬럼명 TIMESTAMP WITH LOCAL TIME ZONE - 서버가 위치한 시간대정보, 보통 TIMESTAMP와 동일

CREATE TABLE TEMP(
    COL1 DATE,
    COL2 TIMESTAMP,
    COL3 TIMESTAMP WITH TIME ZONE,
    COL4 TIMESTAMP WITH LOCAL TIME ZONE);

INSERT INTO TEMP
    VALUES(SYSDATE,SYSDATE,SYSDATE,SYSDATE);

SELECT * FROM TEMP;

기타 자료형

• 2진 자료를 저장하기 위한 자료 타입
• BLOB, ROW, LONG ROW, BFILE 등이 제공

1) RAW

• 상대적으로 작은 용량의 2진 자료를 저장
• 인덱스 처리가 가능
• ORACLE에서 해석이나 변환작업을 수행하지 않는다.
• 최대 2000BYTE까지 처리 가능
• 16진수와 2진수 저장

(사용형식) 컬럼명 RAW(크기)

2) BFILE

• 2진자료 저장
• 대상 2진자료를 데이터베이스 외부에 저장
• 경로 정보(DIRECTORY 객체) 정보만 테이블에 저장
• 4GB까지 저장 가능

(사용형식) 컬럼명 BFILE

• 디렉토리 별칭(Alias) 설정(30BYTE)과 파일명(256BYTE)설정

그림파일 저장순서

1. 그림파일이 저장된 폴더 확인
2. 디렉토리 객체 생성 - 그림이 저장된 디렉토리의 절대 주소로 생성 CREATE DIRECTORY 디렉토리별칭 AS '절대주소'
3. 그림을 저장할 테이블 생성 CREATE TABLE TEMP( COL1 BFILE);
4. 그림 삽입 INSERT INTO TEMP

     VALUES(BFILENAME('디렉토리별칭','파일명.JPG'));

3) BLOB

• 2진자료 저장
• 대상 2진자료를 데이터베이스 내부에 저장
• 4GB까지 저장 가능

(사용형식) 컬럼명 BLOB

그림파일 저장순서

1. 그림파일 준비
2. 디렉토리 객체 생성
3. 테이블 생성
4. 익명블록생성

• 데이터 조회 및 변형을 위한 명령어
• SELECT, INSERT, UPDATE, DELETE

SELECT 문

• 데이터를 조회하는 명령
• SQL 명령 중 가장 많이 사용되는 명령

(사용형식)

SELECT [DISTINCT] | * | 컬럼명 [AS][ " ]컬러별칭[ " ],
       컬럼명 [AS][ " ]컬러별칭[ " ],
             :
       컬럼명 [AS][ " ]컬러별칭[ " ]
 FROM 테이블명
[WHERE 조건]
[GROUP BY 컬럼명[, 컬럼명,...]]
[HAVING 조건] --SUM, AVG, COUNT, MAX, MIN 일때만 사용
[ORDER BY 컬럼명|컬럼인덱스[ASC|CESC][,컬럼명|컬럼인덱스[ASC|CESC],...];

• '[DISTINCT]' : 중복된 자료를 배제할 때 사용
• '컬럼별칭' : 컬럼에 부여된 또 다른 이름
• 컬럼명 AS 별칭
• 컬럼명 별칭
• 컬럼명 [AS] "별칭" : 별칭에 특수문자(공백포함)가 포함된 경우 반드시 " "로 묶어 사용
• '컬럼인덱스' : SELECT 절에서 기술된 해당 컬럼의 순번(1부터 COUNTING)
• 'ASC|DESC' : 정렬방법(ASC : 오름차순으로 기본값, DESC : 내림차순)
• SELECT 문의 실행 순서 : FROM절 -> WHERE절 이하 -> SELECT절

INSERT 문

테이블에 자료를 삽입할 때 사용

(사용형식) INSERT INTO 테이블명[(컬럼명1, 컬럼명2,...)] VALUES(값1, 값2,...);

• '컬럼명1, 컬럼명2,...'은 생략할 수 있다. 략하는 경우 테이블에 존재하는 모든 컬럼의 갯수와 순서 및 데이터 타입에 맞게 자료를 VALUES 절에 기술해야 한다.
• '컬럼명1, 컬럼명2,...'을 사용하는 경우는 선택된 컬럼에 자료를 삽입하고자 하는 경우 기술하며, VALUES절에 기술된 값과 컬럼명은 1:1로 대응 되어야 한다.
• '컬럼명1, 컬럼명2,...' 기술시 NOT NULL 컬럼은 생략 될 수 없다.

예)다음 자료를 EMP 테이블에 저장하시오. [자료] 사원 ID : C1001 사원명 : 홍길동 주소 : 대전시 중구 대흥동 500 부서명 : 총무기획부

INSERT INTO EMP(EMP_ID, EMP_NAME, ADDR, DEPT_NAME)
    VALIES('C1001', '홍길동', '대전시 중구 대흥동 500', '총무기획부');

[자료] 사원ID : C1002 사원명 : 강감찬 주소 : 서울시 성북구 신장위동 300-10 직책 : 부장 부서명 : IT 개발부

INSERT INTO EMP
    VALUES('C1001', '강감찬', '서울시 성북구 신장위동 300-10', NULL, '부장', 'IT 개발부'); -- NULL 대신 '' 사용 가능

UPDATE 문

저장되어 있는 자료(컬럼의 값)를 수정할 때 사용

(사용형식) UPDATE 테이블명 SET 컬럼명 = 값 [,컬럼명 = 값,...][WHERE 조건]

• '컬럼명' : 변경할 자료의 컬럼명
• 'WHERE'절이 생략되면 모든 자료의 해당 컬럼 값을 수정

** 예)'홍길동' 사원의 전화번호를 042-222-8202'로 수정하시오.**

UPDATE EMP
   SET TEL_NO = '042-222-8202'
 WHERE EMP_ID = 'C1001';

예)'강감찬' 사원의 전화번호를 '010-9876-1234'로 직위를 '차장'으로 수정하시오.

UPDATE EMP
   SET TEL_NO = '010-9876-1234', JOB_GRADE = '차장'
 WHERE EMP_NAME = '강감찬';

[문제] 다음 조건에 맞도록 WORK 테이블 등에 자료를 삽입하시오. [처리조건] 사원번호 'C1001'인 홍길동 사원이 오늘 날짜로 'DAE00001' 사업장에 발령 받아 출근한다. 'DAE000010'사업장은 '대전 상수도 관리사업'으로 오늘부터 공사가 개시되고 2012년 6월 30일에 완공을 목표로하는 사업장이다.

INSERT INTO SITE(SITE_NO, SITE_NAME, START_DATE, P_COM)
    VALUES('DAE00001','대전 상수도 관리사업',SYSDATE,'2021-06-30');

INSERT INTO WORK
    VALUEW('C1001', 'DAE00001', SYSDATE);

DELETE 문

• 테이블에 저장된 자료를 삭제할 때 사용
• 관계가 설정된 테이블에서 부모테이블의 행 중 참조되고 있는 자료는 삭제 거절
• ROLLBACK의 대상

(사용형식) DELETE 테이블명 [WHERE 조건];

• 'WHERE'절이 생략되면 테이블의 모든 행이 삭제

예)EMP테이블의 모든 자료를 삭제하시오.

DELETE EMP;

• 데이터 정의어(오라클 객체 생성, 삭제, 변경)
• CREATE, DROP, ALTER

CREATE 문

• 오라클 데이터베이스의 기본 객체인 테이블 생성
• CREATE TABLE 명령 제공

(사용형식) CREATE TABLE 테이블명( 컬러명1 타입명[(크기[BYTE|CHAR])] [NOT NULL][DEFAULT 값], 컬러명2 타입명[(크기[BYTE|CHAR])] [NOT NULL][DEFAULT 값], ... 컬러명n 타입명[(크기[BYTE|CHAR])] [NOT NULL][DEFAULT 값]

(제약사항) [CONSTRAINT 기본키설정명 PRIMARY KEY(컬럼명[, 컬럼명2,...]),] [CONSTRAINT 외래키설정명 FOREIGN KEY(컬럼명[, 컬럼명2,...])

• 기본키설정명 : 해당테이블 스페이스에서 유일한 명칭이어야 한다.
• 외래키설정명 : 해당테이블 스페이스에서 유일한 명칭이어야 한다.
• '테이블명(컬럼명1)' : 외래키가 참조하는 원본 테이블 이름이고, '(컬럼명1)'은 원본테이블에서 사용된 컬럼명

한국건설 물리erd를 기초로 테이블을 생성하시오.

(1)EMP 테이블 생성
CREATE TABLE EMP(
    EMP_ID CHAR(5),
    EMP_NAME VARCHAR2(30) NOT NULL,
    ADDR VARCHAR2(80),
        TEL_NO VARCHAR2(20),
        JOB_GRADE VARCHAR2(50),
        DEPT_NAME VARCHAR2(50),

    CONSTRAINT pk_emp PRIMARY KEY(EMP_ID));

(2)SITE 테이블 생성
CREATE TABLE SITE(
    SITE_NO CHAR(8),  -- 기본키
        SITE_NAME VARCHAR2(5) NOT NULL,
        SITE_TEL_NO VARCHAR2(20),
        CONS_AMT NUMBER(12) DEFAULT 0, --공사금액을 입력하지 않으면 자동으로 0
        INPUT_TER NUMBER(4) DEFAULT 0,
        START_DATE DATE DEFAULT SYSDATE,
        P_COM DATE,
        COM_DATE DATE,
        REMARKS VARCHAR2(100),

        CONSTRAINT pk_site PRIMARY KEY(SITE_NO));

(3)MATERIALS 테이블 생성
CREATE TABLE MATERIALS(
    MAT_ID CHAR(10),
        MAT_NAME VARCHAR2(50) NOT NULL,
        MAT_QTY NUMBER(4) DEFAULT 0,
        MAT_PRICE NUMBER(8) DEFAULT 0,
        PUR_DATE DATE,
        SITE_NO CHAR(8),

        CONSTRAINT pk_materials PRIMARY KEY(MAT_ID),
        CONSTRAINT fk_site FOREIGN KEY(SITE_NO)
            REFERENCES SITE(SITE_NO));

(4)WORK 테이블 생성
CREATE TABLE WORK(
    EMP_ID CHAR(5),
        SITE_NO CHAR(8),
        WST_DATE DATE,

        CONSTRAINT pk_work PRIMARY KEY(EMP_ID, SITE_NO),
        CONSTRAINT fk_work_emp FOREIGN KEY(EMP_ID)
            REFERENCES EMP(EMP_ID),
        CONSTRAINT fk_wokr_site FOREIGN KEY(SITE_NO)
            REFERENCES SITE(SITE_NO));

COMMIT;

DROP 문

• 오라클 객체를 삭제
• ROLLBACK의 대상이 아님

(사용형식) DROP 객체타입 객체명;

예)EMP테이블과 WORK테이블 사이에 존재하는 관계를 삭제하시오.

ALTER TABLE WORK
    DROP CONSTRAINT fk_work_emp;

ALTER TABLE WORK
    DROP CONSTRAINT fk_work_site; --관계 삭제

DROP TABLE EMP;

DROP TABLE SITE; --METERIALS가 자식테이블이기 때문에 DROP 할 수 없다.

DROP TABLE MATERIALS;
DROP TABLE SITE;
DROP TABLE WORK;

선언부만 있고 구현부는 없는 메서드

public abstract class SampleAbstractParent {

    void method(){
        //일반적인 메서드
    }

    //추상 메서드 : 선언부만 있고 구현부는 없는 메서드
    abstract void abstractMethod();

}

class SampleAbstractChild extends SampleAbstractParent{

    //추상 클래스가 되거나
    //추상 메서드에 내용이 되어야 한다.

    @Override //상속받은 내용을 변경한다.
    void abstractMethod() {
        System.out.println("추상 메서드를 상속받아 내용을 만들어줌.");
    }

}

인터페이스

• 인터페이스의 모든 멤버변수는 public static final 제어자를 사용해야한다.

• 인터페이스의 모든 메서드는 public abstract 제어자를 사용해야한다.

• 상수와 추상 메서드만 가질 수 있다.

• 부모클래스의 역할만 한다.

• 다중 상속이 가능하다.

  public interface SampleInterface {
  
    //인터페이스의 모든 멤버변수는 public static final 제어자를 사용해야한다.
    public static final int NUM1 = 1;
  
    //모든 멤버변수의 제어자가 같기 때문에 생략이 가능하다.
    int NUM2 = 2;
  
    //인터페이스의 모든 메서드는 public abstract 제어자를 사용해야한다.
    public abstract void method1();
  
    //모든 메서드의 제어자가 같기 때문에 생략이 가능하다.
    void method2();
  

}

class SampleImplement implements SampleInterface, SampleInterface2 { //인터페이스를 상속받을 때는 implements

@Override
public void method1() {

}

@Override
public void method2() {

}

@Override
public void method3() {

} 

}

interface SampleInterface2{ void method1(); void method3(); }

```