Java8新特性-官方庫新特性

阿新 • • 發佈：2018-02-23

identity nis brush else reat 均值 emp lba long

一、Optional

Java應用中最常見的bug就是空值異常。在Java 8之前，Google Guava引入了Optionals類來解決NullPointerException，從而避免源碼被各種null檢查汙染，以便開發者寫出更加整潔的代碼。Java 8也將Optional加入了官方庫。

Optional僅僅是一個容易：存放T類型的值或者null。它提供了一些有用的接口來避免顯式的null檢查。

API：

Modifier and Type	Method and Description
`static <T> Optional<T>`	`empty()` 返回一個空的 `Optional` 實例。
`boolean`	`equals(Object obj)` 指示某個其他對象是否等於此可選項。
`Optional<T>`	`filter(Predicate<? super T> predicate)` 如果一個值存在，並且該值給定的謂詞相匹配時，返回一個 `Optional`描述的值，否則返回一個空的 `Optional` 。
`<U> Optional<U>`	`flatMap(Function<? super T,Optional<U>> mapper)` 如果一個值存在，應用提供的 `Optional`映射函數給它，返回該結果，否則返回一個空的 `Optional` 。
`T`	`get()` 如果 `Optional`中有一個值，返回值，否則拋出 `NoSuchElementException` 。
`int`	`hashCode()` 返回當前值的哈希碼值（如果有的話），如果沒有值，則返回0（零）。
`void`	`ifPresent(Consumer<? super T> consumer)` 如果存在值，則使用該值調用指定的消費者，否則不執行任何操作。
`boolean`	`isPresent()` 返回 `true`如果存在值，否則為 `false` 。
`<U> Optional<U>`	`map(Function<? super T,? extends U> mapper)` 如果存在一個值，則應用提供的映射函數，如果結果不為空，則返回一個 `Optional`結果的 `Optional` 。
`static <T> Optional<T>`	`of(T value)` 返回具有 `Optional`的當前非空值的Optional。
`static <T> Optional<T>`	`ofNullable(T value)` 返回一個 `Optional`指定值的Optional，如果非空，則返回一個空的 `Optional` 。
`T`	`orElse(T other)` 返回值如果存在，否則返回 `other` 。
`T`	`orElseGet(Supplier<? extends T> other)` 返回值（如果存在），否則調用 `other`並返回該調用的結果。
`<X extends Throwable> T`	`orElseThrow(Supplier<? extends X> exceptionSupplier)` 返回包含的值（如果存在），否則拋出由提供的供應商創建的異常。
`String`	`toString()` 返回此可選的非空字符串表示，適用於調試。

二、Stream

參考：

http://blog.csdn.net/u010425776/article/details/52344425

http://blog.csdn.net/u010425776/article/details/52346644

API：

