'자료구조론' 카테고리의 글 목록

자료구조론

JAVA의 ArrayList 사용법 2019.03.31
LinkedListQueue구현 2019.03.06
스택 자바로 구현 2019.03.06
자바 ArrayList구현방법 / LinkedList구현법(자바 arrayList 정렬하려면 Collections.sort 쓰면 되고 배열 정렬하시려면 Arrays.sort 쓰시면 됩니다) 2019.03.06

JAVA의 ArrayList 사용법

aomee0880 2019. 3. 31. 07:59

2019. 3. 31. 07:59

자바는 컬렉션 프레임 워크라는 자체 라이브러리 안에 arraylist 데이터 스트럭처를 기본적으로 내장하고 있기 때문에

직접 구현해서 사용할 필요가 없다.

1차적으로 ArrayList를 사용하는 방법

2차적 ArrayList를 구현하는 방법

ArrayList생성법

ArrayList numbers = new ArrayList();

new연산자 사용해서 arraylist객체를 만들고 그것은 arraylist 데이터 타입의 변수인 numbers에 할당하고 있다.

<>가 뭐져? -> 제너릭

Iterator it = numbers.iterator();// 반복 사용법

*numbers는 ArrayList객체였다.

우리가 직접적으로 순회 아니고 numbers 객체가 가지고있는 Iterator라는 메소드를 호출하고 있다.

이 메소드는 어떠한 값을 리턴할건데 it에 담길거다.

it라는 변수에 담길 값은 iterator 데이터 타입이라는 거를 알 수 있고 자바에있는 interface

Iterator라는 인터페이스를 구현하고 있는 어떤 객체를 리턴해서 it라는 변수에 담아주고 있다.

//하나하나 꺼내와서 어떠한 처리를 하는 방법

//iterator은 어떠한 값을 return할건데 it라는 변수에 담기게 될

//iterator 데이터 타입으로 알 수 있다. 자바에 있는 interface

//자바에 iterator라는 interface에 접근해서 it에 접근한다.

Iterator it = numbers.iterator();

while(it.hasNext()){

int vaule = it.next();

}

*while문 반복문이 돌면서 int value = it.next()가 순회

it.hasNext()가 true값을 리턴하는 동안에 순회(hasNext는 true,false를 리턴하는 boolean값)

hasNext는 현재 numbers라는 arrayList가 가져올수있는 다음 element가있느냐?

it.next() next메소드 호출 numbers라는 arraylist가 가진 데이터

첫번째 데이터 리턴해서 value에 갖게 된다. 다시 while문 시작되면 hasNext시작됨

다음 element가 있어서 hasNext 가 true여서 next가 또 돈다.

next를 실행해서 마지막 element가져온 이유에 hasNext가 없어서

while문이 종료된다.

이보다 훨씬 쉬운 방법도 있지만 이것도 중요하다 나중에 LinkedLIst보면서 설명

for(int value : numbers){

System.out.println(value);

}

numbers순회하려는 대상이 되는 arrayList가 있고 그앞에는 value가 있따.

for문이 반복적으로 실행

numbers에 저장된 element들이 순차적으로 value라는 int변수에 담겨서

중괄호 사이에 있는 System.out.println(value); value를 꺼내서 하나하나 순차적으로 처리 가능

