主頁 > 後端開發 > JDK 8 新特性之函式式編程 → Stream API

JDK 8 新特性之函式式編程 → Stream API

2020-09-14 09:58:46 後端開發

開心一刻

　　今天和朋友們去K歌，看著這群年輕人一個個唱的賊嗨，不禁感慨道：年輕真好啊！

　　想到自己年輕的時候，那也是拿著麥克風不放的人

　　現在的我沒那激情了，只喜歡坐在角落里，默默的聽著他們唱，就連旁邊的妹子都勸我說：大哥別摸了，唱首歌吧

Stream 初體驗

　　很多時候，我們往往會選擇在資料庫層面進行資料的過濾、匯聚，這就導致我們對 JDK8 的 Stream 應用的特別少，對它也就特別陌生了

　　但有時候，我們可以將原始資料加載到記憶體，在記憶體中進行資料的過濾和匯聚，這樣可以減少資料庫操作，提高查詢效率（非絕對，資料量不大或走索引的情況下，資料庫查詢也是很快的）

　　假設我們在記憶體中進行資料的過濾、匯聚，在 JDK8 之前（或不用 JDK8 的 Stream），我們會如何處理？ 多次 for 回圈結合 if ，并創建多個集合來存放中間結果，最后對中間結果進行匯聚，代碼量會非常大；如果想牛逼一點，用多執行緒來處理，那就更復雜了（執行緒池、并發等問題），Stream 就解決了這些痛點，如果你的 JDK 版本是 8（或更高），你還在用 for 回圈進行資料的過濾和匯聚，那就有點這味了

　　那 Stream 到底是何方神圣，讓樓主如此推崇，我們往下看（再不講重點，樓主怕是要收刀片了！）

　　先聞其聲

　　　　我們先來看看她媽是怎么介紹她的： A sequence of elements supporting sequential and parallel aggregate operations. 

　　　　我們能從中獲取到兩個資訊：

　　　　　　1、Stream 是元素的集合（有點類似 Iterator）

　　　　　　2、對原 Stream 支持順序或并行的匯聚操作

　　　　這她媽的介紹還是比較抽象，我們需要從 Stream 自身下手，慢慢去了解她

　　　　常見的 Stream 介面繼承關系如下

　　　　IntStream, LongStream, DoubleStream 對應的是三種基本型別（int, long, double，不是包裝型別），Stream 對應所有剩余型別

　　　　為什么不是這樣

　　　　或者取消掉 IntStream, LongStream, DoubleStream，由 Stream 對應所有型別 ？

　　　　我們知道基本型別與包裝型別之前的裝箱與拆箱是有性能消耗的，頻繁的轉換會有比較嚴重的性能損耗，所以為不同資料型別設定不同stream介面，可以提高性能，也可以增加特定介面

　　一睹芳容

　　　　上面說了那么多，卻始終未一睹 Stream 的芳容，心里著急呀！我們先來瞟一眼

List<Integer> nums = Arrays.asList(1, 8, 0, 5, 3, 2);
// 統計大于 3 的元素個數
long count = nums.stream().filter(e -> e > 3).count();

　　　　是不是很美？千萬不要以為 Stream 就這？這還只是她的一條腿，她渾身上下都是寶

　　　　通過上面的簡單示例，我們可以剖析出 Stream 的通用語法

　　　　也就是說使用 Stream 基本分三步：創建 Steam、轉換Stream、匯聚，下面我們就從這三步詳細介紹 Stream

創建 Stream

　　Stream 的創建方式有很多，我們只講最常用的兩種

　　基于陣列： Stream<String> arrayStream = Arrays.stream(new String[]{"123", "abc", "A", "張三"}); 

　　基于 Collection： Stream<String> collectionStream = Arrays.asList("123", "abc", "A", "張三").stream(); 

　　把陣列變成 Stream 使用 Arrays.stream() 方法；對于 Collection（List、Set、Queue 等），直接呼叫 stream() 方法就可以獲得 Stream