Modifier and Type	Method and Description
`boolean`	`allMatch(Predicate<? super T> predicate)` 返回此流的所有元素是否與提供的謂詞匹配。
`boolean`	`anyMatch(Predicate<? super T> predicate)` 返回此流的任何元素是否與提供的謂詞匹配。
`static <T> Stream.Builder<T>`	`builder()` 返回一個 `Stream`的構建器。
`<R,A> R`	`collect(Collector<? super T,A,R> collector)` 使用 Collector對此流的元素執行 mutable reduction `Collector` 。
`<R> R`	`collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)` 對此流的元素執行 mutable reduction操作。
`static <T> Stream<T>`	`concat(Stream<? extends T> a, Stream<? extends T> b)` 創建一個懶惰連接的流，其元素是第一個流的所有元素，後跟第二個流的所有元素。
`long`	`count()` 返回此流中的元素數。
`Stream<T>`	`distinct()` 返回由該流的不同元素（根據 `Object.equals(Object)` ）組成的流。
`static <T> Stream<T>`	`empty()` 返回一個空的順序 `Stream` 。
`Stream<T>`	`filter(Predicate<? super T> predicate)` 返回由與此給定謂詞匹配的此流的元素組成的流。
`Optional<T>`	`findAny()` 返回描述流的一些元素的`Optional`如果流為空，則返回一個空的`Optional` 。
`Optional<T>`	`findFirst()` 返回描述此流的第一個元素的`Optional`如果流為空，則返回一個空的`Optional` 。
`<R> Stream<R>`	`flatMap(Function<? super T,? extends Stream<? extends R>> mapper)` 返回由通過將提供的映射函數應用於每個元素而產生的映射流的內容來替換該流的每個元素的結果的流。
`DoubleStream`	`flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)` 返回一個 `DoubleStream` ，其中包含將該流的每個元素替換為通過將提供的映射函數應用於每個元素而產生的映射流的內容的結果。
`IntStream`	`flatMapToInt(Function<? super T,? extends IntStream> mapper)` 返回一個 `IntStream` ，其中包含將該流的每個元素替換為通過將提供的映射函數應用於每個元素而產生的映射流的內容的結果。
`LongStream`	`flatMapToLong(Function<? super T,? extends LongStream> mapper)` 返回一個 `LongStream` ，其中包含將該流的每個元素替換為通過將提供的映射函數應用於每個元素而產生的映射流的內容的結果。
`void`	`forEach(Consumer<? super T> action)` 對此流的每個元素執行操作。
`void`	`forEachOrdered(Consumer<? super T> action)` 如果流具有定義的遇到順序，則以流的遇到順序對該流的每個元素執行操作。
`static <T> Stream<T>`	`generate(Supplier<T> s)` 返回無限順序無序流，其中每個元素由提供的 `Supplier` 。
`static <T> Stream<T>`	`iterate(T seed, UnaryOperator<T> f)` 返回有序無限連續 `Stream`由函數的叠代應用產生 `f`至初始元素 `seed` ，產生 `Stream`包括 `seed` ， `f(seed)` ， `f(f(seed))` ，等
`Stream<T>`	`limit(long maxSize)` 返回由此流的元素組成的流，截短長度不能超過 `maxSize` 。
`<R> Stream<R>`	`map(Function<? super T,? extends R> mapper)` 返回由給定函數應用於此流的元素的結果組成的流。
`DoubleStream`	`mapToDouble(ToDoubleFunction<? super T> mapper)` 返回一個 `DoubleStream` ，其中包含將給定函數應用於此流的元素的結果。
`IntStream`	`mapToInt(ToIntFunction<? super T> mapper)` 返回一個 `IntStream` ，其中包含將給定函數應用於此流的元素的結果。
`LongStream`	`mapToLong(ToLongFunction<? super T> mapper)` 返回一個 `LongStream` ，其中包含將給定函數應用於此流的元素的結果。
`Optional<T>`	`max(Comparator<? super T> comparator)` 根據提供的 `Comparator`返回此流的最大元素。
`Optional<T>`	`min(Comparator<? super T> comparator)` 根據提供的 `Comparator`返回此流的最小元素。
`boolean`	`noneMatch(Predicate<? super T> predicate)` 返回此流的元素是否與提供的謂詞匹配。
`static <T> Stream<T>`	`of(T... values)` 返回其元素是指定值的順序排序流。
`static <T> Stream<T>`	`of(T t)` 返回包含單個元素的順序 `Stream` 。
`Stream<T>`	`peek(Consumer<? super T> action)` 返回由該流的元素組成的流，另外在從生成的流中消耗元素時對每個元素執行提供的操作。
`Optional<T>`	`reduce(BinaryOperator<T> accumulator)` 使用 associative累積函數對此流的元素執行 reduction ，並返回描述減小值的 `Optional` （如果有）。
`T`	`reduce(T identity, BinaryOperator<T> accumulator)` 使用提供的身份值和 associative累積功能對此流的元素執行 reduction ，並返回減小的值。
`<U> U`	`reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner)` 執行 reduction在此流中的元素，使用所提供的身份，積累和組合功能。
`Stream<T>`	`skip(long n)` 在丟棄流的第一個 `n`元素後，返回由該流的 `n`元素組成的流。
`Stream<T>`	`sorted()` 返回由此流的元素組成的流，根據自然順序排序。
`Stream<T>`	`sorted(Comparator<? super T> comparator)` 返回由該流的元素組成的流，根據提供的 `Comparator`進行排序。
`Object[]`	`toArray()` 返回一個包含此流的元素的數組。
`<A> A[]`	`toArray(IntFunction<A[]> generator)` 使用提供的 `generator`函數返回一個包含此流的元素的數組，以分配返回的數組，以及分區執行或調整大小可能需要的任何其他數組。

三、Collectors

API：

