반응형

Java

 

안녕하세요. 후니입니다!

이번 포스팅에서는 메소드 오버로딩(Method Overloading)에 관하여 가볍게 알아보겠습니다.

 

오버로딩(Overloading)이란?

변수 선언시 변수 명이 중복되지 않게 선언한 것처럼 메소드도 마찬가지로 서로 구별될 수 있어야 합니다.

하지만 자바에서는 한 클래스 내에 이름이 같은 메소드가 있더라도 매개변수의 개수 또는 타입이 다르면, 같은 이름을 사용해서 메소드를 사용할 수 있습니다. 이처럼 한 클래스 내에 같은 이름의 메소드를 여러 개 정의하는 것을 메소드 오버로딩(Method Overloading)이라 부르며 간단하게는 오버로딩(Overloading)이라 부릅니다. 코드로 바로 확인해보겠습니다.

 

1
2
int apple;
int apple;

 

만약 위 코드처럼 apple이라는 이름을 가진 변수를 두 번 선언하면 오류가 발생합니다. 하지만 메소드는 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package smile;
 
public class Test {
    public static void main(String[] args) {
        Test t = new Test();
        t.something();
        t.something(10);
        t.something(10,10);
        t.something(10,10.1);
    } 
    void something() {
        System.out.println("something!");
    }
    void something(int i) {
        System.out.println(i);
    }
    void something(int i, int i2) {
        System.out.println(i+i2);
    }
    void something(int i, double d) {
        System.out.println(i+d);
    }
}
Colored by Color Scripter

 

이와 같이 Test클래스 내부에 something()이라는 이름을 가진 메소드가 4개가 있지만 매개변수가 각각 다르므로 사용이 가능합니다. 

 

오버로딩의 조건

1. 메소드의 이름이 같아야합니다.

 - 위 코드보시면 이름이 같은 something()이라는 메소드가 4개가 있지만 사용이 가능하죠?

 

2. 매개변수의 개수 또는 타입이 달라야 합니다.

 - 매개변수가 없는 메소드부터 1개, 2개가 있는 메소드가 있으며 개수가 같더라도 세 번째 something() 메소드는 두 개의 int형 타입이고 마지막 네 번째 something() 메소드는 int형과 double형이기 때문에 오버로딩이 가능합니다.

 

3. 매개변수의 개수와 타입은 같고 리턴타입이 다른 경우는 오버로딩이 성립되지 않습니다.

 - 메소드를 호출하는 부분에서는 호출 할 메소드의 이름과 매개변수 개수, 타입으로 구분짓기 때문에 return타입이 다르다고 해서 오버로딩이 성립되지는 않습니다.

 

그러면 오버로딩은 왜 사용할까?

오버로딩이 없을 경우 두 개의 매개변수를 받아서 정수+정수/ 정수+실수 / 실수+실수를 덧셈하는 add()메소드를 다음과 같이 정의해야합니다.

 

1
2
3
4
5
6
7
8
9
int addInteger(int first, int second){
    return first+second;
}
double addIntDouble(int first, double second){
    return first+second;
}
double addDouble(double first, double second){
    return first+second;    
}
Colored by Color Scripter
 

위 코드를 작성하는데 너무 귀찮았습니다. 가장 귀찮았던 이유는 모두 덧셈하는 기능이지만 타입이 다르다는 이유로 메소드의 이름을 짓기가 어려웠습니다. 다음은 오버로딩을 사용한 코드입니다. 

 

1
2
3
4
5
6
7
8
9
int add(int first, int second){
        return first+second;
}
double add(int first, double second){
        return first+second;
}
double add(double first, double second){
        return first+second;
}
Colored by Color Scripter

 

매개변수가 다르지만 add라는 메소드의 이름이 중복되도 괜찮기 때문에 각 각 메소드의 이름을 짓는 번거로움에서 벗어날 수도 있고 add라는 메소드 이름 하나만 기억하면 되므로 부담이 덜 된다는 장점이 있습니다.

 

반응형
반응형

Java

안녕하세요. 후니입니다.

이번 포스팅에서는 클래스 변수, 인스턴스 변수, 지역 변수에 대해서 알아보도록 하겠습니다.

 

