1. Array to String(배열을 문자로)



자바스크립트


1
2
3
4
5
var myArrayData1 = [1,2,3,4];
 
var myString1 = myArrayData1.toString();
 
console.log(myString1);
cs


출력결과

문자열 myString1 = 1,2,3,4 가 들어가게 된다.



자바

1
2
3
4
5
String[] myArrayData1 = {"Apple", "Banana", "Carrots"};
 
String myString1= Arrays.toString(myArrayData1);
 
System.out.println(myString1);
cs

출력결과
문자열  [Apple, Banana, Carrots] 가 나오게 된다.


2. String to Array(문자를 배열로)



자바스크립트


1
2
3
4
5
6
7
var myArrayData1 =[];
 
var myString1 = "1,2,3,4";
 
myArrayData1 = myData1.split(",");
 
console.log(myArrayData1 );
cs


출력결과

배열 [1, 2, 3, 4] 가 들어가게 된다.



자바

1
2
3
4
5
6
7
String[] myArrayData1 = null;
 
String myString1 = "Apple,Banana,Carrots";
 
myArrayData1 = myString1.split(",");
 
System.out.println(myArrayData1);
cs

출력결과

배열 [Apple,Banana,Carrots] 가 들어가게 된다.



split이라는 메서드를 알기 전까지는 


문자열의 길이와 구분자의 갯수 문자의 위치를 찾아내서 


조건식으로 해당 문자를 찾아 배열로 담았는데 


이제는 그 불편함을 덜어낼수 있을 것 같다.





'전체 > Java' 카테고리의 다른 글

자바 동적변수 생성 테스트. 해결방법은?  (0) 2018.05.30
Camel to Underscores, Underscores to Camel 플러그인 AnyEdit 사용하기  (0) 2018.04.04
부모클래스와 자식클래스 간의 호출, 인터페이스와 클래스 간의 호출  (0) 2017.12.12
인터페이스 개념 이해하기  (0) 2017.10.13
JSONObject, JSONArray, JSONParser 사용해 데이터 만들어 파싱하기  (3) 2017.09.21



코딩을 하다 콜렉션 객체를 사용하려고 


Map  map1 = new HashMap(); 으로 객체를 생성하려고 했는데 객체가 생성되는 것을 확인하였다.


나는 원래 대부분 객체를 생성할 때 

HashMap map1 = new HashMap(); 과 같이 생성자의 이름과 객체명 앞 타입을 앞뒤 동일하게 맞춰 생성하였다. 


HashMap map1 = new HashMap(); 과 

  Map map1 = new HashMap(); 이 뭐가 다른지 궁금했다.


Map map1 = new Map();은 되는 것인가? 


List list1 = new ArrayList(); 은 되는 것인가?


Collection map1 = new HashMap(); 은 되는가? 등등 


테스트를 통해 인터페이스와 클래스 간 호출, 클래스와 클래스 간의 호출에 대해 알 수 있었다.




작업 방법 및 소스 설명

1. Computer 클래스와 Laptop 클래스가 있다.


2. Computer 클래스에는 cpu, ram, power, mainboard 라는 속성이 있고


3. Laptop 클래스에는 Computer 클래스에는 없는 touchPad, wireless 속성이 있다.


4. Computer 클래스는 부모 클래스 이고 Laptop 클래스는 자식 클래스이다.


5. Laptop은 Computer 클래스를 상속받는다.


6. 객체를 생성할 때 Computer 클래스의 computer 변수명으로 Laptop 생성자를 호출시켜 객체 생성한다.


7. computer 객체가 Laptop 클래스의 메소드를 호출할 수 있는지 확인한다.


8. 부모클래스와 자식클래스 간의 호출이므로 computer 객체는 Laptop 클래스의 메소드를 호출 할 수 없으므로 

캐스팅을 이용한다.


9. 인터페이스에서 클래스 호출하는 것은 된다.


10. 인터페이스에서 인터페이스를 객체화 하는 것은 오류가 난다.


11. Map은 인터페이스 이므로 객체화 할수 없으므로 인터페이스 아래 클래스를 호출해 사용해야 한다.


12. Map은 인터페이스 이므로 메소드에 대한 선언만 있으므로 Map과 HashMap 두개의 선언 방식은 같다.




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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
package test1;
 
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
public class ObjectTest {
 
    public static void main(String[] args) {
        
 
        // 1. 부모클래스와 자식클래스 간의 호출
        
        // Computer 클래스로부터 computer이라는 변수명으로 Laptop 생성자 호출시키고 new 연산자 를 통해 객체를 저장할 메모리 할당 후 객체 초기화한다.
        Computer computer = new Laptop();
        computer.setCpu("i7-7700K");
        // ex) computer.setTouchPad("touchModelB"); -> 호출 안됨.
        // computer에선 Laptop 클래스의 메소드를 호출할 수 없다. 
 
        // computer 객체에서 Laptop 클래스의 메소드를 호출 하려면
        // 부모클래스에서 자식클래스 메소드 사용하기 위한 캐스팅이 필요하다.
        ((Laptop) computer).setTouchPad("touchModelB");
        System.out.println(((Laptop) computer).getTouchPad());        
        
        // 2. 인터페이스와 클래스 간의 호출
        
        Map map1 = new Map(); // -> 객체화 오류 발생
        
        // Map은 인터페이스 이므로 객체화 할수 없으므로 객체를 생성할 수 없다.
        // Map ConcurrentHashMap, HashMap, LinkedHashMap, TreeMap 같은 구현클래스를 선택해서 사용해야 한다.
        
        // 1. Map
        Map map2= new HashMap();
        map2.put(1, "데이터1");
        System.out.println(map2.get(1));
        
        // 2. HashMap 
        HashMap hashmap1 = new HashMap();
        hashmap1.put(1, "데이터1");
        System.out.println(hashmap1.get(1));
        
        // Map은 인터페이스 이므로 메소드에 대한 선언만 있으므로 두개의 선언 방식은 똑같다.
        
    }
}
 
