이전에 ArrayList와 함께 Stack을 다뤄보았습니다. Stack하면 또 떠오르는게 Queue죠!

이번에는 Queue에 대하여 제공해주는 method들을 이용하여 테스트만 해보겠습니다.

/**
 * Created by 진우 on 2016-07-17.
 */
public class MyQueueTest {
    public static void main(String[] args) {
        MyQueueTest test = new MyQueueTest();
        test.checkLinkedList();
    }

    public void checkLinkedList() {
        LinkedList<String> queue = new LinkedList<String>();
        queue.add("A");
        queue.addFirst("B");
        System.out.println(queue);

        queue.offerFirst("C");
        System.out.println(queue);

        queue.addLast("D");
        System.out.println(queue);

        queue.offer("E");
        System.out.println(queue);

        queue.offerLast("F");
        System.out.println(queue);

        queue.push("G");
        System.out.println(queue);

        queue.add(0, "H");
        System.out.println(queue);
        System.out.println("Change -> From " + queue.set(3, "I") + " to " + queue.get(3));
        System.out.println("After = " + queue);
    }
}

지난 Java collection과 관련하여 이번에는 Map을 사용해보았습니다. 자바 프로그래머/개발자에게 면접질문으로 Map과 관련하여 간혹 등장하는 경우도 있다고하니, 이론과 함께 기초적인 테스트를 실습해봅시다.

/*
 * Map은 키(key)와 값(value)로 이루어져 있다. 
 * Map은
 * 1. 모든 데이터는 키와 값이 존재한다.
 * 2. 키가 없이 값만 저장될 수는 없다.
 * 3. 값이 없이 키만 저장할 수도 없다.
 * 4. 키는 해당 Map에서 고유해야만 한다.
 * 5. 값은 Map에서 중복되어도 전혀 상관 없다. 
 * 왜냐하면, 여러 이유로 한대 이상의 핸드폰을 개통하여 사용하는 사람은 
 * 존재할 가능성이 매우 많기 때문이다.
 * 
 * Map인터페이스를 구현한 클래스들 : HashMap, TreeMap, LinkedHashMap
 * 
 * (Map과 Hashtable 차이)
 * 1. Map은 컬렉션 뷰를사용하지만, HashTable은 Enumeration 객체를 통해서 데이터를 처리
 * 2. Map은 키,값, 키-값 쌍으로 데이터를 순환하여 처리할 수 있지만,
 * Hashtable은 이중에서 키-값 쌍으로 데이터를 순환하여 처리할 수 없다.
 * 3. Map은 이터레이션을 처리하는 도중에 데이터를 삭제하는 안전한 방법을 제공하나,
 * Hashtable은 그러한 기능을 제공하지 않는다.
 * 
 * 
 * 키나 값에 null 저장가능여부 -> HashMap : 가능, HashTable : 불가능
 * 여러 쓰레드에서 동시 접근 가능 여부 -> HashMap : 불가능, HashTable : 가능
 */
/*
 * (자바의 자료구조)
 * Collection을 구현한 것은 List, Set ,QUeue이며, Map은 별도의 인터페이스로 되어있음
 * List의 대표적인 클래스로는 ArrayList와 LinkedList가 있으며, 보통은 ArrayList를 사용.
 * 
 * List처럼 목록을 처리하기는 하지만, 데이터의 중복이 없고 순서가 필요없는 Set의 대표적인
 * 클래스는 HashSet, TreeSet, LinkedHashSet이 있다.
 * 
 * 데이터가 들어온 순서대로 처리하기 위해 사용되는 Queue의 대표적인 클래스는
 * LinkedList와 PriorityQueue등이 있으며, LinkedList는 List에도 속하고 Queue에도 속하는 특이한 클래스이다.
 * 
 * Map의 대표적인 클래스는 HashMap, TreeMap, LinkedHashMap이 있으며, 대부분 HashMap을 사용
 * 
 * Map의 "키" 목록은 keySet()메소드를 사용하면 Set타입의 데이터를 얻을 수 있고,
 * "값" 목록은 values()메소드를 통하여 collection 타입의 데이터를 얻을 수 있다.
 */
/**
 * Created by 진우 on 2016-07-17.
 */