轉換 Stream

　　轉換 Stream 的目的是對原 Stream 做出某種程度的資料映射/過濾，然后回傳一個新的流，交給下一個操作使用，對原 Stream 是沒有任何影響的，這類操作都是惰性化的（lazy），就是說，僅僅呼叫到這類方法，并沒有真正開始流的遍歷

　　由于獲取的是一個新的流，而不是我們需要的最終結果，所以 轉換 Stream 這個操作有個官方的稱呼： Intermediate ，即中間操作

　　具體的轉換操作有很多，我們挑一些常用的來說明一下

　　distinct

　　　　對 Stream 中的元素進行去重操作（去重邏輯依賴元素的 equals 方法），新生成的 Stream 中沒有重復的元素

List<Integer> nums = Arrays.asList(1, 2, 1, 3, 2, 5);
Stream<Integer> distinctStream = nums.stream().distinct();

　　filter

　　　　對 Stream 中的每個元素使用給定的過濾條件進行過濾操作，新生成的 Stream 只包含符合條件的元素

List<Integer> nums = Arrays.asList(1, 2, 1, 3, 2, 5);
Stream<Integer> filterStream = nums.stream().filter(e -> e >= 2);

　　map

　　　　對 Stream 中的每個元素按給定的轉換規則進行轉換操作，新生成的 Stream 只包含轉換生成的元素

List<Integer> nums = Arrays.asList(1, 2, 1, 3, 2, 5);
Stream<String> mapStream = nums.stream().map(e -> e * e + "");

　　　　JDK1.8 還提供了三個專門針對基本資料型別的 map 變種方法：mapToInt，mapToLong 和 mapToDouble，這三個方法也比較好理解，就是把原始 Stream 轉換成一個新的 Stream，這個新生成的 Stream 中的元素都是對應的基本型別，之所以會有這三個變種方法，是考慮到自動裝箱/拆箱的額外消耗

List<Integer> nums = Arrays.asList(1, 2, 1, 3, 2, 5);
IntStream intStream = nums.stream().mapToInt(e -> e * 2);
LongStream longStream = nums.stream().mapToLong(e -> 3L * e);
DoubleStream doubleStream = nums.stream().mapToDouble(e -> 3.0 * e);

　　flatMap

　　　　與 map 類似

<R> Stream<R> map(Function<? super T, ? extends R> mapper);

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

　　　　不同的是 flatMap 中每個元素轉換得到的是 Stream 物件，然后會把子 Stream 中的元素都放到新的 Stream 中

List<List<String>> groupList = Arrays.asList(Arrays.asList("q","w","e"), Arrays.asList("a", "s", "d"), Arrays.asList("z","x", "c"));
Stream<String> superStarStream = groupList.stream().flatMap(group -> group.stream().map(e -> e + 1));

　　　　簡單點理解就是：把幾個小的集合中的元素經過處理后合并到一個大的集合中

　　　　類似的，JDK1.8 也提供了三個專門針對基本資料型別的 flatMap 變種方法：flatMapToInt，flatMapToLong 和 flatMapToDouble

　　limit

　　　　拷貝原 Stream 中的前 N 個元素到新的 Stream 中，如果原 Stream 中包含的元素個數小于 N，那就獲取其所有的元素

List<Integer> nums = Arrays.asList(1, 2, 1, 3, 2, 5);
Stream<Integer> limitStream = nums.stream().limit(4);

　　skip

　　　　拷貝原 Stream 除了前 N 個元素后剩下的所有元素到新 Stream，如果原 Stream 中包含的元素個數小于 N，那么回傳空 Stream

List<Integer> nums = Arrays.asList(1, 2, 1, 3, 2, 5);
Stream<Integer> skipStream = nums.stream().skip(4);

　　sorted

　　　　對原 Stream 進行排序操作，得到一個新的、有序的 Stream

　　　　排序函式有兩個，一個是用自然順序排序，一個是使用自定義比較器排序