자바에서 변수는 클래스 변수, 인스턴스 변수, 지역 변수 총 세 종류가 있습니다.

세 종류의 변수들을 구분짓는 가장 중요한 요소는 변수의 선언된 위치입니다.

(앞으로 클래스, 인스턴스 변수를 통틀어 부를 때 멤버변수라고 부르겠습니다.)

멤버 변수를 제외한 나머지 변수들은 모두 지역 변수이며, 멤버변수 중 static이 붙은 것은 클래스 변수, 붙지 않은 것은 인스턴스 변수라고 합니다. 참 단순하죠?

 

아래의 코드를 보시면 Happy클래스 내부에 총 3개의 int형 변수가 선언되어 있습니다.

firstsecond변수는 클래스 영역에 선언되어있으므로 멤버 변수입니다. 그 중 second 변수는 변수 명 앞에 static 키워드가 함께 선언되어 있으므로 클래스 변수이며 first는 인스턴스 변수입니다.

그리고 third는 메소드 내부에 선언되어 있으므로 지역변수입니다.

 

1
2
3
4
5
6
7
8
class Happy{
    int first; // 인스턴스 변수
    static int second; // 클래스 변수(static 변수, 공유 변수)
 
    void smile(){
        int third; // 지역 변수
    }
}
Colored by Color Scripter

 

다음 사진<1.1>은 클래스, 인스턴스, 지역변수를 표로 나타낸 것입니다.

 

사진 <1.1> 클래스, 인스턴스, 지역변수 개념

 

인스턴스 변수

인스턴스 변수는 클래스 영역 내에 선언이 되고, 인스턴스를 생성할 때 만들어집니다.

그렇기 때문에 인스턴스 변수의 값을 읽어 오거나 저장하기 위해서는 먼저 인스턴스를 생성해야합니다.

인스턴스는 독립적인 저장공간을 가지므로 서로 다른 값을 가질 수 있습니다. 인스턴스마다 고유한 상태를 유지해야하는 속성의 경우, 인스턴스변수로 선언합니다.

 

클래스 변수

클래스 변수를 선언하는 방법은 인스턴스변수 앞에 static을 붙이기만 하면 됩니다.

인스턴스마다 독립적인 저장공간을 갖는 인스턴스 변수와는 달리, 클래스 변수는 모든 인스턴스가 공통된 저장공간(변수)을 공유하게 됩니다. 그래서 클래스 변수를 공유 변수(shared variable)라고도 부릅니다. 한 클래스의 모든 인스턴스들이 공통적인 값을 유지해야하는 속성의 경우, 클래스 변수로 선언해야 합니다.

인스턴스 변수는 인스턴스를 생성한 후에야 사용가능하지만, 클래스 변수는 인스턴스를 애성하지 않고도 언제라도 바로 사용할 수 있다는 특징이 있으며, ‘클래스이름.클래스변수와 같은 형식으로 사용할 수 있습니다.

클래스가 로딩될 때(클래스가 메모리에 올라갈 때) 생성되어 프로그램이 종료될 때 까지 유지되며, public을 앞에 붙이면 같은 프로그램 어디서나 접근할 수 있는 전역변수(global variable)의 성격을 갖습니다.

 

지역 변수

메소드 내에 선언되어 메소드 내에서만 사용 가능하며, 메소드가 종료되면 소멸되어 사용할 수 없습니다. for문이나 while문 같은 반복문 블록 내에 선언된 변수도 지역 변수이며 블록{}을 벗어나면 소멸되어 사용할 수 없게 됩니다.

 

다은은 예제입니다. 보고 따라해보세요.

 

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
public class Day01 {
    public static void main(String[] args) {    
        System.out.println("Ferrari width : "+Ferrari.width);
        System.out.println("Ferrari height : "+Ferrari.height);
        
        Ferrari spider = new Ferrari();
        spider.color = "red";
        spider.price = 100;
        
        Ferrari roma = new Ferrari();
        roma.color = "black";
        roma.price = 200;
        
        System.out.println("spider는 "+spider.color+","+spider.price+
                "원이며,크기는 "+spider.width+","+spider.height+"입니다.");
        System.out.println("roma는 "+roma.color+","+roma.price+
                "원이며,크기는 "+roma.width+","+roma.height+"입니다.");
        
        spider.width = 2000;
        spider.height = 1000;
        System.out.println("spider의 width와 height를 각각 2000, 1000으로 변경");
        System.out.println("spider는 "+spider.color+","+spider.price+
                "원이며,크기는 "+spider.width+","+spider.height+"입니다.");
        System.out.println("roma는 "+roma.color+","+roma.price+
                "원이며,크기는 "+roma.width+","+roma.height+"입니다.");
        
    }    
}
 
