[JAVA] 제어문

WHITESHIP JAVA LIVE STUDY

🍭 반복문(for each)

for each 는 J2SE 5.0(Java Platform, Standard Edition) 부터 추가되었다.

for each라는 키워드가 따로 있는 것은 아니고 동일한 for를 이용한다.

하지만 조건식 부분이 조금 다르다. 보통 다른 언어에서 for each 라고 많이 하므로 자바에서도 보통 for each 문이라고 말한다.

문법은 아래와 같다.

for (type var: iterate) {
    body-of-loop
}

위 iterate(: 반복하다) 는 루프를 돌릴 객체이고 iterate 객체에서 한개씩 순차적으로 var 에 대입되어 for 문을 수행하게 된다.

iterate 부분에 들어가는 타입은 루프를 돌릴 수 있는 형태인 배열 및 ArrayList 등이 가능하다.

예)

for 문

String [] numbers = {"one", "two", "three"};
for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}

for each 구조로 변경하면 다음과 같다.

String [] numbers = {"one", "two", "three"};
for (String number: numbers) {
    System.out.println(number);
}

ArrayList<String> numbers = new ArrayList<String>();
numbers.add("one");
numbers.add("two");
numbers.add("three");

for (String number: numbers) {
    System.out.println(number);
}

단, foreach 문은 따로 반복회수를 명시적으로 주는 것이 불가능하고, 1스탭씩 순차적으로 반복될때만 사용가능하다는 제약이 있다.

🖇 LinkedList

LinkedList를 알아보기에 앞서 컬렉션 프레임워크를 알고 넘어가자.

 

컬렉션 프레임워크

데이터 군을 저장하는 클래스들을 표준화한 설계 또는 데이터 군을 다루고 표현하기 위한 단일화된 구조(architecture)를 뜻한다.

컬렉션은 다수의 데이터, 데이터 그룹을 의히마고,
프레임워크는 표준화된 프로그래밍 방식을 의미한다.

컬렉션(데이터 그룹, 다수의 데이터)는 크게 세가지 종류로 나뉜다.
이 세가지 컬렉션을 다루는 데 필요한 기능을 가진 3가지 인터페이스가 존재하는데, 바로
List, Set, Map이다.

인터페이스	특징
List	순서 : O 데이터 중복 : O 예) 대기자 명단
	구현 클래스: ArrayList, LinkedList, Stack, Vector 등
Set	순서 : X 데이터 중복 : X 예) 양의 정수 집합, 소수의 집합
	구현 클래스: HashSet, TreeSet 등
Map	키(key)와 값(value)의 쌍(pair)로 이루어진 데이터의 집합. 순서 : X 키의 중복 : X 값의 중복 : O 예) 우편번호, 지역번호(전화번호)
	구현 클래스 : HashMap, TreeMap, Hashtable, Properties 등

위 표의 List 인터페이스를 구현한 클래스 중 하나가 바로 LinkedList이다.

💡 참고
List 와 Set 인터페이스는 공통된 부분이 많아 그 공통된 부분을 모아 만든 Collection 인터페이스가 있다.
즉, List와 Set의 조상으로 Collection 인터페이스가 있는 것이다.

Collection 인터페이스에 정의된 대표적인 메소드

메서드	설명
boolean add(Object o) ⭐ boolean addAll(Collection c)	지정된 객체(o) 또는 Collection(c)의 객체들을 Collction 에 추가한다.
void clear()	Collection의 모든 객체를 삭제한다.
boolean contains(Object o) boolean containsAll(Collection c)	지정된 객체(o) 또는  Collection의 객체들이 Collection에 포함되어 있는지 확인한다.
boolean equals(Object o) ⭐	동일한 Collection 인지 비교한다.
int hashCode()	Collection의 hash code를 반환한다.
boolean isEmpty() ⭐	Collection이 비어있는지 확인한다.
Iterator iterator()	Collection의 📢Iterator를 얻어서 반환한다.
boolean remove(Object o)	지정된 객체를 삭제한다.
boolean removeAll(Collection c)	지정된 Collection에 포함된 객체들을 삭제한다.
boolean retainAll(Collection c)	지정된 Colection에 포함된 객체만을 남기고 다른 객체들은 Collection에서 삭제한다. 이 작업으로 인해 Collection에 변화가 있으면 true를 그렇지 않으면 false를 반환한다.
int size() ⭐	Collection에 저장된 객체의 개수를 반환한다
Object[] toArray()	Collection에 저장된 객체를 객체 배열(Object[])로 반환한다.
OBject[] toArray(Object[] a)	지정된 배열에 Collection의 객체를 저장해서 반환한다.

