欧美成人WWW免费全部网站,国内精品久久久久影院一蜜桃 ,性高朝大尺度少妇大屁股

原文地址http://blog.csdn.net/myherux/article/details/52717492

（一）optional類

創建一個空Optional對象

輸出的是一個空的optional對象

Optional<String> optional = Optional.empty();
System.out.println(optional);
##:Optional.empty

創建一個非空Optional對象

如果person是null，將會立即拋出,而不是訪問person的屬性時獲得一個潛在的錯誤

Person person = new Person("xu","hua");
Optional<Person> optional2 = Optional.of(person);
System.out.println(optional2);
System.out.println(optional2.get());
System.out.println(optional2.get().firstName);
##:Optional[xuhua]
    xuhua
    xu

判斷對象是否存在

System.out.println(optional.isPresent());
System.out.println(optional2.isPresent());
##:false
   true

如果Optional為空返回默認值

System.out.println(optional.orElse("fallback"));
optional.ifPresent(System.out::println);
##:fallback
    xuhua

（二）Lambda表達式

Lambda表達式的使用

java8以前的字符串排列，創建一個匿名的比較器對象Comparator然后將其傳遞給sort方法

```
List<String> names= Arrays.asList("peter", "anna", "mike", "xenia");
Collections.sort(names, new Comparator<String>() {
            @Override
            public int compare(String a, String b) {
            return b.compareTo(a);
        }
    });
```

`java8`使用`lambda`表達式就不需要匿名對象了

```
Collections.sort(names,(String a,String b)->{return b.compareTo(a);});
```

簡化一下：對于函數體只有一行代碼的，你可以去掉大括號{}以及`return`關鍵字

```
Collections.sort(names,(String a,String b)->b.compareTo(a));
```

`Java`編譯器可以自動推導出參數類型，所以你可以不用再寫一次類型
```
Collections.sort(names, (a, b) -> b.compareTo(a));
```
```
##:[xenia, peter, mike, anna]
```

對于`null`的處理
```
List<String> names2 = Arrays.asList("peter", null, "anna", "mike", "xenia");
names2.sort(Comparator.nullsLast(String::compareTo));
System.out.println(names2);
##:[anna, mike, peter, xenia, null]
```

函數式接口,方法，構造器

每一個lambda表達式都對應一個類型，通常是接口類型。

而“函數式接口”是指僅僅只包含一個抽象方法的接口，每一個該類型的lambda表達式都會被匹配到這個抽象方法。

因為默認方法不算抽象方法，所以你也可以給你的函數式接口添加默認方法。

我們可以將lambda表達式當作任意只包含一個抽象方法的接口類型，確保你的接口一定達到這個要求，

你只需要給你的接口添加 @FunctionalInterface 注解，

編譯器如果發現你標注了這個注解的接口有多于一個抽象方法的時候會報錯的。

函數式接口

@FunctionalInterface
public static interface Converter<F, T> {
    T convert(F from);
}
/**原始的接口實現*/
Converter<String, Integer> integerConverter1 = new Converter<String, Integer>() {
    @Override
    public Integer convert(String from) {
        return Integer.valueOf(from);
    }
};

/**使用lambda表達式實現接口*/
Converter<String, Integer> integerConverter2 = (from) -> Integer.valueOf(from);

Integer converted1 = integerConverter1.convert("123");
Integer converted2 = integerConverter2.convert("123");
System.out.println(converted1);   
System.out.println(converted2);   
##:123
123
/**簡寫的lambda表達式*/
Converter<String, Integer> integerConverter3 = Integer::valueOf;
Integer converted3 = integerConverter3.convert("123");
System.out.println(converted3);   
##:123

函數式方法

static class Something {
    String startsWith(String s) {
        return String.valueOf(s.charAt(0));
    }
}
Something something = new Something();
Converter<String, String> stringConverter = something::startsWith;
String converted4 = stringConverter.convert("Java");
System.out.println(converted4);    
##:j

函數式構造器

Java編譯器會自動根據PersonFactory.create方法的簽名來選擇合適的構造函數。

public class Person {
    public String firstName;
    public String lastName;

    public Person() {
    }

    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public String toString(){
        return firstName+lastName;
    }
}

interface PersonFactory<P extends Person> {
    P create(String firstName, String lastName);
}
PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("xu", "hua");
System.out.println(person.toString());
##:xuhua

Lambda作用域

在lambda表達式中訪問外層作用域和老版本的匿名對象中的方式很相似。

你可以直接訪問標記了final的外層局部變量，或者實例的字段以及靜態變量。

static int outerStaticNum = 10;

int outerNum;