class Ferrari{
    String color; 
    int price;
    static int width = 1000;
    static int height = 500;
}
Colored by Color Scripter

 

사진 <1.2> 실행 결과

 

각 Ferrari 인스턴스는 자신만의 색상과 가격을 유지하고 있어야 하므로 인스턴스 변수로 선언하였고

차의 폭(width)과 높이(height)는 모든 인스턴스가 공통적으로 같은 값을 유지해야하므로 클래스 변수로 선언했습니다.

- 코드 세 번째와 네 번째 줄을 보면 클래스변수인 width, height는 Ferrari클래스의 인스턴스를 생성하지 않고 '클래스이름.클래스변수'와 같은 방식으로 사용한 것처럼 직접 접근이 가능합니다.

- Ferrari인스턴스인 spider와 roma는 클래스 변수인 width와 height를 공유하기 때문에 spider의 width와 height를 변경하면 roma의 width와 height값도 바뀐 것과 같은 결과를 얻습니다.

- 클래스 변수를 사용할 때는 Ferrari.width와 같이 '클래스이름.클래스변수'의 형태로 하는 것이 좋습니다.

참조변수 spider,roma를 통해서도 클래스변수를 사용할 수 있지만 이렇게 하면 클래스 변수를 인스턴스 변수로 오해하기 쉽기 때문입니다.

 
반응형
반응형

 

1. Map인터페이스란?

 

 - Map인터페이스는 키(key)와 값(value)을 하나의 쌍으로 묶어서 저장하는 컬렉션 클래스를 구현하는 데 사용됩니다.

   키는 중복될 수 없지만 값은 중복을 허용합니다. 왜냐하면 값을 추출하기 위해서는 key객체에 대응하는 value객체를 반환하는데

   중복된 key객체가 있을 경우 어떠한 key객체를 찾아야하는지 모르기 때문입니다.

  

 - 기존에 저장된 데이터와 중복된 키와 값을 저장하면 기존의 값은 없어지고 마지막에 저장된 값이 남게 됩니다.

   다음은 Map인터페이스의 상속계층도입니다.

 

<사진 1.1> Map인터페이스의 상속계층도

 

2. HashMap컬렉션 클래스

 

 - HashMap<K,V>컬렉션은 java.util패키지에 속한 컬렉션 클래스이다. HashMap은 내부에 '키'와 '값'을 저장하는 자료 구조를 가지고,

   다음과 같이 put()메서드와 get()메서드를 이용하여 요소를 삽입하거나 검색합니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.edu.test;
 
import java.util.*;
 
public class test {
    public static void main(String[] args) {
        HashMap<StringString> hm = new HashMap<StringString>();
        hm.put("apple""사과");
        hm.put("banana""바나나");
        
        System.out.println(hm.get("apple"));
        System.out.println(hm.get("banana"));
        
    }    
}
cs

<사진 1.2> HashMap컬렉션 클래스의 put(), get()메서드 사용 방법

 

 - 8~9번째 코드가 실행되고 나면 HashMap에서는 아래와 같은 형태로 데이터가 저장됩니다.

<사진 1.2 코드 표>

 

 - put(key, value)메서드를 사용하여 "appple"이라는 이름을 갖는 key와 "사과"라는 이름을 갖는 value를 저장합니다.

   그리고 get(key)메서드를 사용하여 key에 대응하는 value 값을 반환합니다. 만약 해시맵에 없는 '키'로 get()을 호출하면 null값을 리턴합니다.

   다음은 결과 화면입니다.

 

