npejava

1. 關於java的異常處理，請詳細解析

A、C、F
unchecked exception，未檢查異常，繼承自RuntimeException，不需要顯示的捕獲，比如空指針異常。通常這種異常是可以避免的，比如通過檢驗對象是否為空，避免發生NPE。

如果只是想要獲取異常的描述信息，可以通過e.getMessage()獲取。
如果要獲取異常棧信息，則可以通過e.printStackTrace()獲取。

2. java.lang.NullPointerException錯誤，請教高手

樓上在說啥涅？這個不是簡單網頁的問題咧。。寫java估計都是用MyEclipse的吧。呵呵，問題在代碼上有一句遺漏了。

首先說一下，這個是空指針異常，估計你不會不知道的，呵呵。

具體問題在你的 rs = stmt.executeQuery(sql)這一行吧。
因為你的sql沒有定義語句，所以rs就為NULL，得不到值，你列印的時候就NullPointerException了唄。

而且一般都不建議這樣寫程序，一般都把增刪查改的函數分開來寫，寫在另外一個專用的工具類裡面。語句也是寫在函數中，不是在外面寫。這樣也免了你拼字元串的辛苦。如果有什麼問題可以「知道」我，我基本在線的。

回答完畢，給分吧。

3. 試編程：求一個數的絕對值。列如輸入-5，則輸出5。第1題怎麼寫

作者 | 沉默王二

來源 | CSDN博客

頭圖 | 付費下載自視覺中國

出品 | CSDN（ID:CSDNnews）
想學習，永遠都不晚，尤其是針對 Java 8 裡面的好東西，Optional 就是其中之一，該類提供了一種用於表示可選值而非空引用的類級別解決方案。作為一名 Java 程序員，我真的是煩透了 NullPointerException（NPE），盡管和它熟得就像一位老朋友，知道它也是迫不得已——程序正在使用一個對象卻發現這個對象的值為 null，於是 Java 虛擬機就怒發沖冠地把它拋了出來當做替罪羊。

當然了，我們程序員是富有責任心的，不會坐視不管，於是就有了大量的 null 值檢查。盡管有時候這種檢查完全沒有必要，但我們已經習慣了例行公事。終於，Java 8 看不下去了，就引入了 Optional，以便我們編寫的代碼不再那麼刻薄呆板。
沒有 Optional 會有什麼問題
我們來模擬一個實際的應用場景。小王第一天上班，領導老馬就給他安排了一個任務，要他從資料庫中根據會員 ID 拉取一個會員的姓名，然後將姓名列印到控制台。雖然是新來的，但這個任務難不倒小王，於是他花了 10 分鍾寫下了這段代碼：
1public class WithoutOptionalDemo {
2 class Member {
3 private String name;
4
5 public String getName() {
6 return name;
7 }
8
9 public void setName(String name) {
10 this.name = name;
11 }
12 }
13
14 public static void main(String[] args) {
15 Member mem = getMemberByIdFromDB();
16 if (mem != null) {
17 System.out.println(mem.getName());
18 }
19 }
20
21 public static Member getMemberByIdFromDB() {
22 // 當前 ID 的會員不存在
23 return null;
24 }
25}

由於當前 ID 的會員不存在，所以 getMemberByIdFromDB() 方法返回了 null 來作為沒有獲取到該會員的結果，那就意味著在列印會員姓名的時候要先對 mem 判空，否則就會拋出 NPE 異常，不信？讓小王把 if (mem != null) 去掉試試，控制台立馬列印錯誤堆棧給你顏色看看。
1Exception in thread "main" java.lang.NullPointerException
2 at com.cmower.dzone.optional.WithoutOptionalDemo.main(WithoutOptionalDemo.java:24)

Optional 是如何解決這個問題的
小王把代碼提交後，就興高采烈地去找老馬要新的任務了。本著虛心學習的態度，小王請求老馬看一下自己的代碼，於是老王就告訴他應該嘗試一下 Optional，可以避免沒有必要的 null 值檢查。現在，讓我們來看看小王是如何通過 Optional 來解決上述問題的。
1public class OptionalDemo {
2 public static void main(String[] args) {
3 Optional optional = getMemberByIdFromDB();
4 optional.ifPresent(mem -> {
5 System.out.println("會員姓名是：" + mem.getName());
6 });
7 }
8
9 public static Optional getMemberByIdFromDB() {
10 boolean hasName = true;
11 if (hasName) {
12 return Optional.of(new Member("沉默王二"));
13 }
14 return Optional.empty();
15 }
16}
17class Member {
18 private String name;
19
20 public String getName() {
21 return name;
22 }
23
24 // getter / setter
25}