// 컴퓨터 클래스에 속성 - cpu, ram, power, mainboard
class Computer{
    String cpu;
    String ram;    
    String power;
    String mainBoard;
    
    public Computer(){
    }
    
    public String getCpu() {
        return cpu;
    }
    public void setCpu(String cpu) {
        this.cpu = cpu;
    }
    public String getRam() {
        return ram;
    }
    public void setRam(String ram) {
        this.ram = ram;
    }
    public String getPower() {
        return power;
    }
    public void setPower(String power) {
        this.power = power;
    }
    public String getMainBoard() {
        return mainBoard;
    }
    public void setMainBoard(String mainBoard) {
        this.mainBoard = mainBoard;
    }
}
 
// 랩탑의 속성 - 터치패드, 무선
class Laptop extends Computer{
    String touchPad;
    String wireless;
    
    public Laptop(){
        super();
    }
    
    public String getTouchPad() {
        return touchPad;
    }
    public void setTouchPad(String touchPad) {
        this.touchPad = touchPad;
    }
    public String getWireless() {
        return wireless;
    }
    public void setWireless(String wireless) {
        this.wireless = wireless;
    }
    
}
cs


해당 소스를 통해 Map은 메소드가 선언만 되어있는 인터페이스인 것을 확인했다.


마지막으로 해당 소스를 첨부한다.



ObjectTest.java




'전체 > Java' 카테고리의 다른 글

Camel to Underscores, Underscores to Camel 플러그인 AnyEdit 사용하기  (0) 2018.04.04
자바, 자바스크립트 Array to String, String to Array 문자열을 배열로 넣는 방법  (0) 2018.04.04
인터페이스 개념 이해하기  (0) 2017.10.13
JSONObject, JSONArray, JSONParser 사용해 데이터 만들어 파싱하기  (3) 2017.09.21
fail-fast 방식 개념  (0) 2017.09.20


인터페이스란 무엇인가? 


인터페이스 예제를 들어 설명하겠다.


1. 유저는 게임을 한다.

2. 유저는 게임들 중의 하나인 오버워치를 플레이 한다.

3. 유저는 게임들 중의 하나인 스타크래프트를 플레이 한다.

4. 오버워치와 스타크래프트는 게임이다.


다음과 같이 정의된 내용을 만들어 보려고 한다.


먼저 OverWatch, StarCraft, User 라는 java파일의 클래스를 만들자.


1
2
3
4
// OverWatch.java
public class OverWatch extends User{
    
}
cs


1
2
3
4
// StarCraft.java
public class StarCraft extends User{
 
}
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// User.java
public class User {
    
    public static void main(String[] args) {
        
        User user = new User();
        OverWatch overwatch = new OverWatch();
        StarCraft starcraft = new StarCraft();
        
        user.play(overwatch);
        user.play(starcraft);
        
    }
    
    public void play(OverWatch overwatch){
        System.out.println("Game is overwatch / FPS");
    }
    
    public void play(StarCraft starCraft){
        System.out.println("Game is starcraft / Strategy Simulation");
    }
}
cs





User클래스에서 객체를 생성하고

play라는 메소드로 생성한 객체를 argument로 넣는다.


현재는 오버워치와 스타크래프트 딱 2가지만 게임을 추가했지만,


배틀그라운드, 리그오브레전드 등등 여러가지 게임을 추가한다고 해보자.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public void play(OverWatch overwatch){
    System.out.println("Game is overwatch / FPS");
}
 
public void play(StarCraft starCraft){
    System.out.println("Game is starcraft / Strategy Simulation");
}
 
public void play(BattleGround battleground){
    System.out.println("Game is battleground / FPS");
}
 
public void play(LOL lol){
    System.out.println("Game is lol / AOS");
}
cs



그러면 다음과 같이 메소드에 대한 인자값이 바뀌어 들어간다는 것을 확인할 수 있다.


게임이라는 객체가 하나하나 추가될때 마다 argument를 계속해서 바꿔주며 메소드에 추가해야하는 문제점이 발생한다.


어떤 게임이 추가되던 argument를 Game이라는 인자로 넣어서 메소드 인자를 다음과 같이 공통으로 빼버리자.


1
2
3
public void play(Game game){
    System.out.println(game.getGame()+" / "+game.getGameType());
}
cs


Game을 공통 인자로 빼기위해선 인터페이스를 생성하여 사용하면 된다.


1
2
3
4
public interface Game {
    public String getGame();
    public String getGameType();
}
cs


인터페이스는 다음과 같이 선언으로 사용할 수 있고

인터페이스 안에 메소드는 body가 없는 선언형태이다.


그럼 이 메소드의 내용은 어디서 알 수 있을까?


이 메소드의 내용은 인터페이스를 상속받는 java파일( OverWatch.java, StarCraft.java )에서 선언하여 채워주면 되는것이다.


인터페이스를 상속받는 모든 java파일은 인터페이스 안의 메소드를 상속받는다.