Modifier and Type	Method and Description
`static <T> Collector<T,?,Double>`	`averagingDouble(ToDoubleFunction<? super T> mapper)` 返回一個 `Collector` ，它產生應用於輸入元素的雙值函數的算術平均值。
`static <T> Collector<T,?,Double>`	`averagingInt(ToIntFunction<? super T> mapper)` 返回一個 `Collector` ，它產生應用於輸入元素的整數值函數的算術平均值。
`static <T> Collector<T,?,Double>`	`averagingLong(ToLongFunction<? super T> mapper)` 返回一個 `Collector` ，它產生應用於輸入元素的長值函數的算術平均值。
`static <T,A,R,RR> Collector<T,A,RR>`	`collectingAndThen(Collector<T,A,R> downstream, Function<R,RR> finisher)` 適應 `Collector`進行額外的整理轉換。
`static <T> Collector<T,?,Long>`	`counting()` 返回 `Collector`類型的接受元件 `T`計數輸入元件的數量。
`static <T,K> Collector<T,?,Map<K,List<T>>>`	`groupingBy(Function<? super T,? extends K> classifier)` 返回 `Collector` “由基團”上的類型的輸入元件操作實現 `T` ，根據分類功能分組元素，並且在返回的結果 `Map` 。
`static <T,K,A,D> Collector<T,?,Map<K,D>>`	`groupingBy(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)` 返回 `Collector` “由基團”上的類型的輸入元件操作實現級聯 `T` ，根據分類功能分組元素，然後使用下遊的指定執行與給定鍵相關聯的值的歸約運算 `Collector` 。
`static <T,K,D,A,M extends Map<K,D>> Collector<T,?,M>`	`groupingBy(Function<? super T,? extends K> classifier, Supplier<M> mapFactory, Collector<? super T,A,D> downstream)` 返回 `Collector` “由基團”上的類型的輸入元件操作實現級聯 `T` ，根據分類功能分組元素，然後使用下遊的指定執行與給定鍵相關聯的值的歸約運算 `Collector` 。
`static <T,K> Collector<T,?,ConcurrentMap<K,List<T>>>`	`groupingByConcurrent(Function<? super T,? extends K> classifier)` 返回一個並發 `Collector` “由基團”上的類型的輸入元件操作實現 `T` ，根據分類功能分組元素。
`static <T,K,A,D> Collector<T,?,ConcurrentMap<K,D>>`	`groupingByConcurrent(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)` 返回一個並發 `Collector` “由基團”上的類型的輸入元件操作實現級聯 `T` ，根據分類功能分組元素，然後使用下遊的指定執行與給定鍵相關聯的值的歸約運算 `Collector` 。
`static <T,K,A,D,M extends ConcurrentMap<K,D>> Collector<T,?,M>`	`groupingByConcurrent(Function<? super T,? extends K> classifier, Supplier<M> mapFactory, Collector<? super T,A,D> downstream)` 返回一個並發 `Collector` “由基團”上的類型的輸入元件操作實現級聯 `T` ，根據分類功能分組元素，然後使用下遊的指定執行與給定鍵相關聯的值的歸約運算 `Collector` 。
`static Collector<CharSequence,?,String>`	`joining()` 返回一個 `Collector` ，按照遇到的順序將輸入元素連接到一個 `String`中。
`static Collector<CharSequence,?,String>`	`joining(CharSequence delimiter)` 返回一個 `Collector` ，按照遇到的順序連接由指定的分隔符分隔的輸入元素。
`static Collector<CharSequence,?,String>`	`joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)` 返回一個 `Collector` ，它將按照指定的 `Collector`分隔的輸入元素與指定的前綴和後綴進行連接。
`static <T,U,A,R> Collector<T,?,R>`	`mapping(Function<? super T,? extends U> mapper, Collector<? super U,A,R> downstream)` 適應一個 `Collector`類型的接受元件 `U`至類型的一個接受元件 `T`通過積累前應用映射函數到每個輸入元素。
`static <T> Collector<T,?,Optional<T>>`	`maxBy(Comparator<? super T> comparator)` 返回一個 `Collector` ，它根據給出的 `Comparator`產生最大元素，描述為 `Optional<T>` 。
`static <T> Collector<T,?,Optional<T>>`	`minBy(Comparator<? super T> comparator)` 返回一個 `Collector` ，根據給出的 `Comparator`產生最小元素，描述為 `Optional<T>` 。
`static <T> Collector<T,?,Map<Boolean,List<T>>>`	`partitioningBy(Predicate<? super T> predicate)` 返回一個 `Collector` ，根據Predicate對輸入元素進行 `Predicate` ，並將它們組織成 `Map<Boolean, List<T>>` 。
`static <T,D,A> Collector<T,?,Map<Boolean,D>>`	`partitioningBy(Predicate<? super T> predicate, Collector<? super T,A,D> downstream)` 返回一個 `Collector` ，它根據Predicate對輸入元素進行 `Predicate` ，根據另一個 `Collector`減少每個分區的值，並將其組織成 `Map<Boolean, D>` ，其值是下遊縮減的結果。
`static <T> Collector<T,?,Optional<T>>`	`reducing(BinaryOperator<T> op)` 返回一個 `Collector` ，它在指定的 `Collector`下執行其輸入元素的 `BinaryOperator` 。
`static <T> Collector<T,?,T>`	`reducing(T identity, BinaryOperator<T> op)` 返回 `Collector`執行下一個指定的減少其輸入元件的 `BinaryOperator`使用所提供的身份。
`static <T,U> Collector<T,?,U>`	`reducing(U identity, Function<? super T,? extends U> mapper, BinaryOperator<U> op)` 返回一個 `Collector` ，它在指定的映射函數和 `BinaryOperator`下執行其輸入元素的 `BinaryOperator` 。
`static <T> Collector<T,?,DoubleSummaryStatistics>`	`summarizingDouble(ToDoubleFunction<? super T> mapper)` 返回一個 `Collector` ， `double`生產映射函數應用於每個輸入元素，並返回結果值的匯總統計信息。
`static <T> Collector<T,?,IntSummaryStatistics>`	`summarizingInt(ToIntFunction<? super T> mapper)` 返回一個 `Collector` ， `int`生產映射函數應用於每個輸入元素，並返回結果值的匯總統計信息。
`static <T> Collector<T,?,LongSummaryStatistics>`	`summarizingLong(ToLongFunction<? super T> mapper)` 返回一個 `Collector` ， `long`生產映射函數應用於每個輸入元素，並返回結果值的匯總統計信息。
`static <T> Collector<T,?,Double>`	`summingDouble(ToDoubleFunction<? super T> mapper)` 返回一個 `Collector` ，它產生應用於輸入元素的雙值函數的和。
`static <T> Collector<T,?,Integer>`	`summingInt(ToIntFunction<? super T> mapper)` 返回一個 `Collector` ，它產生應用於輸入元素的整數值函數的和。
`static <T> Collector<T,?,Long>`	`summingLong(ToLongFunction<? super T> mapper)` 返回一個 `Collector` ，它產生應用於輸入元素的長值函數的和。
`static <T,C extends Collection<T>> Collector<T,?,C>`	`toCollection(Supplier<C> collectionFactory)` 返回一個 `Collector` ，按照遇到的順序將輸入元素累加到一個新的 `Collection`中。
`static <T,K,U> Collector<T,?,ConcurrentMap<K,U>>`	`toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)` 返回一個並發的 `Collector` ，它將元素累加到 `ConcurrentMap` ，其鍵和值是將所提供的映射函數應用於輸入元素的結果。
`static <T,K,U> Collector<T,?,ConcurrentMap<K,U>>`	`toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)` 返回一個並發的 `Collector` ，它將元素累加到一個 `ConcurrentMap` ，其鍵和值是將提供的映射函數應用於輸入元素的結果。
`static <T,K,U,M extends ConcurrentMap<K,U>> Collector<T,?,M>`	`toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier)` 返回一個並發的 `Collector` ，它將元素累加到一個 `ConcurrentMap` ，其鍵和值是將所提供的映射函數應用於輸入元素的結果。
`static <T> Collector<T,?,List<T>>`	`toList()` 返回一個 `Collector` ，它將輸入元素 `List`到一個新的 `List` 。
`static <T,K,U> Collector<T,?,Map<K,U>>`	`toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)` 返回一個 `Collector` ，它將元素累加到一個 `Map` ，其鍵和值是將所提供的映射函數應用於輸入元素的結果。
`static <T,K,U> Collector<T,?,Map<K,U>>`	`toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)` 返回一個 `Collector` ，它將元素累加到 `Map` ，其鍵和值是將提供的映射函數應用於輸入元素的結果。
`static <T,K,U,M extends Map<K,U>> Collector<T,?,M>`	`toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier)` 返回一個 `Collector` ，它將元素累加到一個 `Map` ，其鍵和值是將所提供的映射函數應用於輸入元素的結果。
`static <T> Collector<T,?,Set<T>>`	`toSet()` 返回一個 `Collector` ，將輸入元素 `Set`到一個新的 `Set` 。