1
2
3
hm.put("a","1");
hm.put("b","2");
hm.put("b","3");
cs

 

 - 만약 위와 같은 코드가 실행되고 나면 HashMap에는 아래와 같은 형태로 데이터가 저장됩니다.

 

 

 - 3개의 데이터 쌍을 저장했지만 실제로는 2개 밖에 저장되지 않은 이유는 중복된 키가 있기 때문입니다. 세 번째로 저장한 데이터의 키인

   'b'는 이미 존재하기 때문에 새로 추가되는 대신 기존의 값을 덮어씁니다. 그래서 키 'b'에 연결된 값은 '3'이 됩니다.

 

<사진 1.2 결과 화면>

 

2-1 HashMap의 장단점

 

 장점 :

  1) 요소의 삽입, 삭제 시간이 매우 빠릅니다. 요소의 위치를결정하는 해시 함수가 간단한 코드로 이루어지며, Vector나 ArrayList 컬렉션 클래스처럼

     요소의 삽입 삭제 시 다른 요소들의 위치 이동이 필요 없기 때문입니다.

  2) 요소 검색은 더욱 빠릅니다. HashMap의 get(key)메서드가 호출되면 해시 함수가 ket가 저장된 위치를 단번에 찾아내므로,

      Vector나 ArrayList 컬렉션 클래스처럼 모든 요소들을 하나씩 비교하는 시간 낭비가 전혀 없기 때문이다.

 단점 :

  1) HashMap은 인덱스를 이용하여 요소에 접근할 수 없고 오직  '키'로만 검색해야 합니다. 그러므로 HashMap은 빠른 삽입과 검색이

     필요한 응용에 적합합니다.

 

2-2 HashMap 생성

 

 - HashMap<K, V>에서 K는 '키'로 V에는 '값'으로 사용할 구체적인 타입을 지정하여 사용합니다. 다음은 키와 값을 모두 String 타입으로 지정한

   코드입니다.

 

1
HashMap<StringString> hm = new HashMap<StringString>();
cs

<사진 1.3> HashMap 생성

 

2-3 HashMap 주요 메서드

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.edu.test;
 
import java.util.*;
 
public class test {
    public static void main(String[] args) {
        HashMap<StringString> hm = new HashMap<StringString>();
        hm.put("apple""사과"); // "apple"은 키, "사과"는 값
        hm.put("banana""바나나");
        hm.put("grape""포도");
        System.out.println("첫 번째 요소 :"+hm.get("apple")); // "apple"키에 대응하는 값을 반환
        System.out.println("두 번째 요소 :"+hm.get("banana"));
        System.out.println("hm 내에 있는 요소의 개수 :"+hm.size()); // 현재 hm 내에 있는 요소의 개수 리턴
        hm.remove("apple"); // "apple"키를 갖는 키와 값을 삭제
        System.out.println("첫 번째 요소를 삭제한 결과:"+hm.get("apple"));
    }    
}
cs

<사진 1.4> HashMap컬렉션 클래스 주요 메서드

 

 - 요소 삽입, 추출, 크기 확인, 삭제의 기능을 가진 메서드입니다. 다음은 결과 화면입니다.

 

<사진 1.4 결과 화면>

반응형
반응형

 

 

 - Enumeration, Iterator, ListIterator는 모두 컬렉션에 저장된 요소를 접근하는데 사용되는 인터페이스입니다.

   Enumeration은 Iterator의 구버전이며, ListIterator는 Iterator의 기능을 향상 시킨 것입니다. 자, 이제 하나씩 자세히 살펴보겠습니다.

 

1. Iterator 인터페이스

 

 - Vector 컬렉션 클래스, ArrayList 컬렉션 클래스, LinkedList 컬렉션 클래스와 같이 요소가 순서대로 저장된 컬렉션에서 요소를 순차적으로 검색할 때는

   java.util 패키지에 속한 Iterator 인터페이스를 사용하면 편리합니다.

 

 - List인터페이스 뿐만 아니라, Set인터페이스를 구현한 컬렉션에도 사용 가능합니다. 다음은 Iterator인터페이스의 주요 메서드입니다.

 

 

<사진 1.1> Iterator인터페이스 메서드

 

 - hasNext()메서드와 next()메서드는 Iterator의 핵심 메서드입니다.

 - remove()메서드의 설명에 '선택적 기능'이란 Iterator인터페이스를 구현할 때 remove()메서드가 필수 기능이 아니므로 구현하지

   않아도 괜찮다는 뜻 입니다. 

 - 다음은 ArrayList에 저장된 모든 요소들을 출력하기 위한 코드입니다.

 