현재 인터페이스의 메소드는 getGame(), getGameType() 이다.


이 메소드를 인터페이스를 상속받는 OverWatch.java, StarCraft.java 에서 메소드에 대한 내용을 채워줘야 한다는 것이다.


각 java파일에서 인터페이스를 상속받는 방법은 implements이다. implements Game을 선언하면 Game 인터페이스를 상속받는 다는 뜻이다.


그럼 이 파일에 메소드의 내용을 넣어보자.



1
2
3
4
5
6
7
8
9
10
11
// OverWatch.java
public class OverWatch extends User implements Game{
    
    public String getGame(){
        return "Game is OverWatch";
    }
 
    public String getGameType() {
        return "FPS";
    }   
}
cs



1
2
3
4
5
6
7
8
9
10
11
// StarCraft.java
public class StarCraft extends User implements Game{
 
    public String getGame() {
        return "Game is StarCraft";
    }
 
    public String getGameType() {
        return "Strategy Simulation";
    }   
}
cs


그 다음 User.java 의 play 메소드에 인터페이스 인자와 메소드를 넣는다.



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class User {
    
    public static void main(String[] args) {
        
        User user = new User();
        OverWatch overwatch = new OverWatch();
        StarCraft starcraft = new StarCraft();
        
        user.play(overwatch);
        user.play(starcraft);
        
    }
    
    public void play(Game game){
        System.out.println(game.getGame()+" / "+game.getGameType());
    }
}
cs


어떤 인자를 받느냐에 따라 그 인자가 선언된 java파일의 메소드 내용이 출력하게 된다.


출력 결과


Game is OverWatch / FPS

Game is StarCraft / Strategy Simulation




'전체 > Java' 카테고리의 다른 글

자바, 자바스크립트 Array to String, String to Array 문자열을 배열로 넣는 방법  (0) 2018.04.04
부모클래스와 자식클래스 간의 호출, 인터페이스와 클래스 간의 호출  (0) 2017.12.12
JSONObject, JSONArray, JSONParser 사용해 데이터 만들어 파싱하기  (3) 2017.09.21
fail-fast 방식 개념  (0) 2017.09.20
ArrayList, HashMap의 Call By Value, Call By Reference 참조변수 테스트  (0) 2017.09.20


1. 사전작업


JSON을 사용하기 위해선 json-simple-1.1.1.jar 라는 라이브러리 파일이 필요하다.


maven이나 구글링을 통해 json사용에 필요한 jar 파일을 다운받고 프로젝트 속성 > java build path > Libraries > Add jars를 통해 라이브러리를 추가한다.



2. JSONObject, JSONArray 데이터 입출력 만들기



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
import java.util.ArrayList;
import java.util.HashMap;
 
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
 
public class JsonTest {
 
    public static void main(String[] args) {
        
        JSONObject jsonObject1 = new JSONObject(); // 중괄호에 들어갈 속성 정의 { "a" : "1", "b" : "2" }
        JSONArray jsonArray1 = new JSONArray(); // 대괄호 정의 [{ "a" : "1", "b" : "2" }]
        JSONObject finalJsonObject1 = new JSONObject(); // 중괄호로 감싸 대괄호의 이름을 정의함 { "c" : [{  "a" : "1", "b" : "2" }] }
 
        jsonObject1.put("이름", "잠자리");
        jsonObject1.put("다리갯수", "6");
        jsonArray1.add(jsonObject1);
 
        jsonObject1 = new JSONObject();
        jsonObject1.put("이름", "사슴벌레");
        jsonObject1.put("다리갯수", "6");
        jsonArray1.add(jsonObject1);
        
        finalJsonObject1.put("곤충", jsonArray1);
 
        finalJsonObject1.put("동물", "코끼리");
        finalJsonObject1.put("식물", "무궁화");
        
        System.out.println(finalJsonObject1);
 
        /* finalJsonObject1 출력값
          
         {  
               "식물":"무궁화",
               "곤충":[  
                          {  
                             "이름":"잠자리",
                             "다리갯수":"6"
                          },
                          {  
                             "이름":"사슴벌레",
                             "다리갯수":"6"
                          }
                       ],
               "동물":"코끼리"
          }
          
         */
        
    }
}
 
cs


다음과 같이 만들수는 있는데 작성하고 보면 


Type safety: The method put(Object, Object) belongs to the raw type HashMap. References to generic type HashMap<K,V> should be parameterized

Type safety: The method add(Object) belongs to the raw type ArrayList. References to generic type ArrayList<E> should be parameterized


노란색경고가 뜨며 Generic을 통해 타입을 지정해 safety하게 데이터입력을 넣어라고 말해주고 있다.


json 형태의 데이터를 DB나 웹서버에서 가져올때는 json데이터를 넣어주지않고 적절하게 가공만 하면 되므로 문제되지 않지만 다음과 같이 직접적으로 Generic 타입 선언 없이 put으로만 일방적으로 넣었을때 경고가 나타난것이다.



3. HashMap을 통해 Generic 데이터를 넣고 JSONObject로 형변환한 데이터 넣기



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
import java.util.ArrayList;
import java.util.HashMap;
 
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
 
public class JsonTest2 {
 
