linuxism

Java 7.0 의 놀라운(?)특징 들에 대해서 간단하게 설명하려 합니다.

출처 - 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파일은 이곳에서 다운로드 받을 수 있다.

개선된 점들

Map<String, List<Trade>> trades = new TreeMap<String, List<Trade>> ();

Map<String, List<Trade>> trades = new TreeMap <> ();

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

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

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
    }
  }
}

try(resources_to_be_cleant){
  // your code
}

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
  }
}

int thousand =  1_000;

int million  =  1_000_000

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
  }
}

public void newMultiCatch() {
  try {
    methodThatThrowsThreeExceptions();
  } catch (ExceptionOne | ExceptionTwo | ExceptionThree e) {
    // log and deal with all Exceptions
  }
}

public void newMultiMultiCatch() {
  try {
    methodThatThrowsThreeExceptions();
  } catch (ExceptionOne e) {
    // log and deal with ExceptionOn
  } catch (ExceptionTwo | ExceptionThree e) {
    // log and deal with ExceptionTwo and ExceptionThree
  }
}

새로운 파일 시스템 API (NIO 2.0)

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

• WatchService를 생성한다. 이 서비스는 WatchKeys를 가지고 있는 큐로 구성되어있다.
• 이 WatchService로 모니터링하고 싶은 디렉토리나 파일을 등록한다.
• 등록하는 동안 받고 싶은 이벤트의 타입을 정의한다. (추가, 수정, 삭제등)
• 이벤트를 받기위해 무한대 루프를 실행시켜야만 한다.
• 이벤트가 발생하면 WatchKey 가 큐안으로 저장된다.
• WatchKey를 사용하기 위해 쿼리를 호출한다.

WatchService  watchService = FileSystems.getDefault().newWatchService();