Stream<T> sorted();
Stream<T> sorted(Comparator<? super T> comparator);

　　　　使用起來非常簡單，如下所示

List<Integer> nums = Arrays.asList(1, 2, 1, 3, 2, 5);
// 自然排序，默認升序排序
Stream<Integer> sortedStream = nums.stream().sorted();
// 自定義排序
Stream<Integer> sortedCompareStream = nums.stream().sorted((a, b) -> b.compareTo(a));

　　peek

Stream<T> peek(Consumer<? super T> action);

　　　　生成一個包含原 Stream 所有元素的新 Stream，同時會提供一個消費函式（Consumer 實體），新 Stream 每個元素被消費的時候都會執行給定的消費函式

　　　　與 map 很像，但不會影響新 Stream 中的元素（還是原 Stream 中的元素），可以做一些輸出，外部處理等輔助操作

　　　　這個在實際專案中用的不多，知道是怎么回事就好

匯聚

　　匯聚操作接受一個 Stream 為輸入，反復使用某個匯聚操作，把 Stream 中的元素合并成一個匯總的結果，匯總結果可能是某個值，也可能是一個集合

　　匯聚操作能夠得到我們需要的最終結果，相當于一個終止操作，所以也有另一個稱呼： Terminal ，即結束操作

　　一個流只能有一個 terminal 操作，當這個操作執行后，流就被使用“光”了，無法再被操作，所以這必定是流的最后一個操作，Terminal 操作的執行，才會真正開始流的遍歷

　　JDK1.8 提供了很多常用的匯聚操作，我們一起來看看

　　foreach

　　　　這個類似我們平時的 for 回圈，遍歷 Stream 中的元素，執行指定的操作

List<Integer> nums = Arrays.asList(1, 2, 1, 3, 2, 5);
nums.stream().forEach(num -> System.out.println(num));

　　max min count

　　　　作用就是字面意思

List<Integer> nums = Arrays.asList(1, 2, 1, 3, 2, 5);
// 求最大值
Integer max = nums.stream().max(Comparator.naturalOrder()).get();
// 求最小值
Integer min = nums.stream().min(Comparator.naturalOrder()).get();
// 求元素個數
long count = nums.stream().count();
System.out.println("max = " + max);
System.out.println("min = " + min);
System.out.println("count = " + count);

　　findFirst

　　　　回傳一個 Optional，它包含了 Stream 中的第一個元素，若 Stream 是空的，則回傳一個空的 Optional

List<Integer> nums = Arrays.asList(1, 2, 1, 3, 2, 5);
Integer firstNum = nums.stream().findFirst().get();

　　findAny

　　　　回傳一個 Optional，它包含了 Stream 中的任意一個元素，若 Stream 是空的，則回傳一個空的 Optional

List<Integer> nums = Arrays.asList(1, 2, 1, 3, 2, 5);
Integer anyNum = nums.stream().findAny().get();

　　　　在串行的流中，findAny 和 findFirst回傳的，都是第一個物件；而在并行的流中，findAny 回傳的是最快處理完的那個執行緒的資料，所以說，在并行操作中，對資料沒有順序上的要求，那么 findAny 的效率會比 findFirst 要快的，但是沒有 findFirst 穩定

　　anyMatch

　　　　Stream 中是否有任意一個元素滿足判斷條件，有則回傳 true

List<Integer> nums = Arrays.asList(1, 2, 1, 3, 2, 5);
boolean matchResult = nums.stream().anyMatch(num -> num > 2);

　　allMatch

　　　　Stream 中所有元素都滿足判斷條件則回傳 true

List<Integer> nums = Arrays.asList(1, 2, 1, 3, 2, 5);
boolean matchResult = nums.stream().allMatch(num -> num > 2);

　　noneMatch

　　　　與 allMatch 相反，Stream 中所有元素都不滿足判斷條件，則回傳 true