public class MyMapTest {
    public static void main(String[] args) {
        MyMapTest test = new MyMapTest();
        test.checkHashMap();
//        test.checkHashMapEntry();
//        test.checkTreeMap();
//        test.checkProperties();
//        test.saveAndLoadProperties();
    }
    //////////////////////////////////////////////////////////////////
    public void checkHashMap() {
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("A",  "a");                          //A는 키이고, a는 값이다.
        map.put("A", "1");                       //값이 있는 키에 추가하면, 가장 최근에 추가한것이 뽑힘
        //System.out.println(map.get("A"));         //return -> 1
        //System.out.println(map.get("B"));         //return -> null
        map.put("C",  "c");
        map.put("D",  "d");

        Collection<String> values = map.values();
        for(String tempKey:values) {
            System.out.println(tempKey);
        }
        // Set과 Collection의 차이.
        /*
      Set<String> keySet = map.keySet();
      for(String tempKey:keySet) {
         System.out.println(tempKey+"="+map.get(tempKey));
      } */
    }
    //////////////////////////////////////////////////////////////////
    public void checkHashMapEntry() {
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("A", "a");
        map.put("B", "b");
        map.put("C", "c");
        map.put("D", "d");

      //System.out.println(map.containsKey("A"));       //return -> true
      //System.out.println(map.containsKey("Z"));       //return -> false
      //System.out.println(map.containsValue("a"));     //return -> true
      //System.out.println(map.containsValue("z"));     //return -> false
        map.remove("A");
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for(Map.Entry<String, String> tempEntry:entries) {
            System.out.println(tempEntry.getKey() + " = " + tempEntry.getValue());
        }
    }
    //////////////////////////////////////////////////////////////////
    public void checkTreeMap() {
        TreeMap<String, String> map = new TreeMap<String, String>();
        map.put("A", "a");
        map.put("B", "b");
        map.put("C", "c");
        map.put("D", "d");
        map.put("가", "e");
        map.put("1", "f");
        map.put("a", "g");

        Set<Map.Entry<String, String>> entries = map.entrySet();
        for(Map.Entry<String, String> tempEntry:entries) {
            System.out.println(tempEntry.getKey() + " = " + tempEntry.getValue());
        }
        /*
        TreeMap은 키를 정렬하여 저장하고, 키의 목록을 가져와서 출력하면,
        정렬된 순서대로 제공되는것을 볼 수 있다.
        매우 많은 데이터는 HashMap이 유리하나, 100~1000정도는 TreeMap이 좋음. */
    }
    //////////////////////////////////////////////////////////////////
    public void checkProperties() {
        Properties prop = System.getProperties();       //자신의 JAVA Property를 알 수 있음
        Set<Object> keySet = prop.keySet();
        for(Object tempObject:keySet) {
            System.out.println(tempObject + " = " + prop.get(tempObject));
        }
    }
    //////////////////////////////////////////////////////////////////
    public void saveAndLoadProperties() {
        try {
            //String fileName="test.properties";            // case(1) : .properties
            String fileName="test.xml";                     // case(2) : .xml

            //(해당 프로젝트 디렉토리에 파일이 생길 것입니다.)
            File propertiesFile = new File(fileName); //test.properties 또는 test.xml 파일을 생성하고, 씀.
            FileOutputStream fos = new FileOutputStream(propertiesFile);
            Properties prop = new Properties();
            prop.setProperty("Writer", "Sangmin, Lee");
            prop.setProperty("WriterHome",  "http://www.GodOfJava.com");
            //prop.store(fos,  "Basic Properties file.");   // case(1)
            prop.storeToXML(fos,  "Basic XML file.");       // case(2)
            fos.close();

            FileInputStream fis = new FileInputStream(propertiesFile);
            Properties propLoaded = new Properties();
            //propLoaded.load(fis);                         // case(1)
            propLoaded.loadFromXML(fis);                    // case(2)
            fis.close();
            System.out.println(propLoaded);
        } catch(Exception e) {
            e.printStackTrace();
        }
    }
}

Java 프로그래머/개발자에게는 필수로 알아야하는 collection에 대하여 기초적인 부분으로 스타트를 끊어보았습니다.

Java collection에 대하여 살펴보며, 우선 ArrayList와 Stack을 이용하여 간단하게 사용을 해보았습니다.

/**
 * Created by 진우 on 2016-07-17.
 */
