在这篇文章中，我们将带领您了解java.util.Optional学习笔记的全貌，包括javautility.readmenuselection的相关情况。同时，我们还将为您介绍有关'java.lan

在这篇文章中，我们将带领您了解java.util.Optional 学习笔记的全貌，包括java utility.readmenuselection的相关情况。同时，我们还将为您介绍有关'java.lang.NoClassDefFoundError 由 java.lang.ClassNotFoundException 引起的 Ljava/util/Base64 解析失败 未找到类“java.util.Base64”、android – 解压缩zip文件给出“java.util.zip.ZipException：无法读取版本”或“java.util.ZipException无法读取本地标题版本45”、com.intellij.util.ReflectionUtil 对方法 java.util.ResourceBundle.setParent(java.util.ResourceBundle) 的非法反射访问、guava:java:java.util.Map 和 java.util.Set 的 Key 类型转换的知识，以帮助您更好地理解这个主题。

• java.util.Optional 学习笔记（java utility.readmenuselection）
• 'java.lang.NoClassDefFoundError 由 java.lang.ClassNotFoundException 引起的 Ljava/util/Base64 解析失败 未找到类“java.util.Base64”
• android – 解压缩zip文件给出“java.util.zip.ZipException：无法读取版本”或“java.util.ZipException无法读取本地标题版本45”
• com.intellij.util.ReflectionUtil 对方法 java.util.ResourceBundle.setParent(java.util.ResourceBundle) 的非法反射访问
• guava:java:java.util.Map 和 java.util.Set 的 Key 类型转换

java.util.Optional 学习笔记（java utility.readmenuselection）

java.util.Optional 是 Java 8 新增的类，作为一个持有实例的容器类，可以帮我们把判空的代码写得更优雅，并且该类还提供了一些实用的 api，官方文档在这里，接下来我们通过实战来学习吧:

### 三种 Optional 构造方法 ###
第一种. Optional.of (Object object)：入参 object 不能为空，否则会抛出空指针异常，查看 Optional 源码发现会调用 Objects.requireNonNull 方法，里面有判空：

public static <T> T requireNonNull(T obj) {
   
   
   
        if (obj == null)
            throw new NullPointerException();
        return obj;
    }

第二种. Optional.ofNullable (Object object)：入参 object 可以为空，如果 object 不为空，就创建一个 Optional 实例；如果 object 为空就返回一个 static fainal 的 Option 对象，注意这里不会新建 Option 实例，而是使用一个 static final 的实例 EMPTY，这里比较有意思的是泛型的问题，例如我需要两个 Optional 对象，类型分别是 String 和 Integer，代码如下：

Optional<String> optionalStr = Optional.ofNullable(null);
Optional<Integer> optionalInt = Optional.ofNullable(null);

类型不同又如何保证返回同一个对象呢？直接看 ofNullable 的源码，发现会调用 empty 方法：

public static<T> Optional<T> empty() {
   
   
   
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

原来是通过强制转换实现的，再看 EMPTY 对象：

private static final Optional<?> EMPTY = new Optional<>();

是通过 "?" 声明的；

第三种. Optional.empty ()：就是上面分析 Optional.ofNullable 的时候用到的 empty 方法，直接返回一个 static final 的实例 EMPTY；

Optional.of () 方法的用法有点像断言，对象为空的时候代表着某种业务上不可接受的异常，需要尽早处理，并且业务拒绝执行，这种场景下可以使用 Optional.of；

接下来我们开始实战吧；

### 例子中用到的对象：Student###
Student 是个普通的 bean，有三个字段和对应的 get&set 方法

package com.bolingcavalry;

/**
 * @author willzhao
 * @version V1.0
 * @Description: 一个普通的bean
 * @email zq2599@gmail.com
 * @Date 2017/8/26 下午11:23
 */
public class Student {
   
   
   
    private int id;

    private String name;

    private int age;

    public int getId() {
   
   
   
        return id;
    }

    public void setId(int id) {
   
   
   
        this.id = id;
    }

    public String getName() {
   
   
   
        return name;
    }

    public void setName(String name) {
   
   
   
        this.name = name;
    }

    public int getAge() {
   
   
   
        return age;
    }

    public void setAge(int age) {
   
   
   
        this.age = age;
    }

    public Student(int id, String name, int age) {
   
   
   
        this.id = id;
        this.name = name;
        this.age = age;
    }
}

###Optional.ofNullable 的用法 ###
下面举例说明最常用的 Optional.ofNullable，我们打算根据名称从其他系统获取 student 对象，如果对象为空就返回默认对象，先看不用 Optional 的时候我们平常是怎么写的，如下代码所示，标准的 if&else 判断：

	private Student queryById(int id){
   
   
   
        //TODO 这里模拟从数据库查询
        return null;
    }

    public Student getStudent(int id){
   
   
   
        Student student = queryById(id));

        //如果为空就返回DEFAULT对象
        return student==null ? DEFAULT : student;
    }