while(it.hasNext()){ //hasNext가 true아니면 false를 리턴하는 boolean값을 가진다.

//다음 엘리먼트가 있느냐?

int vaule = it.next(); // numbers라는 arraylist가 갖고있는 데이터

//next가 처음 호출되면 첫번쨰 데이터를 return에서 value에 갖게 된다.

//다시 while문시작되면서 has next 다음 엘리먼트가 있기 떄문에 true

//다시 next가 실행됨 // return값이 value로

//마지막 element를 가지고 온 이후에 다시 hasnext하면 다음값이 없어서

//false가 되어 while문 종료

//나중에 LinkedList보면서 설명 기회

for(int value : numbers){

System.out.println(value);

}

//for문은 반복적으로 실행

//numbers에 저장된 element들이 value라는 int변수에 담겨서

//중괄호 사이에서 사용할 수 있게 됩니다.

//하나하나 꺼내서 처리 가능

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
//ArrayList만드는 방법 프로그래머스 - ArrayList - Java API사용법 -DataStructure
 
import java.util.ArrayList;//ArrayList datastructure는 java util안에 포함됨
import java.util.Iterator;
 
public class Main{
    public static void main(String[] args){
 
        ArrayList<Integer> numbers = new ArrayList<>();
        //제너릭 -> ArrayList가 내부적으로 element들이 Integer 숫자라는 것이다.
        //실제로는 제너릭 사용해야 함.
 
        //데이터 추가 방법
        numbers.add(10); // numbers.add(0,10) //이게 첫번쨰 배열에있다.
        numbers.add(20); // numbers.add(1,50) //두번쨰 배열에 추가
        numbers.add(30); // numbers.add(2,30) //세번쨰 배열에 추가
        numbers.add(40); // numbers.add(3,40) // 네번쨰 배열에 추가
 
        System.out.println("add(값)");
        System.out.println(numbers);
 
            //1번에 50을 추가하고 싶다면
            numbers.add(1,50); // numbers라는 arraylist에 내부적으로 존재하는 배열에 인덱스 1번에 50이라는 값을 끼워 넣음
            //index 1에 빈공간 확보 3뒤로,2뒤로  50을 넣는다.
            System.out.println("\nadd(인덱스, 값)");
            System.out.println(numbers);
 
        
        //데이터 삭제 방법 remove사용
        numbers.remove(2);//인자로 2를 전달하면 인덱스 2의 데이터를 삭제하고 앞으로 한칸씩 댕긴다.
        //index 2의값을 삭제하기때문에 20을 삭제하고 30과 40은 앞으로 전진
        System.out.println("\nremove(인덱스)");
        System.out.println(numbers);
        
 
        //데이터 가져오는 방법 get사용 여기도 인덱스 이용
        System.out.println("\nget(인덱스)");
        System.out.println(numbers.get(2));//두번쨰 인덱스 30을 가져오게 된다.
        
        //데이터 사이즈 가져오기 몇개가 저장됬는지 알수 있다.
        System.out.println("\nsize(데이터크기)");
        System.out.println(numbers.size());
 
        //30의 인덱스 위치
        System.out.println("\nindexOf()");
        System.out.println(numbers.indexOf(30));
 
 
        Iterator it = numbers.iterator(); //it객체를 만들어 <Integer>로 써주는게 훨씬 낫다.
        //numbers라는 arraylist의 iterator메소드를 호출해서 it라는 iterator데이터 타입의 변수 객체를 만든다.
        System.out.println("\niterator");
 
        while(it.hasNext()){ //it가 hasNext로 가져올 element가 있는지 확인
            int value = (int)it.next(); //it.next를 해서 그 return된 값은 value에 담는다.
            //return된 값이 object데이터 타입이라서 int로 캐스팅 해준다. 그래서 it를 <Integer>로 처리하는게 훨씬 바람직
 
            if(value == 30){  //순회 하면서 보시는것처럼 value값이 30이라면
                it.remove();//iterator객체의 메소드인 remove를 통해서 현재 next를 통해서 return한 value값이 있을떄
                //it iterator객체에 30이 마지막으로 return한 값을 list에서 삭제
                //add도 있으니 manual참고
            }
            System.out.println(value);
        }
        System.out.println(numbers);
 
        System.out.println("\nfor each");
        for(int value : numbers){ //numbers에 담긴 내용이 value에 담겨서 순회할떄 마다 element를 하나하나 꺼내서 value에 담음
            System.out.println(value);
        }
        System.out.println("\nfor");
        for(int i=0;i<numbers.size();i++){ //numbers.size보다 작은동안  numbers.get(i)의 값을 하나씩 꺼내서 사용
            System.out.println(numbers.get(i));
        }
    }
}
Colored by Color Scripter
cs

add(값)

[10, 20, 30, 40]

add(인덱스, 값)

[10, 50, 20, 30, 40]

remove(인덱스)

[10, 50, 30, 40]

get(인덱스)

size(데이터크기)

indexOf()

iterator

[10, 50, 40]

for each

for

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package ArrayList;
import java.util.*;
 
public class VectorEx1 {
    public static void main(String[] args) {
        Vector v = new Vector(5); //용량(capacity)이 5인 Vector를 생성한다.
        v.add("1");
        v.add("2");
        v.add("3");
        print(v);
 
        v.trimToSize(); //빈 공간을 없앤다(용량과 크기가 같아진다.
        System.out.println("=========After trimToSize() ===========");
        print(v);
 
        v.ensureCapacity(6);
        System.out.println("========After ensureCapacity(6)======");
        print(v);
 
        v.setSize(7);
        System.out.println("=====After setSize(7)=====");
        print(v); //위에서 6이었던 capacity가 7 더해져서 12가 된다.
 
        v.clear();
        System.out.println("====After clear()======");
        print(v); //용량은 그대로 12이지만 size는 0이 된다.
    }
    public static void print(Vector v){
        System.out.println(v);
        System.out.println("size :"+v.size());
        System.out.println("capacity :"+v.capacity());
    }
}
 
Colored by Color Scripter
cs

[1, 2, 3]

size :3

capacity :5

=========After trimToSize() ===========

[1, 2, 3]

size :3

capacity :3

========After ensureCapacity(6)======

[1, 2, 3]

size :3

capacity :6

=====After setSize(7)=====

[1, 2, 3, null, null, null, null]

size :7

capacity :12

====After clear()======

[]

size :0

capacity :12

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package ArrayList;
import java.util.*;
 
public class ArrayListEx2 {
    public static void main(String[] args) {
        final int LIMIT = 10; //자르고자 하는 글자의 개수를 지정한다.
        String source = "0123456789abcdefghijABCDEFGHIJ!@#$%^&*()ZZZ";
        int length = source.length();
 
        ArrayList list = new ArrayList(length/LIMIT + 10); //크기를 약간 여유 있게 잡는다.
 
        for(int i=0;i<length; i+=LIMIT){
            if(i+LIMIT < length)
                list.add(source.substring(i,i+LIMIT)); //i위치부터 i+LIMIT위치 전까지 출력
            else
                list.add(source.substring(i));
        }
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
    }
}
 
Colored by Color Scripter
cs

0123456789

abcdefghij

ABCDEFGHIJ

!@#$%^&*()

ZZZ

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package ArrayList;
import java.util.*;
 
public class ArrayListEx1 {
    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(List l)을 이용해서 정렬하였다.
        Collections.sort(list2); // Collections.sort(List l)
        print(list1, list2);
 
        //list1에서 저장된 객체가 list2에도 저장되어 있는지 확이
        System.out.println("list1.containsAll(list2):" + list1.containsAll(list2)); //list1이 list2의 모든 요소를 포함하고 있을 때만 true
 
        list2.add("B");
        list2.add("C");
        list2.add(3, "A"); //add(Object obj)를 이용해서 새로운 객체를 저장하였다.
        list2.set(3, "AA"); //set(int index, Object obj)를 이용해서 다른 객체로 변경
        print(list1, list2);
 
        //list1에서 list2와 겹치는 부분만 남기고 나머지는 삭제한다.
        System.out.println("list1.retainAll(list2):" + list1.retainAll(list2)); //retainAll에 의해 list1에 변화가 있었으므로 true를 반환
        print(list1, list2);
 
        //list2에서 list1에 포함된 객체들을 삭제한다.
        for (int i = list2.size() - 1; i >= 0; i--) {
            if (list1.contains(list2.get(i)))
                list2.remove(i);
        }
        print(list1, list2); //list2와의 공통요소 이외에는 모두 삭제되었다(변화가 있었다.)
    }//메인의 끝
 
    static void print(ArrayList list1, ArrayList list2){
        System.out.println("list1:"+list1);
        System.out.println("list2:"+list2);
        System.out.println();
 
    }
}//class의 끝
 