List<Integer> nums = Arrays.asList(1, 2, 1, 3, 2, 5);
boolean matchResult = nums.stream().noneMatch(num -> num > 7);

　　reduce

　　　　reduce 的主要作用是把 Stream 元素組合起來

　　　　它提供一個起始值（種子），然后依照運算規則（BinaryOperator），和 Stream 中的第一個、第二個、第 n 個元素組合，生成一個我們需要的值

　　　　JDK 提供了三種 reduce

T reduce(T identity, BinaryOperator<T> accumulator);

Optional<T> reduce(BinaryOperator<T> accumulator);

<U> U reduce(U identity,
                 BiFunction<U, ? super T, U> accumulator,
                 BinaryOperator<U> combiner);

　　　　引數不同，其回傳值型別是有所不同的，但其語意、作用還是一樣的

　　　　max()、min()其實都是特殊的 reduce，只是因為它們比較常用，所以就簡化書寫專門設計出了它們

@Override
public final Optional<P_OUT> max(Comparator<? super P_OUT> comparator) {
    return reduce(BinaryOperator.maxBy(comparator));
}

@Override
public final Optional<P_OUT> min(Comparator<? super P_OUT> comparator) {
    return reduce(BinaryOperator.minBy(comparator));

}

　　　　reduce 在實際專案中用的不多，又非常靈活，我們就簡單看幾個示例

        List<Integer> nums = Arrays.asList(1, 2, 1, 3, 2, 5);

        // 求和，相當于sum(); 有起始值
        Integer sum1 = nums.stream().reduce(0, Integer::sum);
        Integer sum2 = nums.stream().reduce(0, (a,b) -> a + b);
        // 求和，相當于sum(); 無起始值
        Integer sum3 = nums.stream().reduce(Integer::sum).get();
        System.out.println("sum = " + sum1 + ", sum2 = " + sum2 + ", sum3 = " + sum3);

        // 求最大值，相當于max()
        Integer max = nums.stream().reduce(Integer.MIN_VALUE, Integer::max);
        System.out.println("max = " + max);
        // 求最小值，相當于min()
        Integer min = nums.stream().reduce(Integer.MAX_VALUE, Integer::min);
        System.out.println("min = " + min);
View Code

　　　　reduce 擅長的是生成一個值，如果想要從 Stream 生成一個集合或者 Map 等復雜的物件該怎么辦呢？就需要 collect 出馬了

　　collect

　　　　collect 是 Stream 介面中最靈活的，也是最強大的；JDK 中提供了兩種 collect

// Supplier supplier是一個工廠函式，用來生成一個新的容器；
// BiConsumer accumulator也是一個函式，用來把Stream中的元素添加到結果容器中
// BiConsumer combiner還是一個函式，用來把中間狀態的多個結果容器合并成為一個（并發的時候會用到）
<R> R collect(Supplier<R> supplier,
              BiConsumer<R, ? super T> accumulator,
              BiConsumer<R, R> combiner);

<R, A> R collect(Collector<? super T, A, R> collector);

　　　　我們來各看一個案例

List<String> strList = Arrays.asList("123","abc", "1w1");
String concat  = strList.stream().collect(StringBuilder::new, StringBuilder::append, StringBuilder::append).toString();
System.out.println(concat);

List<String> stringList = strList.stream().collect(Collectors.toList());

 　　　　實際應用中，基本上用的是第二種，而且用的是 JDK 中已經提供好的 Collector，在 Collectors 中提供了很多常用的 Collector， 如下

　　　　我們挑一些比較常用的來說明下，有興趣的可以去通讀下

　　　　轉集合

　　　　　　toList、toSet、toMap

public class StreamTest {