getMemberByIdFromDB() 方法返回了 Optional 作為結果，這樣就表明 Member 可能存在，也可能不存在，這時候就可以在 Optional 的 ifPresent() 方法中使用 Lambda 表達式來直接列印結果。
Optional 之所以可以解決 NPE 的問題，是因為它明確的告訴我們，不需要對它進行判空。它就好像十字路口的路標，明確地告訴你該往哪走。
創建 Optional 對象
1）可以使用靜態方法 empty() 創建一個空的 Optional 對象
1Optional empty = Optional.empty();
2System.out.println(empty); // 輸出：Optional.empty

2）可以使用靜態方法 of() 創建一個非空的 Optional 對象
1Optional opt = Optional.of("沉默王二");
2System.out.println(opt); // 輸出：Optional[沉默王二]

當然了，傳遞給 of() 方法的參數必須是非空的，也就是說不能為 null，否則仍然會拋出 NullPointerException。
1String name = null;
2Optional optnull = Optional.of(name);

3）可以使用靜態方法 ofNullable() 創建一個即可空又可非空的 Optional 對象
1String name = null;
2Optional optOrNull = Optional.ofNullable(name);
3System.out.println(optOrNull); // 輸出：Optional.empty

ofNullable() 方法內部有一個三元表達式，如果為參數為 null，則返回私有常量 EMPTY；否則使用 new 關鍵字創建了一個新的 Optional 對象——不會再拋出 NPE 異常了。
判斷值是否存在
可以通過方法 isPresent() 判斷一個 Optional 對象是否存在，如果存在，該方法返回 true，否則返回 false——取代了 obj != null 的判斷。
1Optional opt = Optional.of("沉默王二");
2System.out.println(opt.isPresent()); // 輸出：true
3
4Optional optOrNull = Optional.ofNullable(null);
5System.out.println(opt.isPresent()); // 輸出：false

Java 11 後還可以通過方法 isEmpty() 判斷與 isPresent() 相反的結果。
1Optional opt = Optional.of("沉默王二");
2System.out.println(opt.isPresent()); // 輸出：false
3
4Optional optOrNull = Optional.ofNullable(null);
5System.out.println(opt.isPresent()); // 輸出：true

非空表達式
Optional 類有一個非常現代化的方法——ifPresent()，允許我們使用函數式編程的方式執行一些代碼，因此，我把它稱為非空表達式。如果沒有該方法的話，我們通常需要先通過 isPresent() 方法對 Optional 對象進行判空後再執行相應的代碼：
1Optional optOrNull = Optional.ofNullable(null);
2if (optOrNull.isPresent()) {
3 System.out.println(optOrNull.get().length());
4}

有了 ifPresent() 之後，情況就完全不同了，可以直接將 Lambda 表達式傳遞給該方法，代碼更加簡潔，更加直觀。
1Optional opt = Optional.of("沉默王二");
2opt.ifPresent(str -> System.out.println(str.length()));

Java 9 後還可以通過方法 ifPresentOrElse(action, emptyAction) 執行兩種結果，非空時執行 action，空時執行 emptyAction。
1Optional opt = Optional.of("沉默王二");
2opt.ifPresentOrElse(str -> System.out.println(str.length()), () -> System.out.println("為空"));

設置（獲取）默認值
有時候，我們在創建（獲取） Optional 對象的時候，需要一個默認值，orElse() 和 orElseGet() 方法就派上用場了。
orElse() 方法用於返回包裹在 Optional 對象中的值，如果該值不為 null，則返回；否則返回默認值。該方法的參數類型和值得類型一致。
1String nullName = null;
2String name = Optional.ofNullable(nullName).orElse("沉默王二");
3System.out.println(name); // 輸出：沉默王二

orElseGet() 方法與 orElse() 方法類似，但參數類型不同。如果 Optional 對象中的值為 null，則執行參數中的函數。
1String nullName = null;
2String name = Optional.ofNullable(nullName).orElseGet(()->"沉默王二");
3System.out.println(name); // 輸出：沉默王二

從輸出結果以及代碼的形式上來看，這兩個方法極其相似，這不免引起我們的懷疑，Java 類庫的設計者有必要這樣做嗎？
假設現在有這樣一個獲取默認值的方法，很傳統的方式。
1public static String getDefaultValue() {
2 System.out.println("getDefaultValue");
3 return "沉默王二";
4}