工作中應用：

註:這個項目微服務架構使用dubbo

一、轉換前數據結構

@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class GeneTreeList extends ResponseBase {
    @XmlElements({@XmlElement(
    name = "tree",
    type = GeneTree.class
)})
    private List<GeneTree> treeList = new ArrayList();

    public GeneTreeList() {
    }

    public List<GeneTree> getTreeList() {
        return this.treeList;
    }

    public void setTreeList(List<GeneTree> treeList) {
        this.treeList = treeList;
    }
}

@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class GeneTree extends ResponseBase {
    @XmlAttribute
    private int portalId;
    @XmlAttribute
    private int parentTreeId;
    @XmlAttribute
    private int treeId;
    @XmlAttribute
    private int treeType;
    @XmlAttribute
    private int layer;
    @XmlAttribute
    private int order;
    private String treeName;
    private boolean isLeaf;
    private String template;
    private int retrieveId;
    private int filmCount;
    private String icon = "";
    private String backgroundImg = "";
    private String cpid = "";
    private String copyright = "";
    private int movieLimitCount;
    private int movieAuditCount;
    private String moviePosterLimit = "";
    private Date updatetime;
    private Date createtime;
    @XmlElements({@XmlElement(
    name = "label",
    type = GeneTreeLabel.class
)})
    private List<GeneTreeLabel> labels = new ArrayList();

    public GeneTree() {
    }
//get/set方法
。。。。。。
}

