SG Dev

이번 예제에서는 ByteArrayInputStream 클래스에 대하여 알아 보겠습니다. ByteArrayInputStream 클래스는 스트림으로 부터 읽은 바이트를 내부 버퍼에 보관 유지합니다. 그리고 내부 카운터에 의해 read() 메소드로 읽혀지는 바이트를 추적합니다.

ByteArrayInputStream 클래스는 바이트 입력 스트림을 표현하는 모든 클래스의 슈퍼 클래스인 추상 클래스 InputStream 을 확장(extends) 합니다.

ByteArrayInputStream 클래스는 JDK 1.0 부터 존재 했습니다.

ByteArrayInputStream 클래스의 구조

생성자

• ByteArrayInputStream(byte[] buf)

- 인자로 넘어온 buf 바이트 배열을 사용하는 ByteArrayInputStream 인스턴스를 생성합니다.

• ByteArrayInputStream(byte[] buf, int offset, int length)

- 인자로 넘어온 buf 바이트 배열을 사용하는 ByteArrayInputStream 인스턴스를 생상하며 인스턴스 초기화시 내부 필드인 pos 는 인자값중 offset 을 할당하고 초기화시 내부 필드인 count 는 offset + length 와 인자값인 buf 의 크기중 최소값으로 설정 됩니다. 버퍼 배열은 복사되지 않습니다. 버퍼의 마크는 지정된 offset 으로 설정됩니다.

ByteArrayInputStream read() 예제

간단한 기본 사용법을 보여주는 예제를 보겠습니다.

package kr.co.leehana.example.bytearrayinputstream;

import java.io.ByteArrayInputStream;
import java.util.Random;

public class ByteArrayInputStreamSimpleExample1 {

	public static void main(String[] args) {
		byte[] buffer = new byte[10];
		Random rnd = new Random();

		for (int i = 0; i < buffer.length; i++) {
			buffer[i] = (byte) rnd.nextInt();
		}

		ByteArrayInputStream b = new ByteArrayInputStream(buffer);

		System.out.println("All the elements in the buffer:");

		int num;
		while ((num = b.read()) != -1) {
			System.out.print(num + " ");
		}
	}
}

위 예제에서 Random 클래스를 이용하여 임의의 숫자를 생성하고 이것을 이용하여 byte 배열을 생성하였습니다. ByteArrayInputStream 클래스에 앞에서 만든 byte 배열을 인자값으로 넘겨 인스턴스를 생성하였습니다. 그리고 난 후 모든 버퍼로부터 숫자들을 read() 메소드를 이용하여 출력하였습니다.

참고로 확인할 내용은 close() 메소드를 호출 하지 않았다는 것입니다. 이것은 close() 메소드를 호출해도 아무일도 일어나지 않기 때문입니다.

ByteArrayInputStream read(byte[]b, int off, int len) 예제

위의 예제에서는 read() 메소드를 이용하여 출력을 하였습니다. 그러나 같은 이름으로 된 인자값만 다른 read(byte[] b, int off, int len) 메소드가 존재합니다. 이 메소드는 off 로부터 len 만큼 바이트 배열로부터 읽습니다.

예제를 살펴 보겠습니다.

package kr.co.leehana.example.bytearrayinputstream;

import java.io.ByteArrayInputStream;

public class ByteArrayInputStreamSimpleExample2 {

	public static void main(String[] args) {
		byte[] buf = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
		ByteArrayInputStream b = new ByteArrayInputStream(buf);

		byte[] newBuffer = new byte[6];
		int num = b.read(newBuffer, 2, 4);

		System.out.println("Bytes read: " + num);

		for (int i = 0; i < newBuffer.length; i++) {
			int nr = (int) newBuffer[i];
			if (newBuffer[i] == 0)
				System.out.print("-null- ");
			else
				System.out.print(nr + " ");
		}
	}
}

위 예제에서 b.read(newBuffer, 2, 4) 를 썻습니다. 이 메소드를 호출할때 넘긴 인자값들은 ByteArrayInputStream 의 인스턴스인 b 로부터 4개의 요소로를 읽어 새로운 바이트 배열인 newBuffer 에 2번째(off) 인덱스부터 4개의(len) 요소를 읽어 대입합니다. 이렇게 해서 newBuffer 바이트 배열의 첫번째와 두번째에 왜 null 값이 들어가는지를 알수 있습니다.

예제를 실행하면 아래와 같은 결과가 출력됩니다.

Bytes read: 4
-null- -null- 1 2 3 4

ByteArrayInputStream 사용자 입력 예제

아래의 예제는 사용자로 부터 입력을 받아 대문자로 출력하는 간단한 예제 입니다.

package kr.co.leehana.example.bytearrayinputstream;

import java.io.ByteArrayInputStream;
import java.util.Scanner;

public class ByteArrayInputStreamCapitalizerExample {

	public static void main(String[] args) {
		Scanner stdIn = new Scanner(System.in);

		System.out.print("Enter a string: ");
		String message = stdIn.nextLine();
		StringBuilder sb = new StringBuilder();

		ByteArrayInputStream str = new ByteArrayInputStream(message.getBytes());

		int ch;
		while ((ch = str.read()) != -1) {
			sb.append(Character.toUpperCase((char) ch));
		}
		System.out.println("Your capitalized message: " + sb.toString());
	}
}

위 예제는 입력받은 문자열로 부터 byte 배열을 가지고와서 ByteArrayInputStream 인스턴스를 이용해 모든 byte 를 출력합니다.

예제를 실행하면 아래와 같은 결과가 출력됩니다.

Enter a string: Hello World Java Code Geeks!
Your capitalized message: HELLO WORLD JAVA CODE GEEKS!

예제 소스

• github.com

출처

• JavaCodeGeeks.com

이번 예제에서는 BufferedInputStream 클래스에 대해 알아보겠습니다. BufferedInputStream 클래스는 입력을 버퍼에 추가 하는 기능과 mark() 메소드와 reset() 메소드가 추가 되어있습니다.

