kungfugay's Blog

public class ArrayQueue {
    private int front;
    private int rear;
    private int maxSize;

    private Object[] queueArray;

    public ArrayQueue(int maxSize) {
        this.maxSize = maxSize;

        front = 0;
        rear = -1;

        queueArray = new Object[maxSize];
    }

    // 큐 공간이 비어 있는지
    public boolean isEmpty() {
        return (front == rear + 1);     // 둘 다 인덱스 0번이면 비어 있음
    }

    // 큐 공간이 가득 차 있는지
    public boolean isFull() {
        return (rear == maxSize - 1);   // 최후단이 배열의 총 크기와 같으면 다 차 있음
    }

    // 추가 -- rear와 연관 (늘어남)
    public void push(Object item) {
        if (isFull()) {
            System.out.println("큐 공간이 가득 차 있습니다");
            return;         // break
        }
        rear++;             // -1에서 0번지로
        queueArray[rear] = item;
    }

    // 삭제 -- front와 연관
    public Object pop() {
        Object item = peek();
        if (item == null) return null;

        front++;
        return item;
    }

    // 산출
    public Object peek() {
        if (isEmpty()) {
            System.out.println("큐 공간이 비어 있습니다");
            return null;
        }
        return queueArray[front];
    }
}

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

        // 배열 사이즈 5로 큐 초기화
        ArrayQueue queue = new ArrayQueue(5);
        
        // 첫번째 요소 삽입
        Integer in = 111;
        queue.push(in);

        // 두번째 요소 삽입
        in = 222;
        queue.push(in);

        // 세번째 요소 삽입
        in = 222;
        queue.push(in);

        // front 위치의 데이터 산출
        Integer peek = (Integer) queue.peek();
        System.out.println(peek);
        
        // 1개 삭제 (front 위치에서)
        queue.pop();

        // front 위치의 데이터 산출
        peek = (Integer) queue.peek();
        System.out.println(peek);
    }
}

public class ArrayStack {
    private int top;
    private int maxSize;
    private Object[] stackArray;            // Object == 어떤 클래스든 다 담을 수 있음

    // 생성자 (배열 크기 -> 배열 초기화, top은 비어있음)
    public ArrayStack (int maxSize) {
        this.maxSize = maxSize;
        stackArray = new Object[maxSize];
        top = -1;
    }

    // 스택 공간이 비어 있는지
    public boolean isEmpty() {
        return (top == -1);                 // -1이면 true고, -1이 아니면 false
    }

    // 스택 공간이 가득 차 있는지
    public boolean isFull() {
        return (top == maxSize -1);         // 배열 사이즈가 10이면 top은 0~9번지 -> 9
    }

    // 추가 -- push
    public void push(Object item) {
        if (isFull()) {
            System.out.println("스택 공간이 가득 차 있음");
            return;             // break
        }
        top++;                  // top은 -1 에서 0
        stackArray[top] = item; // 0번지에 item 삽입
    }

    // 삭제 -- pop
    public Object pop() {       // 삭제된 데이터를 Return -- 반환타입 Object
        Object item = peek();   // top 위치의 아이템을 일단 확인
        if (item == null) {
            System.out.println("스택 공간이 비어 있음");
            return null;
        }
        top--;                  // top은 n에서 n-1
        return item;
    }

    // top(최상단)에 해당되는 데이터 (반환)
    public Object peek() {
        if (isEmpty()) {
            System.out.println("스택 공간이 비어 있음");
            return null;
        }
        return stackArray[top];
    }
}

public class MainClass {
    public static void main(String[] args) {
    /*
        Stack
        First in last out = FILO
        push, pop, peek
        isEmpty, isFull
     */

        // 크기가 5로 Stack 초기화
        ArrayStack stack = new ArrayStack(5);

        // 1번째 요소 삽입
        String str = "AAA";
        stack.push(str);

        // 2번째 요소 삽입
        str = "BBB";
        stack.push(str);

        // 3번째 요소 삽입
        str = "CCC";
        stack.push(str);

        // 최상단 데이터 확인
        String peek = (String) stack.peek();
        System.out.println(peek);

        // 최상단 데이터 삭제
        stack.pop();

        // 최상단 데이터 확인
        peek = (String) stack.peek();
        System.out.println(peek);

    }
}

// HashMap<Integer, String> hMap = new HashMap<>();
Map<Integer, String> hMap = new HashMap<>();

hMap.put(111, "백십일");
hMap.put(222, "이백이십이");
hMap.put(333, "삽백삼십삼");

System.out.println(hMap.size());

String value = hMap.get(333);
System.out.println(value);

Iterator<Integer> it = hMap.keySet().iterator();
while (it.hasNext()) {
    Integer _key = it.next();
    String _value = hMap.get(_key);
    System.out.println("key = " + _key + "\tvalue = " + _value);
}

String remove_value = hMap.remove(222);
System.out.println("삭제된 값 = " + remove_value);

// 검색
// boolean b = hMap.containsKey(333);
if (hMap.containsKey(333)) {
    String val = hMap.get(333);
    System.out.println(val);
}

// 수정 -- 키 값은 수정 안되고 value만
String str = "300 + 30 + 3";
hMap.replace(333, str);

// Sorting
TreeMap<String, String> tMap = new TreeMap<>( fruitMap );

// 오름차순 (자동) -- keySet()
Iterator<String> it1 = tMap.keySet().iterator();

// 내림차순 (자동) -- descendingKeySet()
Iterator<String> it1 = tMap.descendingKeySet().iterator();

// 출력
while (it1.hasNext()) {
    String k = it1.next();
    String v = tMap.get(k);
    System.out.println("key = " + k + "\tvalue = " + v);
}

public interface Animal {
    void printDescript();
}

public class Cat implements Animal {
    @Override
    public void printDescript() {
        System.out.println("야옹야옹");
    }
}

public class AnimalFactory {

    public static Animal create(String name) {
        if (name.equals("야옹이")) {
            return new Cat();
        }
        else if (name.equals("멍멍이")) {
            return new Dog();
        }
        else if (name.equals("황소")) {
            return new Cow();
        }

        return null;
    }
}

public class MainClass {
    public static void main(String[] args) {
        /*
        // 하나씩 생성
        Animal ani1 = AnimalFactory.create("멍멍이");
        Animal ani2 = AnimalFactory.create("야옹이");
        Animal ani3 = AnimalFactory.create("황소");

        ani1.printDescript();
        ani2.printDescript();
        ani3.printDescript();
        */

		// 식별자(=이름)을 배열에 미리 넣고, ArrayList에 인스턴스 삽입
        List<Animal> animalList = new ArrayList<>();
        String[] names = { "멍멍이", "황소", "황소", "멍멍이", "야옹이", "야옹이", "야옹이", "멍멍이" };

		// Factory 클래스를 사용해서 인스턴스 생성 후 ArrayList에 삽입
        for (String name : names) {
            Animal ani = AnimalFactory.create(name);
            animalList.add(ani);
        }

		// 메소드 호출
        for (Animal a : animalList) {
            a.printDescript();
        }
    }
}