📢 Iterator

Iterator는 ArrayList, HashSet 처럼 컬렉션을 반복하는 데 사용할 수 있는 개체이다.
자세히

 

ArrayList

• 순서 O
• 중복 O
• List 인터페이스로 구현됨
• Object 배열을 이용해 데이터를 순차적으로 저장한다.
• 단점
  • 용량을 변경해야할 때 새로운 배열을 생성한 후 기존의 배열로부터 새로 생성된 배열로 데이터를 복사하는 구조라서 효율이 떨어진다

💡 참고로 ArrayList는 배열(Array)와 다르다.

자료구조	Array	ArrayList
사이즈	초기화 시 고정 int[] myArray = new int[6];	초기화 시 사이즈를 표시하지 않음. 유동적 ArrayList<Integer> myArrayList = new ArrayList<>();
속도	초기화 시 메모리에 할당되어 속도가 빠르다.	추가 시 메모리를 재할당하여 속도가 느리다
변경	사이즈 변경 불가	추가, 삭제 가능 add(), remove()
다차원	가능 int[][] multiArray = new int[3][3];	불가능

 

ArrayList의 대표적인 생성자/메서드

메서드	설명
ArrayList()	크기가 10인 ArrayList를 생성
ArrayList(Collection c) ⭐	주어진 컬렉션이 저장된 ArrayList를 생성
ArrayList(int initialCapacity) ⭐	지정된 초기용량을 갖는 ArrayList를 생성 (capacity: 용량, 능력)
boolean add(Object o) ⭐	ArrayList의 마지막에 객체를 추가. 성공하면 true
void add(int index, Object element)	지정된 위치(index)에 객체를 저장
boolean addAll(Collection c)	주어진 컬렉션의 모든 객체를 저장한다.
boolean addAll(int index, Collection c) ⭐	지정된 위치부터 주어진 컬렉션의 모든 객체를 저장한다.
void clear()	ArrayList를 완전히 비운다.
Object clone()	ArrayList를 복제한다.
boolean contains(Object o) ⭐	지정된 객체(o)가 ArrayList에 포함되어 있는지 확인
void ensureCapacity(int minCapacity)	ArrayList의 용량이 최소한 minCapacity가 되도록한다. (capacity: 용량, 능력)
Object get(int index) ⭐	지정된 위치(index)에 저장된 객체를 반환한다.
int indexOf(Object o)	지정도니 객체가 저장된 위치를 찾아 반환한다.
boolean isEmpty()	ArrayList가 비어있는지 확인한다.
Iterator iterator()	ArrayList의 Iterator객치를 반환
int lastIndexOf(Object o)	객체(o)가 저장된 위치를 끝부터 역방향으로 검색해서 반환
ListIterator listIterator()	ArrayList의 ListIterator를 반환
ListIterator listIterator(int index)	ArrayList의 지정된 위치부터 시작하는 ListIterator를 반환
Object remove(int index) ⭐	지정된 위치(index)에 있는 객체를 제거한다.
boolean remove(Object o)	지정한 객체를 제거한다.(성공하면 true, 실패하면 false)
boolean removeAll(Collection c)	지정한 컬렉션에 저장된 것과 동일한 객체들을 ArrayList에서 제거한다.
boolean retainAll(Colleciton c) ⭐	Arraylist에 저장된 객체 중에서 주어진 컬레션과 공통된 것들만을 남기고 나머지는 삭제한다. (retain: 유지하다)
Object set(int index, Object element)	주어진 객체(element)를 지정된 위치(index)에 저장한다.
int size() ⭐	ArrayList에 저장된 객체의 개수를 반환한다.
void sort(Comparator c) ⭐	지정된 정렬 기준(c)으로 ArrayList를 정렬
List subList(int fromIndex, int toIndex) ⭐	fromIndex부터 toIndex사이에 저장된 객체를 반환한다.
Object[] toArray()	ArrayList에 저장된 모든 객체들을 객체 배열로 반환한다.
Object toArray(Object[] a)	ArrayList에 저장된 모든 객체들을 객체 배열 a에 담아 반환한다.
void trimToSize()	용량을 크기에 맞게 줄인다.(빈 공간을 없앤다.)

 