//ArrayList, Stack - Test
/* (자바에서의 자료구조)
 * 1. 순서가 있는 목록인 List형
 * 2. 순서가 중요하지 않은 목록인 Set형
 * 3. 먼저 들어온 것이 먼저 나가는 Queue형
 * 4. 키-값(key-value)으로 저장되는 Map형
 */

//List인터페이스를 주로 구현한 java.util패키지 : ArrayList, Vector, Stack, LinkedList

/*
 * List의 특징 : 배열처럼 순서가 있다.
 * ArrayList와 Vector클래스의 사용법은 거의 동일하고 기능도 비슷.
 * 이 두 클래스는 "크기 확장이 가능한 배열" 이라 보면 된다.
 * ArrayList : 이 객체는 여러명이 달려들어 값을 변경하려하면 문제가 발생할 수 있다.(Thread Safe하지 않다.)
 * Vector : 위 문제가 발생하지 않는다.(Thread Safe하다.)
 * 
 * Stack클래스는 Vector클래스를 확장하여 만들었는데, LIFO를 지원하기 위해 만들어짐
 */
public class MyListTest {
    public static void main(String[] args) {
        MyListTest test = new MyListTest();
        //test.checkArrayList1();
        //test.checkArrayList2();
        //test.checkArrayList3();
        //test.checkArrayList4();
        test.checkStack();
    }

    ///////////////////////////////////////////////////////
    public void checkArrayList1() {
        ArrayList list1 = new ArrayList();
        System.out.println(list1);
        list1.add(new Object());
        System.out.println(list1);
        list1.add("ArrayListSample");
        System.out.println(list1);
        list1.add(new Double(1));
        System.out.println(list1);
    }
    ///////////////////////////////////////////////////////
    public void checkArrayList2() {
        ArrayList<String> list = new ArrayList<String>();
        list.add("Jinwoo");
        list.add("Choi");
        list.add("HUFS");
        list.add("ICE");
        list.add("Suwon");
        list.add(1, "Sirius");

      for(String tempData:list)
         System.out.print(tempData + " ");
        System.out.println();
        /*
      ArrayList<String> jwlist = new ArrayList<String>();
      jwlist.add("0 ");
      jwlist.addAll(list);             //list에 있는 전부를 list2에 add.
      for(String jinwooData:jwlist)
         System.out.println("New List : "+ jinwooData);
        */

        ArrayList<String> jwlist = list; //list2는 list의 주소까지도 사용함.
        list.add("Bye!");
        for(String jinwooData:jwlist)
            System.out.println("New List : " + jinwooData);
    }
    ///////////////////////////////////////////////////////
    public void checkArrayList3() {
        ArrayList<String> list = new ArrayList<String>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");
        list.add("E");

      int listSize = list.size();
      for(int loop=0; loop<listSize; loop++)
         System.out.println("list.get("+loop+")="+list.get(loop));
      String[] strList=list.toArray(new String[0]);

        //String[] tempArray=new String[7]; //String[list.size()]로 하면 맞음.
        //String[] strList = list.toArray(tempArray);
        for(String temp:strList)
            System.out.println(temp);
    }
    ///////////////////////////////////////////////////////
    public void checkArrayList4() {
        ArrayList<String> list = new ArrayList<String>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");
        list.add("E");
        list.add("A");

        //System.out.println("Removed "+list.remove(0));
        //System.out.println(list.remove("A"));
        ArrayList<String> temp = new ArrayList<String>();
        temp.add("A");
        list.removeAll(temp);

        for (int loop = 0; loop < list.size(); loop++)
            System.out.println("list.get(" + loop + ")=" + list.get(loop));
    }

    ////////////////////////////////////////////////////////////
    public void checkStack() {
        Stack<Integer> myStack = new Stack<Integer>();
        for(int loop=0; loop<5; loop++) {
            myStack.push(loop);
            System.out.println(myStack.peek());
        }
        while(!myStack.empty()) {
            System.out.println(myStack.pop());
        }
    }
}

Scan(스캔)은 방화벽과 IDS(침입 탐지 시스템)을 우회하기 위하여 발전했으며, 종류가 매우 다양합니다.

서버의 동작여부를 알아보는 가장 기본적인 스캔은 ping 을 이용하는 것입니다.

검사하고자하는 네트워크에서 동작하는 서버를 찾아내는 일은 공격대상 네트워크에서 공격대상의 IP주소를 결정하는데에 매우 중요합니다.

