public static void main(String[] args) {
NIOSample sample = new NIOSample();
sample.basicWriteAndRead();
}
public void basicWriteAndRead() {
String fileName = "dumpFile" + separator + "text1.txt";
try {
writeFile(fileName, "NIO sample");
readFile(fileName);
} catch (Exception e) {
e.printStackTrace();
}
}
public void writeFile(String fileName, String data) throws Exception {
FileChannel channel = new FileOutputStream(fileName).getChannel(); // FileChannel 객체를 만들려면 FileOutputStream 클래스에 선언된 getChannel을 호출한다.
byte[] bytes = data.getBytes();
ByteBuffer buffer = ByteBuffer.wrap(bytes); // ByteBuffer 클래스에 static으로 선언된 wrap() 메소드를 호출하면 ByteBuffer 객체가 생성되고 매개변수로 저장할 byte 배열을 넘겨주면 된다.
channel.write(buffer); // FileChannel에 선언된 write() 메소드를 buffer에 넘겨주면 파일에 쓰게된다.
channel.close();
}
public void readFile(String fileName) throws Exception {
FileChannel channel = new FileInputStream(fileName).getChannel(); // FileInputStream 클래스에 선언된 getChannel() 메소드를 호출한다.
ByteBuffer buffer = ByteBuffer.allocate(1024); // ByteBuffer의 allocate() 메소드를 통해 buffer 객체를 만들고 데이터가 기본적으로 저장되는 크기를 지정한다
channel.read(buffer); // 채널에 버퍼를 넘겨 담을 버퍼를 알려준다.
buffer.flip(); // buffer에 담겨있는 데이터의 가장 앞으로 이동한다
while (buffer.hasRemaining()) { // 데이터가 더 남아 있는지 확인한다
System.out.println((char)buffer.get()); // 한 바이트씩 데이터를 읽는다
}
channel.close();
}
Buffer에 대해 살펴보자
Buffer는 java.nio.Buffer 클래스를 확장해서 사용하는데 CharBuffer, DoubleBuffer, FloatBuffer, IntBuffer, LongBuffer, ShortBuffer 등이 존재하는데 이 안의 메소드들은 다음과 같다.
리턴 타입
메소드
설명
int
capacity()
버퍼에 담을 수 있는 크기 리턴
int
limit()
버퍼에서 읽거나 쓸 수 없는 첫 위치 리턴
int
position()
현재 버퍼의 위치 리턴
capacity는 버퍼의 크기
position은 현재의 위치
limit은 읽거나 쓸 수 없는 위치
리턴 타입
메소드
설명
Buffer
flip()
limit 값을 현재 position으로 지정한 후 position을 0으로 이동
Buffer
mark()
현재 position을 mark
Buffer
reset()
버퍼의 position을 mark한 곳으로 이동
Buffer
rewind()
현재 버퍼의 position을 0으로 이동
int
remaining()
limit-position 계산 결과를 리턴
boolean
hasRemaining()
position과 limit 값에 차이가 있을 경우 true
Buffer
clear()
버퍼를 지우고 position을 0으로 이동하며 limit을 버퍼의 크기로 변경
\
Java Lambda expression(람다식)
익명 클래스를 사용하면 가독성도 떨어지고 직접 일일이 써야하는 코드량이 늘어난다. 이런 단점을 보완하기 위해 람다식이 만들어졌다. 람다식은 익명 클래스로 전환 가능하며 익명 클래스는 람다 표현식으로 전환 가능하다. 그럼 람다 표현식 전에 익명 클래스부터 알아보자.
Nested 클래스
클래스 안의 클래스를 Nested 클래스라고 불린다. Nested class는 static nested 클래스와 내부 클래스로 구분되는데 이 둘은 static 여부로 구분된다.
내부 클래스는 또 다시 두 가지로 나뉘는데 이름이 있는 내부 클래스를 Local Class, 이름이 없는 클래스를 익명 클래스로 불린다.
public class OuterOfStatic {
static class StaticNested {
private int value = 0;
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
}
}
위와 같은 static 내부 클래스를 가지는 OuterOfStatic 클래스가 있다고 생각해보자. 위의 코드는 컴파일하면 두개의 클래스가 만들어진다.
public class NestedSample {
public static void main(String[] args) {
NestedSample sample = new NestedSample();
sample.makeStaticNestedObject();
}
public void makeStaticNestedObject() {
OuterOfStatic.StaticNested staticNested = new OuterOfStatic.StaticNested();
staticNested.setValue(3);
System.out.println(staticNested.getValue());
}
}
위와 같이 따로 객체를 할당하지 않고 바로 사용하면 된다.
FileChannel channel = new FileOutputStream(fileName).getChannel(); // FileChannel 객체를 만들려면 FileOutputStream
이렇게 만드는 이유는 클래스는 묶어서 용도를 명확하게 하기 위함이다.
구분에서 봤듯이 Static Nested Class와 Inner Class의 차이는 static 하나다. static으로 선언한 클래스를 Inner Class로 선언해보자.
public class OuterOfInner {
class Inner {
private int value = 0;
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
}
}
// static만 빠졌다.
Inner Class를 사용해보자.
public class InnerSample {
public static void main(String[] args) {
InnerSample sample = new InnerSample();
sample.makeInnerObject();
}
public void makeInnerObject() {
OuterOfInner outer = new OuterOfInner();
OuterOfInner.Inner inner = outer.new Inner();
inner.setValue(3);
System.out.println(inner.getValue());
}
}
다소 복잡해졌다. 객체를 생성하기 위해서 outer 객체를 만들고 그 객체를 통해 inner를 만들 수 있다.
이렇게 내부 클래스를 만들었던 이유는 캡슐화 때문이고 대부분 자바 GUI 때문이었다. 특정 버튼이 눌렸을 때 이벤트를 발생하는데 그 때의 작업을 정의하기 위해서 내부 클래스를 사용했다. 하지만 대부분의 버튼 하나당 작업은 하나로 귀결되기 때문에 익명 클래스를 만드는 것이 편하다. 익명 클래스는 Inner 클래스인데 개중 이름이 없는 클래스다.
안드로이드에서도 자주 있었던 패턴인데
public class AnonymousSample {
public static void main(String[] args) {
AnonymousSample sample = new AnonymousSample();
sample.setButtonListener();
}
public void setButtonListener() {
MagicButton button = new MagicButton();
MagicButtonListener listener = new MagicButtonListener();
button.setListener(listener);
button.onClickProcess();
}
}
public class MagicButton {
public MagicButton() {
}
public EventListener listener;
public void setListener(EventListener listener) {
this.listener = listener;
}
public void onClickProcess() {
if(listener != null) {
listener.onClick();
}
}
}
public class MagicButtonListener implements EventListener{
public void onClick() {
System.out.println("Magic Button Clicked !!!");
}
}
다음과 같은 부분이 있다고 하자.
main에서는 MagicButton이 있고 버튼에 대한 리스너를 만들어서 버튼에 리스너를 설정해주고 눌리는 상황을 가정했다. 이런 패턴은 익명함수로 대체가 가능한데
public void setButtonListenerAnonymous() {
MagicButton button = new MagicButton();
EventListener listener = new EventListener() {
@Override
public void onClick() {
System.out.println("Magic Button Clicked !!!");
}
};
button.setListener(listener);
button.onClickProcess();
}
이렇게 익명함수로 만들어버리면 MagicButtonListener를 만들지 않아도 된다.
익명함수는 메모리에 로드하는 클래스 갯수를 줄일 수 있기 때문에 속도 면에서 유리하다고 할 수 있다.
내부 클래스는 모두 다른 클래스에서 재사용할 일이 없을 때만 만들어 줘야 한다.
람다
람다는 익명클래스의 단점을 보완하기 위해 만들어 졌다. 다시말해 인터페이스에 메소드가 하나인 것들만 적용 가능하다.
public interface Calculate {
int operation(int a, int b);
}
다음과 같이 메소드가 하나인 인터페이스가 있을 때 위에서 본 익명 클래스란 다음과 같다.
public class CalculateSample {
public static void main(String[] args) {
Calculate calculate = new Calculate() {
@Override
public int operation(int a, int b) {
return a + b;
}
};
System.out.println(calculate.operation(1, 2));
}
}
굳이 객체를 생성하지 않아도 이렇게 사용할 수 있다는 말이다.
이걸 다시 람다로 사용해주면 위의 코드는 아래와 같은 말이다.
public class CalculateSample {
public static void main(String[] args) {
Calculate calculate = (a, b) -> a + b;
System.out.println(calculate.operation(1, 2));
}
}
기본 람다 표현식은 3부분으로 구성돼있고
매개 변수 목록
화살표 토큰
처리 식
(int x, int y)
->
x + y
위에 대입해보면 이해 될것이다.
메소드가 여러개인 인터페이스를 람다로 사용하려 하면
public interface Calculate {
int operation(int a, int b);
int operationSub(int a, int b);
}
Operator '+' cannot be applied to '<lambda parameter>', '<lambda parameter>'
메소드가 여러개라고 에러가 나온다. 작성자가 여럿이라면 충분히 일어날 수 있는 상황인데
이런 혼동을 피하기 위해
@FunctionalInterface
interface Calculate {
int operation(int a, int b);
}
@FunctionalInterface를 사용하면 이 인터페이스는 하나의 메소드만 선언할 수 있고 그 이상에선 컴파일 에러가 뜬다.
Runnable을 사용해서 람다를 사용해보면
@FunctionalInterface
public interface Runnable {
/**
* When an object implementing interface <code>Runnable</code> is used
* to create a thread, starting the thread causes the object's
* <code>run</code> method to be called in that separately executing
* thread.
* <p>
* The general contract of the method <code>run</code> is that it may
* take any action whatsoever.
*
* @see java.lang.Thread#run()
*/
public abstract void run();
}
Runnable의 정의 는 다음과 같고
public class CalculateSample {
public static void main(String[] args) {
CalculateSample calculateSample = new CalculateSample();
calculateSample.runCommonThread();
}
private void runCommonThread() {
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
};
new Thread(runnable).start();
}
}
Runnable은 인터페이스, Thread는 Runnable에 부가 기능을 더한 클래스다.
따라서 Runnable을 실행하기 위해선 new Thread().start()를 해줬어야 했다.
