albert's blog

2016/09/04

[POI] Write /Read Excel Files in Java using Apache POI

Here has a simple example to demonstrate how to write / read excel file via Apache POI.

Add Apache POI dependency:

<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml</artifactId>
    <version>3.14</version>
</dependency>

Create a POJO class:

package albert.practice.poi;

import java.io.Serializable;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

@Data
@ToString
@AllArgsConstructor
@NoArgsConstructor
public class Issue implements Serializable {
    /**
    * 
    */
    private static final long serialVersionUID = 1L;

    private Integer id;
    private String subject;
    private String status;
    private String priority;
}

Sample code is as bellows:

package albert.practice.poi;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;

import lombok.extern.slf4j.Slf4j;

//http://www.codejava.net/coding/how-to-write-excel-files-in-java-using-apache-poi
//http://viralpatel.net/blogs/java-read-write-excel-file-apache-poi/
@Slf4j
public class PoiExample {

    private static String excelFile = "D:" + File.separator + "issue.xls";

    public static void main(String[] args) throws IOException {
        PoiExample test = new PoiExample();
        test.writeExcel();

        test.readExcel(excelFile);
    }

    public List<Issue> readExcel(String excelFile) throws IOException {

        List<Issue> issues = new ArrayList<Issue>();

        InputStream inputStream = null;
        Workbook workbook = null;
        try {
            // 1. Create a Workbook.
            inputStream = new FileInputStream(new File(excelFile));
            workbook = new HSSFWorkbook(inputStream);

            // 2. Get first sheet
            Sheet sheet = workbook.getSheetAt(0);

            // 3. Iterate through each rows from first sheet
            Iterator<Row> rowIterator = sheet.iterator();
            int rowCount = 1;
            while (rowIterator.hasNext()) {
                // (1) ignore header row
                if (rowCount == 1) {
                rowIterator.next();
                rowCount++;
                }
                // (2) start to read each row from second row
                else {
                    Row row = rowIterator.next();
                    Integer id = Double.valueOf(row.getCell(0).getNumericCellValue()).intValue();
                    String subject = row.getCell(1).getStringCellValue();
                    String status = row.getCell(2).getStringCellValue();
                    String priority = row.getCell(3).getStringCellValue();

                    Issue issue = new Issue();
                    issue.setId(id);
                    issue.setSubject(subject);
                    issue.setStatus(status);
                    issue.setPriority(priority);

                    issues.add(issue);
                 }
             }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (inputStream != null) {
                inputStream.close();
            }
            if (workbook != null) {
                workbook.close();
            }
        }

        for (Issue issue : issues) {
            log.debug("issue = " + issue.toString());
        }

        return issues;
    }

    public void writeExcel() throws IOException {
        // 0. prepare dummy data
        List<Issue> issues = createDummyIssues();

        // 1. Create a Workbook.
        Workbook workbook = new HSSFWorkbook();

        // 2. Create a Sheet.
        Sheet sheet = workbook.createSheet("issue list");

        // 3. create cell style
        CellStyle style = createCellStyle(workbook);

        // 4. Repeat the following steps until all data is processed:
        // (1) Create a Row.
        // (2) Create Cells in a Row. Apply formatting using CellStyle.
        int rowCount = 0;
        Row headerRow = sheet.createRow(rowCount);
        writeHeader(headerRow, style);

        for (Issue issue : issues) {
            Row row = sheet.createRow(++rowCount);
            writeDataForEachRow(issue, row, style);
        }

        // 5. auto resize column width
        for (int i = 0; i < 4; i++) {
            sheet.autoSizeColumn(i);
        }

        // 6. Write to an OutputStream.
        // 7. Close the output stream.
        FileOutputStream outputStream = null;
        try {
            outputStream = new FileOutputStream(excelFile);
            workbook.write(outputStream);

            log.debug("write issue data to excel file successfully");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (outputStream != null) {
                outputStream.close();
            }
            if (workbook != null) {
                workbook.close();
            }
        }
    }

    private void writeHeader(Row headerRow, CellStyle style) {
        Cell cell = headerRow.createCell(0);
        cell.setCellValue("編號");
        cell.setCellStyle(style);

        cell = headerRow.createCell(1);
        cell.setCellValue("主旨");
        cell.setCellStyle(style);

        cell = headerRow.createCell(2);
        cell.setCellValue("狀態");
        cell.setCellStyle(style);

        cell = headerRow.createCell(3);
        cell.setCellValue("優先");
        cell.setCellStyle(style);
    }