1
2
3
4
5
6
List lit = new ArrayList();
 
Iterator it = list.iterator();
while(it.hasNext()) {
    System.out.println(it.next());
}
cs

<사진 1.2>

 

- ArrayList컬렉션 클래스 대신에 List인터페이스를 구현한 다른 컬렉션 클래스(Vector, LinkedList 등)에 대해서도 이와 동일한 코드를

  사용할 수 있습니다. 첫 줄에서 ArrayList대신에 List인터페이스를 구현한 다른 컬렉션 클래스의 객체를 생성하도록 변경하기만 하면 됩니다.

** Map인터페이스는 Collection인터페이스의 자손이 아니므로 iterator()메서드가 존재하지 않습니다.

   Map인터페이스를 구현한 컬렉션 클래스(HashMap, SortedMap 등)는 키(Key)와 값(Value)을 쌍(pair)으로 저장하고 있기 때문에

   iterator()를 직접 호출할 수 없습니다. 그 대신 keySet()이나 entrySet()과 같은 반환 타입이 Set컬렉션인 메서드를 통해서

   키와 값을 각각 따로 Set의 형태로 얻어 온 후에 Set컬렉션에는 iterator()가 존재하므로 iterator()를 호출하여 Iterator를 얻을 수 있습니다.

 

- 다음은 ArrayList에 있는 요소들을 Iterator를 사용하여 읽어 오는 코드입니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.edu.test;
 
import java.util.*;
 
public class test {
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<String>();
        al.add("1");
        al.add("2");
        al.add("3");
        al.add("4");
        al.add("5");
        
        Iterator it = al.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
    }    
}
 
cs

<사진 1.3>

 

 다음은 결과 화면입니다.

 

<사진 1.3 결과 화면>

 

 

2. Enumeration 인터페이스

 

 - Enumeration인터페이스는 컬렉션 프레임웍이 만들어지기 이전에 사용하던 것으로 Iterator의 구버전이라고 생각하면 됩니다.

   이전 버전으로 작성된 소스와의 호환을 위해서 남겨 두고 있을 뿐이므로 가능하면 Enumeration대신 Iterator를 사용하도록 합시다.

 

 - 다음은 Enumeration인터페이스의 메서드입니다. Enumeration은 Iterator와 메서드 이름만 다를 뿐 기능은 같습니다.

 

<사진 1.4> Enumeration인터페이스의 메서드

 

 

3. ListIterator 인터페이스

 

 - ListIterator인터페이스는 Iterator를 상속받아서 기능을 추가한 것입니다. 컬렉션의 요소에 접근할 때 Iterator는 단방향으로만 이동할 수

   있지만 ListIterator는 양방향으로 이동이 가능하다는 장점이 있습니다. 또한 ArrayList나 LinkedList처럼 List인터페이스를 구현한 컬렉션

   클래스에서만 사용할 수 있습니다.

 

 - 다음은 ListIterator인터페이스의 메서드입니다.

 

<사진 1.5> ListIterator인터페이스의 메서드

 

 

 - 다음은 ListIterator인터페이스의 양방향 접근이 가능한 previous()메서드를 호출하여 이전 요소로 접근해보는 코드입니다.

 

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
package com.edu.test;
 
import java.util.*;
 
public class test {
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<String>();
        al.add("1");
        al.add("2");
        al.add("3");
        al.add("4");
        al.add("5");
        
        ListIterator li = al.listIterator(); // 순방향으로 진행하면서 요소를 읽어옵니다.
        
        while(li.hasNext()) {
            System.out.println(li.next());
        }
        System.out.println("-----------");
        
        while(li.hasPrevious()) { // 역방향으로 진행하면서 요소를 읽어옵니다.
            System.out.println(li.previous());
        }
        
        
    }    
}
cs

