본문 바로가기

(Before)BitSchool

2014/05/22 TCP/IP, 유틸리티API

반응형

서버

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
import java.io.*;
import java.net.*;
 
 
public class TcpEchoServer {
 
    public static void main(String[] args) {
        
        ServerSocket serversocket = null;  // static이라 new가 필요없다.
        
        try {
            //1) 소켓생성 --> 클라이언트와 통신 할 수 있는 소켓
            serversocket = new ServerSocket(10001);
            System.out.println("=== 서버 시작 ===");
            //accept메서드 : 대기함수 --> blocking
            // 클라이언트로 부터의 접속을 기다린다.
            
            Socket clientsocket = serversocket.accept(); //return을 안한다.
            // 클라이언트가 접속하면 return한다.
            
            InetAddress addr = clientsocket.getInetAddress(); // 접속한 클라이언트의 주소
            
            System.out.println(addr.getHostAddress()+"님이 접속!!!");
            //에코 서버 : 전달받은 테이터를 그대로 되돌려 주는 형태의 서버
            
            // java stream --> 흐름, 줄기
            InputStream input = clientsocket.getInputStream();  // 입력통로
            OutputStream out = clientsocket.getOutputStream();  // 출력통로
             
            // 출력
            PrintWriter pw = new PrintWriter(new OutputStreamWriter(out));    
            //입력
            BufferedReader br = new BufferedReader(new InputStreamReader(input));
            
            
            String msg = null;
            
            while(true){
                
                if((msg = br.readLine())==null)
                    break;
                
                System.out.println(msg);
                
                
                //pw.println(msg);
                pw.flush(); // 버퍼비우기
                
                
            }
            
            pw.close();
            br.close();
            
            clientsocket.close();
            serversocket.close();
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
 
}
 



클라이언트


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
import java.io.*;
import java.net.*;
 
public class TCPClient {
    public static void main(String[] args) {
        
        try {
            Socket ClientSocket = new Socket("127.0.0.1",10001);  // 소켓 객체 생성과 동시에 서버에 접속  (IP, 포트번호)
            
            BufferedReader Console = new BufferedReader(new InputStreamReader(System.in));  // 화면으로 부터 입력받을 객체
            
            // 서버에 접속한 소켓으로 입출력 스트림 얻어오기
            InputStream in = ClientSocket.getInputStream();    
            OutputStream out = ClientSocket.getOutputStream();
            // 입출력 스트림을 통해 실제 보내고 받기 작업 객체
            PrintWriter pw = new PrintWriter(new OutputStreamWriter(out));  // 출력
            BufferedReader br = new BufferedReader(new InputStreamReader(in));     // 입력
            
            String msg;
            
            // 서버와는 반대로 보내고
            while(true){
                //화면으로 부터 문자열 입력
                msg = Console.readLine();
                
                //보내기
                pw.println(msg);
                pw.flush();  // 버퍼비우기
                
                //받기
                msg = br.readLine();
                
                //화면에 출력!
                System.out.println(msg);
                msg = null;
                
            }
            
            
            
            
        } catch (UnknownHostException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }  
        
    }
}
 
/*에코 서버!!
    1. 1명의 접속자에게만 서비스 할 수 있다.
    ex) 여려명을 접속하고자 한다면 accept를 여러번 한다.
    
*/
 


다중서버

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 java.io.*;
import java.net.*;
 
 
public class MultiServer {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ServerSocket serversocket = null;  // static이라 new가 필요없다.
        
        try {
            //1) 소켓생성 --> 클라이언트와 통신 할 수 있는 소켓
            serversocket = new ServerSocket(10001);
            System.out.println("=== 서버 시작 ===");
            //accept메서드 : 대기함수 --> blocking
            // 클라이언트로 부터의 접속을 기다린다.
            
            Socket clientsocket = null;
            
            int i=0;
            
            while(i<10){
                clientsocket = serversocket.accept(); //return을 안한다.
                // 클라이언트가 접속하면 return한다.
                
                InetAddress addr = clientsocket.getInetAddress(); // 접속한 클라이언트의 주소
            
                System.out.println(addr.getHostAddress()+"님이 접속!!!");
                //에코 서버 : 전달받은 테이터를 그대로 되돌려 주는 형태의 서버
                i++;
            }
            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
 
}
 



1. socket만 저장하는 것이 효율적인가?  

2. 효율적이지 않다면 무엇을 저장해야 하는가?

3. 2번의 무엇을 어떻게 저장 하겠습니까?

4. ArrayList가 최선 입니까?

-중간 데이터를 추가와 삭제가 빈번한 경우 사용하기 좋은 LinkedList

- ArrayList는 마지막 데이터부터 삭제해나간다면 재배치가 필요하지 않기 때문에 상당히 빠르다 .






자료구조

삽입과 삭제가 제한된 스택과 큐

스택 (Stack) - 제한적인 자료구조. 탑이라고 한 끝에서 모든 삽입과 삭제가 일어나는 순서리스트.

- 후입선출이다.

큐(Queue) - 한쪽 끝에서 데이터가 삽입되고 반대쪽 긑에서 삭제가 일어나는 순서리스트.

                - 선입선출이다. 대기열이라고도 한다.


연결리스트(Linked List)

- 크기가 변하는(삽입,삭제) 순차리스트를 요구할 때 각각의 노드들의 연결로 이루어져 있는 리스트의 구조가 필요함.

- 동적인구조. 


컬렉션 인터페이스

- 선형자료구조는 일렬로 되어있는 배열,큐,스택, 연결리스트 같은 것 (Collection)

- 비선형자료구조는 트리이다.   ( Map)

- 컬렉션은 각각의 요소에 접근할 수 있도록 Iterator(반복자)라고 불리우는 인터페이스와 객체를 얻을 수 있는 메소드를 제공한다.  예) for문에서 i가 Iterator이다. 각 항목에 접근할수 있도록 도와준다.



HashSet 클래스

- 해쉬테이블을 기반으로 하여 셋을 구현한 클래스

- 해쉬셋의 장점 : 구성원의 객체와 상관없이 실행시간이 평균적으로 일정하다(큰 크기의 집합에 적당)

- 객체로 null을 구성원으로 갖지않는다.


TreeSet 클래스

- 정렬된 클래스




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
 
public class MyVector {  // 배열을 추상화한 클래스
    private Object[] data;  //저장될 공간
    private int capa;  // 전체 용량
    private int size;   // 현재 저장된 배열의 크기
    
    // 생성자
    public MyVector() {
        size = 0;
        capa = 3;
        data = new Object[16];
    }
    
    public MyVector(int size){
        size = 0;
        this.capa = size;
        data = new Object[this.size];
    }
 
    public int getCapa() {
        return capa;
    }
 
    public int getSize() {
        return size;
    }
    
    // 배열의 행동들
    // 삽입
    public void add(Object o){
        
        if(size==capa){
            Object[] temp = new Object[capa*=2]; 
            
            for(int i=0;i<size;i++){  // 복사
                temp[i] = data[i];
            }
            data = temp;
        }
 
            data[size]=o;
            size++;
    }
    
    public void remove(){
        this.data[size] = null;
        size--;
    }
}
 
class stack extends MyVector{  // 스택구현
    private int top;
    
    public stack(){
        top=0;
    }
    
    public void push(Object o){
        add(o);
    }
    
    public void pop(){
        remove();
    }
}
 


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
 
public class base {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyVector vector = new MyVector();
        
        
        System.out.println(vector.getCapa());
        vector.add(new Integer(10));
    
        System.out.println(vector.getCapa());
        vector.add(new Integer(10));
        
        System.out.println(vector.getCapa());
        vector.add(new Integer(10));
        
        System.out.println(vector.getCapa());
        vector.add(new Integer(10));
        
        System.out.println(vector.getCapa());
        vector.add(new Integer(10));
        
        System.out.println(vector.getCapa());
        vector.add(new Integer(10));
        System.out.println(vector.getSize());
        System.out.println(vector.getCapa());
        System.out.println(vector.getCapa());
        vector.add(new Integer(10));
        System.out.println(vector.getCapa());
        vector.add(new Integer(10));
        System.out.println(vector.getCapa());
        vector.add(new Integer(10));
        System.out.println(vector.getCapa());
        vector.add(new Integer(10));
        System.out.println(vector.getCapa());
        vector.add(new Integer(10));
        System.out.println(vector.getCapa());
        vector.add(new Integer(10));
        
        
    }    
 
}
 


결과값 : 3  3  3  3  6  6  6  6  6 12 12 12 12 



ArrayList

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.util.ArrayList;
import java.util.Iterator;
 
 
public class base {
 