    public static void main(String[] args) {
        Person[] personArray = {
                new Person("shangsan", 23), new Person("張三", 23),
                new Person("lisi", 24), new Person("李四", 24),
                new Person("wangwu", 20), new Person("王五", 20)};
        // 轉 list
        List<Person> personList = Arrays.stream(personArray).collect(Collectors.toList());
        // 轉 set
        Set<Person> personSet = Arrays.stream(personArray).collect(Collectors.toSet());
        // 轉 map, key為 name, value 為 Person 實體
        Map<String, Person> personMap = Arrays.stream(personArray).collect(Collectors.toMap(Person::getName, person -> person));

        System.out.println(personList);
        System.out.println(personSet);
        System.out.println(personMap);
    }

    static class Person {
        private String name;
        private Integer age;

        Person(){}

        Person(String name, Integer age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

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

        public Integer getAge() {
            return age;
        }

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

        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}
View Code

　　　　　　toMap 有兩個注意點

　　　　　　　　1、底層呼叫的是 map.merge 方法，該方法遇到 value 為 null 的情況會報 npe

　　　　　　　　2、遇到重復的 key 會直接拋 IllegalStateException，因為未指定沖突合并策略，也就是第三個引數BinaryOperator<U> mergeFunction

　　　　分組

public class StreamTest {

    public static void main(String[] args) {
        Person[] personArray = {
                new Person("shangsan", 23), new Person("張三", 23),
                new Person("lisi", 24), new Person("李四", 24),
                new Person("wangwu", 20), new Person("王五", 20)};

        // 根據年齡進行分組
        Map<Integer, List<Person>> ageGroup = Arrays.stream(personArray).collect(Collectors.groupingBy(Person::getAge));
        System.out.println(ageGroup);
    }

    static class Person {
        private String name;
        private Integer age;

        Person(){}