ping은 네트워크와 시스템이 정상적으로 작동하는지 확인하기 위한 간단한 유틸리티입니다.

ping은 ICMP(Internet Control Message Protocol)을 사용하며, 기본적으로 TCP/IP 네트워크에서 사용됩니다. 넷웨어(Netware)같이 다른 프로토콜 체제를 쓰는 네트워크에서는 ping 유틸리티도 다릅니다. 따라서 모든 네트워크에 ping이 있는것은 아닙니다.

(* Netware : 가장 광범위하게 설치되었던 노벨(Novell)의 네트워크 서버 운영체제

* ICMP : 호스트서버와 인터넷 게이트웨이 사이에서 메시지를 제어하고 오류를 알려주는 프로토콜 )

ICMP를 이용해 공격대상 시스템의 활성화 여부를 알아보는 방법은 아래 네가지입니다.

1. Echo Request와 Echo Reply를 이용한 방법 (가장 일반적인 방법으로, 일반적으로 옵션없이 ping을 사용하면 됩니다.)

2. Timestamp Request와 Timestamp Reply를 이용한 방법

3. Information Request와 Information Reply를 이용한 방법

4. ICMP Address Mask Request와 ICMP Address Mask Reply를 이용한 방법

ping을 이용한 테스트로는 지난 포스팅에서 ping test를 해보았으므로 참고하시면 됩니다.

라우터나 방화벽 등에서 ICMP Echo Request패킷을 막는 경우가 있는데, 이 때 이용할 수 있는 방법으로 위의 2, 3, 4 번입니다.

첫째로, Timestamp Request패킷을 이용하는 것으로, Timestamp Request패킷은 원격지 시스템의 현재 시각을 알아보기 위한 패킷입니다. Timestamp Request패킷은 송신자가 패킷을 보낸 시각과 수신자가 패킷을 받은 시각, 송신자가 수신자에게 전송하는동안 걸린 시간으로 공격대상의 현재 시스템 시각을 알 수 있게 해줍니다.

상대시스템의 Reply패킷이 돌아온다는 것은 상대시스템이 활성화 되어있음도 알려주는 것입니다.

두번째로, Information Request패킷을 이용하는 것으로 원래 Information Request와 Reply는 메인 프레임의 단말기처럼 부팅할 때 자신의 디스크가 없는 시스템이 스스로 IP를 설정할 수 있도록 하는 패킷으로, 자신의 네트워크를 찾기위해 개발되었습니다. 기본목적은 RARP, Bootp, DHCP같은 프로토콜과 같으나 다른 프로토콜을 이용한 방법에 비해 원시적이라고 할 수 있다. 이 방법에서도 위 Timestamp Request 패킷처럼 죽은 시스템은 Reply패킷을 보내지 않을 것입니다.

마지막으로, ICMP Address Mask Request 와 Reply패킷을 이용하는 것입니다. 이 패킷 역시 두번째 방법처럼 단말기가 부팅될 때 자신이 속한 네트워크의 서브넷 마스크를 알기 위해 보냅니다. 앞의 두 방법과 마찬가지로 Reply패킷이 돌아오는지 확인함으로써 상대 시스템의 활성화여부를 파악할 수 있습니다.

ICMP를 이용한 여러가지 ping은 시스템 하나를 조사하기에는 적절하지만 큰 네트워크에서 활성화 시스템을 찾는데는 효과적이지 않습니다.

네트워크 전체에서 활성화 시스템을 찾는 일을 스위핑(sweeping)이라 합니다. 스위핑은 검색하고자 하는 네트워크에 브로드캐스트 ping을 보내거나 자동화도구를 이용하여 특정범위의 네트워크에 ping을 보냅니다.

Intellij를 사용하여 테스트 해보았습니다. 주 언어가 Java인 프로그래머나 개발자라면 String클래스와 관련하여 기본적인 부분을 익혀야 합니다.

String과 관련하여 여러 method를 만들어봤으니 주석을 하나하나 풀어보며 실행시켜서 테스트해보시고 이해하도록 노력해보시기 바랍니다.

/**
 * Created by 진우 on 2016-07-10.
 */