然後，通過 orElse() 方法和 orElseGet() 方法分別調用 getDefaultValue() 方法返回默認值。
1public static void main(String[] args) {
2 String name = null;
3 System.out.println("orElse");
4 String name2 = Optional.ofNullable(name).orElse(getDefaultValue());
5
6 System.out.println("orElseGet");
7 String name3 = Optional.ofNullable(name).orElseGet(OrElseOptionalDemo::getDefaultValue);
8}

註：類名 :: 方法名是 Java 8 引入的語法，方法名後面是沒有 () 的，表明該方法並不一定會被調用。
輸出結果如下所示：
1orElse
2getDefaultValue
3
4orElseGet
5getDefaultValue

輸出結果是相似的，沒什麼太大的不同，這是在 Optional 對象的值為 null 的情況下。假如 Optional 對象的值不為 null 呢？
1public static void main(String[] args) {
2 String name = "沉默王三";
3 System.out.println("orElse");
4 String name2 = Optional.ofNullable(name).orElse(getDefaultValue());
5
6 System.out.println("orElseGet");
7 String name3 = Optional.ofNullable(name).orElseGet(OrElseOptionalDemo::getDefaultValue);
8}

輸出結果如下所示：
1orElse
2getDefaultValue
3orElseGet

咦，orElseGet() 沒有去調用 getDefaultValue()。哪個方法的性能更佳，你明白了吧？
獲取值
直觀從語義上來看，get() 方法才是最正宗的獲取 Optional 對象值的方法，但很遺憾，該方法是有缺陷的，因為假如 Optional 對象的值為 null，該方法會拋出 NoSuchElementException 異常。這完全與我們使用 Optional 類的初衷相悖。
1public class GetOptionalDemo {
2 public static void main(String[] args) {
3 String name = null;
4 Optional optOrNull = Optional.ofNullable(name);
5 System.out.println(optOrNull.get());
6 }
7}

這段程序在運行時會拋出異常：
1Exception in thread "main" java.util.NoSuchElementException: No value present
2 at java.base/java.util.Optional.get(Optional.java:141)
3 at com.cmower.dzone.optional.GetOptionalDemo.main(GetOptionalDemo.java:9)

盡管拋出的異常是 NoSuchElementException 而不是 NPE，但在我們看來，顯然是在「五十步笑百步」。建議 orElseGet() 方法獲取 Optional 對象的值。
過濾值
小王通過 Optional 類對之前的代碼進行了升級，完成後又興高采烈地跑去找老馬要任務了。老馬覺得這小夥子不錯，頭腦靈活，又幹活積極，很值得培養，就又交給了小王一個新的任務：用戶注冊時對密碼的長度進行檢查。
小王拿到任務後，樂開了花，因為他剛要學習 Optional 類的 filter() 方法，這就派上了用場。
1public class FilterOptionalDemo {
2 public static void main(String[] args) {
3 String password = "12345";
4 Optional opt = Optional.ofNullable(password);
5 System.out.println(opt.filter(pwd -> pwd.length() > 6).isPresent());
6 }
7}

filter() 方法的參數類型為 Predicate（Java 8 新增的一個函數式介面），也就是說可以將一個 Lambda 表達式傳遞給該方法作為條件，如果表達式的結果為 false，則返回一個 EMPTY 的 Optional 對象，否則返回過濾後的 Optional 對象。
在上例中，由於 password 的長度為 5 ，所以程序輸出的結果為 false。假設密碼的長度要求在 6 到 10 位之間，那麼還可以再追加一個條件。來看小王增加難度後的代碼。
1Predicate len6 = pwd -> pwd.length() > 6;
2Predicate len10 = pwd -> pwd.length() < 10;
3
4password = "1234567";
5opt = Optional.ofNullable(password);
6boolean result = opt.filter(len6.and(len10)).isPresent();
7System.out.println(result);

這次程序輸出的結果為 true，因為密碼變成了 7 位，在 6 到 10 位之間。想像一下，假如小王使用 if-else 來完成這個任務，代碼該有多冗長。
轉換值
小王檢查完了密碼的長度，仍然覺得不夠盡興，覺得要對密碼的強度也進行檢查，比如說密碼不能是「password」，這樣的密碼太弱了。於是他又開始研究起了 map() 方法，該方法可以按照一定的規則將原有 Optional 對象轉換為一個新的 Optional 對象，原有的 Optional 對象不會更改。
先來看小王寫的一個簡單的例子：
1public class OptionalMapDemo {
2 public static void main(String[] args) {
3 String name = "沉默王二";
4 Optional nameOptional = Optional.of(name);
5 Optional intOpt = nameOptional
6 .map(String::length);
7
8 System.out.println( intOpt.orElse(0));
9 }
10}