    public static void main(String[] args) {
        
        HashMap<String, Object> myHashMap1 = new HashMap<String, Object>();
        JSONObject jsonObject1 = new JSONObject(); // 중괄호에 들어갈 속성 정의 { "a" : "1", "b" : "2" }
        JSONArray jsonArray1 = new JSONArray(); // 대괄호 정의 [{ "a" : "1", "b" : "2" }]
        JSONObject finalJsonObject1 = new JSONObject(); // 중괄호로 감싸 대괄호의 이름을 정의함 { "c" : [{  "a" : "1", "b" : "2" }] }
        
        myHashMap1.put("이름", "잠자리");
        myHashMap1.put("다리갯수", "6");
        
        jsonObject1 = new JSONObject(myHashMap1); 
        jsonArray1.add(jsonObject1);
        
        myHashMap1 = new HashMap<String, Object>();
        myHashMap1.put("이름", "사슴벌레");
        myHashMap1.put("다리갯수", "6");
        
        jsonObject1 = new JSONObject(myHashMap1);
        jsonArray1.add(jsonObject1);
        
        finalJsonObject1.put("곤충", jsonArray1);
        finalJsonObject1.put("동물", "코끼리");
        finalJsonObject1.put("식물", "무궁화");
        
        System.out.println(finalJsonObject1);
        
        /*
          
         {  
               "식물":"무궁화",
               "곤충":[  
                          {  
                             "이름":"잠자리",
                             "다리갯수":"6"
                          },
                          {  
                             "이름":"사슴벌레",
                             "다리갯수":"6"
                          }
                       ],
               "동물":"코끼리"
          }
          
         */
 
    }
}
cs


다음은 HashMap을 사용해 들어갈 데이터 형식을 Generic <String, Object>로 선언해주어 2번의 노란색 경고를 없앤 코드이다.


출력값은 2번과 3번 모두 동일하다. 



4. String형식의 JSON 데이터를 JSON형식으로 바꾸어 파싱하기


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
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
 
public class StringToJson {
 