用 Optional 之后，如下所示，不需要通过判空来避免空指针异常了:

private Student queryById(int id){
   
   
   
        //TODO 这里模拟从数据库查询
        return null;
    }
    
    public Student getStudent(int id){
   
   
   
        Optional<Student> optional = Optional.ofNullable(queryById(id));

        //如果为空就返回DEFAULT对象
        return optional.orElse(DEFAULT);
    }

orElse 方法可以指定一个 value 为空时的返回对象，如果这个对象需要调用方法才能获取 (例如我们拿不到 DEFAULT 对象，要通过 getDefault () 方法才能拿到)，这是就需要 orElseGet 方法来达到目的，如下：

private Student queryById(int id){
   
   
   
	//TODO 这里模拟从数据库查询
    return null;
}

private Student getDefault(){
   
   
   
	return DEFAULT;
}

public Student getStudent(int id){
   
   
   
	Optional<Student> optional = Optional.ofNullable(queryById(id));

	//如果为空就返回DEFAULT对象
    return optional.orElseGet(() -> getDefault());
}

###Optional 的 map 方法 ###
假如我们的需求是 student 对象非空就返回 name 的大写，如果 student 对象为空就返回 "invalid"，在没有 Optional 的时候写法如下，除了检查 student 变量是否为空，还要检查 name 是否为空：

private Student queryById(int id){
   
   
   
        //TODO 这里模拟从数据库查询
        return null;
}

public String getStudentUpperName(int id){
   
   
   
	Student student = queryById(id);
	if(student!=null && student.getName()!=null){
   
   
   
		return student.getName().toUpperCase();
    }

    return "invalid";
}

用了 Optional 可以这么写：

private Student queryById(int id){
   
   
   
	//TODO 这里模拟从数据库查询
	return null;
}

public String getStudentUpperName(int id){
   
   
   
	Optional<Student> optional = Optional.ofNullable(queryById(id));

    return optional.map(student -> student.getName())
                   .map(name -> name.toUpperCase())
                   .orElse("invalid");
}

由以上代码可以看到，map 可以将一个 Optional 对象转换成另一个，第一次是将 Optional 转换成了 Optional，第二次是将 Optional 转成了另一个 Optional，只是这次将字符串换成了大写；

本次实战的源码已经上传到 git 上，地址是 git@github.com:zq2599/blog_demos.git，里面有多个工程，本次用到的是 optionaldemo，如下图红框所示：

以上就是 Optional 的基本用法，对 Optional 的使用是在习惯上对之前判空写法的挑战，但可以试着去习惯这个简单优雅的小工具；

欢迎关注我的公众号

本文分享 CSDN - 程序员欣宸。
如有侵权，请联系 support@oschina.cn 删除。
本文参与 “OSC 源创计划”，欢迎正在阅读的你也加入，一起分享。

'java.lang.NoClassDefFoundError 由 java.lang.ClassNotFoundException 引起的 Ljava/util/Base64 解析失败 未找到类“java.util.Base64”