    private void writeDataForEachRow(Issue issue, Row row, CellStyle style) {
        Cell cell = row.createCell(0);
        cell.setCellValue(issue.getId());
        cell.setCellStyle(style);

        cell = row.createCell(1);
        cell.setCellValue(issue.getSubject());
        cell.setCellStyle(style);

        cell = row.createCell(2);
        cell.setCellValue(issue.getStatus());
        cell.setCellStyle(style);

        cell = row.createCell(3);
        cell.setCellValue(issue.getPriority());
        cell.setCellStyle(style);
    }

    private CellStyle createCellStyle(Workbook workbook) {
        CellStyle cellStyle = workbook.createCellStyle();
        cellStyle.setBorderBottom((short) 1);
        cellStyle.setBorderTop((short) 1);
        cellStyle.setBorderLeft((short) 1);
        cellStyle.setBorderRight((short) 1);
        cellStyle.setWrapText(true);

        return cellStyle;
    }

    private List<Issue> createDummyIssues() {
        Issue issue1 = new Issue(1, "查不到資料", "新建立", "正常");
        Issue issue2 = new Issue(2, "新增時發生錯誤", "新建立", "高");
        Issue issue3 = new Issue(3, "刪除失敗", "處理中", "高");

        return Arrays.asList(issue1, issue2, issue3);
    }

}

Excel file looks like: https://github.com/junyuo/AlbertGitProject/blob/master/src/albert/practice/poi/issue.xls

Reference
[1] http://www.codejava.net/coding/how-to-write-excel-files-in-java-using-apache-poi
[2] http://viralpatel.net/blogs/java-read-write-excel-file-apache-poi/

2016/09/03

[jackson] How to generate json from java bean and vice versa

Problem
If I would like to do conversation with Java Bean to JSON and JSON to Java Bean, any library can be used?

How-To
Add dependency to your pom.xml

<dependency>
    <groupId>org.codehaus.jackson</groupId>
    <artifactId>jackson-mapper-asl</artifactId>
    <version>1.9.13</version>
</dependency>

Create an User bean for test:

package albert.practice.json;

import java.io.Serializable;

import lombok.Data;
import lombok.ToString;

@Data
@ToString
public class User implements Serializable {
    private static final long serialVersionUID = 1L;

    private String id;
    private String login;
    private String mail;
}

Test code is as bellows:

