Java 7.0 의 놀라운(?)특징 들에 대해서 간단하게 설명하려 합니다.
아래글의 내용의 링크된 출처에서 참고하여 작성한 것이며, 원문을 한글로 번역 및
나의 개인적인 의견을 첨부한 것입니다.
- 출처 : http://metoojava.wordpress.com/2010/11/15/java-7-awesome-features/
나의 개인적인 의견을 첨부한 것입니다.
- 출처 : http://metoojava.wordpress.com/2010/11/15/java-7-awesome-features/
먼저 현재 Java 6을 사용하고 있고 또한 Java 7을 위한 프로젝트가 열심히 진행중인것 같습니다. 새로운 버젼에 대한 관심이 크게 없기에 이에대한 자세한 내용은 더 구글링을 해보아야 할듯 합니다.
Java 7 에서 가장 크고 흥미로운 특징들에 대해서 이제 설명하려 합니다.
간략하게 요약하자면,
- null 체크 방법 개선
- Switch 문 개선
- 멀티예외처리
- 컬렉션 생성자 수정
크게 위 4가지 인것 같습니다. 그럼 위의 내용에 대해 자세하게 설명하도록 하겠습니다.- Switch 문 개선
- 멀티예외처리
- 컬렉션 생성자 수정
1. Null-safe Method invocaton :
자바로 프로그래밍을 하다 보면 NullPointer Exception을 아주 자주 만나게 될것입니다. 심심치않게 만날수 잇는 에러이며, 출처 블로그의 주인장은 구글링을 했을때 약 5,570,000건의 결과가 검색된다고 합니다. 이만큼 자바프로그래머를 괴롭히는 예외가 아닌가 하는 생각이듭니다.
이 예외처리를 위해 노가다가 장난 아니였는데, 이게 된다면 이제 좀 코딩이 편리해 지지 않을까 하는 생각이 듭니다.
현재는 null 체크를 위해 아래와 같은 코드를 사용합니다.
01 public String getPostcode( Person person ) {
02 if( person != null )
03 Address address = person.getAddress();
04 if( address != null )
05 return address.getPostcode();
06 return null;
07 }
02 if( person != null )
03 Address address = person.getAddress();
04 if( address != null )
05 return address.getPostcode();
06 return null;
07 }
하지만, Java 7 에서는 아래와 같이 사용이 가능합니다!
01 public String getPostcode( Person person ) {
02 return person?.getAddress()?.getPostcode();
03 }
02 return person?.getAddress()?.getPostcode();
03 }
위와 같이 4라인의 코드가 단 한라인으로 표현이 가능합니다. "?."연산자는 해당 객체변수가 null 이라면 null을 리턴하고 있습니다. 굳이 null 체크를 해줘야하는 수고가 더는 것입니다. (왜 이제야 이게 나왔을까요..... ㅜㅜ)
2. String in Switch Statements
Java 6 까지의 버전에서는 Switch-case 문에서 case 조건으로 판단할수 잇는 데이터 형은 원시형 데이터로 제한되어 있었습니다. (예를 들어, int, char, long etc )
하지만, Java 7버젼에서는 String 타입을 지원하면서 좀더 가독성이 높은 코드를 만들수 있겠군요. 예전에는 가독성을 높이기 위해 정수형 상수를 지정해서 사용했다면, Java 7에서는 String으로 바로 사용하는게 훨씬 편해질것 같습니다.
( 음.. 근데 성능면에서는 어떤게 빠를지... 이전 정수형 타입으로 하는게 빠르겟죠? )
3. Multi-Exception catch
여러분들은 종종 자바의 예외처리때문에 코딩하는데 어려움이 많을때가 있었을 겁니다. 예외처리를 알아서 해주면 좋겠지만.. 그건 희망사항일 뿐이고, 그나마 좀던 간편하게 작성할수 있어서 좋은것 같습니다.
예를들어 소켓통신 프로그래밍을 한다고 할때 예외처리는 다음과 같이 다중으로 catch 문을 사용해야 했습니다.
01 try {
02 ...... // IO 작업
03 } catch( IOException e ) {
04 e.printStacktrace();
05 } catch( Exception e2 ) [
06 System.out.println(" Exception : " + e2);
07 }
이제 Java 7 부터는 이것을 아래와 같이 좀더 간단하게 코딩이 가능합니다.02 ...... // IO 작업
03 } catch( IOException e ) {
04 e.printStacktrace();
05 } catch( Exception e2 ) [
06 System.out.println(" Exception : " + e2);
07 }
01 try {
02 block of statement
03 } catch( IOException e | Exception e2 ) {
04 block of statement
05 }
02 block of statement
03 } catch( IOException e | Exception e2 ) {
04 block of statement
05 }
4. Bracket Notation for Collection
가장많이 사용하는 ArrayList와 같은 컬렉션을 이용할때, 선언과 동시이 초기화를 하는 방법이 존재하지 않아 상당히 불편했을 겁니다. 저또한 그랬구요. 배열과 같이 한방에 초기화가 된다면 좋았을텐데....
이제 Java 7 부터는 이를 지원한다고 합니다. 별다른 부연설명 없이 아래 코드를 보시는게 빠를것 같습니다.
01 Collection<String> c = new ArrayList();
02 c.add("one");
03 c.add("two");
04 c.add("three");
05 Use :
06 Collection<String> c = new ArrayList {"one", "two", "three"};
02 c.add("one");
03 c.add("two");
04 c.add("three");
05 Use :
06 Collection<String> c = new ArrayList {"one", "two", "three"};
마치며..
우연찬게 Java 7 에 대한 내용을 발견에 이렇게 포스팅을 하지만, 위 내용에는 정확하지 않은 정보가 포함되어 있을수도 있습니다. 의심가는 부분이나, 이해가 가지 않는 부분은 거침없이 태클이나 질문해 주시면 최대한으로 수용하며 답변드리도록 하겠습니다.
제 블로그에 방문해 주신 모든 분들께 감사의 말씀을 드립니다. - 상기 글은 제 블로그에 동시에 게재되었습니다. (http://anyjava.tistory.com)
출처 - http://www.anycoding.com/bbs/board.php?bo_table=acProgram_java&wr_id=5986
===================================================================================
출처 - http://javacan.tistory.com/177
===================================================================================
Java 7의 새로운 특징 : Java7에서의 중요한 변화들과 업데이트된 항목에 대한 조사.
등록일 : 2011년 11월 11일
제공 : 한빛 네트워크
저자 : Madhusudhan Konda
역자 : 김상현
원문 : A look at Java 7's new features 
Java 7에는 개발자들이 좋아할만한 많은 특징들이 있다. switch구문에서 사용하는 String, 다중 exception처리multi-catch exception), try-with-resource 구문, 새로운 파일시스템 API, JVM의 확장, 동적 타입의 언어에 대한 지원, 유사한 작업을 위한 fork와 join 프레임워크 등 분명히 많은 곳에서 수용되어질 것이다.
아래에 Java 7의 특징을 설명하고 예제를 제공하였다.. 이 글에서 사용한 코드가 담긴 zip파일은 이곳에서 다운로드 받을 수 있다.
개선된 점들
Java 7은 Project Coin을 통한 새로운 특징을 포함하고 있다. 이 특징들은 개발자들에게 상당히 유용하다.다이아몬드(<>) 지시자
당신은 사용하고 있는 IDE에 대한 불평으로 Generics를 사용한 경우를 많이 언급해왔을 것이다. 예를 들면 우리가 Map을 이용한 Generics를 선언할 때에 아래와 같이 코드를 작성할 것이다.
Map<String, List<Trade>> trades = new TreeMap<String, List<Trade>> ();이런 선언에 대한 안 좋은 점은 오른쪽에 있는 선언이 불필요하게 보일지라도 우리는 양쪽에 타입을 선언해야만 한다는 것이다. 왼쪽에만 선언한 것으로 컴파일러가 타입을 추측할수 있을까? Java 7을 사용하지 않으면 불가능하다. Java 7에서는 아래와 같이 작성한다.
Map<String, List<Trade>> trades = new TreeMap <> ();얼마나 멋진가? 당신은 인스턴스를 생성하기 위해서 전체 타입을 입력할 필요가 없다. 대신 다이아몬드 지시자라고 불리는 <> 기호를 사용한다. trades = new TreeMap() 과 같이 다이아몬드 지시자를 선언하지 않는 것은 허용되지만 컴파일러가 Type safety warning을 발생시킨다.
switch 구문에서 String 사용
Switch 구문은 기본형과 열거형만 사용이 가능했다. Java 7은 switch 문에서 사용할수 있는 다른 타입을 추가하였다. 바로 String 타입이다.
Trade의 상태로 진행되는 요구사항이 있다고 해보자. 지금까지는 이러한 상황에서 if-else구문을 사용해왔다.
private void processTrade(Trade t) {
String status = t.getStatus();
if (status.equalsIgnoreCase(NEW)) {
newTrade(t);
} else if (status.equalsIgnoreCase(EXECUTE)) {
executeTrade(t);
} else if (status.equalsIgnoreCase(PENDING)) {
pendingTrade(t);
}
}
String으로 동작하는 이 메서드는 대충 만들었다. Java서에서 우리는 String 타입을 변수로 받는 향상된 Switch문을 활용하여 이 메서드를 향상시킬수 있다.public void processTrade(Trade t) {
String status = t.getStatus();
switch (status) {
case NEW:
newTrade(t);
break;
case EXECUTE:
executeTrade(t);
break;
case PENDING:
pendingTrade(t);
break;
default:
break;
}
}
위에 프로그램에서는, 상태 필드를 계속 String.equals() 메서드를 사용한 case label과 비교하였다. 자동 자원 관리
Connection, Files, Input/OutStream 등과 같은 자원은 코드를 작성한 개발자가 수동으로 회수해야만 했다. 보통 우리는 각각의 자원을 회수하기 위해 try-finally 블록을 사용한다. 아래 예제를 보면 리소스를 만들고, 그것을 사용하고 마지막에는 그것을 회수한다.
public void oldTry() {
try {
fos = new FileOutputStream("movies.txt");
dos = new DataOutputStream(fos);
dos.writeUTF("Java 7 Block Buster");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fos.close();
dos.close();
} catch (IOException e) {
// log the exception
}
}
}
그러나, Java 7은 자동으로 리소스를 관리하는 훌륭한 기능을 소개하고 있다. 동작 또한 간단하다. 우리가 해줄 것은 try문 안에 아래와 같이 자원을 선언하는것 뿐이다.try(resources_to_be_cleant){
// your code
}
예전 try문을 사용한 위의 메소드는 아래 보여지는 것처럼 이 새로은 기능을 사용하여 다시 작성될 수 있다.public void newTry() {
try (FileOutputStream fos = new FileOutputStream("movies.txt");
DataOutputStream dos = new DataOutputStream(fos)) {
dos.writeUTF("Java 7 Block Buster");
} catch (IOException e) {
// log the exception
}
}
위의 코드는 또한 이 특징의 다른 측면도 보여주고 있다 : 여러개 자원들에 대해서도 동작을 한다. FileOutputStream과 DataOutputStream 은 각각 세미콜론(;)으로 나눠서 차례로 try 문 안에 쌓여있다. try블록에 존재하는 기능이 한번에 자동으로 스트림을 회수해주기 때문에 우리는 수동으로 스트림을 null 처리하거나 close해줄 필요가 없다. 자동으로 회수되어져야 하는 자원들은 내부적으로 java.lang.AutoCloseable 인터페이스를 구현 해야만 한다.
AutoCloseble 인터페이스를 구현한 리소스들은 자동 자원 관리를 위한 지원자가 될 수 있다. AtutoCloseable은 java.io.Closeable 인터페이스의 부모이고 오직 close() 메서드 하나만을 가지고 있다. 이 close() 메서드는 try 블록이 나왔을 때에 JVM에 의해서 호출된다.
숫자와 관련된 문자에 밑줄 표시
숫자와 관련된 문자들은 분명히 눈 여과기이다. 만약 10개의 0이 있는 숫자가 있다면 당신은 나와 마찬가지로 0을 세어보기 시작할 것이다. 만약 100만 또는 10억의 숫자가 있는데 당신이 오른쪽에서 왼쪽으로 자릿수를 세어보지 않는다면 문자를 인식하는데 실수를 범하기 쉽고 어려울 것이다. 더이상 그럴 필요가 없다. Java 7에는 자릿수를 표시하기 위한 underscores(밑줄)이 포함되어있다. 예를들어, 아래와 같이 1000을 선언 할 수 있다.
int thousand = 1_000;1000000은 아래와 같다.
int million = 1_000_000이번 릴리즈에는 2진수에 대한 것도 소개 되었다. 예를 들어 "0b1"과 같이 2진수도 표현할 수 있어서 개발자들이 더 이상 16진수로 이것을 변환하지 않아도 된다.
향상된 예외처리
예외처리 영역에서 2가지 향상된 점이 있다. Java7에서는 하나의 catch블록을 사용해서 여러개의 예외를 처리하기 위한 multi-catch 기능을 소개하고 있다.
3개의 예외를 처리 해야하는 메서드가 있다고 가정해보자. 현재 상태에서는 아래처럼 각각의 예외를 처리해야 한다.
public void oldMultiCatch() {
try {
methodThatThrowsThreeExceptions();
} catch (ExceptionOne e) {
// log and deal with ExceptionOne
} catch (ExceptionTwo e) {
// log and deal with ExceptionTwo
} catch (ExceptionThree e) {
// log and deal with ExceptionThree
}
}
catch 블록 안에 여러개의 예외를 차례로 처리하는 모습은 어수선해 보인다. 나는 12개의 예외를 잡는 코드를 본적도 있다. 이것은 믿을 수 없을 정도로 비효율적이고 오류를 범하기 쉽다. Java 7은 이 미운 오리새끼를 다루기 위해 언어에 새로운 변화를 가져왔다. 아래에 oldMultiCatch 메서드의 향상된 버전을 보자.public void newMultiCatch() {
try {
methodThatThrowsThreeExceptions();
} catch (ExceptionOne | ExceptionTwo | ExceptionThree e) {
// log and deal with all Exceptions
}
}
여러개의 예외들은 '|' 연산자를 사용해서 1개의 catch블록 안에서 처리된다. 이 방법으로 더이상 12개의 catch문을 작성할 필요가 없다. 그러나 다른 타입에 속하는 여러 개의 예외가 있다면 "multi multi-catch" 블록을 이용하면 된다. 아래 예제에는 이 내용을 보여주고 있다.public void newMultiMultiCatch() {
try {
methodThatThrowsThreeExceptions();
} catch (ExceptionOne e) {
// log and deal with ExceptionOn
} catch (ExceptionTwo | ExceptionThree e) {
// log and deal with ExceptionTwo and ExceptionThree
}
}
다른 분류에 속하는 ExceptionTwo와 ExceptionThree는 다르게 분리되었지만, 하나의 catch블록에서 처리되어있다.새로운 파일 시스템 API (NIO 2.0)
Java IO를 사용한 많은 사람들은 여전히 프레임워크에 의해서 발생되는 골치 거리들을 기억할 것이다. 운영체제나 다중파일 시스템에서 동일하게 적용하기 정말 어렵다. 대부분 예기치 않게 발생된 delete나 rename 메서드가 그런 경우이다. 특정 기호로 연결되어 작동하는 것은 다른 문제이다. 본질적으로 API는 정비가 필요하다.Java IO에서 나타난 위의 문제점들을 풀기 위해서 Java 7은 정비된 많은 종류의 새로운 API를 도입하였다.
NIO2.0은 많이 향상된 점을 가지고 나왔다. 또한 다중파일시스템으로 작업하는 개발자의 삶의 불편을 덜어주기 위해 새로운 클래스들을 도입하였다.
Path를 이용한 처리
새로운 java.nio.file 패키지는 Path, Paths, fileSystem, FileSystems 등과 같은 클래스와 인터페이스로 구성되어있다.
Path는 단순이 file 경로의 참조이다. java.io.File과 비슷하다(더 많은 특징을 가지고 있다). 아래에서는 temp 폴더의 참조 경로를 어떻게 획득하는지를 보여주고 있다.
public void pathInfo() {
Path path = Paths.get("c:\Temp\temp");
System.out.println("Number of Nodes:" + path.getNameCount());
System.out.println("File Name:" + path.getFileName());
System.out.println("File Root:" + path.getRoot());
System.out.println("File Parent:" + path.getParent());
}
실행 결과는 다음과 같다.Number of Nodes:2 File Name:temp.txt File Root:c: File Parent:c:Temp파일이나 디렉토리를 삭제하는 것은 Files 클래스에 있는 delete 메서드를 호출하는 것만큼 간단하다. Files 클래스는 NoSuchFileException을 처리하는 것과 처리하지 않는 2개의 delete 메서드를 가지고 있다.
아래에 delete 메서드 호출은 NoSuchFileException을 던진다. 따라서 해당 exception을 처리해야만 한다.
Files.delete(path);만약 file 또는 디렉토리가 존재하지 않는다면 예외를 던지길 기대하더라도 Files.deleteIfExists(path)은 예외를 던지지 않는다.
파일 시스템에서 효과적으로 동작하는 Files.copy(..)나 Files.move(..)와 같은 유용한 메서드를 사용할수 있다. 당신의 코드에서 링크를 만들때에 단순히 createSymbolicLink(..) 메서드를 사용하면 된다.
알림을 변경한 File
JDK7에서 가장 마음에 드는 점은 File Change Notifications의 추가이다. 아주 오랫동안 기다려왔던 이 기능은 마침내 NIO 2.0에 추가되었다.
API를 구현하는데 관련된 단계는 아래와 같다.
- WatchService를 생성한다. 이 서비스는 WatchKeys를 가지고 있는 큐로 구성되어있다.
- 이 WatchService로 모니터링하고 싶은 디렉토리나 파일을 등록한다.
- 등록하는 동안 받고 싶은 이벤트의 타입을 정의한다. (추가, 수정, 삭제등)
- 이벤트를 받기위해 무한대 루프를 실행시켜야만 한다.
- 이벤트가 발생하면 WatchKey 가 큐안으로 저장된다.
- WatchKey를 사용하기 위해 쿼리를 호출한다.
1. WatchService 객체를 생성한다.
WatchService watchService = FileSystems.getDefault().newWatchService();2. 볼수있는 디렉토리의 참조경로를 가져온다. 나는 파일명을 하드코딩하지말고 파라메터로 전달하기를 추천한다.
path = Paths.get("C:\Temp\temp\");
3. 다음 단계는 모든 종류의 이벤트를 WatchService 에 등록한다.dirToWatch.register(watchService, ENTRY_CREATE, ENTRY_MODIFY, ENTRY_DELETE);이 타입들은 java.nio.file.StandardWatchEventKinds 에 정의된 이벤트 타입들이다.
4. 무한 루프를 초기화하고 이벤트를 잡기위해 시작시킨다.
while(true)
{
WatchKey key = watchService.take(); // this would return you keys
}
5. 키 이벤트들을 통해 실행된다.for (WatchEvent<?> event : key.pollEvents()) {
Kind<?> kind = event.kind();
System.out.println("Event on " + event.context().toString() + " is " + kind);
}
예를들어, temp 디렉토리를 수정하거나 삭제하면 콘솔창에 각각 아래와 같은 문장을 보게 될것이다.Event on temp is ENTRY_MODIFY Event on temp is ENTRY_DELETEDirPolice 소스와 과련된 메서드는 아래에 게시되어있다. (전체 소스코드 다운로드)
/**
* This initiates the police
*/
private void init() {
path = Paths.get("C:\Temp\temp\");
try {
watchService = FileSystems.getDefault().newWatchService();
path.register(watchService, ENTRY_CREATE, ENTRY_DELETE,
ENTRY_MODIFY);
} catch (IOException e) {
System.out.println("IOException"+ e.getMessage());
}
}
/**
* The police will start making rounds
*/
private void doRounds() {
WatchKey key = null;
while(true) {
try {
key = watchService.take();
for (WatchEvent<?> event : key.pollEvents()) {
Kind<?> kind = event.kind();
System.out.println("Event on " + event.context().toString() + " is " + kind);
}
} catch (InterruptedException e) {
System.out.println("InterruptedException: "+e.getMessage());
}
boolean reset = key.reset();
if(!reset)
break;
}
}
Fork와 Join
Java 프로그램에서 병렬코어들을 효과적으로 사용하는것은 항상 도전이었다. 여러개의 코어에 작업을 나눠주고 결과를 리턴받기위해 그것들을 조인하는 소수의 프레임워크들이 있다. Java7은 Fork와 Join 프레임워크로 이 기능들을 포함했다.기본적으로 소규모 작업이 더 이상의 분할이 없이 해결될 수 있을 때까지 Fork-Join은 작업들을 소규모로 나눈다. divide-and-conquer 알고리즘과 비슷하다. 이 프레임워크에서 주목할만한 중요한 개념은 원칙적으로 worker thread는 더이상 유휴상태일리가 없다는 것이다. 바쁜 worker들로부터 작업을 "훔친다" 는 것은 이 프레임워크가 work-stealing algorithm를 구현했다는 것이다.
Fork-Join 메카니즘을 지원하는 코어 클래스들은 ForkJoinPool과 ForkJoinTask이다.
ForkJoinPool 은 기본적으로 위에서 말했던 work-stealingalgorithm을 구현한 ExecutorService를 특화시켜서 구현한것이다.
우리는 수많은 프로세서들을 동일한 레벨의 대상으로 제공함으로써 ForkJoinPool 객체를 생성한다.
ForkJoinPool pool = new ForkJoinPool(numberOfProcessors)여기서 numberOfProcessors = Runtime.getRunTime().availableProcessors();
그러나 ForkJoinPool의 기본 인스턴스는 위에서 얻은 동일한 개수로 동일한 단계로 설정 해야 한다.
해결해야 할 문제는 ForkJoinTask 안에 만들어져 있다. 그러나 RecursiveAction 과 RecursiveTask 클래스는 특별하게 구현되어 있다. 이 2개 클래스의 차이점은 앞에것은 리턴값이 없는 반면에 뒤에것은 특정 타입의 오브젝트를 리턴한다는 것이다.
여기 당신의 요구사항을 나타낸 RecursiveAction 와 RecursiveTask 클래스를 어떻게 생성하는지 보여주고 있다.(나는 RecursiveAction 클래스를 사용했다.)
public class MyBigProblemTask extends RecursiveAction {
@Override
protected void compute() {
. . . // your problem invocation goes here
}
}
당신은 computing 기능을 필요하는 곳에 compute 메서드를 오버라이드 해야한다. 그리고 ForkJoinPool 안에 있는 호출 메서드 부름으로써 ForkJoinTask를 Executor에 전달한다.pool.invoke(task);
동적 언어 지원
Java는 변수, 메서드와 반환값들의 타입을 컴파일 시간에 체크하는 정적인 유형의 언어이다. JVM은 타입정보를 찾는것에 대한 우려 없이 런타임시간에 강력히 정의된 바이트 코드를 실행시킨다.동적으로 타입이 정해지는 다른 유형의 언어들이 있다. Ruby, Python, Clojure 는 이 분류에 속한다. 이 언어들은 타입이 실행시간때까지 정해지지 않는다. 어떤 필요한 타입의 정보를 가지고 있지 않다는것은 Java에서는 불가능하다.
동적 언어를 효과적으로 실행하는 것을 임시적으로 처리한것에 대한 자바진형에 압력이 증가하였다. 이들 언어들을 JVM에서 실행하는 것이 가능할지라도, 제약과 제한이 없는 것 은 아니었다.
Java7에 있는 동적호출이라는 새로운 기능을 소개하였다. 이것은 자바 이외의 언어의 요구사항을 포함하기 위해 가상머신을 변경하여 만든것이다. java.lang.invoke 라는 새로운 패키지는 MethodHandle, CallSite등과 같은 클래스로 구성되어있고 동적 언어에 대한 지원을 확장하기 위해 만들어졌다.
마무리
우리가 알아본 Java7은 개발자의 얼굴을 웃음짓게 할 몇 가지 부가 기능들을 가지고 있다. 그리고 오픈소스 지원과 JVM 확장을 통한 동적언어 지원은 자바 진형 이외의 개발자들에게도 좋은 평가를 받을것임에 틀림없다.출처 - http://www.hanb.co.kr/network/view.html?bi_id=1780
===================================================================================
자바 7에서 관심 있는 부분과 아쉬운 점
출처 - http://gyumee.egloos.com/3196932
'Development > Java' 카테고리의 다른 글
| java - File 클래스 (0) | 2012.10.23 |
|---|---|
| java - xml 읽고 쓰기 (1) | 2012.10.22 |
| java - 메서드 체인닝(Method chaining) (0) | 2012.10.08 |
| java - Timer 및 TimerTask Class (0) | 2012.10.06 |
| java - 가비지 컬렉션(Garbage Collection) (0) | 2012.10.05 |