void testScopes() {
    
    /**變量num可以不用聲明為final*/
    int num = 1;

    /**可以直接在lambda表達式中訪問外層的局部變量*/
    Lambda2.Converter<Integer, String> stringConverter =
                    (from) -> String.valueOf(from + outerStaticNum+num);
    String convert = stringConverter.convert(2);
    System.out.println(convert);   
    ##:13
    /**但是num必須不可被后面的代碼修改（即隱性的具有final的語義），否則編譯出錯*/
    //num=3;

    /**lambda內部對于實例的字段以及靜態變量是即可讀又可寫*/
    Lambda2.Converter<Integer, String> stringConverter2 = (from) -> {
        outerNum = 13;
        return String.valueOf(from + outerNum);
    };
    System.out.println(stringConverter2.convert(2));
    System.out.println("\nBefore:outerNum-->" + outerNum);
    outerNum = 15;
    System.out.println("After:outerNum-->" + outerNum);
    ##:Before:outerNum-->13
       After:outerNum-->15
    
    String[] array = new String[1];
    Lambda2.Converter<Integer, String> stringConverter3 = (from) -> {
        array[0] = "Hi here";
        return String.valueOf(from);
    };
    stringConverter3.convert(23);
    System.out.println("\nBefore:array[0]-->" + array[0]);
    array[0] = "Hi there";
    System.out.println("After:array[0]-->" + array[0]);
    ##:Before:array[0]-->Hi here
       After:array[0]-->Hi there
}

（三）Stream類

java.util.Stream 表示能應用在一組元素上一次執行的操作序列。

Stream 操作分為中間操作或者最終操作兩種，最終操作返回一特定類型的計算結果，而中間操作返回Stream本身，這樣你就可以將多個操作依次串起來。

Stream 的創建需要指定一個數據源，比如 java.util.Collection的子類，List或者Set，Map不支持。

Stream的操作可以串行執行或者并行執行。

Stream的基本接口

List<String> stringCollection = new ArrayList<>();
stringCollection.add("ddd2");
stringCollection.add("aaa2");
stringCollection.add("bbb1");
stringCollection.add("aaa1");
stringCollection.add("bbb3");
stringCollection.add("ccc");
stringCollection.add("bbb2");
stringCollection.add("ddd1");

Filter 過濾.

Filter通過一個predicate接口來過濾并只保留符合條件的元素，該操作屬于中間操作，所以我們可以在過濾后的結果來應用其他Stream操作（比如forEach）。

forEach需要一個函數來對過濾后的元素依次執行。

forEach是一個最終操作，所以我們不能在forEach之后來執行其他Stream操作。
```
stringCollection
    .stream()
    .filter((s) -> s.startsWith("a"))
    .forEach(System.out::println);
```
Sorted 排序.

Sorted是一個中間操作，返回的是排序好后的Stream。

如果你不指定一個自定義的Comparator則會使用默認排序.
```
stringCollection
   .stream()
   .sorted()
   .forEach(System.out::println);
System.out.println(stringCollection);//原數據源不會被改變
```

Map.

中間操作map會將元素根據指定的Function接口來依次將元素轉成另外的對象.

stringCollection
    .stream()
    .map(String::toUpperCase)
    .map((s)->s+" space")
    .sorted((a, b) -> b.compareTo(a))
    .forEach(System.out::println);

Match

Stream提供了多種匹配操作，允許檢測指定的Predicate是否匹配整個Stream。

所有的匹配操作都是最終操作，并返回一個boolean類型的值。

boolean anyStartsWithA = stringCollection
    .stream()
    .anyMatch((s) -> s.startsWith("a"));
System.out.println(anyStartsWithA);      // true

boolean allStartsWithA = stringCollection
    .stream()
    .allMatch((s) -> s.startsWith("a"));
System.out.println(allStartsWithA);      // false

boolean noneStartsWithZ = stringCollection
    .stream()
    .noneMatch((s) -> s.startsWith("z"));
System.out.println(noneStartsWithZ);      // true

Count

計數是一個最終操作，返回Stream中元素的個數，返回值類型是long。

long startsWithB = stringCollection
    .stream()
    .filter((s) -> s.startsWith("b"))
    .count();
System.out.println(startsWithB);    // 3

Reduce

Reduce是一個最終操作，允許通過指定的函數來講stream中的多個元素規約為一個元素，規約后的結果是通過Optional接口表示的。

Optional<String> reduced =
    stringCollection
            .stream()
            .sorted()
            .reduce((s1, s2) -> s1 + "#" + s2);

reduced.ifPresent(System.out::println);
##:aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2

并行stream和串行stream

串行stream

