国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

Stream流與Lambda表達式(三) 靜態工廠類Collectors

phodal / 3600人閱讀

摘要:陳楊一靜態工廠類實現方式一靜態工廠類實現方式靜態工廠類最終由實現通過實現通過實現底層由實現是的一種具化表現形式使用拼接字符串二靜態工廠類常用收集器二靜態工廠類常用收集器返回一個不可修改的按照相遇的順序返回一個不可修改的無序返回

/**
 * @author 陳楊
 */

@SpringBootTest
@RunWith(SpringRunner.class)
public class CollectorsDetail {

    private List names;
    private List students;
    private List> snames;

    @Before
    public void init() {

        names = Arrays.asList("Kirito", "Asuna", "Sinon", "Yuuki", "Alice");
        snames = Arrays.asList(Collections.singletonList("Kirito"), Collections.singletonList("Asuna"),
                Collections.singletonList("Sinon"), Collections.singletonList("Yuuki"),
                Collections.singletonList("Alice"));

        students = new Students().init();
    }

    @Test
    public void testCollectorsDetail() {
一、靜態工廠類Collectors 實現方式
//    一、靜態工廠類Collectors 實現方式

//    Collectors 靜態工廠類   最終由CollectorImpl實現
//       1、 通過CollectorImpl實現
//       2、 通過reducing()實現---> reducing()底層由CollectorImpl實現


//    Collectors.toList()  是 Collectors.toCollection()的一種具化表現形式
//    Collectors.joining() 使用StringBuilder.append 拼接字符串
二、靜態工廠類Collectors 常用收集器
//    二、靜態工廠類Collectors 常用收集器

/*
      返回一個(不可修改)unmodifiable List的ArrayList  按照相遇的順序encounter order
@since 10
@SuppressWarnings("unchecked")
public static 
        Collector> toUnmodifiableList() {
    return new CollectorImpl<>((Supplier>) ArrayList::new, List::add,
            (left, right) -> { left.addAll(right); return left; },
            list -> (List)List.of(list.toArray()),
            CH_NOID);
}*/


/*
      返回一個(不可修改)unmodifiable Set的HashSet 無序
@since 10
@SuppressWarnings("unchecked")
public static 
        Collector> toUnmodifiableSet() {
    return new CollectorImpl<>((Supplier>) HashSet::new, Set::add,
            (left, right) -> {
                if (left.size() < right.size()) {
                    right.addAll(left); return right;
                } else {
                    left.addAll(right); return left;
                }
            },
            set -> (Set)Set.of(set.toArray()),
            CH_UNORDERED_NOID);
}
*/


/*
      返回一個flatMapping扁平化mapper處理后 由downstream收集的 累加器處理的結果合并  單線程
@since 9
public static 
        Collector flatMapping(Function> mapper,
        Collector downstream) {
    BiConsumer downstreamAccumulator = downstream.accumulator();
    return new CollectorImpl<>(downstream.supplier(),
            (r, t) -> {
                try (Stream result = mapper.apply(t)) {
                    if (result != null)
                        result.sequential().forEach(u -> downstreamAccumulator.accept(r, u));
                }
            },
            downstream.combiner(), downstream.finisher(),
            downstream.characteristics());
}*/



/*
      對符合Predicate預期結果 進行過濾filtering 使用downstream 收集元素
@since 9
public static 
        Collector filtering(Predicate predicate,
        Collector downstream) {
    BiConsumer downstreamAccumulator = downstream.accumulator();
    return new CollectorImpl<>(downstream.supplier(),
            (r, t) -> {
                if (predicate.test(t)) {
                    downstreamAccumulator.accept(r, t);
                }
            },
            downstream.combiner(), downstream.finisher(),
            downstream.characteristics());
}*/


/*
      使用Map映射key-->keyMapper-->Key value-->valueMapper-->Value
      對映射后的結果進行組裝entrySet-->Map (unmodifiable Map)
@since 10
@SuppressWarnings({"rawtypes", "unchecked"})
public static 
        Collector> toUnmodifiableMap(Function keyMapper,
        Function valueMapper) {
    Objects.requireNonNull(keyMapper, "keyMapper");
    Objects.requireNonNull(valueMapper, "valueMapper");
    return collectingAndThen(
            toMap(keyMapper, valueMapper),
            map -> (Map)Map.ofEntries(map.entrySet().toArray(new Map.Entry[0])));
}*/


/*
      使用Map映射key-->keyMapper-->Key value-->valueMapper-->Value
      mergeFunction 對相同key 映射后的進行Value 合并操作
      對映射后的結果進行組裝entrySet-->Map (unmodifiable Map)

@since 10
@SuppressWarnings({"rawtypes", "unchecked"})
public static 
        Collector> toUnmodifiableMap(Function keyMapper,
        Function valueMapper,
        BinaryOperator mergeFunction) {
    Objects.requireNonNull(keyMapper, "keyMapper");
    Objects.requireNonNull(valueMapper, "valueMapper");
    Objects.requireNonNull(mergeFunction, "mergeFunction");
    return collectingAndThen(
            toMap(keyMapper, valueMapper, mergeFunction, HashMap::new),
            map -> (Map)Map.ofEntries(map.entrySet().toArray(new Map.Entry[0])));
}*/
//    Collectors 收集器
System.out.println("-----------------------------------------
");

//    使用ArrayList集合 按照流中元素排列先后順序 進行添加操作
List unmodifiableList = names.stream().collect(Collectors.toUnmodifiableList());
System.out.println(unmodifiableList);
System.out.println("---------------------------------------
");


//    使用HashSet集合 對流中元素順序 進行添加操作
Set unmodifiableSet = names.stream().collect(Collectors.toUnmodifiableSet());
System.out.println(unmodifiableSet);
System.out.println("---------------------------------------
");


//    將集合扁平化展開 對其中的字符串的每個字母 進行大寫轉換 使用ArrayList對轉換后的結果進行收集
List strings = snames.stream()
        .collect(Collectors.flatMapping(list -> list.stream().map(String::toUpperCase), Collectors.toList()));
System.out.println(strings);
System.out.println("---------------------------------------
");


//    對流中元素進行遍歷 對符合預期要求的元素 使用ArrayList集合存放
List filteringPredicate = names.stream().collect(Collectors.filtering("Kirito"::equals,
        Collectors.toList()));
System.out.println(filteringPredicate);
System.out.println("---------------------------------------
");


//    對流中元素進行遍歷  對key-->keyMapper value-->valueMapper 映射 得到Map集合
Map> listMap = students.stream()
        .collect(Collectors.toUnmodifiableMap(Student::getId, student -> {
            List stus = new ArrayList<>();
            stus.add(student);
            return stus;
        }));

System.out.println(listMap);
System.out.println("---------------------------------------
");


//    對流中元素進行遍歷 對key-->keyMapper-->Key value-->valueMapper-->Value 映射
//    對滿足相同Key的元素 Value進行合并
Map lengthName = names.stream()
        .collect(Collectors.toUnmodifiableMap(String::length,
                String::toString, (str1, str2) -> str1 + "	" + str2));
System.out.println(lengthName);
System.out.println("---------------------------------------
");
三、groupingBy分組
//    三、groupingBy分組

//    分組 groupingBy

//    對T元素按 key進行分組 --> 分組的依據 classifier--> 分組后的集合 value--> 得到 Map
/*
Returns a {@code Collector} implementing a "group by" operation on
input elements of type {@code T}, grouping elements according to a
         classification function, and returning the results in a {@code Map}.

The classification function maps elements to some key type {@code K}. The collector produces a {@code Map>} whose keys are the values resulting from applying the classification function to the input elements, and whose corresponding values are {@code List}s containing the input elements which map to the associated key under the classification function.

There are no guarantees on the type, mutability, serializability, or thread-safety of the {@code Map} or {@code List} objects returned.*/ /* 按照key對T進行classifier分組 使用List集合收集分組結果 單線程 線程安全 public static Collector>> groupingBy(Function classifier) { return groupingBy(classifier, toList()); }*/ /* 按照key對T進行classifier分組 使用自定義收集器downstream 收集分組結果 單線程 線程安全 public static Collector> groupingBy(Function classifier, Collector downstream) { return groupingBy(classifier, HashMap::new, downstream); }*/ /* 按照key對T進行classifier分組 使用自定義mapFactory 重置downstream的CollectorImpl實現 使用自定義收集器downstream 收集分組結果 單線程 線程安全 public static > Collector groupingBy(Function classifier, Supplier mapFactory, Collector downstream) { Supplier downstreamSupplier = downstream.supplier(); BiConsumer downstreamAccumulator = downstream.accumulator(); BiConsumer, T> accumulator = (m, t) -> { K key = Objects.requireNonNull(classifier.apply(t), "element cannot be mapped to a null key"); A container = m.computeIfAbsent(key, k -> downstreamSupplier.get()); downstreamAccumulator.accept(container, t); }; BinaryOperator> merger = Collectors.>mapMerger(downstream.combiner()); @SuppressWarnings("unchecked") Supplier> mangledFactory = (Supplier>) mapFactory; // 不進行強制類型轉換 重構CollectorImpl實現 if (downstream.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)) { return new CollectorImpl<>(mangledFactory, accumulator, merger, CH_ID); } else { // 進行強制類型轉換 重構CollectorImpl實現 @SuppressWarnings("unchecked") Function downstreamFinisher = (Function) downstream.finisher(); Function, M> finisher = intermediate -> { intermediate.replaceAll((k, v) -> downstreamFinisher.apply(v)); @SuppressWarnings("unchecked") M castResult = (M) intermediate; return castResult; }; return new CollectorImpl<>(mangledFactory, accumulator, merger, finisher, CH_NOID); } }*/

//    分組
System.out.println("-----------------------------------------
");


//    select * from students group by sex ;
Map> sexStudent =
        students.stream().collect(Collectors.groupingBy(Student::getSex));
System.out.println(sexStudent);
System.out.println("-----------------------------------------
");


//    select sex, count(*) from students group by sex ;
Map sexCount =
        students.stream().collect(Collectors.groupingBy(Student::getSex, Collectors.counting()));
System.out.println(sexCount);
System.out.println("-----------------------------------------
");


//    select sex,avg(salary) from students group by sex ;
Map avgSexSalary = students.stream().collect
        (Collectors.groupingBy(Student::getSex, Collectors.averagingDouble(Student::getSalary)));
System.out.println(avgSexSalary);
System.out.println("-----------------------------------------
");


//    嵌套分組  先根據sex分組 再對結果按照addr進行分組
Map>> NestedGroupBy = students.stream()
        .collect(Collectors.groupingBy(Student::getSex, Collectors.groupingBy(Student::getAddr)));
System.out.println(NestedGroupBy);
System.out.println("-----------------------------------------
");


//    使用自定義收集器downstream 按性別分組  使用HashSet進行 結果收集
Map> sexHashSet = students.stream()
        .collect(Collectors.groupingBy(Student::getSex, Collectors.toCollection(HashSet::new)));
System.out.println(sexHashSet);
System.out.println("-----------------------------------------
");


//    使用自定義收集器downstream 按性別分組  使用HashSet進行 結果收集  重置CollectorImpl實現
Map> sexCustomCollectorImpl = students.stream()
        .collect(Collectors.groupingBy(Student::getSex, Hashtable::new, Collectors.toCollection(HashSet::new)));
System.out.println(sexCustomCollectorImpl);
System.out.println("-----------------------------------------
");
四、groupingByConcurrent分組
 //    四、groupingByConcurrent分組

 //    分組 groupingByConcurrent

 //    流的適用條件:
 //          無序 Collector.Characteristics.UNORDERED
 //          并發 Collector.Characteristics.CONCURRENT
 //    This is a {@link Collector.Characteristics#CONCURRENT concurrent} and
 //    {@link Collector.Characteristics#UNORDERED unordered} Collector.


 /*
       按照key對T進行classifier分組
       使用List集合收集分組結果
 public static 
         Collector>>
 groupingByConcurrent(Function classifier) {
     return groupingByConcurrent(classifier,  ::new, toList());
 }*/


/*
       按照key對T進行classifier分組
       使用自定義收集器downstream 收集分組結果
public static 
         Collector> groupingByConcurrent(Function classifier,
         Collector downstream) {
     return groupingByConcurrent(classifier, ConcurrentHashMap::new, downstream);
 }*/


 /*
       按照key對T進行classifier分組
       使用自定義累加器mapFactory  重置downstream的CollectorImpl實現
       使用自定義收集器downstream 收集分組結果
 public static >
 Collector groupingByConcurrent(Function classifier,
         Supplier mapFactory,
         Collector downstream) {
     Supplier downstreamSupplier = downstream.supplier();
     BiConsumer downstreamAccumulator = downstream.accumulator();
     BinaryOperator> merger = Collectors.>mapMerger(downstream.combiner());
     @SuppressWarnings("unchecked")
     Supplier> mangledFactory = (Supplier>) mapFactory;
     BiConsumer, T> accumulator;
     if (downstream.characteristics().contains(Collector.Characteristics.CONCURRENT)) {
         accumulator = (m, t) -> {
             K key = Objects.requireNonNull(classifier.apply(t), "element cannot be mapped to a null key");
             A resultContainer = m.computeIfAbsent(key, k -> downstreamSupplier.get());
             downstreamAccumulator.accept(resultContainer, t);
         };
     }
     else {
         accumulator = (m, t) -> {
             K key = Objects.requireNonNull(classifier.apply(t), "element cannot be mapped to a null key");
             A resultContainer = m.computeIfAbsent(key, k -> downstreamSupplier.get());
             //  多個操作-->同時操作同一個結果容器-->同一時間,有且只有一個進行實際操作-->線程同步
             synchronized (resultContainer) {
                 downstreamAccumulator.accept(resultContainer, t);
             }
         };
     }

     if (downstream.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)) {
         return new CollectorImpl<>(mangledFactory, accumulator, merger, CH_CONCURRENT_ID);
     }
     else {
         @SuppressWarnings("unchecked")
         Function downstreamFinisher = (Function) downstream.finisher();
         Function, M> finisher = intermediate -> {
             intermediate.replaceAll((k, v) -> downstreamFinisher.apply(v));
             @SuppressWarnings("unchecked")
             M castResult = (M) intermediate;
             return castResult;
         };
         return new CollectorImpl<>(mangledFactory, accumulator, merger, finisher, CH_CONCURRENT_NOID);
     }
 }*/
//    分組 無序 并發
System.out.println("-----------------------------------------
");

//    按性別分組  使用ArrayList進行 結果收集
ConcurrentMap> sexStudentConcurrent = students.stream()
        .collect(Collectors.groupingByConcurrent(Student::getSex));
System.out.println(sexStudentConcurrent);
System.out.println("-----------------------------------------
");


//    使用自定義收集器downstream 按性別分組  使用HashSet進行 結果收集
ConcurrentMap> sexHashSetConcurrent = students.stream()
        .collect(Collectors.groupingByConcurrent(Student::getSex, Collectors.toCollection(HashSet::new)));
System.out.println(sexHashSetConcurrent);
System.out.println("-----------------------------------------
");


//    使用自定義收集器downstream 按性別分組  使用HashSet進行 結果收集  重置CollectorImpl實現
ConcurrentReferenceHashMap> sexCustomCollectorImplConcurrent =
        students.stream().collect(Collectors.groupingByConcurrent(Student::getSex,
                ConcurrentReferenceHashMap::new, Collectors.toCollection(HashSet::new)));
System.out.println(sexCustomCollectorImplConcurrent);
System.out.println("-----------------------------------------
");
五、partitioningBy分區
//    五、partitioningBy分區

//  分區  partitioningBy

/*
      對滿足預期的條件 進行分區 使用ArrayList 進行結果的收集
public static 
        Collector>> partitioningBy(Predicate predicate) {
    return partitioningBy(predicate, toList());
}*/


/*
      對滿足預期的條件 進行分區 使用自定義收集器downstream 進行結果的收集
public static 
        Collector> partitioningBy(Predicate predicate,
        Collector downstream) {
    BiConsumer downstreamAccumulator = downstream.accumulator();
    BiConsumer, T> accumulator = (result, t) ->
            downstreamAccumulator.accept(predicate.test(t) ? result.forTrue : result.forFalse, t);
    BinaryOperator op = downstream.combiner();
    BinaryOperator> merger = (left, right) ->
            new Partition<>(op.apply(left.forTrue, right.forTrue),
                    op.apply(left.forFalse, right.forFalse));
    Supplier> supplier = () ->
            new Partition<>(downstream.supplier().get(),
                    downstream.supplier().get());
    if (downstream.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)) {
        return new CollectorImpl<>(supplier, accumulator, merger, CH_ID);
    }
    else {
        Function, Map> finisher = par ->
                new Partition<>(downstream.finisher().apply(par.forTrue),
                        downstream.finisher().apply(par.forFalse));
        return new CollectorImpl<>(supplier, accumulator, merger, finisher, CH_NOID);
    }
}*/
        //    分區
        System.out.println("-----------------------------------------
");

        //    select * from students partition by (addr == Sword Art Online) ;
        Map> addrPartition = students.stream().collect
                (Collectors.partitioningBy(student -> student.getAddr().equals("Sword Art Online")));
        System.out.println(addrPartition);
        System.out.println("-----------------------------------------
");


        //    嵌套分區  先根據sex分區 再對結果按照addr進行分區
        Map>> NestedPartiton = students.stream()
                .collect(Collectors.partitioningBy(student -> student.getSex().equals("Male"),
                        Collectors.partitioningBy(student -> student.getAddr().equals("Sword Art Online"))));
        System.out.println(NestedPartiton);
        System.out.println("-----------------------------------------
");


        //    使用自定義downstream收集器分區
        Map> addrCustomPartition = students.stream().collect(Collectors.partitioningBy
                (student -> student.getAddr().equals("Sword Art Online"), Collectors.toCollection(HashSet::new)));
        System.out.println(addrCustomPartition);
        System.out.println("-----------------------------------------
");

    }

}
六、測試結果
  .   ____          _            __ _ _
 / / ___"_ __ _ _(_)_ __  __ _    
( ( )\___ | "_ | "_| | "_ / _` |    
 /  ___)| |_)| | | | | || (_| |  ) ) ) )
  "  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v2.1.2.RELEASE)

2019-02-20 16:58:15.870  INFO 13392 --- [           main] c.j.d.java8.Stream.CollectorsDetail      : Starting CollectorsDetail on DESKTOP-87RMBG4 with PID 13392 (started by 46250 in E:IdeaProjectsdesign)
2019-02-20 16:58:15.871  INFO 13392 --- [           main] c.j.d.java8.Stream.CollectorsDetail      : No active profile set, falling back to default profiles: default
2019-02-20 16:58:16.383  INFO 13392 --- [           main] c.j.d.java8.Stream.CollectorsDetail      : Started CollectorsDetail in 0.708 seconds (JVM running for 1.421)
-----------------------------------------

[Kirito, Asuna, Sinon, Yuuki, Alice]
---------------------------------------

[Yuuki, Asuna, Kirito, Sinon, Alice]
---------------------------------------

[KIRITO, ASUNA, SINON, YUUKI, ALICE]
---------------------------------------

[Kirito]
---------------------------------------

{5=[Student(id=5, name=Alice, sex=Female, age=14, addr=Alicization, salary=9.99999999E8)], 4=[Student(id=4, name=Yuuki, sex=Female, age=15, addr=Alfheim Online, salary=9.99999999E8)], 3=[Student(id=3, name=Sinon, sex=Female, age=16, addr=Gun Gale Online, salary=9.99999999E8)], 2=[Student(id=2, name=Asuna, sex=Female, age=17, addr=Sword Art Online, salary=9.99999999E8)], 1=[Student(id=1, name=Kirito, sex=Male, age=18, addr=Sword Art Online, salary=9.99999999E8)]}
---------------------------------------

{6=Kirito, 5=Asuna    Sinon    Yuuki    Alice}
---------------------------------------

-----------------------------------------

{Female=[Student(id=2, name=Asuna, sex=Female, age=17, addr=Sword Art Online, salary=9.99999999E8), Student(id=3, name=Sinon, sex=Female, age=16, addr=Gun Gale Online, salary=9.99999999E8), Student(id=4, name=Yuuki, sex=Female, age=15, addr=Alfheim Online, salary=9.99999999E8), Student(id=5, name=Alice, sex=Female, age=14, addr=Alicization, salary=9.99999999E8)], Male=[Student(id=1, name=Kirito, sex=Male, age=18, addr=Sword Art Online, salary=9.99999999E8)]}
-----------------------------------------

{Female=4, Male=1}
-----------------------------------------

{Female=9.99999999E8, Male=9.99999999E8}
-----------------------------------------

{Female={Alicization=[Student(id=5, name=Alice, sex=Female, age=14, addr=Alicization, salary=9.99999999E8)], Sword Art Online=[Student(id=2, name=Asuna, sex=Female, age=17, addr=Sword Art Online, salary=9.99999999E8)], Gun Gale Online=[Student(id=3, name=Sinon, sex=Female, age=16, addr=Gun Gale Online, salary=9.99999999E8)], Alfheim Online=[Student(id=4, name=Yuuki, sex=Female, age=15, addr=Alfheim Online, salary=9.99999999E8)]}, Male={Sword Art Online=[Student(id=1, name=Kirito, sex=Male, age=18, addr=Sword Art Online, salary=9.99999999E8)]}}
-----------------------------------------

{Female=[Student(id=4, name=Yuuki, sex=Female, age=15, addr=Alfheim Online, salary=9.99999999E8), Student(id=3, name=Sinon, sex=Female, age=16, addr=Gun Gale Online, salary=9.99999999E8), Student(id=5, name=Alice, sex=Female, age=14, addr=Alicization, salary=9.99999999E8), Student(id=2, name=Asuna, sex=Female, age=17, addr=Sword Art Online, salary=9.99999999E8)], Male=[Student(id=1, name=Kirito, sex=Male, age=18, addr=Sword Art Online, salary=9.99999999E8)]}
-----------------------------------------

{Female=[Student(id=4, name=Yuuki, sex=Female, age=15, addr=Alfheim Online, salary=9.99999999E8), Student(id=3, name=Sinon, sex=Female, age=16, addr=Gun Gale Online, salary=9.99999999E8), Student(id=5, name=Alice, sex=Female, age=14, addr=Alicization, salary=9.99999999E8), Student(id=2, name=Asuna, sex=Female, age=17, addr=Sword Art Online, salary=9.99999999E8)], Male=[Student(id=1, name=Kirito, sex=Male, age=18, addr=Sword Art Online, salary=9.99999999E8)]}
-----------------------------------------

-----------------------------------------

{Male=[Student(id=1, name=Kirito, sex=Male, age=18, addr=Sword Art Online, salary=9.99999999E8)], Female=[Student(id=2, name=Asuna, sex=Female, age=17, addr=Sword Art Online, salary=9.99999999E8), Student(id=3, name=Sinon, sex=Female, age=16, addr=Gun Gale Online, salary=9.99999999E8), Student(id=4, name=Yuuki, sex=Female, age=15, addr=Alfheim Online, salary=9.99999999E8), Student(id=5, name=Alice, sex=Female, age=14, addr=Alicization, salary=9.99999999E8)]}
-----------------------------------------

{Male=[Student(id=1, name=Kirito, sex=Male, age=18, addr=Sword Art Online, salary=9.99999999E8)], Female=[Student(id=4, name=Yuuki, sex=Female, age=15, addr=Alfheim Online, salary=9.99999999E8), Student(id=3, name=Sinon, sex=Female, age=16, addr=Gun Gale Online, salary=9.99999999E8), Student(id=5, name=Alice, sex=Female, age=14, addr=Alicization, salary=9.99999999E8), Student(id=2, name=Asuna, sex=Female, age=17, addr=Sword Art Online, salary=9.99999999E8)]}
-----------------------------------------

{Female=[Student(id=4, name=Yuuki, sex=Female, age=15, addr=Alfheim Online, salary=9.99999999E8), Student(id=3, name=Sinon, sex=Female, age=16, addr=Gun Gale Online, salary=9.99999999E8), Student(id=5, name=Alice, sex=Female, age=14, addr=Alicization, salary=9.99999999E8), Student(id=2, name=Asuna, sex=Female, age=17, addr=Sword Art Online, salary=9.99999999E8)], Male=[Student(id=1, name=Kirito, sex=Male, age=18, addr=Sword Art Online, salary=9.99999999E8)]}
-----------------------------------------

-----------------------------------------

{false=[Student(id=3, name=Sinon, sex=Female, age=16, addr=Gun Gale Online, salary=9.99999999E8), Student(id=4, name=Yuuki, sex=Female, age=15, addr=Alfheim Online, salary=9.99999999E8), Student(id=5, name=Alice, sex=Female, age=14, addr=Alicization, salary=9.99999999E8)], true=[Student(id=1, name=Kirito, sex=Male, age=18, addr=Sword Art Online, salary=9.99999999E8), Student(id=2, name=Asuna, sex=Female, age=17, addr=Sword Art Online, salary=9.99999999E8)]}
-----------------------------------------

{false={false=[Student(id=3, name=Sinon, sex=Female, age=16, addr=Gun Gale Online, salary=9.99999999E8), Student(id=4, name=Yuuki, sex=Female, age=15, addr=Alfheim Online, salary=9.99999999E8), Student(id=5, name=Alice, sex=Female, age=14, addr=Alicization, salary=9.99999999E8)], true=[Student(id=2, name=Asuna, sex=Female, age=17, addr=Sword Art Online, salary=9.99999999E8)]}, true={false=[], true=[Student(id=1, name=Kirito, sex=Male, age=18, addr=Sword Art Online, salary=9.99999999E8)]}}
-----------------------------------------

{false=[Student(id=4, name=Yuuki, sex=Female, age=15, addr=Alfheim Online, salary=9.99999999E8), Student(id=3, name=Sinon, sex=Female, age=16, addr=Gun Gale Online, salary=9.99999999E8), Student(id=5, name=Alice, sex=Female, age=14, addr=Alicization, salary=9.99999999E8)], true=[Student(id=2, name=Asuna, sex=Female, age=17, addr=Sword Art Online, salary=9.99999999E8), Student(id=1, name=Kirito, sex=Male, age=18, addr=Sword Art Online, salary=9.99999999E8)]}
-----------------------------------------

文章版權歸作者所有,未經允許請勿轉載,若此文章存在違規行為,您可以聯系管理員刪除。

轉載請注明本文地址:http://specialneedsforspecialkids.com/yun/73351.html

相關文章

  • Stream流與Lambda達式(二) Stream收集器 Collector接口

    摘要:一收集器接口陳楊收集器接口匯聚操作的元素類型即流中元素類型匯聚操作的可變累積類型匯聚操作的結果類型接口一種可變匯聚操作將輸入元素累積到可變結果容器中在處理完所有輸入元素后可以選擇將累積的結果轉換為最終表示可選操作歸約操作 一、Stream收集器 Collector接口 package com.java.design.java8.Stream; import com.java.desi...

    or0fun 評論0 收藏0
  • Java8新特性總覽

    摘要:新特性總覽標簽本文主要介紹的新特性,包括表達式方法引用流默認方法組合式異步編程新的時間,等等各個方面。還有對應的和類型的函數連接字符串廣義的歸約匯總起始值,映射方法,二元結合二元結合。使用并行流時要注意避免共享可變狀態。 Java8新特性總覽 標簽: java [TOC] 本文主要介紹 Java 8 的新特性,包括 Lambda 表達式、方法引用、流(Stream API)、默認方...

    mayaohua 評論0 收藏0
  • Stream流與Lambda達式(一) 雜談

    摘要:一流轉換為數組集合陳楊將流轉換為數組將流轉換為數組將流轉換為集合將流轉換為集合解析 一、流 轉換為數組、集合 package com.java.design.java8.Stream; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.boot.test.context...

    Harpsichord1207 評論0 收藏0
  • Java8學習小記

    摘要:但有一個限制它們不能修改定義的方法的局部變量的內容。如前所述,這種限制存在的原因在于局部變量保存在棧上,并且隱式表示它們僅限于其所在線程。 2014年,Oracle發布了Java8新版本。對于Java來說,這顯然是一個具有里程碑意義的版本。尤其是那函數式編程的功能,避開了Java那煩瑣的語法所帶來的麻煩。 這可以算是一篇Java8的學習筆記。將Java8一些常見的一些特性作了一個概要的...

    CHENGKANG 評論0 收藏0
  • 引入流

    摘要:流的使用一般包括三件事一個數據源來執行一個查詢一個中間操作鏈,形成一條流水線一個終端操作,執行流水線并生成結果以上便是流的一些基礎知識,下一章會更加深入理解流。實戰第四章引入流讀書筆記歡迎加入咖啡館的春天。 流是什么 幾乎每個 Java 應用都會制造和處理集合。流 允許我們以聲明性方式處理集合(通過類似于 SQL 查詢語句來表達,而不是臨時寫一個實現)。此外 流 還可以透明地并行處理,...

    phodal 評論0 收藏0

發表評論

0條評論

最新活動
閱讀需要支付1元查看
<