ArrayList 예제

package com.java.test;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        ArrayList list1 = new ArrayList(10);
        list1.add(new Integer(5));
        list1.add(new Integer(4));
        list1.add(new Integer(2));
        list1.add(new Integer(0));
        list1.add(new Integer(1));
        list1.add(new Integer(3));

        ArrayList list2 = new ArrayList(list1.subList(1,4));
        print(list1, list2);

        Collections.sort(list1); // list1과 list2를 정렬한다.
        Collections.sort(list2);
        print(list1, list2);

        System.out.println("list1.containsAll(list2) : " + list1.containsAll(list2));

        list2.add("B");
        list2.add("C");
        list2.add(3, "A");
        print(list1, list2);

        list2.set(3, "AA");
        print(list1, list2);

        // list1에서 list2와 겹치는 부분만 남기고 나머지는 삭제한다.
        System.out.println("list1.retainAll(list2) : " + list1.retainAll(list2));

        print(list1, list2);

        // list2에서 list1에 포함된 객체들을 삭제한다.
        // 만약 변수 i를 증가시켜가면서 삭제하면, 한 요소가 삭제될 때마다
        // 빈 공간을 채우기 위해 나머지 요소들이 자리 이동을 하기 때문에 올바른 결과를 얻을 수 없다.
        for(int i = list2.size() - 1 ; i >= 0 ; i--) {
            if(list1.contains(list2.get(i)))
                list2.remove(i);
        }

        print(list1, list1);
    }

    static void print(ArrayList list1, ArrayList list2) {
        System.out.println("list1 :" + list1);
        System.out.println("list2 :" + list2);
        System.out.println();
    }
}

ArrayList 예제 결과 화면

LinkedList

• 배열의 단점을 보완하기 위해 고안된 자료구조
• 불연속적으로 존재하는 데이터를 서로 연결(link)한 형태

✏ 배열의 단점
1. 크기를 변경할 수 없다.
2. 비순차적인 데이터의 추가 또는 삭제에 시간이 많이 걸린다

각 요소(node)들은 자신과 연결된 다음 요소에 대한 참조(주소값)와 데이터로 구성되어 있다.

ex) 참조(주소값) : 0x300 / 데이터 : 0

class Node {
    Node next; // 다음 요소의 주소를 저장
    Object obj; // 데이터를 저장
}

 

LinkedList 의 삭제

삭제하고자 하는 요소의 이전요소가 삭제하고자 하는 요소의 다음 요소를 참조하도록 변경하기만 하면된다. 

단 하나의 참조만 변경하면 삭제가 이루어지는 것이다.  

linkedList의 데이터 삭제

LinkedList 의 추가

새로운 요소를 생성한 다음 추가하고자 하는 위치의 이전 요소의 참조를 새로운 요소에 대한 참조로 변경해주고,

새로운 요소가 그 다음 요소를 참조하도록 변경하기만 하면 되므로 처리속도가 매우 빠르다.

linkedList의 데이터 추가

linkedList는 이동방향이 단방향이기 때문에 다음 요소에 대한 접근은 쉽지만 이전요소에 대한 접근은 어렵다.