<사진 1.6> ListIterator인터페이스의 previous()메서드 사용

 

 - Iterator인터페이스는 단방향으로만 이동하기 때문에 컬렉션의 마지막 요소에 다다르면 더 이상 사용할 수 없지만,

   ListIterator인터페이스는 양방향으로 이동하기 때문에 각 요소간의 이동이 자유롭습니다. 다만 이동하기 전에 hasNext()메서드나

   hasPrevious()메서드를 호출하여 이동할 수 있는지 확인해야합니다.

반응형
반응형

 

1. Vector클래스란?

 

 - Vector 클래스는 ArrayList클래스와 같이 컬렉션 프레임웍에서 가장 많이 사용되는 컬렉션 클래스 일 것입니다.

   이 둘은List 인터페이스를 구현하기 때문에 List인터페이스의 특징인

   1. 저장순서를 유지하며

   2. 중복을 허용합니다.

   라는 특징을 가지고 있습니다.

 

 - Vector클래스의 기능을 개선 한 것이 ArrayList클래스입니다. Vector 클래스는 기존에 작성된 소스와의 호환성을 위해서 계속 남겨 두고 있을

   뿐이기 때문에 가능하면 Vector클래스보다 ArrayList클래스를 사용하는 것이 바람직하다고 할 수 있습니다.

   다음은 Vector클래스와 ArrayList클래스의 공통점과 차이점을 나타내는 표입니다.

 

<사진 1.1> Vector클래스와 ArrayList클래스의 비교

 

2. 벡터 생성하는 방법

 

 - 벡터를 생성할 때, Vector<E>의 E에 요소로 사용할 타입을 지정하면 됩니다. 예를 들어, 정수 값만 삽입 가능한 벡터를 만들고자 한다면

   다음과 같이 E 요소에 Integer를 지정하여 벡터를 생성하면 됩니다.

 

       Vector<Integer> v = new Vector<Integer>();

 

   만약 문자열만 삽입 가능한 벡터를 만들고 싶으면 다음과 같이 벡터를 생성하면 됩니다.

 

       Vector<String> v = new Vector<String>();.

 

   만일 Vector<E>에서 E 요소에 구체적인 타입을 지정하지 않는다면 컴파일러가 경고 메시지를 출력합니다.

 

3. Vector 클래스의 주요 메서드

 

 1) 벡터에 요소 삽입

 

   - add() 메서드를 사용하여 벡터의 끝이나 중간에 요소를 삽입할 수 있습니다. 다음은 정수 1, 2, 3을 순서대로 벡터에 삽입하는 코드입니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
package com.edu.test;
 
import java.util.*;
 
public class test {
    public static void main(String[] args) {
        Vector<Integer> v = new Vector<Integer>();
        v.add(1);
        v.add(2);
        v.add(3);
    }    
}
cs

<사진 1.2> add() 메서드 사용

 

   - 벡터 v에는 Integer 외의 다른 타입의 객체를 삽입할 수 없습니다. 현재 제네릭이 Integer로 선언되어 있는데

     add() 메서드의 인자 값으로 정수형이 아닌 다른 타입을 삽입할 경우에는 오류가 발생합니다.

 

<사진 1.3>

 

   - 초기에 선언한 Integer 타입이 아닌 문자열 3을 삽입하였으니 빨간 줄이 생기면서 컴파일 오류가 발생하였습니다.

   - 참고로 벡터에는 null값을 삽입할 수 있기 때문에, 벡터를 검색할 때 null값이 존재할 수 있음을 염두해 두어야 합니다.

 

   - 다음은 add()메서드를 사용하여 벡터의 중간에 객체를 삽입해보겠습니다. 다음은 현재 벡터 v에 [1, 2, 3]이 저장 되어 있지만

     인덱스 1번 위치에 100 요소를 삽입해보는 코드입니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.edu.test;
 
import java.util.*;
 
public class test {
    public static void main(String[] args) {
        Vector<Integer> v = new Vector<Integer>();
        v.add(1);
        v.add(2);
        v.add(3);
        
        v.add(1,100);
    }    
}
 
cs

<사진 1.4>

 

 - v.add(1,100); 는 인덱스 1의 위치에 정수 100을 삽입한다는 코드입니다. 다음은 결과 화면입니다.

 