@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class GeneTreeLabel implements Serializable {
    @XmlAttribute
    private int typeId;
    @XmlAttribute
    private String typeName = "";
    @XmlAttribute
    private int labelId;
    @XmlAttribute
    private String labelName = "";

    public GeneTreeLabel() {
    }
}

技術分享圖片

二、定義轉換後數據結構

@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class LabelList extends ResponseBase {
    @XmlElements({@XmlElement(
            name = "Child",
            type = OutChild.class
    )})
    private List<OutChild> childs = new ArrayList();

    public LabelList(){}

    public List<OutChild> getChilds() {
        return childs;
    }

    public void setChilds(List<OutChild> childs) {
        this.childs = childs;
    }
}

@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class OutChild extends ResponseBase {
    @XmlAttribute
    private String typeName;
    @XmlAttribute
    private  int typeId;

    @XmlElements({@XmlElement(
            name = "label",
            type = OutLabel.class
    )})
    private List<OutLabel> labels = new ArrayList();
    public OutChild(){}

    public List<OutLabel> getLabels() {
        return labels;
    }

    public void setLabels(List<OutLabel> labels) {
        this.labels = labels;
    }

    public void setTypeName(String typeName) {
        this.typeName = typeName;
    }

    public void setTypeId(int typeId) {
        this.typeId = typeId;
    }

    public String getTypeName() {

        return typeName;
    }

    public int getTypeId() {
        return typeId;
    }
}

@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class OutLabel extends ResponseBase {
    @XmlAttribute
    private int labelId;
    @XmlAttribute
    private String labelName;

    public OutLabel(){}

    public int getLabelId() {
        return labelId;
    }

    public void setLabelId(int labelId) {
        this.labelId = labelId;
    }

    public String getLabelName() {
        return labelName;
    }

    public void setLabelName(String labelName) {
        this.labelName = labelName;
    }
}

技術分享圖片

三、處理邏輯

@Override
public LabelList labellist(Integer epgid) {
    LabelList labelList = new LabelList();

    if (epgid == null) {
        labelList.setParamInvalidResponse("epgId", String.valueOf(epgid));
        return labelList;
    }
    int treeid = 0;
    boolean opl = true;
    //geneTreeList-->labelList
    GeneTreeList geneTreeList = treeService.getTreeList(epgid, treeid, opl);

    if (null == geneTreeList) {
        labelList.setNoDataResponse();
        return labelList;
    }

    if (geneTreeList.getTreeList().size() > 0) {
        ChangeIbsTreeList.change(labelList, geneTreeList);
        labelList.setSucessResponse(ResponseStatus.Source.None);
    } else {
        labelList.setNoDataResponse();
    }
    return labelList;
}

下面代碼中註釋的是我寫的邏輯，很原始的方法。

public class ChangeIbsTreeList {
//    private static boolean[] flag1 = new boolean[100];//以typeid為數組下標