Colored by Color Scripter
cs

list1:[5, 4, 2, 0, 1, 3]

list2:[4, 2, 0]

list1:[0, 1, 2, 3, 4, 5]

list2:[0, 2, 4]

list1.containsAll(list2):true

list1:[0, 1, 2, 3, 4, 5]

list2:[0, 2, 4, AA, B, C]

list1.retainAll(list2):true

list1:[0, 2, 4]

list2:[0, 2, 4, AA, B, C]

list1:[0, 2, 4]

list2:[AA, B, C]

저작자표시

'자료구조론 > 링크드리스트(LinkedList), ArrayList' 카테고리의 다른 글

LinkedListQueue구현 (0)	2019.03.06
자바 ArrayList구현방법 / LinkedList구현법(자바 arrayList 정렬하려면 Collections.sort 쓰면 되고 배열 정렬하시려면 Arrays.sort 쓰시면 됩니다) (0)	2019.03.06

LinkedListQueue구현

aomee0880 2019. 3. 6. 11:40

2019. 3. 6. 11:40

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
package cc.yaboong.ds.linkedlist;
 
/**
 * Created by yaboong on 2018. 1. 15..
 */
public class LinkedListQueue<T extends Comparable<T>> {
    private Node head, tail;
 
    private class Node{
        T item;
        Node next;
    }
 