이 점을 보완한 것이 더블 링크드 리스트(이중 연결 리스트, doubly linked list)이다.

 

더블 링크드 리스트

단순히 링크드 리스트에 참조변수를 하나 더 추가하여 다음 요소에 대한 참조뿐 아니라 이전 요소에 대한 참조가 가능하도록 했을 뿐, 그 외에는 링크드 리스트와 같다.

더블 링크드 리스트는 링크드 리스트보다 각 요소에 대한 접근과 이동이 쉽기 때문에 링크드 리스트보다 더 많이 사용된다.

class Node {
    Node next; // 다음 요소의 주소를 저장
    Node previous; // 이전 요소의 주소를 저장
    Object obj; // 데이터를 저장
}

더블드 링크드 리스트

더블 써큘러 링크드 리스트

이중 원형 연결 리스트.

더블 링크드 리스트의 접근성을 보다 향상 시킨 것

단순히 더블링크드 리스트의 첫번째 요소와 마지막 요소를 서로 연결 시킨 것이다.

더블 써큘러 링크드 리스트

링크드 리스트의 생성자와 메서드

생성자 또는 메서드	설명
LinkedList()	LinkedList 객체를 생성
LinkedList(Colection c)	주어진 컬렉션을 포함하는 LinkedList 객체를 생성
boolean add(Object o)	지정된 객체(o)를 LinkedList의 끝에 추가. 저장에 성공하면 true, 실패하면 false
void add(int index, Object element)	지정된 위치(index)에 객체(elemnt)를 추가
boolean addAll(Collection c)	주어진 컬렉션에 포함된 모든 요소를 LinkedList의 끝에 추가한다. 성공하면 ture, 실패하면 false
boolean addAll(int index, Collection c)	지정된 위치(index)에 주어진 컬렉션에 포함된 모든 요소를 추가. 성공하면 true. 실패하면 false
void clear()	LinkedList의 모든 요소를 삭제
boolean contains(Object c)	지정된 객체가 LinkedList에 포함되었는지 알려줌
boolean containsAll(Collection c)	지정된 컬렉션의 모든 요소가 포함되었는지 알려줌
Object get(int index)	지정된 위치(index)의 객체를 반환
int indexOf(Object o)	지정된 객체가 저장된 위치(앞에서 몇 번째)를 반환
boolean isEmpty()	LinkedList가 비어있는지 알려준다. 비어있는 true
Iterator iterator()	iterator를 반환한다.
int lastIndexOf(Object o)	지정된 객체의 위치(index)를 반환(끝부터 역순검색)
ListIterator listIterator()	ListIterator를 반환한다.
ListIterator listIterator(int index)	지정된 위치에서부터 시작하는 ListIterator를 반환
Object remove(int index)	지정된 위치(index)의 객체를 LinkedList에서 제거
boolean remove(Object o)	지정된 객체를 LinkedList에서 제거, 성공하면 true. 실패하면 false
boolean removeAll(Collection c)	지징된 컬렉션이 요소와 일치하는 요소를 모두 삭제
boolean retainAll(Collection c)	지정된 컬렉션의 모든 요소가 포함되어 있는지 확인
Object set(int index, Object element)	지정된 위치(index)의 객체를 주어진 객체로 바꿈
int size()	LinkedList에 저장된 객체의 수를 반환
ListsubList(int fromIndex, Object element)	LinkedList의 일부를 List로 반환
Object[] toArray()	LinkedList에 저장된 객체를 배열로 반환
Object[] toArray(Object[] a)	LinkedList에 저장된 객체를 주어진 배열에 저장하여 반환
Object element()	LinkedList의 첫번째 요소를 반환
boolean offer(Object o)	지정된 객체(o)를 LinkedList의 끝에 추가. 성공하면 true, 실패하면 false
Object peek()	LinkedList의 첫 번째 요소를 반환
Object poll()	LinkedList의 첫 번째 요소를 반환
Object remove()	LinkedList의 첫 번째 요소를 제거
void addFirst(Object o)	LinkedList의 맨 앞에 객체(o)를 추가
void addLast(Object o)	LinkedList의 맨 끝에 객체(o)를 추가
Iterator descendingIterator()	역순으로 조회하기 위한 DescendingIterator를 반환
Object getFirst()	LinkedList의 첫 번재 요소를 반환
Object getLast()	LinkedList의 마지막 요소를 반환
boolean offerFirst(Object o)	LinkedList의 맨 앞에 객체(o)를 추가. 성공하면 true
boolean offerLast(Object o)	LinkedList의 맨 긑에 객체(o)를 추가. 성공하면 true
Object peekFirst()	LinkedList의 첫번째 요소를 반환
Object peekLast()	LinkedList의 마지막 요소를 반환
Object pollFirst()	LinkedList의 첫번째 요소를 반환하면서 제거
Object pollLast()	LinkedList의 마지막 요소를 반환하면서 제거
Object pop()	removeFirst()와 동일
void push(Object o)	addFirst()와 동일
Object removeFirest()	LinkedList의 첫번째 요소를 제거
Object removeLast()	LinkedList의 마지막 요소를 제거
boolean removeFirstOccurrence(Object o)	LinkedList에서 쳇번째로 일치하는 객체를 제거
boolean removeLastOccurrence(Object o)	LinkedList에서 마지막으로 일치하는 객체를 제거

 