    public static void change(LabelList labellist, GeneTreeList geneTreeList) {

        List<GeneTreeLabel> geneTreeLabelList = new LinkedList<>();


        //獲取所有的label
        for (GeneTree geneTree : geneTreeList.getTreeList()) {
            geneTreeLabelList.addAll(geneTree.getLabels());
        }
        if (geneTreeLabelList.size() == 0) {
            return;
        }
        //根據lableid和typeid生成不同的map
		//geneTreeLabelList.stream():可以用來獲取流，參考：http://blog.csdn.net/u010425776/article/details/52344425  http://blog.csdn.net/u010425776/article/details/52346644
		//根據List創建Map：Map<Integer, Integer> map = list.stream().collect(Collectors.toMap(p -> p, q->q*3));
		//Collectors.toMap(GeneTreeLabel::getLabelId, c -> c, (e1, e2) -> e1):
			//	GeneTreeLabel::getLabelId:是接收一個任務並產生一個只包含該任務標題的鍵的Function
			//	 c -> c:一個用來返回任務本身的lambda表達式:http://www.importnew.com/16436.html   http://blog.csdn.net/u010425776/article/details/52334455
			//	(e1, e2) -> e1:處理重復問題
        Map<Integer, GeneTreeLabel> lableMap = geneTreeLabelList.stream().collect(Collectors.toMap(GeneTreeLabel::getLabelId, c -> c, (e1, e2) -> e1));
        Map<Integer, GeneTreeLabel> typeMap = geneTreeLabelList.stream().collect(Collectors.toMap(GeneTreeLabel::getTypeId, c -> c, (e1, e2) -> e1));
        //按type分類
        Map<Integer, List<GeneTreeLabel>> groupbyType =
                geneTreeLabelList.stream().collect(groupingBy(GeneTreeLabel::getTypeId));

        //遍歷生成Childs
		//t是integer類型
		//map是映射：將GeneTreeLabel轉換成GeneTreeLabel.getTypeId()為int類型，然後去重
		//然後將int類型映射成函數需要的類型
		//註：第三行用到了得到的lableMap、typeMap、groupbyType
        List<OutChild> OutChilds =
                (geneTreeLabelList.stream().map(GeneTreeLabel -> GeneTreeLabel.getTypeId()).distinct().collect(Collectors.toList()))
                        .stream().map(t -> GeneTreeLabel2OutChild(typeMap.get(t), groupbyType, lableMap)).collect(Collectors.toList());


        //遍歷Childs，set Labels
        for (OutChild child : OutChilds) {
            child.setLabels((groupbyType.get(child.getTypeId()).stream().map(GeneTreeLabel::getLabelId).distinct().collect(Collectors.toList())).stream().map(t -> GeneTreeLabel2OutLabel(lableMap.get(t))).collect(Collectors.toList()));
        }
        labellist.setChilds(OutChilds);

//        for (int i = 0; i < flag1.length; i++) {
//            flag1[i] = false;
//        }
//        List<GeneTree> treeList = geneTreeList.getTreeList();
//        List<OutChild> childList = new ArrayList<>();
//        getTreeList(treeList, childList);
//        labellist.setChilds(childList);
    }

    private static OutChild GeneTreeLabel2OutChild(GeneTreeLabel geneTreeLabel, Map<Integer, List<GeneTreeLabel>> groupbyType, Map<Integer, GeneTreeLabel> lableMap) {
        OutChild outChild = new OutChild();
        outChild.setTypeId(geneTreeLabel.getTypeId());
        outChild.setTypeName(geneTreeLabel.getTypeName());

        //List<OutLabel> labels = (groupbyType.get(geneTreeLabel.getTypeId()).stream().map(GeneTreeLabel -> GeneTreeLabel.getLabelId()).distinct().collect(Collectors.toList())).stream().map(t -> GeneTreeLabel2OutLabel(lableMap.get(t))).collect(Collectors.toList());

        //OutChild.setLabels(null);
        return outChild;
    }