    public boolean isEmpty(){
        return head == null;
    }
 
    // 데이터의 추가는 tail 에 한다 (들어온 순서대로 줄을 세우는 셈)
    public void enqueue(T item){
        Node oldlast = tail;        // 기존의 tail 을 잠시 보관해두고
        tail = new Node();          // 새로운 tail 을 생성한다
        tail.item = item;
        tail.next = null;
        if(isEmpty()) head = tail;  // queue 가 비어있으면 head = tail 로 head 와 tail 이 같은 node 를 가리키게 한다
        else oldlast.next = tail;   // queue 가 비어있지 않으면 기존 tail 의 next = 새로운 tail 로 해주면 된다
    }
 
    // 데이터 꺼내는 작업은 head 로 한다 (먼저 들어왔던 데이터부터 꺼낸다)
    public T dequeue(){
        // 비어있는 경우
        if(isEmpty()){
            tail = head;
            System.out.println("Queue is empty");
            return null;
        }
        // 비어있지 않으면
        else{
            T item = head.item;     // head 의 데이터를 저장
            head = head.next;       // 기존 head 다음 node (혹은 null) 를 head 로 설정해준다
            return item;
        }
    }
 
    public void print(){
        Node mover = head;
        while(mover != null){
            System.out.println(mover.item);
            mover = mover.next;
        }
    }
 
    public static void main(String[] args) {
        LinkedListQueue<String> queue = new LinkedListQueue<>();
 
        queue.enqueue("My ");
        queue.enqueue("life ");
        queue.enqueue("is ");
        queue.enqueue("being ");
        queue.enqueue("refactored ");
 
        System.out.println("<enqueued items>");
        queue.print();
 
        for (int i=0; i<7; i++)
            queue.dequeue();
 
        System.out.println("\n<after dequeue>");
        queue.print();
    }
}
Colored by Color Scripter
cs

저작자표시

'자료구조론 > 링크드리스트(LinkedList), ArrayList' 카테고리의 다른 글

JAVA의 ArrayList 사용법 (0)	2019.03.31
자바 ArrayList구현방법 / LinkedList구현법(자바 arrayList 정렬하려면 Collections.sort 쓰면 되고 배열 정렬하시려면 Arrays.sort 쓰시면 됩니다) (0)	2019.03.06

스택 자바로 구현

aomee0880 2019. 3. 6. 11:40

2019. 3. 6. 11:40

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
/* Array를 이용한 스택 구현
 * 1. 변수 : 배열, MAX 사이즈, top
 * 2. isEmpty : boolean, isFull : boolean
 * 3. input -> push : void
 * 4. output -> pop : data type of stack
 * */
 
public class Stack {
    private int MAX_SIZE;
    private int[] stack;
    private int top;
 
    public Stack() {
        MAX_SIZE = 5;
        stack = new int[MAX_SIZE];
        top = -1;
    }
 
    private boolean isEmpty() {
        return top == -1 ? true : false;
    }
    private boolean isFull() {
        return (top + 1 == MAX_SIZE) ? true : false;
    }
 
    public void push(int data) {
        if (!isFull())
            stack[++top] = data;
    }
 
    public int pop() {
        if (!isEmpty())
            return stack[top--];
        return -1;
    }
 
    public void display() {
        System.out.print("top : " + top + "\nstack : ");
        for (int idx = 0; idx <= top; idx++)
            System.out.print(stack[idx] + " ");
        System.out.println();
    }
}
Colored by Color Scripter
cs