    public static void main(String[] args) {
        String jsonString1 = "{\"식물\":\"무궁화\",\"곤충\":[{\"이름\":\"잠자리\",\"다리갯수\":\"6\"},{\"이름\":\"사슴벌레\",\"다리갯수\":\"6\"}],\"동물\":\"코끼리\"}";
        JSONParser jsonParser1 = new JSONParser();
        JSONObject jsonObject1;
 
        try {
            
            jsonObject1 = (JSONObject) jsonParser1.parse(jsonString1);
            JSONArray jsonArray1 = (JSONArray) jsonObject1.get("곤충");
      
            for(int i=0; i<jsonArray1.size(); i++){
                System.out.println("곤충"+ i +" : " +jsonArray1.get(i));            
                JSONObject objectInArray = (JSONObject) jsonArray1.get(i);
                System.out.println("Key값은 "+objectInArray.get("이름"));
                System.out.println("Value값은 "+objectInArray.get("다리갯수"));
            }
            /*
             
                곤충0 : {"이름":"잠자리","다리갯수":"6"}
                Key값은 잠자리
                Value값은 6
                
                곤충1 : {"이름":"사슴벌레","다리갯수":"6"}
                Key값은 사슴벌레
                Value값은 6
             
             */
            
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}
cs


String 형의 JSON 값을 JSON형으로 바꾸어 파싱을 해 출력하는 코드이다.

파싱을 위해 JSONParser를 사용했고 단계적으로 Array, Object에 접근해 값을 찾아가고 있다.

소스코드 첨부파일

workspace.zip


'전체 > Java' 카테고리의 다른 글

부모클래스와 자식클래스 간의 호출, 인터페이스와 클래스 간의 호출  (0) 2017.12.12
인터페이스 개념 이해하기  (0) 2017.10.13
fail-fast 방식 개념  (0) 2017.09.20
ArrayList, HashMap의 Call By Value, Call By Reference 참조변수 테스트  (0) 2017.09.20
Jackson JSON 라이브러리 mapper.readTree 사용하기, Iterator 이용하기  (0) 2017.09.14


Iterator를 학습하는 도중


Enumeration과 Iterator를 비교하는 글을 보게 되어 정리하게 되었다.




1. Enumeration이란?


Enumeration은 객체들의 집합(Vector)에서 각각의 객체들을 한순간에 하나씩 처리할 수 있는 메소드를 제공하는 컬렉션이다.


Enumeration 객체는 new 연산자로 생성할 수 없으며, Vector를 이용하여 생성할 수 있다.


Vector 클래스의 elements() 라는 메소드는 객체의 모든 요소들을 Enumeration 객체로 반환한다.



 Enumeration 메소드

 설명

 boolean hasMoreElements()

 Vector로 부터 생성된 Enumeration의 요소가 있으면 true, 아니면 false 반환

 Object nextElement()

 Enumeration 내의 다음 요소를 반환한다. 





2. Iterator란?


Iterator는 Enumeration 클래스와 매우 유사하며 자바의 컬렉션 프레임웍에서 컬렉션에 저장되어 있는 요소들을 읽어오는 방법을 표준화한 방법이다.




 Iterator 메소드

 설명

 boolean hasNext()

 읽어 올 요소가 남아있는지 확인하는 메소드이다. 있으면 true, 없으면 false를 반환한다.

 Object next()

 Iterator 내의 다음 요소를 반환한다. 




3. Enumeration과 Iterator 의 차이점


Enumeration과 Iterator 의 가장 큰 차이점은 fail-fast 방식 개념이다.


콜렉션 클래스들은 저장된 객체들에 대한 순차적 접근을 제공한다.


Enumeration은 순차적 접근 시 콜렉션 객체에 변경이 일어나도 이를 무시하고, 끝까지 동작한다.


Iterator는 순차적 접근이 모두 끝나기 전에 콜렉션 객체에 변경이 일어날 경우 순차적 접근이 실패되면서 예외를 return하게 되는데 이를 fail-fast 방식이라고 부른다.



다음은 Junit을 이용해 fail-fast 동작에 대한 테스트 코드이다.



3.1 Iterator Junit 테스트



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
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
 
 
public class FailFastTest {
 
    private List<Integer> myList;
 
    @Before
    public void init() {
        myList = new ArrayList<Integer>();
 
        for (int i = 0; i < 1000; i++) {
            myList.add(i);
        }
    }
 
    @Test
    public void iteratorTest() throws InterruptedException {
 
        new MyThread().start();
 
        Iterator<Integer> it = myList.iterator();
        while (it.hasNext()) {
            Thread.sleep(10);
            System.out.println(it.next());
        }
    }
 
 
    class MyThread extends Thread {
 
        @Override
        public void run() {
            System.out.println("MyThread Start :");
            try {
                Thread.sleep(1000); // 1초 동안 sleep
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
 
            myList.remove(1); // iterator collection 객체 변경 
            
            System.out.println(myList);
            
            // iterator로 받아 반복을 돌린 객체는 객체가 변경되면 멈춘다.
            // 출력값 : 1이 remove된 순간 객체 변경을 알고 반복을 멈춤 0~99, {0,2,3 ... 999} 출력됨.
        }
    }
}
cs



3.2 Enumeration Junit 테스트



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
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
 
import org.junit.Before;
import org.junit.Test;
 
 
public class FailFastTest {
 
    private Vector<Integer> vecList;
 
    @Before
    public void init() {
        vecList = new Vector<Integer>();
 
        for (int i = 0; i < 1000; i++) {
            vecList.add(i);
        }
    }
 
  @Test
  public void enumerationTest() throws InterruptedException {
      new MyThread().start();
 
      Enumeration<Integer> en = vecList.elements();  
      while (en.hasMoreElements()) {
          Thread.sleep(10);
          System.out.println(en.nextElement());
      }
  }
 
 
    class MyThread extends Thread {
 
        @Override
        public void run() {
            System.out.println("MyThread Start :");
            try {
                Thread.sleep(1000); // 1초 동안 sleep
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
 
            vecList.remove(1); // Enumeration collection 객체 변경 
            
            System.out.println(vecList);
            
            // Enumeration으로 받아 반복을 돌린 객체는 객체가 변경되어도 멈추지않는다.
            // 출력값 : 0 ~ 999 출력이 되고 반복문으로 숫자가 찍히는 중간에 {0,2,3 ... 999} 출력됨.
        }
    }
}
cs


자바 콜렉션 프레임워크에 포함되어 있는 List, Vector, HashTable 등은 모두 fail-fast 방식으로 동작하지만

Enumeration 인터페이스만 fail-fast 방식이 아니다.




'전체 > Java' 카테고리의 다른 글

인터페이스 개념 이해하기  (0) 2017.10.13
JSONObject, JSONArray, JSONParser 사용해 데이터 만들어 파싱하기  (3) 2017.09.21
ArrayList, HashMap의 Call By Value, Call By Reference 참조변수 테스트  (0) 2017.09.20
Jackson JSON 라이브러리 mapper.readTree 사용하기, Iterator 이용하기  (0) 2017.09.14
해쉬맵 형태의 엔티티 값을 ArrayList로 바꿔 Key와 Value를 추가하는 방법  (0) 2017.09.07


ArrayList, HashMap의 Call By Value, Call By Reference 참조변수 테스트



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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
import java.util.ArrayList;
import java.util.HashMap;
 
import sun.text.CompactShortArray.Iterator;
 
 
public class AddressTest {
    
    public static class CallByValue{
        public int a;
    }
 
    public static void CallByReference(CallByValue param){
        param.a = 100;
    }
    
    public static void main(String[] args) {
        
        // ---------------------------------- #case1----------------------------------------------
        
        ArrayList<Integer> myArrayList1=new ArrayList<Integer>();
        ArrayList<Integer> myArrayList2=new ArrayList<Integer>();
        
        myArrayList1.add(10);
        myArrayList1.add(20);
        myArrayList1.add(30);
        // myArrayList1 = 10,20,30
 
        myArrayList2 = myArrayList1;
        
        myArrayList2.add(40);
        myArrayList2.add(0,5);
        myArrayList1.add(50);
        // myArrayList2 = 5,10,20,30,40
        
        System.out.println("myArrayList1값: "+myArrayList1); // 5,10,20,30,40
        System.out.println("myArrayList2값: "+myArrayList2); // 5,10,20,30,40
        
        // ---------------------------------- #case2----------------------------------------------
        
        HashMap<Integer, String> myHashMap1 = new HashMap<Integer, String>();
        HashMap<Integer, String> myHashMap2 = new HashMap<Integer, String>();
 
        myHashMap1.put(3, "사이다");
        myHashMap1.put(1, "커피");
        myHashMap1.put(2, "우유");
        System.out.println("myHashMap1값: "+myHashMap1); // myHashMap1값: {3=사이다, 2=우유, 1=커피}
        myHashMap2 = myHashMap1;
        
        myHashMap2.put(4,"콜라");
        myHashMap2.put(5,"보리차");
        
        System.out.println("myHashMap1값: "+myHashMap1); // myHashMap1값: {5=보리차, 4=콜라, 3=사이다, 2=우유, 1=커피}
        System.out.println("myHashMap2값: "+myHashMap2); // myHashMap2값: {5=보리차, 4=콜라, 3=사이다, 2=우유, 1=커피}
        System.out.println(myHashMap2.keySet()); // [5, 4, 3, 2, 1]
        
        java.util.Iterator<Integer> myIterator = myHashMap2.keySet().iterator();
        while(myIterator.hasNext()){
            Integer key = myIterator.next();
            System.out.println(key+myHashMap2.get(key));
        }
        
        // ---------------------------------- #case3----------------------------------------------
        
        int a = 1;
        int b;
        
        b = a;
        b = 10;
        
        System.out.println("a값: "+a); // a = 1
        System.out.println("b값: "+b); // b = 10
        
        
        // ---------------------------------- #case4----------------------------------------------
        
        String c = new String();
        String d = new String();
        
        c = "ccc" ; 
        d = c ;
        d = "ddd";
        
        System.out.println("c값: " + c); // c = ccc
        System.out.println("d값: " + d); // d = ddd
        
        // ---------------------------------- #case5----------------------------------------------
        
        CallByValue callbyValue1 = new CallByValue();    
        callbyValue1.a = 200;
        System.out.println("callbyValue1값: "+callbyValue1.a); // 200
        CallByReference(callbyValue1);
        System.out.println("callbyValue1값: "+callbyValue1.a); // 100
    }
 
}
cs


case 1을 보면 myArrayList1과 myArrayList2는 서로 다른 변수로 선언 되어 있고


myArrayList1의 값을 add 해주고 myArrayList2 = myArrayList1 로 myArrayList1의 주소를 참조하고 있다.


그리고 myArrayList2의 값을 add해주고 myArrayList1값과 myArrayList2값을 찍어주면


같은 값(5,10,20,30,40) 이 출력된다.



case 2도 HashMap을 사용했는데 myHashMap2 = myHashMap1 로 주소를 참조해


myHashMap1과 myHashMap2의 같은 값{5=보리차, 4=콜라, 3=사이다, 2=우유, 1=커피}이 출력된다.




case 3과 case 4는 call by value 로 객체를 생성해 값을 집어넣거나 값을 직접적으로 넣어도 서로 다른 값이 나오게 된다.



case 5는 메소드를 타게하여 주소로 접근해 값을 변경시키고 있다.



'전체 > Java' 카테고리의 다른 글

인터페이스 개념 이해하기  (0) 2017.10.13
JSONObject, JSONArray, JSONParser 사용해 데이터 만들어 파싱하기  (3) 2017.09.21
fail-fast 방식 개념  (0) 2017.09.20
Jackson JSON 라이브러리 mapper.readTree 사용하기, Iterator 이용하기  (0) 2017.09.14
해쉬맵 형태의 엔티티 값을 ArrayList로 바꿔 Key와 Value를 추가하는 방법  (0) 2017.09.07



Jackson JSON 라이브러리 mapper.readTree 사용하기


JsonNode myJsonNode = mapper.readTree(myJson); // String myJson값을 Json형태로 바꿔서


Iterator itr = myJsonNode2.getElements(); // Iterator를 사용해 요소를 객체로 저장한다.



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
import java.io.IOException;
import java.util.Iterator;
 
import org.codehaus.jackson.JsonNode;
import org.codehaus.jackson.JsonProcessingException;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.node.ObjectNode;
 
public class JacksonTest {
 
    public static void main(String[] args) throws JsonProcessingException, IOException {
     ObjectMapper mapper = new ObjectMapper();
     String myJson = "{\"a\":1990, \"b\":\"b is string\", \"c\": [{\"d1\":\"d1 is string\"}, {\"d2\":\"d2 is string\"}]}";
     
     myJson1(mapper, myJson);
     myJson2(mapper, myJson);
     
    }
    
    // 1. mapper.readTree 사용하기 
    private static void myJson1(ObjectMapper mapper, String myJson) throws JsonProcessingException, IOException {
        JsonNode myJsonNode = mapper.readTree(myJson);
        System.out.println("myJsonNode1:"+myJsonNode); 
        // myJsonNode1:{"a":1990,"b":"b is string","c":[{"d1":"d1 is string"},{"d2":"d2 is string"}]}
 
        if (myJsonNode.isObject()) {
            ObjectNode obj = (ObjectNode) myJsonNode;
            if (obj.has("c")) {
                 JsonNode valueC= obj.get("c").get(0).get("d1");
                 System.out.println("valueC Text값: "+valueC.getTextValue()); // valueC Text값: d1 is string
            }
        }
    }
    // 2. mapper.readTree와 Iterator 사용하기 
    private static void myJson2(ObjectMapper mapper, String myJson) throws JsonProcessingException, IOException {
        JsonNode myJsonNode2 = mapper.readTree(myJson);
        System.out.println("myJsonNode2:"+myJsonNode2); 
        // myJsonNode2:{"a":1990,"b":"b is string","c":[{"d1":"d1 is string"},{"d2":"d2 is string"}]}
 
        Iterator itr = myJsonNode2.getElements();
        
        while( itr.hasNext()) {
            JsonNode obj = (JsonNode)itr.next(); 
            System.out.println(obj);
        }
    }
}
cs



[출력 결과]


myJsonNode1:{"a":1990,"b":"b is string","c":[{"d1":"d1 is string"},{"d2":"d2 is string"}]}

valueC Text값: d1 is string

myJsonNode2:{"a":1990,"b":"b is string","c":[{"d1":"d1 is string"},{"d2":"d2 is string"}]}

1990

"b is string"

[{"d1":"d1 is string"},{"d2":"d2 is string"}]



'전체 > Java' 카테고리의 다른 글

인터페이스 개념 이해하기  (0) 2017.10.13
JSONObject, JSONArray, JSONParser 사용해 데이터 만들어 파싱하기  (3) 2017.09.21
fail-fast 방식 개념  (0) 2017.09.20
ArrayList, HashMap의 Call By Value, Call By Reference 참조변수 테스트  (0) 2017.09.20
해쉬맵 형태의 엔티티 값을 ArrayList로 바꿔 Key와 Value를 추가하는 방법  (0) 2017.09.07

작업 방법


1. 해쉬맵 형태 Entity > ArrayList로 변환 


2. ArrayList에서 필요한 값에 대한 키에 접근 > 적절한 분기 처리하여 필요한 값에 대한 데이터를 추출 


3. 추출한 데이터를 다시 해쉬맵형태의 Entity에 키, 밸류로 넣음


4. 해쉬맵 형태의 엔티티를 ArrayList에 추가 > ArrayList를 해쉬맵 형태의 엔티티에 넣음



해쉬맵 형태로 들어가있는 Entity에서 ArrayList로 형 변환하여(ArrayList myArrList1 = EntityUtil.ResultSetToList(rslt);) 

담겨있는 데이터는 총 2개이다.


이 ArrayList 파람값에 접근해 값을 추출하여 새로운 키값을 만들어 값을 넣어주고 싶다.


1
2
3
4
5
6
7
8
9
10
[
    {reply_yn=N, inquiry_seq=265194, faq_ty1_nm=배송, mall_faq_ty_nm=매장상품, proc_dt=0.0, title_txt=테스트3, cancel_yn=N, user_nm=이상현, reply_ready=N, ord_store_nm=null, inquiry_dt2=2017-09-06 15:45:04, store_id=0075, inquiry_dt=2017-09-06, oos_yn=N, my_mall_faq_ty=63300, ord_store_id=null, user_id=20901762, r_num=1, faq_ty2_nm=미배송/수량부족, inquiry_kind=G, rownum=1, inquiry_txt=1234, reply_sms_update_dt=null, mod_dt=2017-09-06, basicreply_team=null, faq_ty1=63310, rating_cd=Brand-New, modstaff=null, ord_ty=인터넷, ord_no=100012934, mod_dt2=2017-09-06 15:45:04, reply_sms_yn=N, store_nm=잠실점, inquiry_img=null}
    {reply_yn=N, inquiry_seq=265193, faq_ty1_nm=주문, mall_faq_ty_nm=공통/기타, proc_dt=0.0, title_txt=테스트1, cancel_yn=N, user_nm=이상현, reply_ready=N, ord_store_nm=null, inquiry_dt2=2017-09-06 15:44:25, store_id=0075, inquiry_dt=2017-09-06, oos_yn=N
        , mall_ord_info= [
                        {"mart_style_type":"19030","god_nm":"프리미엄 물티슈 70매 캡형 10팩","mart_style_name":"[택배상품]","god_cnt":"0","trade_date":"2017.08.31","store_nm":"잠실점","ord_st":"결제완료","ord_no":"100011806"}
                       ,{"mart_style_type":"19020","god_nm":"[레고\/씨티(CITY)] 소방트럭과 보트 - 7213_레고코리아정품_BASIC \/ 1","mart_style_name":"[택배상품]","god_cnt":"0","trade_date":"2017.08.30","store_nm":"잠실점","ord_st":"상품준비중","ord_no":"100011660"}
                       ,{"mart_style_type":"19030","god_nm":"[순둥이]PC-01\/프리미엄 무향 플레인 물티슈 70매 캡형 10팩_BASIC \/ 1","mart_style_name":"[택배상품]","god_cnt":"0","trade_date":"2017.08.28","store_nm":"잠실점","ord_st":"주문취소","ord_no":"100011329"}
                 ]
        , my_mall_faq_ty=64100, ord_store_id=null, user_id=20901762, r_num=2, faq_ty2_nm=픽업/퀵배송 주문문의, inquiry_kind=G, rownum=2, inquiry_txt=테스트22, reply_sms_update_dt=null, mod_dt=2017-09-06, basicreply_team=null, faq_ty1=64140, rating_cd=Brand-New, modstaff=null, ord_ty=인터넷, ord_no=100011660, mod_dt2=2017-09-06 15:44:25, reply_sms_yn=N, store_nm=잠실점, inquiry_img=null}
]
cs




데이터가 저장되어있는 ArrayList의 이름은 myArrList1 이다.


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
public Entity selectInquiryExcelList(UserConnection conn, Entity param) throws SQLException {
    ArrayList myArrList1 = EntityUtil.ResultSetToList(rslt); // ArrayList 저장됨.
    ArrayList  queryArrayResult = new ArrayList();
    
    String mall_ord_info;
    String myData;
    
    for (int i = 0; i < myArrList1.size(); i++) { // ArrayList 크기만큼 돌리고
        Entity myArrListInfoEntity = new Entity();
        myArrListInfoEntity = (Entity)myArrList1.get(i); // ArrayList[0~N]  
        myData = myArrListInfoEntity.getString("reply_yn"); //  myData = ArrayList[0~N].reply_yn value(Y or N)
        mall_ord_info = myArrListInfoEntity.getString("mall_ord_info");  // mall_ord_info 컬럼 접근해서
        if(myData == 'N'){
            if(mall_ord_info.length() > 0){ // mall_ord_info 컬럼 안 Array 크기만큼 반복
                if(mall_ord_info.contains("store_nm")){
                    int myint1 =  mall_ord_info.indexOf("store_nm\":\"");
                    myint1 = myint1 + 11;
                    int myint2 =  mall_ord_info.indexOf("\",\"ord_st");
                    String myStringValue1 = mall_ord_info.substring(myint1,myint2); // 주문점포명에 대한 정보 얻어냄
                    myArrListInfoEntity.put("my_ord_info_store", myStringValue1); // 뽑아낸 주문점포명에 대한 데이터를 Entity안에 다시 해쉬맵 형태의 Key, Value 형태로 넣어줌
                }                      
            }                    
        }
        queryArrayResult.add(myArrListInfoEntity); // add를 사용해 Entity 형태의 해쉬맵 데이터를 다시 ArrayList에 넣어줌.
        // 기존의 데이터에서 키와 밸류를 추가해 들어가게 된다.
    }
    _DATA.put("_DATA" , queryArrayResult);
    return _DATA
}
cs



ArrayList 크기만큼 반복하며 돌며 한 row안에 있는 값을 적절히 분기처리하여 indexOf와 substring을 사용해

값을 추출하고 추출한 데이터를 새로운 키값인 "my_ord_info_store" 의 Value로 넣어주고 있다.

해당 반복문이 종료되면 ArrayList 안에

my_ord_info_store 라는 Key로 추가되어 재정의된 ArrayList가 나오게 된다.


1
2
3
4
5
6
7
8
9
10
[
    {reply_yn=N, my_ord_info_store=잠실점, inquiry_seq=265194, faq_ty1_nm=배송, mall_faq_ty_nm=매장상품, proc_dt=0.0, title_txt=테스트3, cancel_yn=N, user_nm=이상현, reply_ready=N, ord_store_nm=null, inquiry_dt2=2017-09-06 15:45:04, store_id=0075, inquiry_dt=2017-09-06, oos_yn=N, my_mall_faq_ty=63300, ord_store_id=null, user_id=20901762, r_num=1, faq_ty2_nm=미배송/수량부족, inquiry_kind=G, rownum=1, inquiry_txt=1234, reply_sms_update_dt=null, mod_dt=2017-09-06, basicreply_team=null, faq_ty1=63310, rating_cd=Brand-New, modstaff=null, ord_ty=인터넷, ord_no=100012934, mod_dt2=2017-09-06 15:45:04, reply_sms_yn=N, store_nm=잠실점, inquiry_img=null}
    {reply_yn=N, my_ord_info_store=잠실점, inquiry_seq=265193, faq_ty1_nm=주문, mall_faq_ty_nm=공통/기타, proc_dt=0.0, title_txt=테스트1, cancel_yn=N, user_nm=이상현, reply_ready=N, ord_store_nm=null, inquiry_dt2=2017-09-06 15:44:25, store_id=0075, inquiry_dt=2017-09-06, oos_yn=N
        , mall_ord_info= [
                        {"mart_style_type":"19030","god_nm":"프리미엄 물티슈 70매 캡형 10팩","mart_style_name":"[택배상품]","god_cnt":"0","trade_date":"2017.08.31","store_nm":"잠실점","ord_st":"결제완료","ord_no":"100011806"}
                       ,{"mart_style_type":"19020","god_nm":"[레고\/씨티(CITY)] 소방트럭과 보트 - 7213_레고코리아정품_BASIC \/ 1","mart_style_name":"[택배상품]","god_cnt":"0","trade_date":"2017.08.30","store_nm":"잠실점","ord_st":"상품준비중","ord_no":"100011660"}
                       ,{"mart_style_type":"19030","god_nm":"[순둥이]PC-01\/프리미엄 무향 플레인 물티슈 70매 캡형 10팩_BASIC \/ 1","mart_style_name":"[택배상품]","god_cnt":"0","trade_date":"2017.08.28","store_nm":"잠실점","ord_st":"주문취소","ord_no":"100011329"}
                 ]
        , my_mall_faq_ty=64100, ord_store_id=null, user_id=20901762, r_num=2, faq_ty2_nm=픽업/퀵배송 주문문의, inquiry_kind=G, rownum=2, inquiry_txt=테스트22, reply_sms_update_dt=null, mod_dt=2017-09-06, basicreply_team=null, faq_ty1=64140, rating_cd=Brand-New, modstaff=null, ord_ty=인터넷, ord_no=100011660, mod_dt2=2017-09-06 15:44:25, reply_sms_yn=N, store_nm=잠실점, inquiry_img=null}
]
cs



'전체 > Java' 카테고리의 다른 글

인터페이스 개념 이해하기  (0) 2017.10.13
JSONObject, JSONArray, JSONParser 사용해 데이터 만들어 파싱하기  (3) 2017.09.21
fail-fast 방식 개념  (0) 2017.09.20
ArrayList, HashMap의 Call By Value, Call By Reference 참조변수 테스트  (0) 2017.09.20
Jackson JSON 라이브러리 mapper.readTree 사용하기, Iterator 이용하기  (0) 2017.09.14

+ Recent posts

티스토리툴바