    public static void main(String[] args) {
        
        ArrayList array = new ArrayList();
        array.add(new Integer(10));
        array.add(new Integer(20));
        array.add(new Integer(30));
        array.add(new Integer(40));
        array.add(new Integer(50));
        
        //System.out.println(array.size());  // 현재 array리스트에 들어있는 값의 갯수
        
        //array--> java의 일반 배열 
        Object[] p = array.toArray();
        
        for(int i=0;i<p.length;i++){
            System.out.println(p[i]);
        }
        
        // arrayList의 배열스러운 출력방법
        for(int i=0;i<array.size();i++){
            System.out.println(array.get(i));
        }
        
        
        //iterator을 이용한 접근법
        Iterator pi = array.iterator();
        
        while(pi.hasNext()){  // hasNext는 다음것을 검사하는것
            System.out.println(pi.next());
        }
        array.remove(2);  // 인덱스 0에 해당하는 값을 지운다.
        
        
        pi = array.iterator();
        while(pi.hasNext()){  // hasNext는 다음것을 검사하는것
            System.out.println(pi.next());
        }
        
    }    
}
 


Linked List

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
import java.util.*;
 
 
public class base {
 
    public static void main(String[] args) {
        
        LinkedList list = new LinkedList();
        
        //list는 어느곳에서나 동일 한 형태의 삽입 삭제를 갖고 있다.
        
        list.add(new Integer(10));
        list.addLast(new Integer(20));
        list.addFirst(new Integer(30));  // 맨앞에 값넣기
        
        Iterator it = list.iterator();
        
        while(it.hasNext()){  
            System.out.println(it.next());
        }
        
        //list.remove(1);
        list.removeLast();
        
        it = list.iterator();
        while(it.hasNext()){  
            System.out.println(it.next());
        }
    }    
}
 





반응형