        Person(String name, Integer age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

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

        public Integer getAge() {
            return age;
        }

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

        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}
View Code

　　　　求和

// 年齡求和 summingInt、summingLong、summingDouble 類似
Integer ageSum = Arrays.stream(personArray).collect(Collectors.summingInt(Person::getAge));
System.out.println("age sum = " + ageSum);

　　　　求平均值

// 求平均值 averagingInt、averagingLong、averagingDouble 類似
Double averageAge = Arrays.stream(personArray).collect(Collectors.averagingInt(Person::getAge));
System.out.println("average age = " + averageAge);

　　　　其他

// 統計人數
Long count = Arrays.stream(personArray).collect(Collectors.counting());
System.out.println("人數 = " + count);

List<Integer> intList = Arrays.asList(1, 2, 3, 1, 5, 2);
// 求和
Integer sum = intList.stream().collect(Collectors.reducing(0, (a, b) -> a + b));
System.out.println("sum = " + sum);

// 字串拼接
List<String> strList = Arrays.asList("123", "abc", "666");
String str = strList.stream().collect(Collectors.joining(",", "(", ")"));
System.out.println(str);

并行流

　　前面講了那么多，都是基于順序流（Stream），JDK1.8 也提供了并行流： parallelStream ，使用起來非常簡單，通過 parallelStream() 可能創建并行流，流的操作還是和順序流一樣

List<Integer> intList = Arrays.asList(1, 2, 3, 1, 5, 2);
boolean result = intList.parallelStream().anyMatch(e -> e > 5);
System.out.println("result = " + result);

　　顧名思義，并行流可以運用多核特性(forkAndJoin)進行并行處理，從而大幅提高效率，既然能提高效率，為什么實際專案中，順序流用的更多，而并行流用的非常少了，還是有一些原因的

　　1、parallelStream 是執行緒不安全的

　　　　一旦出現并發問題，大家都懂的，非常頭疼

　　2、parallelStream 適用于 CPU 密集型任務

　　　　如果 CPU 負載已經很大，還用并行流，不但不會提高效率，反而會降低效率

　　　　并行流不適用于 I/O 密集型任務，很可能會造成 I/O 阻塞

　　3、并行流無法保證元素順序，輸出結果具有不確定性

　　　　如果我們的業務需要關注元素先后順序，那么不能用并行流

　　4、lambda 的執行并不是瞬間完成的，所有使用 parallel stream 的程式都有可能成為阻塞程式的源頭

總結

　　Stream 特點

　　　　無存盤：Stream 不是資料結構并不保存資料，它是有關演算法和計算的，它只是某種資料源的一個視圖，資料源可以是一個陣列，Java 容器或 I/O channel

　　　　函式式編程：每次轉換，原有 Stream 不改變，回傳一個新的 Stream 物件，這就允許對其操作可以像鏈條一樣排列；轉換程序可以多次

　　　　惰性執行：Stream 上的轉換操作（中間操作）并不會立即執行，只有執行匯聚操作（終止操作）時，轉換操作才會執行

　　　　一次消費：Stream 只能被使用一次，一旦遍歷過就會失效，就像容器的迭代器那樣，想要再次遍歷必須重新生成

　　Stream 優點

　　　　代碼簡潔且易理解，這個感受是最明顯的，用與不用 Stream，代碼量與可閱讀性相差甚遠

　　　　多核友好，如果想多執行緒處理，只需要調一下 parallel() 方法，僅此而已

　　Stream 操作分類

　　　　分兩類：中間操作（Intermediate）、結束操作（Terminal）

　　　　中間操作總是會惰式執行，呼叫中間操作只會生成一個標記了該操作的新 stream，僅此而已

　　　　結束操作會觸發實際計算，計算發生時會把所有中間操作積攢的操作以 pipeline 的方式執行，這樣可以減少迭代次數；計算完成之后stream就會失效

　　性能問題

　　　　在對于一個 Stream 進行多次轉換操作 (Intermediate 操作)，每次都對 Stream 的每個元素進行轉換，而且是執行多次，這樣時間復雜度就是 N（轉換次數）個 for 回圈里把所有操作都做掉的總和嗎？其實不是這樣的，轉換操作都是 lazy 的，多個轉換操作只會在 Terminal 操作的時候融合起來，一次回圈完成，我們可以這樣簡單的理解，Stream 里有個操作函式的集合，每次轉換操作就是把轉換函式放入這個集合中，在 Terminal 操作的時候回圈 Stream 對應的集合，然后對每個元素執行所有的函式

　　　　關于順序流、并行流、傳統 for 的性能問題，大家看看這個：Java Stream API性能測驗、for回圈與串行化、并行化Stream流性能對比

參考

　　Java 8 中的 Streams API 詳解

　　JDK8函式式編程之Stream API

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/33606.html

標籤：Java

上一篇：Struts+Servlet+JDBC網上手機銷售系統

下一篇：Docker 極簡入門教程，傻瓜都能看懂！

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 【C++】Microsoft C++、C 和匯編程式檔案

    ......

    uj5u.com 2020-09-10 00:57:23 more
  • 例外宣告

    相比于斷言適用于排除邏輯上不可能存在的狀態，例外通常是用于邏輯上可能發生的錯誤。 例外宣告 Item 1：當函式不可能拋出例外或不能接受拋出例外時，使用noexcept 理由 如果不打算拋出例外的話，程式就會認為無法處理這種錯誤，并且應當盡早終止，如此可以有效地阻止例外的傳播與擴散。 示例 //不可 ......

    uj5u.com 2020-09-10 00:57:27 more
  • Codeforces 1400E Clear the Multiset(貪心 + 分治)

    鏈接：https://codeforces.com/problemset/problem/1400/E 來源：Codeforces 思路：給你一個陣列，現在你可以進行兩種操作，操作1：將一段沒有 0 的區間進行減一的操作，操作2：將 i 位置上的元素歸零。最終問：將這個陣列的全部元素歸零后操作的最少 ......

    uj5u.com 2020-09-10 00:57:30 more
  • UVA11610 【Reverse Prime】

    本人看到此題沒有翻譯，就附帶了一個自己的翻譯版本 思考 這一題，它的第一個要求是找出所有 $7$ 位反向質數及其質因數的個數。 我們應該需要質數篩篩選1~$10^{7}$的所有數，這里就不慢慢介紹了。但是，重讀題，我們突然發現反向質數都是 $7$ 位，而將它反過來后的數字卻是 $6$ 位數，這就說明 ......