package albert.practice.json;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.codehaus.jackson.JsonGenerationException;
import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.type.TypeReference;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class JacksonTest {

    public static void main(String[] args) {
        JacksonTest test = new JacksonTest();
        String jsonString = test.convertOjbectToJson();

        List<User> users = test.convertJsonToObject(jsonString);
        for (User user : users) {
           log.debug("user = " + user.toString());
        }
    }

    public List<User> convertJsonToObject(String jsonString) {
        ObjectMapper mapper = new ObjectMapper();
        List<User> users = new ArrayList<User>();
        try {
            users = mapper.readValue(jsonString, new TypeReference<List<User>>() {
        });
    } catch (JsonParseException e) {
        e.printStackTrace();
    } catch (JsonMappingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
        return users;
    }

    public String convertOjbectToJson() {
        List<User> users = createUsers();
        String jsonString = "";

        ObjectMapper mapper = new ObjectMapper();

        try {
            jsonString = mapper.writeValueAsString(users);
        } catch (JsonGenerationException e) {
            e.printStackTrace();
        } catch (JsonMappingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        log.debug("jsonString = " + jsonString);
        return jsonString;
    }

    private List<User> createUsers() {
        User albert = new User();
        albert.setId("1");
        albert.setLogin("albert");
        albert.setMail("albert@gmail.com");

        User mandy = new User();
        mandy.setId("2");
        mandy.setLogin("mandy");
        mandy.setMail("mandy@gmail.com");

        User verio = new User();
        verio.setId("3");
        verio.setLogin("verio");
        verio.setMail("verio@gmail.com");

        List<User> users = new ArrayList<User>();
        users.add(albert);
        users.add(mandy);
        users.add(verio);

        return users;
    }

}

print log:

2016-06-01 15:35:39.630 [main] DEBUG albert.practice.json.JacksonTest - jsonString = [{"id":"1","login":"albert","mail":"albert@gmail.com"},{"id":"2","login":"mandy","mail":"mandy@gmail.com"},{"id":"3","login":"verio","mail":"verio@gmail.com"}]
2016-06-01 15:35:39.670 [main] DEBUG albert.practice.json.JacksonTest - user = User(id=1, login=albert, mail=albert@gmail.com)
2016-06-01 15:35:39.670 [main] DEBUG albert.practice.json.JacksonTest - user = User(id=2, login=mandy, mail=mandy@gmail.com)
2016-06-01 15:35:39.670 [main] DEBUG albert.practice.json.JacksonTest - user = User(id=3, login=verio, mail=verio@gmail.com)

Reference
[1] http://www.mkyong.com/java/how-to-convert-java-object-to-from-json-jackson/
[2] https://stackoverflow.com/questions/28821715/java-lang-classcastexception-java-util-linkedhashmap-cannot-be-cast-to-com-test

2016/09/02

[閱讀筆記] 97 Things Every Programmer Should Know (1/2)

最新式的電腦，只不過是加速加重了人與人之間一直以來的問題，最終，溝通者要面對的，依然在於如何表達出自己要說的
技術債 (technical debt) 就像貸款，你可以為了時程決定「先快速做完」，而不是「做好」，你會在短期內得利，但在債務還清之前都必須支付利息。滿足一時的程式碼，會使新增功能與重構變得困難。時間越久，傷害越大。事實上，往往都是當事情糟到你不得不修正時，你才會真的回頭去解決當初的問題，但是這時候程式碼已經變得很難修正。
記得要儘快償還技術債 (technical debt)，否則會因為草率的行為而嚐到惡果。
我們常認為別人的想法和我們一樣，但事實上不是。心理學將此稱為共識偏誤（false consensus bias)。請直接去問使用者會怎麼操作，你不算是使用者
使用者傾向於只要有能用的方法就好，他們一旦找到一種可行的方法之後，就會一直用，不論這個方法是多麼迂迴。因此，最好準備一條明顯的道路，而不是給兩三種道路供選擇
你也會發現使用者所描述的，和他們實際做的往往有段落差。因此最好的方法是直接觀察使用者，花幾個小時觀察，比起花一整天想使用者到底要什麼，反而可以得到更多資訊
coding standard 應該是靈活不死板的，隨著專案演進，需求改變，一些當初看似聰明的想法，在幾個月後已經不見得聰明了
柏拉圖曾說：風格之美、和諧、優美與節奏取決於簡約。美麗的程式的最低限度是簡單的程式碼。不只職責簡單，與系統的其他部分也要保持簡單的關係。簡單、乾淨、可測試的程式碼，可以提高可讀性、可維護性、開發效率。美，就在簡單中誕生，在簡單之中發現
在你重構前，你要思考：

從現有的程式碼與其對應的測試開始，從當前系統的錯誤中學到教訓
避免全部重寫的誘惑，重寫代表要放棄經年累月的測試
多次漸進式的修改會優於一次大量的修改
每次development iteration結束後，要確保現有的測試都必須通過
程式碼的結構與風格不符合你的喜好，不是重構的正確理由
新技術的出現不足以成為重構的理由
每個人都是會犯錯的，重構不保證新的程式碼一定比較好

童子軍有一條規則：『每次離開營區時，都要讓它比剛到的時候更乾淨』。也就是說，如果你發現環境髒亂，不管是誰造成的，你都要把它打掃乾淨，留給下一批露營者有更好的環境。相同的，你不必在 check in 前讓每個模組盡善盡美，只要讓它比當初 check out 的時候好一點點就可以，如改善了變數名稱、將一個過長的function拆成兩個小的function等。軟體開發團隊要互相幫助，互相清理程式碼。成員門遵循童子軍規則，不只是為了自己，而是因為這對每一個人都好。
Debug 時，回想福爾摩斯的建議：「除去不可能的，剩下的即使不尋常，那也是真相。」
面對multi-thread 的系統，簡潔的設計非常重要，簡潔代表容易debug
程式碼的排版很重要，有研究指出，我們花在瀏覽和閱讀程式碼，找出哪裡該修改的時間，比實際修改的時間多更多。所以程式排版有三個優化措施：易於瀏覽、清楚的排版、緊湊的格式
code review 不只是找出並修正程式錯誤，更重要的是分享知識，並建立普遍的coding方針。code review 的重點是在 review 的過程當中去學習、了解這些程式碼
採用表達力佳（但相對較短）的名稱來命名物件、型別與函式，讓程式碼本身具備如文件的說明能力
註解應該要說出程式碼所沒有表達、也無法表達的事情。如果程式自己可以說清楚的事情，你就不需要為它加上註解
外科醫生知道必須要切出傷口才能進行手術，也知道傷口是暫時的，會痊癒的。害怕改變程式碼導致癱瘓，可能正是造成系統落入癱瘓的起點。投入時間 refactor，對於專案的整個生命週期可以帶來數倍的價值，也因為有了處理病態系統的經驗，也成為了解系統應當如何運作的專家
無論你認為你的程式碼有多麼不可能出現錯誤，你也應該每一次都檢查並處理，即使你現在不做，你也不會省下時間，你未來還是要還債，而且累積越久，要還的債更多，未來會連本帶利要你償還
如果你忽視一項錯誤，選擇視而不見，假裝沒這件事情，你其實在承擔巨大的風險，你也無法預料這個巨大的風險會在何時向你反撲。
放著錯誤不管會造成

脆弱的程式碼且難以debug
不安全的程式碼
糟糕的結構

沒有開發經驗的專案經理會認為程式設計師做的事情很簡單，而沒有管理經驗的程式設計師，也認為專案經理做的事情很簡單
軟體的構成實體，應當對於擴充保持開放，但對修改保持封閉
DRY ( Don’t Repeat Yourself ) 的原則，是指開發人員要學會便是重複的程式碼，也懂得利用更好的實踐和更適當的抽象化來消除重複，比起只知道用不必要的重複來污染程式的人，可以產出更乾淨的程式碼。DRY 原則，位開發人員提供基本指引，幫助開發人員所產出的程式變得更簡單、更容易維護且品質更好
假設有個物件，其典型的特色是需要先完成幾件事情才能開始使用，此時就可以使用abstract factory pattern or factory method pattern 來實現。如果某個物件有多種可變的行為，那麼這些行為可以用strategy pattern 來實作並放進物件，不該用一個巨大的 if-else 結構
當一個class 的containment (封裝）被破壞，常會看到其method 出現大量的if-then-else的結構，這樣的method 很容易崩壞且幾乎無法維護

2016/09/01

[閱讀筆記] Security Analysis (Part 3)

債券的價格與收益，不是經過預期風險的數學計算所決定，其由市場受歡迎度所決定。市場歡迎度反應投資人對此投資標的的風險認定，還有其他因素如社會大眾對此標的的熟悉度以及交易容易度
收益與風險之間的關係無法做精確的數學計算，這不像保險業中的年齡與死亡率之間的關係，有明確的定義。投資的損失不是某個時間點，而是一段時間區間
大型的公司並不保證低風險與健全的財務，當一家公司的資產債務比不成比例的話，即便是大型的公司，體質一樣脆弱
優先股是股票和債券的混血產品，但表現比較像是債券。持有優先股的投資人通常可以領取固定的股利（不論公司盈虧）、若公司破產戶清算時（在普通股之前，債權人之後）優先請求發行公司的收益和資產
優先股的特色有：優先股如債券一樣，如果通貨膨脹率和利率上升，優先股的價值會下滑，如果通貨膨脹率和利率下降，優先股的價值會上揚；優先股投資人不能參與公司的成長，普通股股東則能獲得的資本利得；優先股不像債券那麼安全，因為股利可能逾期未發放
非累積優先股的持有者要注意，公司若該年度的營運不佳或即便是營運良好，公司可以不按照規定的股利分配給股東。累積優先股的股東也不能要求公司在以後年度中予以補發。一般來講，對投資者來說，累積優先股比非累積優先股具有更大的優越性
一般公司會發行優先股有幾個情況：1. 籌資清償債務。2. 籌資度過難關。3. 增加公司資產。公司通常只發行一種普通股，卻可發行好幾種優先股。第一優先配發股利的股票，稱作第一優先股或A級優先股，接下來的優先股稱為第二優先股或B級優先股，以下類推
投資人不要看到"保證收益"的字眼就被沖昏了頭，似乎其提供了安全、無風險的保障，但是實際上，還是要端視發行者的財務狀況。若保證者的財務狀況不佳，其保證是完全沒有保障的
1931年時，不動產市場潰堤，不動產債券持有人總算可以認清，不動產債券的抵押品只是一個名字，其價值完全仰賴其抵押品在當時潰堤後所剩餘的價值
不要因B公司是某強大母公司的子公司，而買此子公司的債券，把合約看清楚，當B公司違約時，母公司是否有需要做擔保，若沒有時，那你要考慮清楚
投資人應該定期檢視手上的投資標的，不要認為其永遠安全無虞。當發現投資標的有問題時，應該將其轉換到另外一個較好的投資標的
如遇到1921-1922、1937-38那種大蕭條的時候，不管是什麼樣的投資組合，一定都很難全身而退、不受影響。不過這時也是一個好時機，針對自己的投資組合做好體檢，並可考慮剃除體質不良的投資標的，並轉換到較好的標的
一般大眾常會尋求銀行的專員提供理財建議，但是其是否正確，有待懷疑。別以為靠理專的建議就可以省下你研究的時間，想要投資就要自己分析、挖掘問題
投資銀行(Investment Banking Houses)的建議並不可靠，因為他們不會是一個公正、客觀的理財顧問，因為他們自己就在販售基金，當然是優先推薦自己家的基金，故別把販售基金的公司的建議當作你的主要資訊來源
如果一直想著想抓住市場鐘擺，永遠想要買在低點、賣在高點，那你是在投機不是在投資
在牛市的時候，跟著人群走很容易，但是判斷哪些是值得買、沒有超過其真實價值的標的，卻是很困難的
人性很習慣的跟著人群走，尤其在dot-com boom的時候，當每個人都在快速致富，你不太容易能保持冷靜，當個旁觀者
清算價值（Liquidation Value）是指公司撤銷或解散時，資產經過清算後，每一股份所代表的實際價值。在理論上，清算價值等於清算時的帳面價值，但由於公司的大多數資產只以低價售出，再扣除清算費用後，清算價值往往小於帳面價值
當公司的股價低於清算價值（Liquidation Value），要麻就是股價太低，不然就是公司即將解散
「價格」與「價值」的缺口，就代表投資的安全保障或邊際，如以40美分的價格買進1美元的紙鈔
當一家了不起的企業，遭遇一個巨大、嚴重，但可解決的問題的衝擊時，這時就是一個絕佳的投資機會
Buffett 會去找一些宣告破產的公司進行評估，若其債務收益率大於目前的權益，他會大舉買進，並取得公司的控制權。以MCI公司為例，若清算其資產只有40億，但是若讓他持續經營，可以產生120~150億的收入，讓MCI重整會比清算來得有利
Graham and Dodd 認為，投資人不應該去購買低評等債券與優先股，應該把注意力放在普通股
股票市場就像一台voting machine，會產生這樣的結果，一部分是偏見，一部分是情緒，而不是一台精確的、公正的weighing machine
市場的價格常常會與其真實價格不一致，但是市場有與生俱來的能力來修正此差異
當一家公司的股票突然停止發放股利時，你應該要考慮去賣掉它。相同的，當一檔債券突然停止配息，你也應該考慮要賣掉它。
Wall Street 裡面沒有 bull，也沒有bear，只有shark，他會持續地尋找食物，把那些資產錯誤配置的投資人的金錢吃光光
多頭市場 (bull market) 總是在悲觀中誕生，在懷疑中成長，在樂觀中成熟，在陶醉中死亡
證券的價格與收益無法透過任何精確的數學計算運算出來，其端視本身受歡迎的程度來決定
Graham與Dodd建議不要購買高收益債券，因為當遭遇危機，經過崩壞後，大部份都無法復原
人性傾向貪婪、恐懼、猜疑與壓力，喜歡跟著人群走，你要有獨立思考能力，抵抗人性弱點，不要害怕與眾不同
A convertible bond should not be converted by the investor. It should be either held or sold.
債券的收益來自當初承諾的配息率；股票的收益來自企業經營績效所配發的股利
股票投資的基本問題是：如何評估一間企業的價值。在1930年代，那時後的企業以煤礦、鐵路、公共事業為主，所以以評估有形資產即可；但目前是以服務業為主的時代，諸如品牌、軟體等，都屬於無形資產，故比以前更難評估
自由現金流(free cash flow)表示的是公司可以自由支配的現金。如果自由現金流豐富，則公司可以償還債務、開發新產品、回購股票、增加股息支付

Total Pageviews