List<String> values = new ArrayList<>(MAX);
for (int i = 0; i < MAX; i++) {
    UUID uuid = UUID.randomUUID();
    values.add(uuid.toString());
}

long t0 = System.nanoTime();
long count = values.stream().sorted().count();
System.out.println(count);

long t1 = System.nanoTime();
long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("sequential sort took: %d ms", millis));

并行stream

并行stream是在運行時將數據劃分成了多個塊，然后將數據塊分配給合適的處理器去處理。

只有當所有塊都處理完成了，才會執行之后的代碼。

List<String> values = new ArrayList<>(MAX);
for (int i = 0; i < MAX; i++) {
    UUID uuid = UUID.randomUUID();
    values.add(uuid.toString());
}

long t0 = System.nanoTime();
long count = values.parallelStream().sorted().count();
System.out.println(count);

long t1 = System.nanoTime();
long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("parallel sort took: %d ms", millis));

時間結果比較：

1000000
sequential sort took: 717 ms
1000000
parallel sort took: 303 ms

IntStream接口

IntStream接口是stream的一種，繼承了BaseStream接口。

range

IntStream.range(0, 10)
        .forEach(i -> {
            if (i % 2 == 1) System.out.print(i+" ");
        });
##:1 3 5 7 9 

OptionalInt reduced1 =
    IntStream.range(0, 10)
            .reduce((a, b) -> a + b);
System.out.println(reduced1.getAsInt());

int reduced2 =
    IntStream.range(0, 10)
            .reduce(7, (a, b) -> a + b);
System.out.println(reduced2);
##:45
   52

sum

System.out.println(IntStream.range(0, 10).sum());

Stream的應用

Map<String, Integer> unsortMap = new HashMap<>();
unsortMap.put("z", 10);
unsortMap.put("b", 5);
unsortMap.put("a", 6);
unsortMap.put("c", 20);
unsortMap.put("d", 1);
unsortMap.put("e", 7);
unsortMap.put("y", 8);
unsortMap.put("n", 99);
unsortMap.put("j", 50);
unsortMap.put("m", 2);
unsortMap.put("f", 9);

使用stream類來對map的value排序

public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue(Map<K, V> map) {
    Map<K, V> result = new LinkedHashMap<>();
    map.entrySet().parallelStream()
            .sorted((o1, o2) -> (o2.getValue()).compareTo(o1.getValue()))
            .forEachOrdered(x -> result.put(x.getKey(), x.getValue()));
    return result;
}
System.out.println(sortByValue(unsortMap));
##:{n=99, j=50, c=20, z=10, f=9, y=8, e=7, a=6, b=5, m=2, d=1}

List<Object> list = new ArrayList<>();
JSONObject data1 = new JSONObject();
data1.put("type", "支出");
data1.put("money", 500);
JSONObject data2 = new JSONObject();
data2.put("type", "收入");
data2.put("money", 1000);
JSONObject data3 = new JSONObject();
data3.put("type", "借貸");
data3.put("money", 100);
list.add(data1);
list.add(data2);
list.add(data3);

使用stream類來處理list``里面的json`數據

    /**
     * 按money的值來排列json
     */
    list.stream()
            .filter(x -> JSONObject.fromObject(x).containsKey("money"))
            .sorted((b, a) -> Integer.valueOf(JSONObject.fromObject(a).getInt("money")).compareTo(JSONObject.fromObject(b)
                    .getInt("money")))
            .forEach(System.out::println);
    /**
     * 找到最小的money
     */
    Integer min = list.stream()
            .filter(x -> JSONObject.fromObject(x).containsKey("money"))
            .map(x -> JSONObject.fromObject(x).getInt("money"))
            .sorted()
            .findFirst()
            .get();
    System.out.println(min);
    /**
     * 計算type的數目
     */
    Map<String, Integer> type_count = new HashMap<>();
    list.stream()
            .filter(x -> JSONObject.fromObject(x).containsKey("type"))
            .map(x -> JSONObject.fromObject(x).getString("type"))
            .forEach(x -> {
                if (type_count.containsKey(x)) type_count.put(x, type_count.get(x) + 1);
                else type_count.put(x, 1);
            });
    System.out.println(type_count.toString());
    ##:
    {"type":"收入","money":1000}
    {"type":"支出","money":500}
    {"type":"借貸","money":100}
    100
    {借貸=1, 收入=1, 支出=1}

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

【轉】java8-基礎

【轉】java8-基礎

（一）optional類

（二）Lambda表達式

（三）Stream類

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

【轉】java8-基礎

（一）optional類

（二）Lambda表達式

（三）Stream類

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频