在上面這個例子中，map() 方法的參數 String::length，意味著要 將原有的字元串類型的 Optional 按照字元串長度重新生成一個新的 Optional 對象，類型為 Integer。
搞清楚了 map() 方法的基本用法後，小王決定把 map() 方法與 filter() 方法結合起來用，前者用於將密碼轉化為小寫，後者用於判斷長度以及是否是「password」。
1public class OptionalMapFilterDemo {
2 public static void main(String[] args) {
3 String password = "password";
4 Optional opt = Optional.ofNullable(password);
5
6 Predicate len6 = pwd -> pwd.length() > 6;
7 Predicate len10 = pwd -> pwd.length() < 10;
8 Predicate eq = pwd -> pwd.equals("password");
9
10 boolean result = opt.map(String::toLowerCase).filter(len6.and(len10 ).and(eq)).isPresent();
11 System.out.println(result);
12 }
13}

好了，我親愛的讀者朋友，以上就是本文的全部內容了——可以說是史上最佳 Optional 指南了，能看到這里的都是最優秀的程序員，二哥必須要伸出大拇指為你點個贊。
https://blog.csdn.net/qing_gee/article/details/104767082

4. java用ireport 列印報表，求助大神

將需要批量列印的內容生成的結果集傳遞給報表模板就可以了，會自動批量列印。
不預覽循環批量列印要怎樣實現？

需要調用列印介面 JasperPrintManager類可以直接實現列印。具體資料你可以參考Api
我用的是printReport 方法。
主要就是先在伺服器端生成JasperPrint對象，返回給客戶端。
下面代碼網路到的，你可以參考。
import java.io.File;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NameNotFoundException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.sql.DataSource;
import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.JasperPrintManager;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import com.lowagie.text.ExceptionConverter;
import com.sofn.struts.dto.UserInfoDTO;
import com.sofn.struts.op.UserInfo;
import com.sofn.util.UserSessionOperate;
public class ReportViewAction extends Action {
(org.apache.struts.action.ActionMapping, org.apache.struts.action.ActionForm, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
public ActionForward execute(ActionMapping mapping,ActionForm form, HttpServletRequest request,HttpServletResponse response)
throws Exception {
//已編譯文件路徑和格式
String fp =this.getServlet().getServletContext().getRealPath("/")+ "report\\jasper\\"+ request.getAttribute("rdoc")+ ".jasper";
File reportFile = new File(fp);
// System.out.println("報表路徑!!!!!!!"+reportFile);
Map parameters = (Map) request.getAttribute("paras");
byte[] bytes = null;
List list = new ArrayList();
DataSource ds = null;
JasperPrint jasperPrint=null;
//參數傳遞
UserSessionOperate uso = new UserSessionOperate();
String user = uso.getUser(request);
UserInfo eidr = new UserInfo();
UserInfoDTO eidrdto = null;
String deptname = "物流部門";
String username = "陳雲剛";
parameters.put("marker", username);
parameters.put("bumen", deptname);
//資料庫連接
try {
String source = "java:comp/env/jdbc/posuse";
Context ic = null;
if (ic == null)
ic = new InitialContext();
ds = (DataSource) ic.lookup(source);
if (ds == null) {
System.out.println("Reportview----22222!");
}
} catch (NameNotFoundException nfe) {
nfe.toString());
} catch (Exception ne) {
ne.printStackTrace();
}
//使用數據源
if (request.getAttribute("datasource") != null) {
list = (List) request.getAttribute("reportlist");
JRBeanCollectionDataSource jds =new JRBeanCollectionDataSource(list); //使用數據源

}
//使用SQL查詢
try {
jasperPrint =JasperFillManager.fillReport(reportFile.getPath(),parameters,ds.getConnection());//填充報表數據生成JasperPrint對象
JasperPrintManager.printReport(jasperPrint, false);//2008-08-25 直接列印,不用預覽PDF直接列印 true為彈出列印機選擇.false為直接列印.
} catch (JRException jre) {
//System.out.println("Reportview----JRException88888");
jre.printStackTrace();
} catch (ExceptionConverter ec) {
ec.getLocalizedMessage());
ec.printStackTrace();
} catch (NullPointerException npe) {
npe.getLocalizedMessage());
npe.getMessage());
npe.toString());
System.err);
} catch (Exception ee) {
ee.printStackTrace();
}
//輸出
response.setContentType("application/octet-stream");
ServletOutputStream ouputStream = response.getOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(ouputStream);
oos.writeObject(jasperPrint);//將JasperPrint對象寫入對象輸出流中
oos.flush();
oos.close();
ouputStream.flush();
ouputStream.close();
return mapping.findForward("view"); //轉向
}
}