    private static OutLabel GeneTreeLabel2OutLabel(GeneTreeLabel geneTreeLabel) {
        OutLabel outLabel = new OutLabel();
        outLabel.setLabelId(geneTreeLabel.getLabelId());
        outLabel.setLabelName(geneTreeLabel.getLabelName());
        return outLabel;
    }

//    public static void getTreeList(List<GeneTree> treeList, List<OutChild> childList) {
//
//        Iterator<GeneTree> it = treeList.iterator();
//        while (it.hasNext()) {
//            GeneTree geneTree = it.next();
//            List<GeneTreeLabel> labels = geneTree.getLabels();
//            setLabels(labels, childList);
//        }
//    }
//
//    public static void setLabels(List<GeneTreeLabel> labels, List<OutChild> childList) {
//        Iterator<GeneTreeLabel> it = labels.iterator();
//        while (it.hasNext()) {
//            GeneTreeLabel label = it.next();
//
//            if (false == flag1[label.getTypeId()]) {//如果標誌為false，說明child不存在
//                OutChild outChild = new OutChild();
//                outChild.setTypeId(label.getTypeId());
//                outChild.setTypeName(label.getTypeName());
//
//                List<OutLabel> outLabellist = new ArrayList<>();
//                OutLabel outLabel = new OutLabel();
//                outLabel.setLabelId(label.getLabelId());
//                outLabel.setLabelName(label.getLabelName());
//                outLabellist.add(outLabel);
//
//                outChild.setLabels(outLabellist);
//
//                childList.add(outChild);
//
//                flag1[label.getTypeId()] = true;
//            } else {                                 //否則已經建立這個類型的child,然後遍歷child集合，找到對應的child
//                Iterator<OutChild> it1 = childList.iterator();
//                while (it1.hasNext()) {
//                    OutChild outChild = it1.next();
//                    if (outChild.getTypeId() == label.getTypeId()) {//找到對應的child，然後查找child裏面的label是否重復
//                        List<OutLabel> outLabels = outChild.getLabels();
//                        Iterator<OutLabel> it2 = outLabels.iterator();
//                        int i = 0;
//                        while (it2.hasNext()) {//遍歷得到label
//                            OutLabel outLabel = it2.next();
//                            if (outLabel.getLabelId() == label.getLabelId()) {
//                                break;
//                            }
//                            i = i + 1;
//                        }
//                        if (i >= outLabels.size()) {
//                            OutLabel outLabel = new OutLabel();
//                            outLabel.setLabelId(label.getLabelId());
//                            outLabel.setLabelName(label.getLabelName());
//                            outLabels.add(outLabel);
//
//                            outChild.setLabels(outLabels);
//                        }
//                    }
//                }
//            }
//        }
//    }
}

Java8新特性-官方庫新特性

identity nis brush else reat 均值 emp lba long 一、Optional Java應用中最常見的bug就是空值異常。在Java 8之前，Google Guava引入了Optionals類來解決NullPointerExceptio

Java8新特性探索之新日期時間庫

一、為什麼引入新的日期時間庫 Java對日期，日曆及時間的處理一直以來都飽受詬病，尤其是它決定將java.util.Date定義為可修改的以及將SimpleDateFormat實現成非執行緒安全的。關於這個新的時間日期庫的最大的優點就在於它定義清楚了時間日期相關的一些概念，比方說，瞬時時間（Instant）

Java8新特性之：新的日期和時間API

java8 時間日期API 一. LocalDate、LocalTime、Instant、Duration以及Period 1.LocalDate只提供日期，不含當天時間信息LocalDate date = LocalDate.of(2018, 5, 03); int year = da

《JDK10新特性官方文件》– 五月翻譯邀請

原文連結邀請者：小村長概述本篇是 Open JDK10官方文件的新特性介紹翻譯邀請函。北京時間3月21日，Oracle官方宣佈JDK10正式釋出。從此JDK開啟一個新的旅程。因為Oracle和OpenJDK大致相同，所以在此採用的是OpenJDK的版本進行翻譯的。本次翻譯邀

《JDK10新特性官方文件》JEP304：垃圾收集器介面

作者： Roman Kennke 建立時間：2016/08/06 08:45 更新時間：2018/04/09 12:37 型別：特性狀態：已關閉/已提交元件：hotspot/gc 範圍：實現類討論： openjdk.java.net上的hotspot-gc-dev 影響：L 持續時

《JDK10新特性官方文件》JEP307: G1 Full GC的並行化

作者： Stefan Johansson 建立時間：2017/01/17 11:40 更新時間：2018/03/29 07:39 型別：特性狀態：已關閉/已提交元件：hotspot/gc 範圍：實現類討論： openjdk.java.net上的hotspot-gc-dev 影響：M

《JDK10新特性官方文件》在可選記憶體裝置上的分配堆記憶體

原文連結 JEP 316: 在可選記憶體裝置上的分配堆記憶體 Owner Kishor Kharbas Created 2016/12/13 19:31 Updated 2018/03/20 20:32 Type Feature Status C

Java8新特性——Map的新方法

今天是高考的日子，是大四師兄師姐答辯畢業的日子。一代又來，一代又去。好久沒寫部落格，藉此特殊日子整理一下前不久學java8新特性時寫的程式碼，留下痕跡。（本部落格的程式碼根據學習整理，加上個人的理解而成，關於某個新特性的介紹程式碼裡的註釋已經闡述清楚，故不再寫文字介紹，

JDK10新特性官方文件翻譯