public class MyStringTest {
    public static void main(String[] args) {
        MyStringTest test = new MyStringTest();
        test.constructors();
        //System.out.println(test.nullCheck(null));     //Return -> true
        //System.out.println(test.nullCheck("hello"));  //Return -> false
        //test.compareCheck();                            //Return -> Length of Text, isEmpty of Text
        //test.equalCheck();
        //test.compareToCheck();
        //test.addressCheck();
        //test.matchCheck();
        //test.indexOfCheck();
        //test.lastIndexOfCheck();
        //test.substringCheck1();
        //test.splitCheck();
        //test.trimCheck();
        //test.replaceCheck();
        //test.formatCheck();
    }

    public void constructors() {
        try {
            String src = "대한민국";

            // java파일 기본 encoding
            System.out.println("file encoding : " + System.getProperty("file.encoding"));

            // 기본 encoding의 바이트 배열
            byte[] bytearray = src.getBytes();

            System.out.println();
            System.out.println("기본 encoding 문자열 길이 : "+new String(bytearray).length());
            System.out.println("기본 encoding 바이트 길이 : "+bytearray.length);
            System.out.println("기본 encoding 문자열      : "+new String(bytearray));
            System.out.println();

            // euc-kr encoding의 바이트 배열
            byte[] euckrbyte = src.getBytes("euc-kr");
            System.out.println("euc-kr 문자열 길이 : "+new String(euckrbyte).length());
            System.out.println("euc-kr 바이트 길이 : "+euckrbyte.length);
            System.out.println("euc-kr 문자열 : "+new String(euckrbyte));

            /*
         String::getBytes 는 자바 내부에 관리되는 유니코드 문자열을 인자로 지정된 캐릭터셋의 바이트 배열로 반환하는 메서드이며,
         new String(바이트배열, 캐릭터셋) 생성자는 해당 바이트 배열을 주어진 캐릭터 셋으로 간주 하여 스트링을 만드는 생성자입니다.

         흔히 할 수 있는 실수로, 캐릭터 변환이랍시고 new String(바이트배열, 변환하고싶은 희망사항 캐릭터셋) 을 쓰는 오류가 있을 것입니다.
         자바 내부에서 처리하는 문자열은 일괄적으로 같은 유니코드 형식으로 처리되며,
         이기종 전송 등 필요한 경우에는 getBytes()로 해당 문자열 바이트 배열로 변환 뒤 전송하면 그만일 것입니다.
         다만 예전 구형 웹서버등을 사용한 프로젝트의 경우의 문자열을 원래 캐릭터로 복구하는 코드가 위의 new String 을 쓰는 경우가 있는데,
         이건 웹 서버에서 캐릭터셋을 잘못 해석하여 주는 것을 바로잡는 코드이거나, 비슷한 캐릭터 코드에서 코드로 해석한 것이며, 캐릭터 셋 변환이 아님을 알아둡시다.
         */
            ////////////////////////////////////////
            
            String str = "한글";
            //"한글" 의 str값에 따라서 아래 출력이 바뀜. EUC-KR은 한자에 2Byte씩, UTF-16은 한자에 3Byte씩.

            byte[] array1 = str.getBytes();
            printByteArray(array1);
            String str1 = new String(array1);
            System.out.println(str1);
         
            byte[] array2 = str.getBytes("EUC-KR");
            printByteArray(array2);
            String str2 = new String(array2, "EUC-KR");
            System.out.println(str2);

            byte[] array3 = str.getBytes("UTF-16");
            printByteArray(array3);
            String str3 = new String(array3, "UTF-16");
            System.out.println(str3);
        }
        catch(Exception e) {
            e.printStackTrace();
        }
    }

    public void printByteArray(byte[] array) {
        for(byte data:array) {
            System.out.print(data + " ");
        }
        System.out.println();
    }
    ////////////////////////////////////////////////////////

    public boolean nullCheck(String text) {
        if(text == null)
            return true;
        else
            return false;
    }

    ////////////////////////////////////////////////////////

    public void compareCheck() {
        String txt = "You must know String class";
        System.out.println("Length of Text = " + txt.length());
        System.out.println("isEmpty of Text=" + txt.isEmpty());
    }

    ////////////////////////////////////////////////////////

    public void equalCheck() {
        String text = "Check value";
        //String text2 = "Check value";
        String text2 = new String("Check value");               //새로운 String 객체 생성
        if(text == text2)
            System.out.println("text == text2 result is same.");
        else
            System.out.println("text == text2 result is different.");

        if(text.equals("Check value"))
            System.out.println("text.equals(text2) result is same.");
        else
            System.out.println("text.equals(text2) result is different.");

        String text3 = "check value";
        if(text.equalsIgnoreCase(text3))
            System.out.println("text.equalsIgnoreCase(text3) result is same.");
        else
            System.out.println("text.equalsIgnoreCase(text3) result is different.");
    }