5. 昆明電腦培訓學校告訴你程序員需要掌握哪些開發框架和語言

一般情況下，java編程開發程序員都掌握了許多的編程開發工具和框架來輔助項目工作。今天我們就一起來了解一下，對於java程序員來說有哪些好用的編程框架語言。

Kotlin是JVM上比較新的語言之一，來自IntelliJ開發商JetBrains。它是一種靜態類型語言，旨在提供一種混合OO和FP的編程風格。Kotlin編譯器生成的位元組碼與JVM兼容，可以在JVM上運行及與現有的庫互操作。2017年，谷歌支持將其用於Android開發，Kotlin獲得了重大突破。

JetBrains有一個明確的目標：讓Kotlin成為一種多平台語言，並提供Java互操作性。Kotlin近的成功和成熟水平為它進入伺服器端提供了一個很好的機會。

選擇Kotlin的理由

許多語言都試圖成為更好的Java。Kotlin在語言和生態系統方面做得都很好。成為更好的Java，同時又要保護JVM和巨大的庫空間，這是一場姍姍來遲的進化。這種方法與來自JetBrains和谷歌的支持相結合，使它成為一個真正的競爭者。讓我們來看看Kotlin帶來的一些特性。

類型推斷——類型推斷是一等特性。Kotlin推斷變數的類型，而不需要顯式指定。在需要明確類型的情況下，也可以指定類型。

通過引入var關鍵字，Java10也在朝著類似的方向發展。雖然表面看起來類似，但它的范圍僅限於局部變數，不能用於欄位和方法簽名。

嚴格空檢查——Kotlin將可空代碼流視為編譯時錯誤。它提供了額外的語法來處理空檢查。值得注意的是，它提供了鏈式調用中的NPE保護。

與Java互操作——Kotlin在這方面明顯優於其他JVM語言。它可以與Java無縫地交互。可以在Kotlin中導入框架中的Java類並使用，反之亦然。值得注意的是，Kotlin集合可以與Java集合互操作。

不變性——Kotlin鼓勵使用不可變的數據結構。常用的數據結構(Set/List/Map)是不可變的，除非顯式地聲明為可變的。變數也被指定為不可變(val)和可變(var)。昆明北大青鳥http://www.kmbdqn.cn/發現所有這些變化對狀態可管理性的影響是顯而易見的。

簡潔而富有表達力的語法——Kotlin引入了許多改進，這些改進對代碼的可讀性產生了重大影響。

6. 如何更好地使用Java 8的Optional

Java 8中的Optional<T>是一個可以包含或不可以包含非空值的容器對象，在 Stream API中很多地方也都使用到了Optional。
java中非常討厭的一點就是nullpoint，碰到空指針就會出錯拋Exception，然後需要逐行檢查是哪個對象為空，帶來大量的不必要精力損耗，拋出NPE錯誤不是用戶操作的錯誤，而是開發人員的錯誤，應該被避免，那麼只能在每個方法中加入非空檢查，閱讀性和維護性都比較差。
如下面這個代碼的手工非空檢查：
public void addAddressToCustomer(Customer customer, Address newAddress){ if ( customer == null || newAddress == null) return; if ( customer.getAddresses() == null ){ customer.setAddresses ( new ArrayList<>()); } customer.addAddress(newAddress);}

