지난 File Test에 이어서 path와 file에 대해 이것저것 Check해보는 메소드들을 사용해보았습니다.


/**
* Created by 진우 on 2016-07-19.
*/
public class MyFileTest {
public static void main(String[] args) {
MyFileTest fileTest = new MyFileTest();

String path = "C:\\";
// String path = "C:\\sirius.txt";
fileTest.checkPath(path);

String fileName = "jinwoo.txt";
fileTest.checkFile(path, fileName);
fileTest.checkList(path);
}

public void checkPath(String path) {
File file = new File(path);
System.out.println(path + "is exists?" + file.exists());

System.out.println("Make " + path + " Result => " + file.mkdir());
System.out.println(path + "is Directory? => " + file.isDirectory());
System.out.println(path + "is File? => " + file.isFile());
System.out.println(path + "is hidden? => " + file.isHidden());

System.out.println(path + "can Read? => " + file.canRead());
System.out.println(path + "can Write? => " + file.canWrite());
System.out.println(path + "can Execute? => " + file.canExecute());

System.out.println(path + " last modified => " + file.lastModified());
System.out.println(path + " last modified => " + new Date(file.lastModified()));
System.out.println("Delete " + path + " result => " + file.delete());
}

public void checkFile(String path, String fileName) {
File file = new File(path, fileName);
try {
System.out.println("Create Result => " + file.createNewFile());
System.out.println("Absolute Path => " + file.getAbsolutePath());
System.out.println("Absolute File => " + file.getAbsoluteFile());
System.out.println("Canonical Path => " + file.getCanonicalPath());
System.out.println("Canonical File => " + file.getCanonicalFile());

System.out.println("Name => " + file.getName());
System.out.println("Path => " + file.getPath());
} catch (IOException ioe) {
ioe.printStackTrace();
}
}
}


결과 창)

참고로, C 디렉토리는 권한이 필요하기 때문에 Make Result와 Delete는 false가 되었습니다. 

(코드 내부에서 Delete는 조심해서 사용하시기 바랍니다. FileName을 중요한 파일로 테스트하시면 날릴수도 있습니다.)


WRITTEN BY
SiriusJ

,

Java로 개발 시에 File을 열고 쓰는 등의 기초 작업에 대하여 다뤄보겠습니다.


/**
* Created by 진우 on 2016-07-19.
*/
public class MyManageTextFile {
public static void main(String[] args) {
MyManageTextFile managerTest = new MyManageTextFile();
int count = 10;

String path = "C:\\" + separator + "jinwoo.txt";
//managerTest.writeFile(path, numberCount);
managerTest.readFile(path);
System.out.println();
managerTest.readFileScanner(path);
}

public void writeFile(String fileName, int count) {
FileWriter fw = null;
BufferedWriter bw = null;

try {
fw = new FileWriter(fileName);
bw = new BufferedWriter(fw);

for(int loop=0; loop<=count; loop++) {
bw.write(Integer.toString(loop));
bw.newLine();
}
System.out.println("Write Success!");
} catch(IOException ioe) {
ioe.printStackTrace();
} catch(Exception e) {
e.printStackTrace();
} finally {
if(bw != null) {
try {
bw.close();
} catch(IOException ioe) {
ioe.printStackTrace();
}
}
if(fw != null) {
try {
fw.close();
} catch (IOException ioe) {
ioe.printStackTrace();
}
}
}
}

public void readFile(String fileName) {
FileReader fr = null;
BufferedReader br = null;

try {
fr = new FileReader(fileName);
br = new BufferedReader(fr);
String data;
while((data = br.readLine()) != null) {
System.out.println(data);
}
System.out.println("Read Success!");
} catch (IOException ioe) {
ioe.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
} finally {
if(br != null) {
try {
br.close();
} catch (IOException ioe) {
ioe.printStackTrace();
}
}
if(fr != null) {
try {
fr.close();
} catch (IOException ioe) {
ioe.printStackTrace();
}
}
}
}

public void readFileScanner(String fileName) {
File file = new File(fileName);
Scanner sc = null;
try {
sc = new Scanner(file);
while(sc.hasNextLine()) {
System.out.println(sc.nextLine());
}
System.out.println("Read Scanner Success!");
} catch (FileNotFoundException fe) {
fe.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
} finally {
if(sc != null) {
sc.close();
}
}
}
}



WRITTEN BY
SiriusJ

,

이어온 Collection 포스팅에서 이제 마지막, Set에 대한 부분입니다.

다른 List, Queue, Map과 같은 collection들과 함께 마지막으로 Set을 살펴봅시다.


/*
* java.util패키지에 Collection이라는 인터페이스가 있는데, List, Set, Queue가 이 인터페이스를 구현한 것이다.
* 보통은 List, Set, Queue, Map이라는 네 가지 자료구조를 사용한다.
* Set은 중복되는 데이터를 허용하지 않는다. 즉, 중복되는 데이터는 하나만 뽑는다.
*/
/**
* Created by 진우 on 2016-07-17.
*/
public class MySetTest {
public static void main(String[] args) {
MySetTest test = new MySetTest();

String[] fruits = new String[]{
"Apple", "Banana", "Orange",
"Grapefruit", "Pineapple", "Mango",
"Watermelon", "Melon", "Strawberry",
"Orange", "Blueberry", "Lemon",
"Apple"
};
System.out.println(test.getFruits(fruits));
}

public int getFruits(String[] fruits) {
if(fruits == null) return 0;
if(fruits.length == 1) return 1;
HashSet<String> fruitsSet = new HashSet<String>();
for(String fruit:fruits) {
fruitsSet.add(fruit);
}
showFruitSet(fruitsSet); //Same function with showFruitSet2
//showFruitSet2(fruitsSet); //Same function with showFruitSet
return fruitsSet.size();
}
//////////////////////////////////////////////////////
public void showFruitSet(HashSet<String> fruitSet) {
for(String tmp : fruitSet) {
System.out.print(tmp + " ");
}
System.out.println();
}

public void showFruitSet2(HashSet<String> fruitSet) {
Iterator<String> iter = fruitSet.iterator();
while(iter.hasNext()) {
System.out.print(iter.next()+" ");
}
System.out.println();
}
}



WRITTEN BY
SiriusJ

,

이전에 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);
}
}



WRITTEN BY
SiriusJ

,

지난 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();
}
}
}



WRITTEN BY
SiriusJ

,

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());
}
}
}



WRITTEN BY
SiriusJ

,

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를 사용해야만 한다.
*/
}



WRITTEN BY
SiriusJ

,

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() 메소드를 통하여 전송하게 됩니다.


WRITTEN BY
SiriusJ

,