    ////////////////////////////////////////////////////////

    public void compareToCheck() {
        String text="A";
        String text2="B";
        String text3="C";

        System.out.println(text2.compareTo(text));
        System.out.println(text2.compareTo(text3));
        System.out.println(text.compareTo(text3));

      /*
      compareTo 메소드는 정렬할때 사용하게되는데, true, false의 결과가 아니라,
      비교하려는 매개변수로 넘겨준 String 객체가 알파벳순으로 앞에있으면 양수를,
      뒤에있으면 음수를 리턴합니다. 알파벳 순서만큼 그 숫자값은 커지게 됩니다.
      */
    }

    ////////////////////////////////////////////////////////

    public void addressCheck() {
        String addresses[] = new String[] {
                "It is test String Class",
                "why are not you test String",
                "It is very important thing of Class",
        };
        int startCount=0, endCount=0, containCount=0;
        String startText="It";
        String endText="Class";
        String containText="test";

        for(String address:addresses) {
            if(address.startsWith(startText)) {
                startCount++;
            }
            if(address.endsWith(endText)) {
                endCount++;
            }
            if(address.contains(containText)) {
                containCount++;
            }
        }
        System.out.println("Starts with - " + startText + " - count is " + startCount);
        System.out.println("Ends with - " + endText + " - count is " + endCount);
        System.out.println("Contains with - " + containText +  " - count is " + containCount);
    }

    ////////////////////////////////////////////////////////

    public void matchCheck() {
        String text = "This is a text";
        String compare1 = "is";
        String compare2 = "this";
        System.out.println(text.regionMatches(2, compare1, 0, 1));
        //매개변수가 4개인 메소드
        System.out.println(text.regionMatches(5, compare1, 0, 2));
        //매개변수가 4개인 메소드
        System.out.println(text.regionMatches(true, 0, compare2, 0, 4));
        //매개변수가 5개인 메소드

      /*  (regionMatches 메소드 매개변수 설명)
       *
       * ignoreCase : true일 경우 대소문자 구분을 하지 않고, 값을 비교
       * toffset : 비교 대상 문자열의 확인 시작 위치를 지정
       * other : 존재하는지를 확인할 문자열을 의미
       * ooffset : other 객체의 확인 시작 위치를 지정
       * len : 비교할 char의 개수를 지정
       */
    }

    ////////////////////////////////////////////////////////
    //index 위치를 return값으로 받습니다. 없다면 -1
    public void indexOfCheck() {
        String text="Java technology is both a programming language and a platform.";
        System.out.println(text.indexOf('a'));
        System.out.println(text.indexOf("a "));
        System.out.println(text.indexOf('a', 20));
        System.out.println(text.indexOf("a ", 20));
        System.out.println(text.indexOf('z'));
    }

    ////////////////////////////////////////////////////////
    public void lastIndexOfCheck() {
        String text="Java technology is both a programming language and a platform.";
        System.out.println(text.lastIndexOf('a'));
        System.out.println(text.lastIndexOf("a "));
        System.out.println(text.lastIndexOf('a', 20));
        System.out.println(text.lastIndexOf("a ", 20));
        System.out.println(text.lastIndexOf('z'));
    }

    ////////////////////////////////////////////////////////
   /* 문자열의 일부 값을 잘라내는 메소드 : substring */
    public void substringCheck1() {
        String text = "Java technology";
        String technology = text.substring(5);
        System.out.println(technology);
        String tech = text.substring(5,  9);
        System.out.println(tech);
    }

    ////////////////////////////////////////////////////////
   /* 문자열을 여러개의 String배열로 나누는 split 메소드 */
    public void splitCheck() {
        String text = "Java technology is both a programming language and a platform.";
        String[] splitArray=text.split(" ");
        for(String temp:splitArray) {
            System.out.println(temp);
        }
    }
    ////////////////////////////////////////////////////////
   /* 문자열을 합치는 메소드와 공백을 없애는 메소드 : trim */
    public void trimCheck() {
        String strings[] = new String[] {
                " a", " b ", "    c", "d    ", "e   f", "     "
        };
        for(String string:strings) {
            System.out.println("Before = ["+string+"] ");
            System.out.println("After = Trim["+string.trim()+"] ");
        }
    }

////////////////////////////////////////////////////////
   /* 내용을 교체하는 메소드 : replace */
    public void replaceCheck() {
        String text="The String class represents character strings.";
        System.out.println(text.replace('s',  'z'));
        System.out.println(text);
        System.out.println(text.replace("tring",  "trike"));
        System.out.println(text.replaceAll(" ",  "|"));
        System.out.println(text.replaceFirst(" ",  "|"));
    }