    uj5u.com 2020-09-10 00:57:36 more
  • 統計區間素數數量

    1 #pragma GCC optimize(2) 2 #include <bits/stdc++.h> 3 using namespace std; 4 bool isprime[1000000010]; 5 vector<int> prime; 6 inline int getlist(int ......

    uj5u.com 2020-09-10 00:57:47 more
  • C/C++編程筆記：C++中的 const 變數詳解，教你正確認識const用法

    1、C中的const 1、區域const變數存放在堆疊區中，會分配記憶體（也就是說可以通過地址間接修改變數的值）。測驗代碼如下： 運行結果： 2、全域const變數存放在只讀資料段（不能通過地址修改，會發生寫入錯誤）， 默認為外部聯編，可以給其他源檔案使用（需要用extern關鍵字修飾） 運行結果： ......

    uj5u.com 2020-09-10 00:58:04 more
  • 【C++犯錯記錄】VS2019 MFC添加資源不懂如何修改資源宏ID

    1. 首先在資源視圖中，添加資源 2. 點擊新添加的資源，復制自動生成的ID 3. 在解決方案資源管理器中找到Resource.h檔案，編輯，使用整個專案搜索和替換的方式快速替換 宏宣告 4. Ctrl+Shift+F 全域搜索，點擊查找全部，然后逐個替換 5. 為什么使用搜索替換而不使用屬性視窗直 ......

    uj5u.com 2020-09-10 00:59:11 more
  • 【C++犯錯記錄】VS2019 MFC不懂的批量添加資源

    1. 打開資源頭檔案Resource.h，在其中預先定義好宏 ID（不清楚其實ID值應該設定多少，可以先新建一個相同的資源項，再在這個資源的ID值的基礎上遞增即可） 2. 在資源視圖中選中專案資源，按F7編輯資源檔案，按 ID 型別 相對路徑的形式添加 資源。（別忘了先把檔案拷貝到專案中的res檔案 ......

    uj5u.com 2020-09-10 01:00:19 more
  • C/C++編程筆記：關于C++的參考型別，專供新手入門使用