<사진 1.4 결과 화면>

 

 - 결과를 보면 기존의 인덱스 1 위치에 있던 2와 그 뒤에 있던 3이 모두 한 자리씩 뒤로 이동했습니다.

   만약 벡터에 1개의 요소(인덱스 0의 위치)만 들어있는 상태인데 2의 위치에 요소를 삽입할 경우엔 예외가 발생합니다. 왜냐하면

   인덱스 1이 빈 공간이 되기 때문입니다.

 

 2) 벡터 내의 요소 알아내기

 

   - 벡터 내에 존재하는 요소를 알아내기 위해서는 get() 메서드와 elementAt() 메서드를 사용합니다. 다음은 get()메서드를 사용한 코드입니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.edu.test;
 
import java.util.*;
 
public class test {
    public static void main(String[] args) {
        Vector<Integer> v = new Vector<Integer>();
        v.add(1);
        v.add(2);
        v.add(3);
        v.add(4);
        v.add(5);
        
        for(int i=0; i<v.size(); i++) {
            System.out.println(v.get(i));
        }
    }    
}
 
cs

<사진 1.5>

 

 - 벡터 v에 정수 1, 2, 3, 4, 5를 삽입했습니다. 벡터 v에 있는 모든 요소들을 순서대로 출력하기 위해 for문을 사용했습니다.

 - v.get(0)이 실행될 경우 벡터 v가 가리키고 있는 0번째 인덱스의 값을 추출합니다.

 

 - 다음은 현재 벡터 v의 상태를 그림으로 표현했습니다.

 

<사진 1.6>

 

 - 벡터 v는 0x100(임의의 주소로 아무렇게나 정한 것입니다)이라는 주소 값을 갖고 있는 위치를 가리키고 있습니다.

   현재 0x100위치에는

   0번 인덱스에 1,

   1번 인덱스에 2,

   2번 인덱스에 3,

   3번 인덱스에 4,

   4번 인덱스에 5라는 값을 저장하고 있습니다. 그래서 v.get(0)메서드를 호출할 경우 벡터 v가 가리키고 있는 0번째 인덱스 값인 1을 반환합니다.

   다음은 <사진 1.5> 코드의 결과 화면입니다.

 

<사진 1.5 결과 화면>

 

 - 벡터 v가 가리키고 있는 모든 요소들을 출력했습니다.

 

 3) 벡터에서 요소 삭제

 

 - 벡터 내의 임의의 인덱스에 있는 요소를 삭제할 수 있습니다. remove() 메서드를 사용하면 됩니다.

 

       v.remove(1); // 벡터 v가 가리키고 있는 1번째 인덱스의 값을 삭제하는 코드입니다.

 

 - 다음은 remove() 메서드를 사용한 코드입니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.edu.test;
 
import java.util.*;
 
public class test {
    public static void main(String[] args) {
        Vector<Integer> v = new Vector<Integer>();
        v.add(1);
        v.add(2);
        v.add(3);
        v.add(4);
        v.add(5);
        
        v.remove(1);
        
        for(int i=0; i<v.size(); i++) {
            System.out.println(v.get(i));
        }
    }    
}
 
cs

<사진 1.7>

 

 - 현재 벡터 v는 정수 1, 2, 3, 4, 5를 배열로 저장하고 있는 상태에서 14번째 줄 코드에서 remove()메서드를 사용하여 인덱스 1 위치에 있는 요소를

   삭제하고 벡터 v가 저장하고 있는 모든 요소들을 출력하고자 합니다. 다음은 결과 화면입니다.

 

<사진 1.7 결과 화면>

 

 - 인덱스 1 위치에 있던 정수 2를 삭제 하여 뒤에 있던 요소들이 한 자리씩 앞으로 이동하였습니다.

 

 - 벡터의 모든 요소를 삭제하고자 한다면 v.removeAllElements(); 를 호출하면 됩니다.

반응형
반응형

 

 

배열은 연관된 data를 관리하기 위한 수단이다. 그런데 배열에는 몇가지 불편한 점이 있는데 그 중의 하나가 한번 정해진 배열의 크기는 변경할 수 없다는 점이다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package hoony.tistory.java;
 