path = Paths.get("C:\Temp\temp\");

dirToWatch.register(watchService, ENTRY_CREATE, ENTRY_MODIFY, ENTRY_DELETE);

while(true)
{
  WatchKey key = watchService.take(); // this would return you keys
}

for (WatchEvent<?> event : key.pollEvents()) {
  Kind<?> kind = event.kind();
  System.out.println("Event on " + event.context().toString() + " is " + kind);
}

Event on temp is ENTRY_MODIFY 

Event on temp is ENTRY_DELETE

/**
 * 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

ForkJoinPool pool = new ForkJoinPool(numberOfProcessors)

public class MyBigProblemTask extends RecursiveAction {
  @Override
  protected void compute() {
    . . . // your problem invocation goes here
  }
}

pool.invoke(task);

동적 언어 지원

마무리

출처 - http://www.hanb.co.kr/network/view.html?bi_id=1780

===================================================================================

자바 7에서 관심 있는 부분과 아쉬운 점

출처 - http://gyumee.egloos.com/3196932

SQL joins are used to query data from two or more tables, based on a relationship between certain columns in these tables. This means everything you have learned so far can be applied after you’ve created this new, joined table.

How Does a Join Work?

Let’s begin by looking at our two tables, the supplier table and the product. First, the supplier table contains the following rows:

mysql> SELECT * FROM suppliers;
+-------------+---------------+-------------------+------------------+
| supplier_id | supplier_name | supplier_address  | supplier_contact |
+-------------+---------------+-------------------+------------------+
|           1 | Microsoft     | 1 Microsoft Way   | Bill Gates       |
|           2 | Apple, Inc.   | 1 Infinite Loop   | Steve Jobs       |
|           3 | EasyTech      | 100 Beltway Drive | John Williams    |
|           4 | WildTech      | 100 Hard Drive    | Alan Wilkes      |
+-------------+---------------+-------------------+------------------+
4 rows in set (0.00 sec)

And our product table contains the following rows:

SELECT * FROM product;
+-----------+----------------------------+-----------------------------+-------------+
| prod_code | prod_name                  | prod_desc                   | supplier_id |
+-----------+----------------------------+-----------------------------+-------------+
|         1 | CD-RW Model 4543           | CD Writer                   |           3 |
|         2 | EasyTech Mouse 7632        | Cordless Mouse              |           3 |
|         3 | WildTech 250Gb 1700        | SATA Disk Drive             |           4 |
|         4 | Microsoft 10-20 Keyboard   | Ergonomic Keyboard          |           1 |
|         5 | Apple iPhone 8Gb           | Smart Phone                 |           2 |
+-----------+----------------------------+-----------------------------+-------------+

As you can see from the above output, the product rows contain a column which holds the supplier_id of the supplier from which the product is obtained. Now that we have the tables created, we can begin to perform some joins.

Performing a Cross-Join

Joining tables involves combining rows from two tables. The most basic of join types is the cross-join. The cross-join simply assigns a row from one table to every row of the second table. This is of little or no use in real terms, but for the purposes of completeness, the syntax for a cross-join is as follows:

SELECT column_names FROM table1, table2;

For example, if we were to perform the following command on our sample table we would get the following output:

+----------------------------+---------------+
| prod_name                  | supplier_name |
+----------------------------+---------------+
| CD-RW Model 4543           | Microsoft     |
| CD-RW Model 4543           | Apple, Inc.   |
| CD-RW Model 4543           | EasyTech      |
| CD-RW Model 4543           | WildTech      |
| EasyTech Mouse 7632        | Microsoft     |
| EasyTech Mouse 7632        | Apple, Inc.   |
| EasyTech Mouse 7632        | EasyTech      |
| EasyTech Mouse 7632        | WildTech      |
| WildTech 250Gb 1700        | Microsoft     |
| WildTech 250Gb 1700        | Apple, Inc.   |
| WildTech 250Gb 1700        | EasyTech      |
| WildTech 250Gb 1700        | WildTech      |
| Microsoft 10-20 Keyboard   | Microsoft     |
| Microsoft 10-20 Keyboard   | Apple, Inc.   |
| Microsoft 10-20 Keyboard   | EasyTech      |
| Microsoft 10-20 Keyboard   | WildTech      |
| Apple iPhone 8Gb           | Microsoft     |
| Apple iPhone 8Gb           | Apple, Inc.   |
| Apple iPhone 8Gb           | EasyTech      |
| Apple iPhone 8Gb           | WildTech      |
+----------------------------+---------------+

As you can see, it is hard to imagine how this could of use in many situations. A much more useful type of join is the Equi-Join or Inner Join.

Equi-Join (aka the Inner Join)

The Equi-Join joins rows from two or more tables based on comparisons between a specific column in each table. The syntax for this approach is as follows:

SELECT column_names FROM table1, table2 WHERE (table1.column = table2.column);

For example, to extract the product name and supplier name for each row in our product table we would use the following command:

SELECT prod_name, supplier_name, supplier_address FROM product, suppliers WHERE (product.supplier_id = suppliers.supplier_id);

Note that we have to use what is known as the fully qualified name for the supplier_id column in each table since both tables contain a supplier_id. A fully qualified column name is defined by specifying the table name followed by a dot (.) and then the column name.

The result of the above command is to produces a list of products and the name and address of the supplier for each product:

+--------------------------+---------------+-------------------+
| prod_name                | supplier_name | supplier_address  |
+--------------------------+---------------+-------------------+
| Microsoft 10-20 Keyboard | Microsoft     | 1 Microsoft Way   |
| Apple iPhone 8Gb         | Apple, Inc.   | 1 Infinite Loop   |
| CD-RW Model 4543         | EasyTech      | 100 Beltway Drive |
| EasyTech Mouse 7632      | EasyTech      | 100 Beltway Drive |
| WildTech 250Gb 1700      | WildTech      | 100 Hard Drive    |
+--------------------------+---------------+-------------------+
5 rows in set (0.00 sec)

Performing a Left Join or a Right Join

Another way to join tables is use a LEFT JOIN in the select statement.The LEFT JOIN causes the tables to be joined before any WHERE clause is used. The syntax for this type of join is:

SELECT column names FROM table1 LEFT JOIN table2 ON (table1.column = table2.column);

Therefore, we can perform a LEFT JOIN that gives us the same result as our Equi-Join:

SELECT prod_name, supplier_name, supplier_address FROM product LEFT JOIN suppliers 
ON (product.supplier_id = suppliers.supplier_id);
+----------------------------+---------------+-------------------+
| prod_name                  | supplier_name | supplier_address  |
+----------------------------+---------------+-------------------+
| CD-RW Model 4543           | EasyTech      | 100 Beltway Drive |
| EasyTech Mouse 7632        | EasyTech      | 100 Beltway Drive |
| WildTech 250Gb 1700        | WildTech      | 100 Hard Drive    |
| Microsoft 10-20 Keyboard   | Microsoft     | 1 Microsoft Way   |
| Apple iPhone 8Gb           | Apple, Inc.   | 1 Infinite Loop   |
+----------------------------+---------------+-------------------+

One key different with the LEFT JOIN is that it will also list rows from the first table for which there is no match in the second table. For example, suppose we have product in our product table for which there is no matching supplier in the supplier table. When we run our SELECT statement the row will still be displayed, but with NULL values for the supplier columns since no such supplier exists:

+----------------------------+---------------+-------------------+
| prod_name                  | supplier_name | supplier_address  |
+----------------------------+---------------+-------------------+
| CD-RW Model 4543           | EasyTech      | 100 Beltway Drive |
| EasyTech Mouse 7632        | EasyTech      | 100 Beltway Drive |
| WildTech 250Gb 1700        | WildTech      | 100 Hard Drive    |
| Microsoft 10-20 Keyboard   | Microsoft     | 1 Microsoft Way   |
| Apple iPhone 8Gb           | Apple, Inc.   | 1 Infinite Loop   |
| Moto Razr                  | NULL          | NULL              |
+----------------------------+---------------+-------------------+

The opposite effect can be achieved using a RIGHT JOIN, whereby all the rows in a the second table (i.e. our supplier table) will be displayed regardless of whether that supplier has any products in ourproduct table:

SELECT prod_name, supplier_name, supplier_address FROM product RIGHT JOIN suppliers 
ON (product.supplier_id = suppliers.supplier_id); 
+--------------------------+-----------------+------------------------+
| prod_name                | supplier_name   | supplier_address       |
+--------------------------+-----------------+------------------------+
| Microsoft 10-20 Keyboard | Microsoft       | 1 Microsoft Way        |
| Apple iPhone 8Gb         | Apple, Inc.     | 1 Infinite Loop        |
| CD-RW Model 4543         | EasyTech        | 100 Beltway Drive      |
| EasyTech Mouse 7632      | EasyTech        | 100 Beltway Drive      |
| WildTech 250Gb 1700      | WildTech        | 100 Hard Drive         |
| NULL                     | Hewlett Packard | 100 Printer Expressway |
+--------------------------+-----------------+------------------------+

Creating Joins with WHERE and USING

The next step is to incorporate some WHERE clauses into our LEFT and RIGHT joins. Say, for example, that we wish to list only products supplied by Microsoft:

SELECT prod_name, supplier_name, supplier_address FROM product RIGHT JOIN suppliers 
ON (product.supplier_id = suppliers.supplier_id) WHERE supplier_name='Microsoft';
+--------------------------+---------------+------------------+
| prod_name                | supplier_name | supplier_address |
+--------------------------+---------------+------------------+
| Microsoft 10-20 Keyboard | Microsoft     | 1 Microsoft Way  |
+--------------------------+---------------+------------------+
1 row in set (0.00 sec)

The USING clause further simplifies the tasks of creating joins. The purpose of USING is to avoid the use of fully qualified names (such as product.supplier_id and supplier.supplier_id) when reference columns that reside in different tables but have the names. For example, to perform the same join above based on the values of product.supplier_id and supplier.supplier_id we can simply use the following syntax:

SELECT prod_name, supplier_name, supplier_address FROM product 
LEFT JOIN suppliers USING (supplier_id) WHERE supplier_name='Microsoft';

Resulting in the following output:

+--------------------------+---------------+------------------+
| prod_name                | supplier_name | supplier_address |
+--------------------------+---------------+------------------+
| Microsoft 10-20 Keyboard | Microsoft     | 1 Microsoft Way  |
+--------------------------+---------------+------------------+
1 row in set (0.00 sec)

출처 - http://webduos.com/mysql-join-syntax/#.UIC1-W8xqAg

===================================================================================

출처 - http://creaplz.tistory.com/97

javascript Map HashMap

출처 - http://atspeed.blogspot.kr/2011/01/javascript-hashmap.html