另外還有一些開發人員喜歡通過非空檢查來實現業務邏輯，空對象不應該用來決定系統的行為，它們是意外的Exceptional值，應當被看成是錯誤，而不是業務邏輯狀態。
當我們一個方法返回List集合時，應該總是返回一個空的List，而不是Null，這就允許調用者能夠遍歷它而不必檢查Null，否則就拋出NPE。
但是如果我們根據標識鍵ID查詢資料庫，沒有查到，需要返回一個空對象怎麼辦？有人建議拋出Exception，其實這不符合函數方法一進一出的原則，變成一個函數方法有兩個返回，一個是正常返回，一個出錯Exception，函數式編程範式告誡我們不要輕易拋Exception。
這時Java 8的Optional就發揮作用了，允許我們返回一個空的對象。
Optional<T>有方法 isPresent() 和 get() 是用來檢查其包含的對象是否為空或不是，然後返回它，如：
Optional<SomeType> someValue = someMethod();
if (someValue.isPresent()) { // check
someValue.get().someOtherMethod(); // retrieve and call
}
但是這種用法並不能體現Java 8的全部好處，你可以將Optional看成是需要使用某個T值的方法之間某種中間人或者協調者Mediator，而不只是一個普通對象的包裝器。
如果你有一個值返回類型T，你有一個方法需要使用這個值，那麼你可以讓 Optional<T> 處於中間，確保它們之間交互進行，而不必要人工干預。
這樣，協調者Optional<T>能夠照顧T的值提供給你的方法作為輸入參數，在這種情況下，如果T是空，可以確保不會出錯，這樣在T值為空時也可以讓一切都正常運作，你也可以讓Optional<T>執行其他動作，如執行一段代碼塊等等，這樣它就實際上是語言機制的很好的補充。
下面這個案例涉及到Lambda表達式 方法引用，是將單詞流中第一個以"L"開始單詞取出，作為返回結果是一個Optional<String>。

7. Java的異常中什麼是」被檢查的異常「，什麼是」不被檢查的異常「被檢查是怎樣檢查的

Java中異常分為2種情況One：已檢查異常(編譯異常)Two：未檢查異常(RunIng異常)檢查時異常指的是在編譯期間Java的編譯器對代碼的一種檢測比如 int i;System.out.println(i+2);在編譯期就過不去,Java對變數的使用必須初始化為檢查異常就比較多了數組越界,類型轉換錯誤,空指針........在程序跑起來之後才曉得

8. 如何更好地使用Java 8的Optional

Java8中的Optional是一個可以包含或不可以包含非空值的容器對象，在StreamAPI中很多地方也都使用到了Optional。java中非常討厭的一點就是nullpoint，碰到空指針就會出錯拋Exception，然後需要逐行檢查是哪個對象為空，帶來大量的不必要精力損耗，拋出NPE錯誤不是用戶操作的錯誤，而是開發人員的錯誤，應該被避免，那麼只能在每個方法中加入非空檢查，閱讀性和維護性都比較差。如下面這個代碼的手工非空檢查：(Customercustomer,AddressnewAddress){if(customer==null||newAddress==null)return;if(customer.getAddresses()==null){customer.setAddresses(newArrayList());}customer.addAddress(newAddress);}另外還有一些開發人員喜歡通過非空檢查來實現業務邏輯，空對象不應該用來決定系統的行為，它們是意外的Exceptional值，應當被看成是錯誤，而不是業務邏輯狀態。當我們一個方法返回List集合時，應該總是返回一個空的List，而不是Null，這就允許調用者能夠遍歷它而不必檢查Null，否則就拋出NPE。但是如果我們根據標識鍵ID查詢資料庫，沒有查到，需要返回一個空對象怎麼？有人建議拋出Exception，其實這不符合函數方法一進一出的原則，變成一個函數方法有兩個返回，一個是正常返回，一個出錯Exception，函數式編程範式告誡我們不要輕易拋Exception。這時Java8的Optional就發揮作用了，允許我們返回一個空的對象。Optional有方法isPresent()和get()是用來檢查其包含的對象是否為空或不是，然後返回它，如：OptionalsomeValue=someMethod();if(someValue.isPresent()){//checksomeValue.get().someOtherMethod();//retrieveandcall}但是這種用法並不能體現Java8的全部好處，你可以將Optional看成是需要使用某個T值的方法之間某種中間人或者協調者Mediator，而不只是一個普通對象的包裝器。如果你有一個值返回類型T，你有一個方法需要使用這個值，那麼你可以讓Optional處於中間，確保它們之間交互進行，而不必要人工干預。這樣，協調者Optional能夠照顧T的值提供給你的方法作為輸入參數，在這種情況下，如果T是空，可以確保不會出錯，這樣在T值為空時也可以讓一切都正常運作，你也可以讓Optional執行其他動作，如執行一段代碼塊等等，這樣它就實際上是語言機制的很好的補充。下面這個案例涉及到Lambda表達式方法引用，是將單詞流中第一個以"L"開始單詞取出，作為返回結果是一個Optional。