LinkedList 와 ArrayList 비교

• 순차적으로(마지막 요소부터 역순으로) 추가/삭제하는 경우에는 ArrayList가 LinkedList보다 빠르다
  • ArrayList는 마지막 데이터부터 삭제할 경우 각 요소들의 재배치가 필요하지 않기 때문에 빠름. 단지 마지막 요소의 값을 null로 바꾸기만 하면되니까.
• 중간 데이터를 추가/삭제하는 경우에는 LinkedList가 ArrayList보다 빠르다
  • LinkedList는 각 요소간의 연결만 변경해주면 되기 때문에 빠름
  • ArrayList는 각 요소들을 재배치 하여 추가할 공간을 확보하거나 빈 공간을 채워야하기 때문에 처리속도가 늦다.

컬렉션	읽기(접근시간	추가/삭제	비고
ArrayList	빠르다	느리다	순차적인 추가삭제는 더 빠름 비효율적인 메모리 사용
LinkedList	느리다	빠르다	데어타가 많을수록 접근성이 떨어짐

 

🛒 Stack

• Last In First Out(LIFO)
• 활용 예
  • 수식 계산
  • 수식괄호검사
  • 워드프로세서의 undo/redo
  • 웹브라우저의 뒤로/앞으로

스택의 메서드

메서드	설명
boolan empty()	Stack이 비어있는지 알려준다.
Object peek()	Stack의 맨 위에 저장된 객체를 반환. pop()과 달리 Stack에서 객체를 꺼내지는 않음.(비었을 때는 EmptyStackException 발생)
Object pop()	Stack의 맨 위에 저장된 객체를 꺼낸다. (비었을 때는 EmptyStack
Object push(Object Item)	Stack에 객체(item)를 저장한다.
int search(Object o)	Stack에서 주어진 객체(o)를 찾아서 그 위치를 반환. 못찾으면 -1을 반환. (배열과 달리 위치는 0이 아닌 1부터 시작)

🎹 Queue

• First In First Out(First In First Out)
• 활용 예
  • 최근 사용 문서
  • 인쇄작업 대기목록
  • 버퍼(buffer)

메서드	설명
boolean add(Object o)	지정된 객체를 Queue에 추가한다. 성공하면 true를 반환, 저장공간이 부족하면 IlegalStateException 발생
Object remove()	Queue에서 객체를 꺼내 반환. 비어있으면 NoSuchElementException 발생
Object element	삭제 없이 요소를 읽어온다. peek와 달리 Queue가 비었을 때 NoSuchElementException 발생
boolean offer(Object o)	Queue에 객체를 저장. 성공하면 true, 실패하면 false를 반환
Object poll()	Queue에 객체를 꺼내서 반환. 비어있으면 null을 반환
Object peek()	삭제없이 요소를 읽어온다. Queue가 비어있으며 null을 반환

PriorityQueue

• Queue 인터페이스의 구현체 중 하나
• 저장한 순서에 관계없이 우선순위가 높은 것부터 꺼낸다
• null을 저장할 수 없다(NullPointerException)
• 저장공간으로 배열 사용
• 힙(heap)이라는 자료구조 형태로 저장
• 가장 큰 값이나 가장 작은 값을 빠르게 찾을 수 있다.

Deque (Double-Enbed Queue)

• Queue의 변형
• 양 쪽 끝에 추가/삭제가 가능 (Queue는 한 쪽 끝으로만 추가/ 삭제 가능)
• Duque의 조상이 Queue
• 구현체는 ArrayDeque, LinkedList

덱(Deque)의 메서드에 대응하는 큐와 스택의 메서드

Deuque	Queue	Stack
offerLast()	offer()	push()
pollLast()		pop()
pollFirst()	poll()
peekFirst()	peek()
paeekLast()		peek()

😵 과제

LinkedList를 구현하세요

• 정수를 저장하는 ListNode 클래스를 구현하세요
• ListNode add(ListNode head, ListNode nodeToadd, int position)을 구현하세요
• ListNode remove(ListNode head, int positionToRemove)를 구현하세요
• boolean contains(ListNode head, ListNode nodeToCheck)를 구현하세요

public class ListNode {
    int data;
    ListNode next;

    public ListNode() {}
    public ListNode(int data) {
        this.data = data;
        this.next = null;
    }

    public ListNode add(ListNode head, ListNode nodeToAdd, int position) {
        ListNode node = head;

        //position 이전까지 탐색
        for (int i = 0; i < position - 1; i++) {
            node = node.next;
        }

        //지정 위치에 노드 삽입
        nodeToAdd.next = node.next;
        node.next = nodeToAdd;
        return head;
    }

    public ListNode remove(ListNode head, int positionToRemove) {
        ListNode node = head;

        //삭제 위치가 가장 앞인경우
        if(positionToRemove == 0){
            ListNode deleteToNode = node;
            head = node.next;
            deleteToNode.next = null;
            return deleteToNode;
        }
        for (int i = 0; i < positionToRemove - 1; i++) {
            node = node.next;
        }

        //지정 위치 노드 삭제
        ListNode deleteToNode = node.next;
        node.next = deleteToNode.next;
        deleteToNode.next = null;
        return deleteToNode;
    }

    public boolean contains(ListNode head, ListNode nodeToCheck) {
        while (head != null) {
            if (head.data == nodeToCheck.data) {
                return true;
            }
            head = head.next;
        }
        return false;
    }

    public void print(ListNode node) {
        while (node != null) {
            System.out.print(node.data);
            node = node.next;
        }
    }
}

Stack을 구현하세요

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

public class Stack {
    private int top = 0;
    private int StackArr[];

    public Stack(int size) {
        StackArr = new int[size];
    }

    public void push(int data) {
        top++;
        StackArr[top] = data;
    }

    public int pop() {
        int ret = StackArr[top];
        top--;
        return ret;
    }

    public void print() {
        for (int i = top; i > 0; i--) {
            System.out.println("|" + StackArr[i] + "|");
        }
        System.out.println("ㅡ");
    }
}

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

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

public class ListNodeStack {
    int top;
    ListNode node;

    public ListNodeStack() {
        this.node = null;
        this.top = -1;
    }

    public void push(int data) {
        ListNode pushNode = new ListNode(data);
        if (node == null) {
            node = new ListNode(data);
            top++;
        } else {
            node = node.add(node, pushNode, ++top);
        }
    }

    public int pop() {
        if (top == -1) {
            System.out.println("Empty");
            return top;
        }
        return node.remove(node, top--).data;
    }

    public void print(ListNode node) {
        while (node != null) {
            System.out.print(node.data);
            node = node.next;
        }
    }
}