public class ArrayListTest {
    public static void main(String[] args) {
        String[] str = new String[3]; // 크키가 3인 String 배열을 선언했다.
        str[0= "one";
        str[1= "two";
        str[2= "three";
        str[3= "four"// 이 부분을 입력하면 오류가 발생한다.
        
        for(int i=0; i<str.length; i++) {
            System.out.println(str[i]);
        }
        
    }
}
 
cs

<코드1.1>

<코드1.1>처럼 처음에 선언한 배열의 크기를 벗어나면 오류가 발생한다. 이러한 불편함을 "컬렉션 프레임워크"를 사용하면 줄어든다.

 

아례의 예를 살펴보자.

 

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
package hoony.tistory.java;
 
import java.util.ArrayList;
 
public class ArrayListTest {
    public static void main(String[] args) {
        String[] str = new String[3];
        str[0= "one";
        str[1= "two";
        str[2= "three";
        
        for(int i=0; i<str.length; i++) {
            System.out.println(str[i]);
        }
        
        ArrayList al = new ArrayList();
        al.add("one");
        al.add("two");
        al.add("three");
        
        for(int i=0; i<al.size(); i++) {
            System.out.println(al.get(i));
        }
    }
}
 
cs

<코드1.2>

 

<코드1.1>처럼 배열은 크기를 한번 지정하면 크기보다 많은 수의 값을 저장할 수 없다는 것을 확인했다. 하지만

<코드1.2>를 보면 ArrayList는 크기를 미리 지정하지 않아도 많은 수의 값을 저장이 가능하다. 

 

배열을 사용할 때 배열의 길이를 구할 때는 .length를 사용했지만 ArrayList에서는 size() 메서드를 호출한다.

또한 특정한 값을 가져올 때 배열은 [인덱스 번호]를 사용했지만 ArrayList는 get(int index) 메서드를 호출한다. get() 메서드의 인자

으로 인덱스 번호를 입력하면 인덱스 값에 해당하는 값을 추출할 수 있다.

 

그런데 ArrayList를 사용할 때 주의해야 할 점이 있다.  <코드1.2>의 21~23 라인의 코드를 아래처럼 변경해보겠다.

 

1
2
3
4
5
for(int i=0; i<al.size(); i++) {
    String value = al.get(i);
    System.out.print(value);
}
 
cs

<코드1.3>

 

<코드1.3>을 컴파일하면 오류가 발생한다. 왜냐하면 ArrayList의 add() 메서드는 인자 값으로 어떤 형태의 값이 올지 알 수 없다.

즉, byte, short, int, long, char, stirng 등등 모든 타입이 입력 가능하다는 것이다. 그런데 get() 메서드를 사용하여 값을 추출한 후에

String 타입에 저장하기 때문에 오류가 발생한다.

( add() 메서드는 인자 값으로 모든 데이터의 조상인 Object 타입으로 데이터를 받는다. )

 

현 상황에서 오류를 해결하기 위한 방법은 아래 코드처럼 2가지 방법이 있다.

 

1
2
3
4
5
6
7
8
9
for(int i=0; i<al.size(); i++) {
    String value = (String)al.get(i); // 형변환
    System.out.print(value);
}
 
for(int i=0; i<al.size(); i++) {
    String value = al.get(i)+""// 문자열 더하기
    System.out.print(value);
}
cs

<코드1.4>

 

첫 번째 방법은 get() 메서드의 반환 값을 String타입으로 형변환 시켜주는 것이고 두 번째 방법은 get() 메서드의 반환 값과 ""(문자열)을 덧셈 연산을 해주는 것이다.(어떠한 타입 + String 타입 = String 타입이되기 때문이다.)

 

하지만 위의 방식은 예전의 방식이다. 이제는 아래와 같이 Generic(제너릭)을 사용해야 한다.

 

1
2
3
4
5
6
7
8
9
ArrayList<String> al = new ArrayList<String>();
al.add("one");
al.add("two");
al.add("three");
for(int i=0; i<al.size(); i++){
    String value = al.get(i);
    System.out.println(value);
}
 
cs

<코드1.5>

 

제너릭을 사용하면 ArrayList 내에서 사용할 데이터 타입을 인스턴스를 생성할 때 지정할 수 있기 때문에 데이터를

추출 할 때 굳이 형변환 또는 문자열 덧셈 연산을 하지 않아도 된다.

 

반응형

+ Recent posts