    ////////////////////////////////////////////////////////
   /* 특정 형식에 맞춰 값을 치환하는 메소드 : format */
    public void formatCheck() {
        String text = "'My name is %s." + "I'm %d years old, and I'm %f cm.";
        String realText = String.format(text, "Choi jinwoo", 26, 178.5);
        System.out.println(realText);
    }

    ////////////////////////////////////////////////////////

   /* immutable(변경 불가능한)한 String의 단점을 보완하는 클래스에는 StringBuffer와 StringBuilder 가 있습니다.
    * StringBuffer : Thread safe 함.
    * StringBuilder : Thread safe 하지 않음.
    * 속도는 StringBuilder가 더 빠름.
    *
    * (String, StringBuilder, StringBuffer 클래스의 공통점)
    * 모두 문자열을 다룬다, CharSequence 인터페이스를 구현했다.
    *
    *  일반적으로 하나의 메소드 내에서 문자열을 생성하여 더할 경우에는
    *  StringBuilder를 사용해도 전혀 상관 없다.
    *
    *  그러나, 어떤 클래스에 문자열을 생성하여 더하기위한 문자열을 처리하기 위한
    *  인스턴스 변수가 선언되었고, 여러 쓰레드에서 이 변수를 동시에 접근하는 일이
    *  있는 경우에는 반드시 StringBuffer를 사용해야만 한다.
    */
}

DNS에 관한 정보를 얻어오는 툴로는 nslookup, dig 등이 있습니다. 이번엔 가장 일반적인 nslookup을 사용해 보겠습니다. nslookup은 윈도우와 리눅스에 기본으로 설치되어 있습니다.

(* 리눅스를 이용하지 않거나 쓸일이 많이 없는 프로그래머/개발자라도 최소한 기초적인 지식 정도는 갖추고 있는것이 좋다고 생각합니다.)

cmd창을 띄워서 nslookup명령을 실행하면 현재 기본 DNS서버로 설정된 DNS서버와 연결되는 것을 확인할 수 있습니다. bns1.hananet.net은 SK Broadband의 DNS서버입니다. ns(Name Server)는 DNS서버를 가리키는 일반 표현입니다.

여기서, 조사하려는 DNS서버를 바꾸고 싶으면 server xxx.xxx.xxx.xxx 형식으로 입력합니다. (kns.kornet.net은 KT의 DNS서버입니다.)

- 도메인 정보 수집

: 특정 도메인에 관한 정보를 알고 싶을 때에는 아래와 같이 해당 도메인 이름을 입력합니다.

> www.google.com

이제, 이 DNS서버에는 어떤 ns가 있는지 확인하는 방법에는 어떤 것이 있는지 살펴보겠습니다.

검색하고자 하는 서버의 종류를 설정할 때는 set type 명령을 이용합니다.

set type=ns 라고 입력한 뒤, 검색하고자 하는 도메인을 입력합니다. google.com에 대해 검색한 결과 ns 서버 4개가 같은 IP주소로 운영됨을 알 수 있습니다.

set type명령으로 출력되는 DNS정보를 DNS레코드라고 하고, set type명령으로 확인할 수 있는 DNS의 레코드는 아래 표와 같습니다.

Whois는 도메인에 관한 정보확인을 위해 유용하게 쓰입니다. Whois서버에서 얻을 수 있는 정보는 대표적으로 아래와 같은 것들이 있습니다.

- 등록, 관리 기관

- 도메인 이름, 도메인 관련 인터넷 자원 정보

- 목표 사이트 네트워크 주소와 IP주소

- 등록자, 관리자, 기술 관리자의 이름 및 연락처, 이메일 계정

- 레코드 생성 시기와 갱신 시기

- 주 DNS 서버와 보조 DNS서버

- IP주소의 할당 지역 위치