    今天要講的是C++中我最喜歡的一個用法——參考，也叫別名。 參考就是給一個變數名取一個變數名，方便我們間接地使用這個變數。我們可以給一個變數創建N個參考，這N + 1個變數共享了同一塊記憶體區域。(參考型別的變數會占用記憶體空間，占用的記憶體空間的大小和指標型別的大小是相同的。雖然參考是一個物件的別名，但 ......

    uj5u.com 2020-09-10 01:00:22 more
  • 【C/C++編程筆記】從頭開始學習C ++：初學者完整指南

    眾所周知，C ++的學習曲線陡峭，但是花時間學習這種語言將為您的職業帶來奇跡，并使您與其他開發人員區分開。您會更輕松地學習新語言，形成真正的解決問題的技能，并在編程的基礎上打下堅實的基礎。 C ++將幫助您養成良好的編程習慣（即清晰一致的編碼風格，在撰寫代碼時注釋代碼，并限制類內部的可見性），并且由 ......

    uj5u.com 2020-09-10 01:00:41 more
最新发布
  • Rust中的智能指標:Box<T> Rc<T> Arc<T> Cell<T> RefCell<T> Weak

    Rust中的智能指標是什么 智能指標（smart pointers）是一類資料結構，是擁有資料所有權和額外功能的指標。是指標的進一步發展 指標（pointer）是一個包含記憶體地址的變數的通用概念。這個地址參考，或 ” 指向”（points at）一些其 他資料 。參考以 & 符號為標志并借用了他們所 ......

    uj5u.com 2023-04-20 07:24:10 more
  • Java的值傳遞和參考傳遞

    值傳遞不會改變本身，參考傳遞（如果傳遞的值需要實體化到堆里）如果發生修改了會改變本身。 1.基本資料型別都是值傳遞 package com.example.basic; public class Test { public static void main(String[] args) { int ......

    uj5u.com 2023-04-20 07:24:04 more
  • [2]SpinalHDL教程——Scala簡單入門

    第一個 Scala 程式 shell里面輸入 $ scala scala> 1 + 1 res0: Int = 2 scala> println("Hello World!") Hello World! 檔案形式 object HelloWorld { /* 這是我的第一個 Scala 程式 * 以 ......

    uj5u.com 2023-04-20 07:23:58 more
  • 理解函式指標和回呼函式

    理解 函式指標 指向函式的指標。比如： 理解函式指標的偽代碼 void (*p)(int type, char *data); // 定義一個函式指標p void func(int type, char *data); // 宣告一個函式func p = func; // 將指標p指向函式func ......

    uj5u.com 2023-04-20 07:23:52 more
  • Django筆記二十五之資料庫函式之日期函式

    本文首發于公眾號：Hunter后端 原文鏈接：Django筆記二十五之資料庫函式之日期函式 日期函式主要介紹兩個大類，Extract() 和 Trunc() Extract() 函式作用是提取日期，比如我們可以提取一個日期欄位的年份，月份，日等資料 Trunc() 的作用則是截取，比如 2022-0 ......

    uj5u.com 2023-04-20 07:23:45 more
  • 一天吃透JVM面試八股文

    什么是JVM？ JVM，全稱Java Virtual Machine（Java虛擬機），是通過在實際的計算機上仿真模擬各種計算機功能來實作的。由一套位元組碼指令集、一組暫存器、一個堆疊、一個垃圾回收堆和一個存盤方法域等組成。JVM屏蔽了與作業系統平臺相關的資訊，使得Java程式只需要生成在Java虛擬機 ......

    uj5u.com 2023-04-20 07:23:31 more
  • 使用Java接入小程式訂閱訊息！

    更新完微信服務號的模板訊息之后，我又趕緊把微信小程式的訂閱訊息給實作了！之前我一直以為微信小程式也是要企業才能申請，沒想到小程式個人就能申請。 訊息推送平臺🔥推送下發【郵件】【短信】【微信服務號】【微信小程式】【企業微信】【釘釘】等訊息型別。 https://gitee.com/zhongfuch ......

    uj5u.com 2023-04-20 07:22:59 more
  • java -- 緩沖流、轉換流、序列化流

    緩沖流 緩沖流, 也叫高效流, 按照資料型別分類： 位元組緩沖流：BufferedInputStream，BufferedOutputStream 字符緩沖流：BufferedReader，BufferedWriter 緩沖流的基本原理，是在創建流物件時，會創建一個內置的默認大小的緩沖區陣列，通過緩沖 ......

    uj5u.com 2023-04-20 07:22:49 more
  • Java-SpringBoot-Range請求頭設定實作視頻分段傳輸

    老實說，人太懶了，現在基本都不喜歡寫筆記了，但是網上有關Range請求頭的文章都太水了 下面是抄的一段StackOverflow的代碼...自己大修改過的，寫的注釋挺全的，應該直接看得懂，就不解釋了 寫的不好...只是希望能給視頻網站開發的新手一點點幫助吧. 業務場景：視頻分段傳輸、視頻多段傳輸（理 ......

    uj5u.com 2023-04-20 07:22:42 more
  • Windows 10開發教程_編程入門自學教程_菜鳥教程-免費教程分享

    教程簡介 Windows 10開發入門教程 - 從簡單的步驟了解Windows 10開發，從基本到高級概念，包括簡介，UWP，第一個應用程式，商店，XAML控制元件，資料系結，XAML性能，自適應設計，自適應UI，自適應代碼，檔案管理，SQLite資料庫，應用程式到應用程式通信，應用程式本地化，應用程式 ......

    uj5u.com 2023-04-20 07:22:35 more

Copyright © 2010-2020 有解無憂