BufferedInputStream 클래스는 InputStream 클래스의 모든 메소드를 오버라이드 하는 FilterInputStream 클래스를 확장합니다.

BufferedInputStream 클래스는 JDK 1.0 부터 존재 해왔습니다.

BufferedInputStream 클래스의 생성자 기본 구조

생성자

• BufferedInputStream(InputStream in)

- 인자값으로 넘어온 입력 스트림을 나중에 사용하기 위해 저장하는 BufferedInputStream 인스턴스를 만듭니다.

• BufferedInputStream(InputStream in, int size)

- 지정된 크기를 가지는 BufferedInputStream 인스턴스를 만들어 인자로 넘어온 입력 스트림을 나중에 사용하기 위해 저장합니다.

BufferedInputStream 간단 예제

BufferedInputStream 클래스의 기본 사용법을 보여줍니다.

package kr.co.leehana.example.bufferedinputstream;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class BufferedInputStreamSimpleExample {

	public static void main(String[] args) {
		BufferedInputStream input = null;
		try {
			input = new BufferedInputStream(new FileInputStream("test.txt"));
			StringBuilder sb = new StringBuilder();
			while (input.available() > 0) {
				sb.append((char) input.read());
			}

			System.out.println("read this :");
			System.out.println(sb.toString());
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (input != null) {
				try {
					input.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

이 예제에서는 텍스트 파일을 읽어 파일안에 있는 텍스트를 콘솔에 출력 합니다. 파일의 내용을 읽기 위해 입력 스트림으로 FileInputStream 클래스를 이용하여 BufferedInputStream 인스턴스를 생성하였습니다. 그리고 StringBuilder 클래스에 char 형의 데이터 타입으로 추가 해주고 마지막에 스트링타입으로 출력 하였습니다.

마지막에는 잊지말고 BufferedInputStream 인스턴스를 close() 메소드를 호출하여 닫아 주어야 합니다.

BufferedInputStream 추가 예제

이번 예제는 web 서비스로부터 응답된 내용을 출력하는 것을 보여드립니다. 이 예제를 위해 간단한 HttpClient 클래스를 먼저 만들겠습니다.

package kr.co.leehana.example.bufferedinputstream;

import java.io.BufferedInputStream;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;

public class SimpleHttpClient {

	private URL baseurl;

	public SimpleHttpClient(String baseurl) throws MalformedURLException {
		this.baseurl = new URL(baseurl);
	}

	public SimpleHttpClient(URL url) {
		this.baseurl = url;
	}

	public String get(String route) throws IOException {
		StringBuilder sb = new StringBuilder();
		String base = this.baseurl.getHost();
		URL u = new URL("http://" + base + route);
		URLConnection conn = u.openConnection();
		BufferedInputStream in = new BufferedInputStream(conn.getInputStream());

		while (in.available() > 0) {
			sb.append((char) in.read());
		}

		return sb.toString();
	}
}

위 클래스는 간단한 HTTP 클라이언트 입니다. get() 메소드를 호출 하여 웹서비스로 부터 결과를 스트링 타입으로 반환합니다.

아래는 HTTP 클라이언트 클래스를 이용하는 예제 입니다.

package kr.co.leehana.example.bufferedinputstream;

import java.io.IOException;

public class BufferedInputStreamWebExample {

	public static void main(String[] args) {
		try {
			SimpleHttpClient client = new SimpleHttpClient("http://httpbin.org");
			String myIp = client.get("/ip");
			System.out.println(myIp);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

예제에서는 간단한 웹서비스인 http://httpbin.org/ 사이트를 이용하였습니다. HTTP client 의 get() 메소드를 호출하게되면 현재 내 컴퓨터의 IP 주소를 JSON 타입으로 반환을 받게 됩니다. 이렇게 반환된 문자열은 JSON 을 다룰 수 있는 어떤 라이브러리든 이용하여 활용 할 수 있을것입니다.

{
  "origin": "223.62.190.39"
}

BufferedInputStream 추가 정보

BufferedInputStream 클래스는 인스턴스가 만들어질때 내부에 버퍼링 배열을 만듭니다. 스트림의 바이트가 입력되면 스트림으로부터 필요에 따라 한번에 다수의 바이트가 내부 버퍼에 추가 됩니다. 그리고 mark() 메소드는 입력 스트림의 특정 위치를 기억합니다. reset() 메소드는 입력 스트림의 마지막 mark 된 위치로 재설정 됩니다.

예제

• github.com

출처

• JavaCodeGeeks.com

이번 예제에서는 java.util.List 인터페이스에 있는 두가지 메소드인 E remove(int index) 와 boolean remove(Object o) 에 대해 알아 보겠습니다. 

• E remove(int index)

- list 내의 지정된 인덱스 위치에 있는 object 를 제거합니다.

• boolean remove(Object o)

- 지정된 object 가 list 내에 존재하면 존재하는 첫번째 항목을 제거합니다.

- 이 메소드는 list 내에 존재하는 object 들과 equals() 메소드로 비교하여 제거 합니다.

두가지 메소드에 대한 예제를 살펴보겠습니다.

먼저 두 예제에서 공통으로 사용할 User 클래스 입니다.

User 클래스

package kr.co.leehana.example.listremove;

public class User {
	private String firstname;
	private String lastname;

	public User(String firstname, String lastname) {
		this.firstname = firstname;
		this.lastname = lastname;
	}

	@Override
	public String toString() {
		return "User [firstname=" + firstname + ", lastname=" + lastname + "]";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result
				+ ((firstname == null) ? 0 : firstname.hashCode());
		result = prime * result
				+ ((lastname == null) ? 0 : lastname.hashCode());
		return result;
	}

	// firstname 과 lastname 이 같을때에만 동일하다고 판단.
	// 이클립스에서 자동으로 생성해주는 방법을 사용.
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		User other = (User) obj;
		if (firstname == null) {
			if (other.firstname != null)
				return false;
		} else if (!firstname.equals(other.firstname))
			return false;
		if (lastname == null) {
			if (other.lastname != null)
				return false;
		} else if (!lastname.equals(other.lastname))
			return false;
		return true;
	}
}

E remove(int index)

package kr.co.leehana.example.listremove;

import java.util.ArrayList;
import java.util.List;

public class ListRemoveIndexExample {

	public static void main(String[] args) {
		List strList = new ArrayList();
		strList.add("one");
		strList.add("two");
		strList.add("three");

		for (String str : strList)
			System.out.println(str);

		strList.remove(1); // two 제거
		System.out.println("## String 리스트에서 1번째 인덱스의 object 를 제거 한 뒤 ###");

		for (String str : strList)
			System.out.println(str);
		
		System.out.println();

		List userList = new ArrayList();
		userList.add(new User("Tom", "Hawk"));
		userList.add(new User("홍", "길동"));
		userList.add(new User("Michael", "Jordan"));

		for (User user : userList)
			System.out.println(user);

		userList.remove(0);

		System.out.println("### User 리스트로부터 0번째 인덱스의 object 를 제거 한 뒤 ###");
		for (User user : userList)
			System.out.println(user);
	}
}

boolean remove(Object o)

package kr.co.leehana.example.listremove;

import java.util.ArrayList;
import java.util.List;

public class ListRemoveObjectExample {

	public static void main(String[] args) {
		List strList = new ArrayList();
		strList.add("one");
		strList.add("two");
		strList.add("three");

		for (String str : strList)
			System.out.println(str);

		strList.remove("two"); // two 제거
		System.out.println("## String 리스트에서 two object 를 제거 한 뒤 ###");

		for (String str : strList)
			System.out.println(str);

		System.out.println();

		List userList = new ArrayList();
		userList.add(new User("Tom", "Hawk"));
		userList.add(new User("홍", "길동"));
		userList.add(new User("Michael", "Jordan"));

		for (User user : userList)
			System.out.println(user);

		userList.remove(new User("홍", "길동"));

		System.out.println("### User 리스트로부터 홍길동 object 를 제거 한 뒤 ###");
		for (User user : userList)
			System.out.println(user);

	}
}

위 예제에서는 User object 를 ArrayList 에 넘겨 해당하는 object 를 삭제 하였습니다. 이 예제에서 주목해야 할 중요한 점은 List 의 remove(Object o) 메소드가 제대로 동작하게 만들기 위해 User 클래스에서 equals() 메소드를 오버라이드 했다는 점입니다.

예제

• github.com

출처

• JavaCodeGeeks.com

자바에있는 System 클래스에 대한 간단한 예제를 몇가지 살펴 보겠습니다. 이 System 클래스는 유용한 필드들을 포함하고 있는데, 표준입력, 표준출력, 표준에러 스트림입니다. System 클래스는 final 로 선언되어 있어서 클래스를 인스턴스화 할 수 없습니다.

또한 System 클래스는 많은 수의 메소드들을 포함하고 있으며 그것들을 이용하여 외부에서 정의된 프로퍼티들이나 환경변수, 파일들과 라이브러리들을 읽거나 할 수 있습니다. 또한 System 클래스는 다른 배열로 배열의 일부를 복사하는 간단한 메소드가 포함되어 있습니다.

System 클래스는 JDK 1.0 부터 포함되어 있었습니다.

System 필드들

• System.in

        - 표준 입력 스트림

• System.out

        - 표준 출력 스트림

• System.err

        - 표준 오류 스트림

• 참조 : 위의 세가지 스트림들은 이미 열려 있으며 데이터에 접근할 준비가 되어있습니다.

Read line example

package kr.co.leehana.example.system;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class ReadLineExample {

	public static void main(String[] args) throws IOException {
		BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
		
		// 표준 입력 스트림으로부터 라인을 읽습니다.
		String inputLine = reader.readLine();
		
		StringBuilder builder = new StringBuilder(inputLine);
		builder.reverse(); // 입력된 라인을 역으로 정렬
		
		System.out.println("Input string : " + inputLine);
		System.out.println("Reversed string : " + builder.toString());
		System.err.println("Reversed string : " + builder.toString());
		
		reader.close(); // 열려 있는 스트림 닫기
	}
}

위의 예제에서 우리는 표준 입력 스트림으로 부터 완료된 라인을 읽을것 입니다. 그리고 읽어 들인 라인을 역으로 정렬(reversed)하여 표준 출력과 표준 오류 스트림을 이용하여 쓰는 것을 보여줍니다. 예제가 실행 되고 나면 아래와 같은 결과가 출력 됩니다.

Input string : Hello from Java Code Geeks!
Reversed string : !skeeG edoC avaJ morf olloH
Reversed string : !skeeG edoC avaJ morf olloH

Array copy

System 클래스는 현재 배열의 일부를 다른 배열로 복사 할 수 있는 메소드를 제공합니다. 그 메소드의 정의는 다음과 같습니다.

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

각각의 인자들

• src : 원본 배열
• srcPos : 원본 배열에서 복사가 시작 될 위치
• dest : 복사의 대상이 될 배열
• destPos : 복사의 대상이 될 배열에 복사를 할 위치
• length : 복사가 될 요소의 갯수

예제를 보겠습니다.

package kr.co.leehana.example.system;

public class ArrayCopyExample {
	
	private final static int TOTAL_ELEMENTS = 10;

	public static void main(String[] args) {
		int[] src = new int[TOTAL_ELEMENTS];
		
		for (int i = 0; i < TOTAL_ELEMENTS; i++)
			src[i] = i + 1;
		
		System.out.print("Source array : ");
		for (int i = 0; i < TOTAL_ELEMENTS; i++)
			System.out.print(src[i] + " ");
		System.out.println();
		
		int destSize = src.length / 2;
		int[] dest = new int[destSize];
		System.arraycopy(src, 0, dest, 0, destSize);
		
		System.out.print("Destination array : ");
		for (int i = 0; i < destSize; i++)
			System.out.print(dest[i] + " ");
		System.out.println();
	}
}

위 예제에서 우리는 원본 배열의 절반을 대상 배열에 복사를 하였습니다. 예제를 실행하면 아래와 같은 결과 출력 됩니다.

Source array : 1 2 3 4 5 6 7 8 9 10
Destination array : 1 2 3 4 5

System Properties

System 클래스는 private 인스턴스로 Properties 클래스를 포함하고 있으며, 현재 동작중인 환경에 대한 구성을 제공합니다.

• 참조 : 중요한 시스템 프로퍼티들은 여기에서 확인 해볼수 있습니다.

아래의 예제를 통해 몇가지 시스템 프로퍼티들을 콘솔에 출력 해보겠습니다.

package kr.co.leehana.example.system;

public class SystemPropertiesExample {

	public static void main(String[] args) {
		// 현재 시스템의 자바 버전을 출력합니다.
		System.out.println("Java version: "
				+ System.getProperty("java.version"));

		// 현재 시스템의 OS 버전을 확인 합니다.
		System.out.println("OS version: " + System.getProperty("os.version"));

		// 현재 유저의 홈디렉토리를 출력 합니다.
		System.out
				.println("Home directory: " + System.getProperty("user.home"));
	}
}

예제를 실행하면 아래와 같은 출력을 볼 수 있으며, 이 출력된 내용은 플랫폼에 따라 달라질 수 있습니다.

Java version: 1.6.0_65
OS version: 10.9.5
Home directory: /Users/voyaging

Environmental variables (환경 변수들)

또한 System 클래스는 환경변수를 읽을 수 있는 getenv() 메소드를 제공하며, 모든 환경 변수를 Map 클래스로 반환합니다.

예제를 통해 확인 해보겠습니다.

package kr.co.leehana.example.system;

import java.util.Map;

public class EnvironmentalVariablesExample {
	public static void main(String[] args) {
		Map<String, String> vars = System.getenv();

		// 모든 환경 변수를 출력합니다.
		for (String key : vars.keySet())
			System.out.println("Key: " + key + ", Value: " + vars.get(key));
	}
}

예제를 실행하면 아래와 같은 출력을 볼 수 있으며, 이 출력된 내용은 플랫폼에 따라 달라질 수 있습니다.

Key: APP_ICON_20159, Value: ../Resources/sts.icns
Key: SHELL, Value: /bin/bash
Key: TMPDIR, Value: /var/folders/6p/cx6thx5n3wj7p_698lk7jy_w0000gn/T/
Key: com.apple.java.jvmMode, Value: client
(중략)
Key: JAVA_MAIN_CLASS_22572, Value: kr.co.leehana.example.system.EnvironmentalVariablesExample

Current Time (현재시간)

System 클래스는 간단한 currentTimeMillis() 메소드를 제공하고 있으며, 현재의 시간을 밀리세컨드로 반환합니다. 이 메소드에 의해 반환되는 값은 현재 시간에서 1970년 1월 1일 자정 UTC 의 시간을 뺀 값입니다.

예제는 아래와 같습니다.

package kr.co.leehana.example.system;

public class CurrentTimeMillisExample {

	public static void main(String[] args) {
		System.out.println("The current time in milliseconds : "
				+ System.currentTimeMillis());
	}
}

예제

• github.com 

출처

• JavaCodeGeeks.com

이번 예제는 BufferedOutputStream 클래스에 대한 예제 입니다. 이 클래스는 버퍼링된 출력 스트림을 구현합니다. 이렇게 출력 스트림을 설정하게 되면 어플리케이션에서는 각각의 바이트를 쓰기 위해 시스템을 호출 하지 않고 여러개의 바이트를 기본이 되는 출력 스트림에 작성 할 수 있습니다.

BufferedOutputStream 클래스는 FilterOutputStream 클래스를 확장하였으며 FilterOutputStream 은 출력 스트림을 필터 처리 하는 모든 클래스의 상위 클래스입니다. 이러한 스트림은 기본적인 데이터의 sink 로 사용하기 위한 기존에 이미 존재하는 출력 스트림 (기본이 되는 출력 스트림)의 최상위에 있습니다. 다만, 데이터를 도중에 변경하는것이나 추가 기능을 제공하는 경우도 있습니다.

BufferedOutputStream 클래스는 JDK 1.0 부터 도입 되었습니다.

BufferedOutputStream 클래스의 기본 구조.

생성자

• BufferedOutputStream(OutputStream out)

            - 기본이 되는 출력 스트림에 데이터를 작성 하기 위한 버퍼링 된 출력 스트림을 생성합니다. 

• BufferedOutputStream(OutputStream out, int size)

            - 기본이 되는 출력 스트림에 데이터를 작성 하기 위한 버퍼링 된 출력 스트림을 지정된 버퍼 사이즈로 생성합니다.

BufferedOutputStream 예제-1

다음 소스를 통해 어떻게 BufferedOutputStream 클래스를 이용하여 파일을 작성하는지 살펴 보겠습니다.

package kr.co.leehana.example.bufferedoutputstream;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedOutputStreamBasicExample {

	public static void main(String[] args) {
		BufferedOutputStream stream = null;
		try {
			stream = new BufferedOutputStream(new FileOutputStream("out.txt"));
			stream.write("Hello, World!".getBytes());
			stream.write(System.getProperty("line.separator").getBytes());
			stream.write("I am writting into a file using BufferedOutputStream"
					.getBytes());
			stream.write(System.getProperty("line.separator").getBytes());
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (stream != null) {
				try {
					stream.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

BufferedOutputStream 클래스에는 두개의 write() 메소드가 존재 합니다.

• write(byte[] b, int off, int len)

• write(int b)

위 예제에서는 write(byte[] b) 를 사용하였는데 이것은 상위 클래스인 FilterOutputStream 클래스의 메소드 입니다. 또한 위 예제에서 사용한 write() 메소드는 바이트배열을 인자로 받기 때문에 getByte() 메소드를 강제로 호출 하였습니다.

항상 기억해야 하는것은 BufferedOutputStream 인스턴스의 사용이 끝났을 때 혹은 더이상 작성할 내용이 없을 때에는 close() 메소드를 호출해야 한다는것입니다.

BufferedOutputStream 예제-2

이번에는 BufferedOutputStream 클래스를 이용하여 파일에 로깅을 기록하는 예제를 살펴 보겠습니다.

먼저 Logger 클래스를 작성합니다.

package kr.co.leehana.example.bufferedoutputstream;

import java.io.FileNotFoundException;
import java.io.IOException;

public class BufferedOutputStreamLoggingExample {

	public static void main(String[] args) {
		Logger logger = null;
		try {
			logger = new Logger("out.log");
			logger.log("Log message 1");
			logger.log("Log message 2");
		} catch (FileNotFoundException ex) {
			ex.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (logger != null) {
				try {
					logger.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

다음은 위 Logger 클래스를 테스트 하기 위해 main 메소드가 포함된 테스트 클래스를 살펴 보겠습니다.

package kr.co.leehana.example.bufferedoutputstream;

import java.io.FileNotFoundException;
import java.io.IOException;

public class BufferedOutputStreamLoggingExample {

	public static void main(String[] args) {
		Logger logger = null;
		try {
			logger = new Logger("out.log");
			logger.log("Log message 1");
			logger.log("Log message 2");
		} catch (FileNotFoundException ex) {
			ex.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (logger != null) {
				try {
					logger.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

출력된 파일을 열어보면 두줄로 쓰여진 로깅 내용을 확인 할 수 있을 것입니다.

BufferedOutputStream 에 대한 추가 내용

BufferedOutputStream 클래스는 직접적으로 출력 스트림에 쓰지 않습니다. 당연하겠지만 이 클래스는 더 나은 성능으로 스트림에 쓰기 위해 버퍼에 먼저 쓰게 됩니다. 한가지 기억할 것은 버퍼의 크기를 생성자에 넘겨 줄 수 있다는것입니다. 만약 아무값도 넘기지 않으면 기본값(8192)으로 설정됩니다. close() 메소드를 호출하면 버퍼의 내용을 스트림에 쓰게 됩니다. 이것을 확인 하기 위해close() 메소드를 호출 하지 않으면 파일에는 아무것도 쓰지 않게 됩니다.

만약 스트림을 닫지 않고 버퍼의 내용을 파일에 쓰고 싶을때에는 flush() 메소드를 호출 하면 됩니다. 만약 close() 메소드를 호출 한뒤 write() 나 flush() 메소드를 호출하게 되면 IOException 이 발생합니다.

마지막으로 BufferedOutputStream 클래스의 모든 메소드는 IOException 이 발생 할 수 있기 때문에 BufferedOutputStream 클래스의 메소드들을 이용할때에는 try-catch 를 사용해야 합니다.

소스코드

• github.com

참조

• JavaCodeGeeks.com

BufferedWriter 클래스에 대하여 간단한 예제를 통해 알아보려고 합니다.
BufferedWriter 클래스는 문자들을 버퍼링하여 문장, 배열, 단일 문자를 효율적으로 문자 출력 스트림(character output stream) 에 기록합니다. BufferedWriter 클래스는 문자 스트림에 기록하기 위해 추상 클래스인 Writer 를 상속하였습니다. 서브 클래스들은 반드시 write(char[] cbuf, int off, int len), flush(), close() 메소드를 구현해야 합니다. 대부분의 서브 클래스들은 더 높은 효율성, 기능의 추가, 혹은 양쪽 모두를 제공하기 위해 일부 메소드들을 오버라이드 (override) 하기도 합니다.

BufferedWriter 클래스는 JDK 1.1 부터 존재했습니다.

BufferedWriter 의 생성자 구조

• BufferedWriter(Writer out)

기본 크기를 가지는 출력 버퍼로 버퍼링 된 문자형 출력 스트림 (character output stream) 객체를 만듭니다.

• BufferedWriter(Writer out, int size)

매개변수로 주어진 크기를 가지는 출력 버퍼로 버퍼링된 문자형 출력 스트림 객체를 만듭니다.

BufferedWriter 의 기본 예제

BufferedWriter 클래스가 어떻게 파일에 문자를 기록하는지 살펴 보겠습니다.

package kr.co.leehana.example.bufferedwriter;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class SimpleBufferedWriterExample1 {

	public static void main(String[] args) {
		String greetings = "Hello!!!";
		String description = "I am written into a file";

		BufferedWriter writer = null;

		try {
			writer = new BufferedWriter(new FileWriter(new File("output.txt")));
			writer.write(greetings);
			writer.newLine();
			writer.write(description);
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (writer != null) {
				try {
					writer.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

BufferedWriter 는 매개변수로 Writer 클래스를 가지고 오고 예제에서는 Writer 추상 클래스를 상속한 OutputStreamWriter 의 서브클래스인 FileWriter 클래스를 사용하였습니다. 중간에 writer.newLine() 메소드를 사용하였는데 이는 플랫폼 (Mac, Linux, Windows) 의 시스템 환경변수에 등록된 line.separator 를 사용하여 호환성을 높였습니다. 여기에서 중요한 것은 마지막에 호출된 close() 메소드 입니다. 항상 기억해야 할것은 파일에 쓰기가 완료되면 close() 메소드를 반드시 호출 해줘야 한다는 것입니다.
생성된 파일을 열어보면 위에서 입력한 두줄의 텍스트가 있는것을 확인 할 수 있을 것입니다.

BufferedWriter 의 또 다른 예제

BufferedWriter 의 flush() 메소드를 사용하는 Logger 클래스를 만들어서 log 파일을 생성하는 예제 입니다.

package kr.co.leehana.example.bufferedwriter;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Date;

public class Logger {
	private BufferedWriter writer;

	public Logger(String filename) throws IOException {
		this.writer = new BufferedWriter(new FileWriter(new File(filename)));
	}

	public Logger(File logFile) throws IOException {
		this.writer = new BufferedWriter(new FileWriter(logFile));
	}

	public void log(String s) throws IOException {
		String date = new Date().toString();
		this.writer.write(date + " : " + s);
		this.writer.newLine();
		this.writer.flush();
	}

	public void close() throws IOException {
		this.writer.close();
	}
}

위 Logger 클래스를 테스트 하는 예제 코드 입니다.

package kr.co.leehana.example.bufferedwriter;

import java.io.IOException;

public class SimpleBufferedWriterExample2 {

	public static void main(String[] args) {
		Logger logger = null;
		try {
			logger = new Logger("log.txt");
			logger.log("Test 1");
			logger.log("Test 2");
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (logger != null) {
				try {
					logger.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

출력된 log 파일을 열어보면 하나의 로그 파일에 두줄의 로그가 기록된것을 확인 할 수 있을 것입니다.

BufferedWriter 클래스에 대한 추가 정보

BufferedWriter 클래스를 다음과 같이 생성함으로써 출력 스트림에 쓸 수도 있습니다.
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));

BufferedWriter 클래스는 직접 출력 스트림 (output stream) 에 쓰지 않습니다. 사실 BufferedWriter 클래스는 더 나은 성능을 위해 스트림에 기록되는 버퍼 입니다. 기억해야 할만한것으로는 생성자의 매개변수로 버퍼의 크기를 지정할 수 있다는것과 지정하지 않으면 기본 크기를 가지는 버퍼를 사용한다는 것입니다. close() 메소드가 호출되면 버퍼가 기록되는것이 아니고 스트림에 기록됩니다. 이를 확인 하기 위해서 close() 메소드를 주석처리해서 실행 해보면 파일에 아무것도 기록되지 않은것을 확인 할 수 있습니다.

만약 스트림을 닫지 않고 버퍼를 파일에 계속 쓰고 싶으면 flush() 메소드를 사용하면 됩니다. close() 메소드가 호출된 후 write() 메소드나 flush() 메소드를 호출 하게 되면 IOException 이 발생합니다.

마지막으로 모든 메소드는 IOException 이 발생 할 수 있으니 try catch 문을 이용해야 합니다.

소스코드

• github.com

출처

• JavaCodeGeeks.com

java 에서 많이 사용하는 java.util.List 객체를 일반 배열로 변환 하는 방법에 대한 예제 입니다.
java.util.List 에는 이를 위해 두가지의 메소드가 존재 합니다.

• T[] toArray(T[] a)
• Object[] toArray()

이 두가지 메소드들은 적절한 순서로 java.util.List 에 담겨 있는 모든 요소를 포함하는 배열을 반환합니다.
두 메소드의 시그네쳐에서 확인 할 수 있듯이 두 메소드의 차이는 첫번째는 런타임에 지정된 (T[]) 배열을 반환하고, 두번째는 Object[] 유형의 배열을 반환 한다는 것입니다.
두가지 모두의 예를 한번 살펴 보겠습니다.

먼저 두개의 예제에서 공통으로 사용할 User 클래스를 만들겠습니다.

User 클래스

package kr.co.leehana.example.listtoarray;

public class User {
	private String name;
	private int age;

	public User(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return this.name;
	}

	public int getAge() {
		return this.age;
	}
}

T[] toArray(T[] a) 예제

package kr.co.leehana.example.listtoarray;

import java.util.ArrayList;
import java.util.List;

public class ListToArrayExampleWithArgument {

	public static void main(String[] args) {
		runExample();
		runExample2();
	}

	private static void runExample() {
		List<String> strList = new ArrayList<String>();
		strList.add("One");
		strList.add("Two");
		strList.add("Three");

		String[] strArray = strList.toArray(new String[strList.size()]);

		for (int i = 0; i < strArray.length; i++) {
			System.out.println("output : " + strArray[i]);
		}
	}

	private static void runExample2() {
		List<User> userList = new ArrayList<User>();
		userList.add(new User("Hana Lee", 37));
		userList.add(new User("Gildong Hong", 41));

		User[] userArray = userList.toArray(new User[userList.size()]);

		for (int i = 0; i < userArray.length; i++) {
			System.out.println("User name : " + userArray[i].getName());
			System.out.println("User age : " + userArray[i].getAge());
		}
	}
}

위의 예제에서는 cast 를 하지 않았다는것을 확인 하세요. 반환되는 형식이 바로 매개변수로 넘긴 형식이 됩니다. 이 방법은 cast 를 줄이고 런타임에 반환되는 배열의 형태를 결정 할 때 사용될 수 있습니다.

Object[] toArray() 예제

package kr.co.leehana.example.listtoarray;

import java.util.ArrayList;
import java.util.List;

public class ListToArrayExampleWithNoneArgument {

	public static void main(String[] args) {
		runExample();
		runExample2();
	}

	private static void runExample() {
		List<String> strList = new ArrayList<String>();
		strList.add("One");
		strList.add("Two");
		strList.add("Three");

		Object[] objArray = strList.toArray();

		for (int i = 0; i < objArray.length; i++) {
			System.out.println("output : " + objArray[i].toString());
		}
	}

	private static void runExample2() {
		List<User> userList = new ArrayList<User>();
		userList.add(new User("Hana Lee", 37));
		userList.add(new User("Gildong Hong", 41));

		Object[] objArray = userList.toArray();

		for (int i = 0; i < objArray.length; i++) {
			User user = (User) objArray[i];
			System.out.println("User name : " + user.getName());
			System.out.println("User age : " + user.getAge());
		}
	}
}

위의 예제는 반환된 Object[] 배열을 String[] 으로 바로 변환 할 수 없기 때문에 Object[] 배열로 부터 요소를 꺼낸뒤 toString 메소드를 호출 해줍니다. 물론 그냥 String 이기 때문에 직접 호출 한다고 해도 큰 문제는 없습니다.

그리고 두번째 User 객체를 이용하여 출력 하는 메소드에서는 출력을 위해 User 객체로 cast 를 해야 한다는것을 확인하세요.

소스 코드

• github.com

출처

• JavaCodeGeeks.com

FileWriter 클래스가 어떻게 문자 스트림을 사용하는지에 대해 알아 보겠습니다. 기본적으로 파일을 사용할 수 있는지 혹은 생성이나 삭제가 가능 할지는 플랫폼(MAC, Linux, Windows ETC) 에 따라 달라집니다. 일부 플랫폼들은 특별히 파일을 쓰기 위해 여는 작업을 한번에 오직 하나의 FileWriter 객체를 사용 할 수 있습니다. 이러한 상황에에서는 관련된 파일이 이미 열려 있는 경우 FileWriter 생성자 호출은 실패 하게 됩니다.

FileWriter 클래스는 OutputStreamWriter 클래스를 확장하며 문자 스트림과 바이트 스트림 사이에 다리 역활을 합니다. 여기에 기록된 문자는 지정된 캐릭터셋을 이용하여 바이트로 인코딩 됩니다. 이 캐릭터셋은 지정된 이름을 사용하거나 명시적으로 부여 할 수 있고 또는 플랫폼들의 기본 캐릭터셋을 사용하게 됩니다.

FileWriter 클래스는 JDK 1.1 부터 존재 했습니다. 

FileWriter 클래스 구조

• FileWriter(File file)
  File 객체를 매개변수로 넘겨 FileWriter 객체를 생성합니다.

• FileWriter(File file, boolean append)
  File 객체를 매개변수로 넘겨 FileWriter 객체를 생성합니다. 만약 두번째 매개변수값이 true 이면 파일의 마지막 다음 줄 첫번째에 바이트를 쓰게 됩니다.

• FileWriter(FileDescriptor fd)
  File descriptor 와 관련된 FileWriter 객체를 생성합니다.

• FileWriter(String filename)
  지정된 파일이름으로 FileWriter 객체를 생성합니다.

• FileWriter(String filename, boolean append)
  지정된 파일이름으로 FileWriter 객체를 생성합니다. 만약 두번째 매개변수값이 true 이면 파일의 마지막 다음 줄 첫번째에 바이트를 쓰게 됩니다.
  
  

FileWriter 예제를 살패 보겠습니다

FileWriter 의 기본적인 사용 예제 입니다.

package kr.co.leehana.example.filewriter;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class SimpleFileWriterExample {

	private static final String LINE_SEPARATOR = System
			.getProperty("line.separator");

	// jdk 7
	// private static final String LINE_SEPARATOR = System.lineSeparator();

	public static void main(String[] args) throws IOException {
		String name = "Hana Lee";
		int age = 37;
		double temp = 27.3d;
		FileWriter fw = null;

		try {
			fw = new FileWriter(new File("textfile.txt"));

			fw.write(String.format("My name is %s.", name));
			fw.write(LINE_SEPARATOR);
			fw.write(String.format("I am %d years old.", age));
			fw.write(LINE_SEPARATOR);
			fw.write(String.format("Today's temperature is %.2f.", temp));
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (fw != null)
				fw.close();
		}
		
		System.out.println("Done");
	}
}

FileWriter 의 append 에 대한 예제 입니다.

FileWriter 의 append 매개변수 사용방법에 대한 예제 입니다. 이 예제에서 간단한 Logger 객체를 만들어서 로그 데이터를 파일에 작성하겠습니다.

package kr.co.leehana.example.filewriter;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Date;

public class Logger {
	private static final String LINE_SEPARATOR = System
			.getProperty("line.separator");
	private File logFile;

	public Logger() {
	}

	public Logger(String fileName) {
		this.logFile = new File(fileName);
	}

	public Logger(File logFile) {
		this.logFile = logFile;
	}

	public void log(String str) {
		FileWriter fw = null;
		try {
			fw = new FileWriter(this.logFile, true);
			String date = new Date().toString();
			fw.write(date + " : " + str);
			fw.write(LINE_SEPARATOR);
		} catch (IOException e) {
			System.err.println("Couldn't log this : " + str);
		} finally {
			if (fw != null) {
				try {
					fw.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

아래 클래스는 Logger 객체를 생성하고 log 메소드를 호출할때 로그 데이터를 매개변수로 넘겨 파일에 로그 데이터를 쓰는 작업을 하게 됩니다.
Logger 객체를 생성할때 두가지 다른 생성자를 만들어서 테스트 해볼 수 있는 예제 입니다.

package FileWriterAppendExample;

import java.io.File;

import kr.co.leehana.example.filewriter.Logger;

public class FileWriterAppendExample {

	public static void main(String[] args) {
		Logger log1 = new Logger("file1.log");

		File logFile = new File("file2.log");
		Logger log2 = new Logger(logFile);

		log1.log("This is written in the first file");
		log2.log("This is written in the second file");

		log1.log("This is appended to the first file");
		log2.log("This is appended to the second file");
	}
}

추가 정보

FileWriter 클래스의 모든 생성자들은 매개변수로 넘어온 File 객체나 파일이름이 이미 존재 하면서 디렉토리 일때 혹은 파일 생성이 되지 않거나 어떤 이유로 파일 열기가 되지 않을 경우 IOException 오류가 발생합니다.

소스 코드

• github.com

출처

• JavaCodeGeeks.com

java.util.concurrent.RejectedExecutionException 을 해결 하는 방법에 대해 예제 코드와 해결 방법에 대하여 이야기 해보겠습니다.

threads 를 만들어서 Executor 인터페이스를 이용하여 실행 하는 경우 실행 할 수 없는 상태가 될 수도 있습니다.

이것은 몇가지 이유가 있을 수 있고 아래의 예제를 통해 보여드리도록 하겠습니다.

그리고 RejectedExecutionException 은 java.lang.RuntimeException 이라는 것을 주목 할 필요가 있습니다.

RejectedExecutionException 예외를 설명 하기 위해 ThreadPoolExecutor 를 이용하여 몇개의 worker thread 들을 실행하는 간단한 java 어플리케이션을 만들것입니다.

어떻게 만들었는지 아래의 코드를 보겠습니다.

아래의 코드는 ThreadPoolExecutor 클래스가 어떻게 당신이 만든 task 들을 몇개의 thread 들을 만들어 실행하는지 보여줍니다.

프로그램을 실행하면 정상적으로 실행 되는 것을 확인할 수 있습니다.

우리는 ThreadPoolExecutor 를 이용하였는데 pool 의 크기를 3으로 설정 하였습니다.

이것이 의미 하는것은 3개의 thread 들을 만들것이고 3개의 task worker 들을 채워 넣을것입니다.

우리가 새로운 task 를 만들어 ThreadPoolExecutor 에 submit 을 하게 되면 3개의 pool 중 하나가 사용 가능 하게 될때까지 BlockingQueue 에 배치하고 대기 하게 됩니다.

이 예제의 경우 15의 크기를 가지는 ArrayBlockingQueue 를 사용합니다. ArrayBlockingQueue 를 사용한 이유는 나중에 설명 합니다.

예제에서 우리는 10개의 task 들을 만들어 실행 할 것입니다.

RejectedExecutionException 의 한가지 이유중에는 새로운 task 를 executor 가 shutdown 된 후에 실행 하려고 할때 발생합니다.

shutdown 메소드가 호출 된 후에는 오래된 task 들은 여전히 실행되지만, 더이상 새로운 task 들을 실행 할 수 없게 됩니다.

이 오류에 대한 내용을 아래의 예제를 통해 확인 해보겠습니다.

프로그램을 실행하게 되면 RejectedExecutionException 이 출력 될 것입니다.

Executor 가 그의 책임 아래 더이상 task 들을 처리 할 수 없을때 나타나는 예제 입니다.

로컬 메모리의 한계에 도달했을 때 Exception 이 발생합니다.

이 예제에서 로컬 메모리는 ArrayBlockingQueue 의 크기인 15 에 해당합니다.

만약 ArrayBlockingQueue 에 저장 할 수 있는 것보다 더 많은 task 들을 실행 하려고 하면 RejectedExecutionException 이 발생합니다.

예제를 살펴 보겠습니다.

15의 크기를 가지는 ArrayBlockingQueue 는 자신의 크기인 15 보다 더 많은 thread 들을 저장 할 수 없습니다.

하지만 예제에서 우리는 20개의 thread 들을 실행 하려고 하였습니다.

20개의 thread 가 빠르게 처리 된다면 오류가 발생 하지 않을 수도 있지만 우리는 Worker.java 코드에서 Thread.sleep() 으로 딜레이를 주었기 때문에 ThreadPoolExecutor 에서 빠르게 처리 하지 못하고 BlockingQueue 에 저장하게 되는데 이때 15개를 넘어가기 때문에 오류가 발생 한것입니다.

만약 18개의 thread 들을 만들었다면 정상적으로 실행 될 것입니다. 한번 생각해보는것도 좋을꺼 같습니다.

먼저 다음 두가지의 경우를  체크 해봅니다.

  1) shutdown 메소드가 호출 된 후 Executor 가 실행 되는것을 주의 해서 프로그래밍을 한다.

  2) Executor 가 처리 할 수 있는 것보다 더 많은 task 들을 실행 하지 않는다.

두번째의 경우는 쉽게 해결이 가능 합니다. 크기에 제한이 없는 자료구조를 이용 하면 됩니다.

예를 들면 LinkedBlockingQueue 가 있습니다.

만약 LinkedBlockingQueue 를 사용 하였는데도 여전히 문제가 발생한다면 첫번째 케이스를 의심 해봐야 합니다.

만약 첫번째 케이스에도 해당하지 않는다면 분명 여러가지 복합적인 문제가 있을 수 있습니다.

예를 들면 다른 thread 들이 deadlock 에 걸려 메모리가 꽉 차거나 LinkedBlockingQueue 는 제한 없이 계속 쌓이므로 메모리의 사용이 많아져서 문제가 발생 할 수 있습니다.

우리는 두번째 케이스를 좀 더 세밀하게 촛점을 맞춰 해결하려고 합니다.

ThreadPoolExecutor 는 15개 보다 더 많은 task 들을 처리 할 수 있습니다. 

이 예제에서는 ArrayBlockingQueue 를 사용하고 있고 이는 새로운 task 가 실행되기 전에 처리가 완료된다면 자연스럽게 오류가 없이 실행이 될 수 있습니다.

약간의 꼼수 같은 예제 이지만 한번 살펴 보겠습니다.

예제를 실행 해보면 문제없이 실행 되는것을 확인 할 수 있습니다.

예제를 실행해 보면 마치 ThreadPoolExecutor 가 15개 이상의 task 들을 처리 할 수 있는 것 처럼 보이지만 사실 약간의 꼼수를 이용하여 딜레이를 줘 ThreadPoolExecutor 가 이미 처리 중인 task 들이 충분히 처리 되어 queue 를 비울 수 있는 시간을 벌게 해줬기 때문에 가능한것이다. Thread.sleep(3000); 이부분은 꼭 3000 이 아니라 적절한 값을 주면 됩니다.

소스

• Github.com

예제 출처 : 

• JavaCodeGeeks.com