private File downloadpath = new File(Environment.getExternalStorageDirectory() + "/Test/file.zip");
private File unzipLoc = new File(Environment.getExternalStorageDirectory() + "/Test/");
        FileInputStream fin = new FileInputStream(downloadpath); 
        ZipInputStream zin = new ZipInputStream(fin);
        ZipEntry ze = null; 
        while ((ze = zin.getNextEntry()) != null) 
        { 
            FileOutputStream fout = new FileOutputStream(unzipLoc + ze.getName()); 
            for (int c = zin.read(); c != -1; c = zin.read()) 
            { 
                fout.write(c); 
            } 

            zin.closeEntry(); 
            fout.close(); 
        } 
        zin.close(); 

public void readCSV(String fileName) {
    fileLocation = fileName;
    File csvFile = new File(fileName);
    Scanner sfile;
//    noOfColumns = 0;
//    noOfRows = 0;
    data = new ArrayList<ArrayList>();
    int colCounter = 0;
    int rowCounter = 0;
    
    try {
        sfile = new Scanner(csvFile);
        
        while (sfile.hasNextLine()) {
            String aLine = sfile.nextLine();
            Scanner sline = new Scanner(aLine);
            sline.useDelimiter(",");
            colCounter = 0;
            while (sline.hasNext()) {
                if (rowCounter == 0) 
                    data.add(new ArrayList<String>());
                
                
                data.get(colCounter).add(sline.next());
                colCounter++;
            }
            rowCounter++;
            sline.close();
        }
//        noOfColumns = colCounter;
//        noOfRows = rowCounter;
        sfile.close();
    } catch (FileNotFoundException e) {
        System.out.println("File to read " + csvFile + " not found!");
    }
} 

fun main() {
println("Hello world")
}

package net.gdface.facelog;

import static com.google.common.base.Preconditions.checkNotNull;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.junit.Test;

import com.google.common.base.Function;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterators;
import com.google.common.collect.Maps;
import com.google.common.collect.Maps.EntryTransformer;

public class TestTransform {
    /** 
     * convert {@code Map<K1,V>} to {@code Map<K2,V>}   
     * @return {@linkplain ImmutableMap}
     */
    public static final <K1,K2,V>Map<K2,V> transform(Map<K1,V>fromMap,final Function<K1,K2>transformer){
        checkNotNull(fromMap,"fromMap is null");
        checkNotNull(transformer,"transformer is null");
        // 新的Map对象Key类型已经是K2了，只是Value类型成了Entry
        ImmutableMap<K2, Entry<K1, V>> k2Entry = Maps.uniqueIndex(fromMap.entrySet(), new Function<Entry<K1, V>,K2>(){
            @Override
            public K2 apply(Entry<K1, V> input) {               
                return transformer.apply(input.getKey());
            }});
        // 再做一次转换将Entry<K1, V>转换成V,这个过程并没有创建新的Map,只是创建了k2Entry的代理对象
        Map<K2, V> k2V = Maps.transformEntries(k2Entry, new EntryTransformer<K2,Entry<K1,V>,V>(){
            @Override
            public V transformEntry(K2 key, Entry<K1, V> value) {
                return value.getValue();
            }});
        return k2V;
    }
    /** 
     * convert {@code Set<E1>} to {@code Set<E2>}
     * @return {@link ImmutableSet} 
     */
    public static final <E1,E2>Set<E2> transform(final Set<E1>fromSet,final Function<E1,E2>transformer){
        checkNotNull(fromSet,"fromMap is null");
        checkNotNull(transformer,"transformer is null");
        return ImmutableSet.copyOf(Iterators.transform(fromSet.iterator(), transformer));
    }
    @Test
    public void test() {
        Map<String, String> m1 = Maps.<String,String>newLinkedHashMap();
        m1.put("1", "apple");
        m1.put("2", "orangle");
        m1.put("3", "banana");
        System.out.println(m1);
        Map<Integer, String> m2 = transform(m1, new Function<String,Integer>(){

            @Override
            public Integer apply(String input) {
                return Integer.valueOf(input);
            }});
        System.out.println(m2.toString());
    }

}