도메인을 통해 IP를 알아보고, 프로그래머는 그 IP를 WHOIS서버에 검색해서 아래의 그림과 같은 정보들을 얻을 수 있습니다. 저는 대표적으로 네이버와 구글에 ping을 보내어 IP를 알아본 후 검색해 본 결과로 아래와 같습니다.

먼저 윈도우사용자라면 cmd창을 이용하여 cmd를 실행시키고, 

다음과 같이 ping을 보내면, 응답을 통해 IP를 알아볼 수 있습니다. 네이버도 동일한 방법으로 해줍시다.

그리고 Whois서버는 우리나라에서는 대표적으로 KISA에서 서비스를 제공하고 있고 그 밖의 arin이라는 곳도 있습니다.

1) https://www.arin.net/

위의 URL에 접속하면 아래와 같이 Whois서버로 IP를 검색할 수 있습니다. 여기서 위의 cmd에서 얻은 IP를 입력하여 검색합니다.

해당 IP에 대한 정보를 얻을 수 있습니다.

(* 또한, IP를 알아보지 않고 검색창에 google 만 입력하여 쿼리를 전송하게 되면 아래와 같이 구글 사이트에 대한 여러 네트워크와 서버를 확인할 수 있습니다.)

2) http://whois.nic.or.kr/kor/ 

이번에는 네이버에 대한 IP를 통해 정보를 얻어보았습니다.

지역별 Whois서버 목록은 아래 표와 같이 정리해보았습니다.

Java에 입문하는 초보 프로그래머/개발자를 위하여 이번엔 지난번 Socket을 이용한 서버/클라이언트에 이어 DatagramSocket을 이용한 UDP 서버/클라이언트에 대한 부분을 다뤄보려 합니다.

[MyDatagramServer.java]

import java.net.DatagramPacket;
import java.net.DatagramSocket;

/**
 * Created by 진우 on 2016-07-09.
 */
public class MyDatagramServer {
    public static void main(String[] args) {
        MyDatagramServer serv = new MyDatagramServer();
        serv.startDatagramServer();
    }

    public void startDatagramServer() {
        DatagramSocket sockserv = null;
        try {
            sockserv = new DatagramSocket(9629);
            int bufferLength = 256;
            byte[] buffer = new byte[bufferLength];
            DatagramPacket packet = new DatagramPacket(buffer, bufferLength);

            while(true) {
                System.out.println("Server: Waiting for request");
                sockserv.receive(packet);
                int dataLength = packet.getLength();
                System.out.println("Server: received. Data Length="+dataLength);

                String data = new String(packet.getData(), 0, dataLength);
                System.out.println("Received data:"+data);
                if(data.equals("End of Test")) {
                    System.out.println("Stop Datagram Server");
                    break;
                }
                System.out.println("---------");
            }
        } catch(Exception e) {
            e.printStackTrace();
        } finally {
            if(sockserv != null) {
                try {
                    sockserv.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 서버에서는 Client를 Listen할 포트를 9629로 지정합니다. 그리고 DatagramPacket을 생성하여 데이터를 주고받게 됩니다. 전체적인 구조는 지난번의 Socket을 이용하는 구조와 유사합니다. receive() 메소드를 이용하여 패킷을 받을 때까지 대기하게 됩니다.

[MyDatagramClient.java]

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/**
 * Created by 진우 on 2016-07-09.
 */
public class MyDatagramClient {
    public static void main(String[] args) {
        MyDatagramClient cli = new MyDatagramClient();
        cli.sendDatagram();
    }

    public void sendDatagram() {
        for(int loop = 1; loop <= 5; loop++) {
            sendDatagramData("Just Test Client - Server (" + loop + ")");
        }
        sendDatagramData("End of Test");
    }

    public void sendDatagramData(String data) {
        try {
            DatagramSocket sockcli = new DatagramSocket();
            InetAddress addr = InetAddress.getByName("127.0.0.1");
            byte[] buffer = data.getBytes();

            DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length, addr, 9629);
            sockcli.send(packet);
            System.out.println("Client:Sent data!");
            sockcli.close();
            Thread.sleep(1000);
        } catch(Exception e) {
            e.printStackTrace();
        }
    }
}

 Client에서는 DatagramSocket을 생성하고, 패킷을 통해 해당되는 IP와 PORT로 패킷을 send() 메소드를 통하여 전송하게 됩니다.