來自開源社群jdk 10新特性中英對照翻譯文件JDK10 包含 12 個JEP (改善提議）：【286】區域性變數型別推斷：對於開發者來說，這是 JDK10 唯一的真正特性。它向 Java 中引入在其他語言中很常見的 var ，比如 JavaScript 。只要編譯

mysql Innodb 新特性 warm up(預熱) 特性

轉http://mysql.taobao.org/monthly/2014/10/06/ 提要相對於納秒級的記憶體訪問延時，普通的機械盤達到了毫秒級的隨機訪問延時，對於OLTP應用來說，物理IO絕對是目前資料庫管理系統的最大效能殺手，所以增加記憶體的大小，提高IO的命中率無疑可以作為一種降

Kubernetes1.6新特性：POD高階排程-汙點和容忍特性/報告節點問題特性

(一) 核心概念Pod是kubernetes中的核心概念，kubernetes對於Pod的管理也就是對Pod生命週期的管理以及對Pod進行排程管理。Kubernetes早期版本使用系統預設排程器來對Pod進行統一排程管理，在1.2版本中增加了多個排程器特性，多個排程器可以並

kubernetes1.4新特性：增加新節點健康狀況型別DiskPressure_Kubernetes中文社群

背景資料在Kubernetes架構圖中可以看到，節點（Node）是一個由管理節點委託執行任務的worker。它能執行一個或多個Pods，節點（Node）提供了執行容器環境所需要的所有必要條件，在Kubernetes之前版本中叫做Minion。相關結構體通過下面這張圖可以看到在Kube

利用AWS快照和AMI特性快速開新服

如果在亞馬遜平臺上有一組服，想快速再開一組一模一樣架構的，還包括RDS，而且RDS不用重新建庫，EC2例項也不用停機，怎麼最快最省事？步驟簡述：（1）將線上服EC2例項註冊成AMI （2）基於該AMI建立例項，可同時建立多個（3）給線上RDS做sn

Android9.0 新特性 8.0 新特性

9.0 特性： 1.劉海模式，相容適配劉海樣子，手機內有可以直接設定劉海模式開發，不用去找多個廠家手機就可以進行相容性適配。 2.ai智慧應用，動態電量控制，控制電量分配，對於近期少用的少分配 3.全域性夜間模式，支援夜間模式的設定。 4.長圖截圖功能。 5.自帶日

一起看期待已久的.NET Core 3.0新的單檔案部署特性，記在昨日VS2019更新後

VS2019又又又迎來一次新的更新，這次的重點在.NET Core, 妥妥的更新好，默默地反選2.2，一切都在意料之中。這次我們來看VS2019的新特性單檔案部署： https://www.talkingdotnet.com/create-trimmed-self-contained-executabl

rman數據庫恢復；關鍵/非重要文件、影像副本、控制文件、還原點、非歸檔、增量、新數據庫、災難性回復

mod sse nom 恢復文件增量 ase control def 裝載運行全然恢復：在 ARCHIVELOG 模式下丟失了系統重要數據文件: 假設某個數據文件丟失或損壞。且該文件屬於 SYSTEM 或 UNDO 表空間，請運行下面步驟： 1. 實例可能會也可

接到新數據庫時，分析業務常用的SQL語句

增加臨時 columns != question 名稱信息語句 insert USE DataBaseName--清空當前GridView顯示，釋放內存： SELECT GETDATE() --數據庫關系圖 SELECT * FROM sysdiagra

更新CentOS Mysql到官方較新版本[以6.5為例]

生成 inux 依次 font fig 目前 http line spa 需求來源： CentOS: 6.9 x64 自帶mysql版本較舊，需要卸載後安裝到5.6版本. 1.查看目前mysql 版本 2.如果發現有系統自帶mysql，而且比想要裝的5.6舊。果斷

Mysql數據庫四大特性、事物的四個隔離、基本MySQL語句、獨立表空間

mysql數據庫四大特性、事物的四個隔離、基本mysql語句、獨立表空間Mysql數據庫四大特性、事物的四個隔離、基本MySQL語句、獨立表空間本人學習mysql的時候感覺筆記有點散所以自己做了一個整合，而且有些概念介紹的太官方了，所以自己根據理解總結了一下。（有不對的請指點！） mysql：sql：關系型

數據庫事務特性和隔離級別

read 事務隔離 mil 對數 alt tro 取數部分失敗事務一組業務操作，要麽全部成功，要麽全部不成功。 ----------------事務的特性-------------- 原子性：一個事務是一個整體，不可分割，事務中的操作要麽都成功，要麽都失敗。

Java8新特性-官方庫新特性

二、Stream

三、Collectors

相關推薦