java Stream流練習

来源:https://www.cnblogs.com/xw1203/archive/2022/11/01/16846833.html
-Advertisement-
Play Games

1.遍歷/匹配（foreach/find/match） Stream也是支持類似集合的遍歷和匹配元素的，只是Stream中的元素是以Optional類型存在的。Stream的遍歷、匹配非常簡單。 List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 7, ...


1.遍歷/匹配（foreach/find/match）

Stream也是支持類似集合的遍歷和匹配元素的，只是Stream中的元素是以Optional類型存在的。Stream的遍歷、匹配非常簡單。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 7, 8, 9, 0, 100);
// find使用，查找第一個元素
Optional<Integer> first = list.stream().findFirst();
log.info(first.get().toString());

// match使用，判斷是否存在某個值
boolean b1 = list.stream().anyMatch(value -> value >= 100);
boolean b2 = list.stream().anyMatch(value -> value > 10);
log.info(String.valueOf(b1));
log.info(String.valueOf(b2));

// foreach使用，遍歷輸出元素
list.stream().filter(value -> value > 4).forEach(System.out::print);
System.out.println();
list.forEach(System.out::print);

2.篩選（filter）

篩選，是按照一定的規則校驗流中的元素，將符合條件的元素提取到新的流中的操作。

// 數字篩選
List<Integer> list = Arrays.asList(1, 3, 4, 5, 6, 7, 8, 9, 10, 20);

ArrayList<Integer> arrayList1 = new ArrayList<>();
list.stream().filter(value -> value > 4).forEach(value -> arrayList1.add(value));
log.info(arrayList1.toString());

ArrayList<Integer> arrayList2 = new ArrayList<>();
list.stream().filter(value -> value <= 4).forEach(arrayList2::add);
log.info(arrayList2.toString());

// 對象篩選
List<User> userList1 = Arrays.asList(
        new User(1, "xw", "男"),
        new User(2, "zgx", "男"),
        new User(3, "gg", "男"),
        new User(4, "whb", "男"),
        new User(5, "yda", "男"),
        new User(6, "bhm", "女")
);

List<User> userList2 = new ArrayList<>();
userList1.stream().filter(user -> user.getId() > 2).forEach(userList2::add);
log.info(userList2.toString());

userList1.stream().filter(user -> 					         user.getName().equals("xw")).forEach(System.out::println);

HashMap<String, Optional<User>> userHashMap = new HashMap<>();
Optional<User> man = userList1.stream().filter(user -> user.getSex().equals("男")).findFirst();
        userHashMap.put("man", man);
        log.info(userHashMap.toString());

3.聚合（max/min/count)

max、min、count這些字眼你一定不陌生，沒錯，在mysql中我們常用它們進行數據統計。Java stream中也引入了這些概念和用法，極大地方便了我們對集合、數組的數據統計工作。

max、min、count

 // max & min & count
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 89, 9, 0, 10, 20, 30);

Optional<Integer> max = list.stream()
        .max(Comparator.comparing(Integer::intValue));
log.info(String.format("最大值是：%d", max.get()));

Optional<Integer> min = list.stream()
        .min(Comparator.comparing(value -> value.intValue()));
log.info(String.format("最小值是：%d", min.get()));

Integer count1 = Math.toIntExact(list.stream().count());
log.info(String.format("list總元素量1為：%d", count1));

Integer count2 = Math.toIntExact(list.stream().filter(value -> value > 5).count());
log.info(String.format("list元素值大於5的個數：%d", count2));


List<User> userList = Arrays.asList(
        new User(1, "xw", "男", 22),
        new User(2, "zgx", "男", 22),
        new User(3, "whb", "男", 23),
        new User(4, "gg", "男", 30),
        new User(5, "yda", "男", 22),
        new User(6, "bhm", "女", 22),
        new User(7, "lwn", "女", 22)
);
Optional<User> ageMax = userList.stream().max(Comparator.comparing(value -> value.getAge()));
log.info(String.format("年齡最大的是：%s", ageMax.get()));

Optional<User> ageMin = userList.stream().filter(user -> user.getSex().equals("男")).min(Comparator.comparing(User::getAge));
log.info(String.format("性別為男且年齡最小的：%s", ageMin.get()));

Integer count3 = Math.toIntExact(userList.stream().filter(user -> user.getAge() > 22).count());
log.info(String.format("年齡大於22的用戶數量為：%d", count3));

4.映射(map/flatMap)

映射，可以將一個流的元素按照一定的映射規則映射到另一個流中。分為map和flatMap：

  • map：接收一個函數作為參數，該函數會被應用到每個元素上，並將其映射成一個新的元素。
  • flatMap：接收一個函數作為參數，將流中的每個值都換成另一個流，然後把所有流連接成一個流。

map

// map
List<Integer> list1 = Arrays.asList(1, 3, 5, 6, 7, 8, 0, 10, 20, 22, 39);
List<Integer> collect1 = list1.stream().filter(value -> value > 7).collect(Collectors.toList());
log.info(String.format("list1元素值大於7的有: %s", collect1));

List<String> list2 = Arrays.asList("xw", "sjdk", "sf", "jk", "hoksh", "shdfj", "jhgkj");
List<String> collect2 = list2.stream().map(String::toUpperCase).collect(Collectors.toList());
log.info(String.format("list2元素值全轉大寫，結果：%s", collect2));

List<User> userList1 = Arrays.asList(
        new User(1, "xw", "男", 22),
        new User(2, "zgx", "男", 22),
        new User(3, "whb", "男", 23),
        new User(4, "gg", "男", 30),
        new User(5, "yda", "男", 22),
        new User(6, "bhm", "女", 22),
        new User(7, "lwn", "女", 22),
        new User(8, "ksj", "女", 22)
);
List<User> userList2 = userList1.stream()
        .map(user -> {
            if (user.getSex().equals("女")) {
                user.setAge(user.getAge() - 2);
            }
            user.setName(user.getName().toUpperCase());
            return user;
        })
        .filter(user -> user.getAge() > 19 && user.getSex().equals("女"))
        .collect(Collectors.toList());
log.info(String.format("修改結果為：%s", userList2));

flatMap

// flatMap
List<String> stringList = userList1.stream()
        .flatMap(user -> {
            Stream<String> stream = Arrays.stream(user.toString().split("="));
            return stream;
        })
        .collect(Collectors.toList());
log.info(String.format("flatMap處理前：%s", userList1));
log.info(String.format("flatMap轉換結果：%s", stringList));

5.歸約(reduce)

歸約，也稱縮減，顧名思義，是把一個流縮減成一個值，能實現對集合求和、求乘積和求最值操作。

// 求和
List<Integer> list1 = Arrays.asList(1, 3, 5, 2, 1, 5, 89, 23, 89, 23, 34);
Integer sum = list1.stream().reduce(0, Integer::sum);
log.info(String.format("list1中各元素之和：%d", sum));

// 求積
List<Integer> list2 = Arrays.asList(1, 2, 4);
Optional<Integer> product = list2.stream().reduce((x, y) -> x * y);
log.info(String.format("list中2各元素之積：%d", product.get()));

// 求最大值1
Optional<Integer> max1 = list1.stream().reduce(Integer::max);
log.info(String.format("list1中的最大值是：%d", max1.get()));

// 求最大/小值2
Optional<Integer> min1 = list1.stream().reduce((x, y) -> x < y ? x : y);
log.info(String.format("list1中的最小值：%d", min1.get()));

List<User> userList1 = Arrays.asList(
        new User(1, "xw", "男", 22),
        new User(2, "zgx", "男", 22),
        new User(3, "whb", "男", 23),
        new User(4, "gg", "男", 30),
        new User(5, "yda", "男", 22),
        new User(6, "bhm", "女", 23),
        new User(7, "lsn", "女", 22),
        new User(8, "ksj", "女", 22)
);

Integer maxAge1 = userList1.stream().reduce(0, (maxAge, user) -> maxAge > user.getAge() ? maxAge : user.getAge(), Integer::max);
log.info(String.format("年齡最大是：%d", maxAge1));

Optional<Integer> max2 = userList1.stream().map(User::getAge).reduce(Integer::max);
Optional<Integer> max3 = userList1.stream().map(User::getAge).reduce((x, y) -> x > y ? x : y);
log.info(String.format("年齡最大是：%d", max2.get()));
log.info(String.format("年齡最大是：%d", max3.get()));

Integer stringMaxLength = userList1.stream()
        .filter(user -> user.getAge() > 22 && user.getAge() < 25)
        .flatMap(user -> {
            Stream<String> newStream = Arrays.stream(user.toString().split("="));
            return newStream;
        })
        .collect(Collectors.toList())
        .stream().map(String::toUpperCase)
        .reduce(0, (maxLength, string) -> maxLength > string.length() ? maxLength : string.length(), Integer::max);

log.info(String.format("最大字元串長度為：%s", stringMaxLength));

6.收集(collect)

collect，收集，可以說是內容最繁多、功能最豐富的部分了。從字面上去理解，就是把一個流收集起來，最終可以是收集成一個值也可以收集成一個新的集合。

collect主要依賴java.util.stream.Collectors類內置的靜態方法。

6.1歸集(toList/toSet/toMap)

因為流不存儲數據，那麼在流中的數據完成處理後，需要將流中的數據重新歸集到新的集合里。toList、toSet和toMap比較常用，另外還有toCollection、toConcurrentMap等複雜一些的用法。

toList

List<Integer> list1 = Arrays.asList(1, 2, 8, 0, 9, 0, 1, 23, 32, 37, 49, 48);
List<Integer> collect1 = list1.stream().filter(value -> value > 5).collect(Collectors.toList());
log.info(String.format("list1中收集>5的結果為：%s", collect1));

toSet

Set<Integer> collect2 = list1.stream().filter(value -> value < 5).collect(Collectors.toSet());
log.info(String.format("list1中收集<5的結果為：%s", collect2));
collect2.forEach(value -> {System.out.print(value + " ");

toMap

List<User> userList1 = Arrays.asList(
        new User(1, "xww", "男", 22),
        new User(2, "zgx", "男", 22),
        new User(3, "whb", "男", 23),
        new User(4, "gg", "男", 30),
        new User(5, "yda", "男", 22),
        new User(6, "bhm", "女", 23),
        new User(7, "lsn", "女", 22),
        new User(8, "ksj", "女", 22)
);

Map<String, User> userMap = userList1.stream()
         .filter(user -> user.getSex().equals("女"))
         .collect(Collectors.toMap(User::getName, user -> user));
log.info(String.format("性別為女的用戶轉map：%s", userMap));

6.2 統計(count/averaging)

Collectors提供了一系列用於數據統計的靜態方法：

  • 計數：count
  • 平均值：averagingInt、averagingLong、averagingDouble
  • 最值：maxBy、minBy
  • 求和：summingInt、summingLong、summingDouble
  • 統計以上所有：summarizingInt、summarizingLong、summarizingDouble
List<Integer> list = Arrays.asList(1, 2, 3, 2, 5, 3, 9, 8, 7, 6, 29, 10, 22);

// count
long count = list.stream().filter(value -> value > 10).count();
log.info(String.format("list中元素>10的個數為：%d", count));

// average
Double average = list.stream().filter(value -> value > 1).collect(Collectors.averagingInt(Integer::intValue));
log.info(String.format("list中元素>1的元素平均值為：%.2f", average));

List<User> userList1 = Arrays.asList(
        new User(1, "xww", "女", 22),
        new User(2, "zgx", "男", 22),
        new User(3, "whb", "男", 23),
        new User(4, "gg", "男", 30),
        new User(5, "yda", "男", 22),
        new User(6, "bhm", "女", 23),
        new User(7, "lsn", "女", 22),
        new User(8, "ksj", "女", 22)
);

Double averageAge = userList1.stream()
        .filter(user -> user.getSex().equals("男"))
        .map(User::getAge)
        .collect(Collectors.averagingInt(Integer::intValue));
log.info(String.format("男用戶的平均年齡為：%d 歲", averageAge.intValue()));

// mapToInt
int ageSum = userList1.stream()
        .filter(user -> user.getSex().equals("女"))
        .mapToInt(User::getAge)
        .sum();
log.info(String.format("女用戶的年齡之和為：%d", ageSum));

// summarizingInt 統計 計數、總和、最小值、平均值、最大值
IntSummaryStatistics recording = userList1.stream()
        .filter(user -> user.getSex().equals("男"))
        .collect(Collectors.summarizingInt(User::getAge));
log.info(String.format("記錄所有男用戶的年齡各項值，結果為：%s", recording));

6.3 分組(partitioningBy/groupingBy)

  • 分區：將stream按條件分為兩個Map，比如員工按薪資是否高於8000分為兩部分。
  • 分組：將集合分為多個Map，比如員工按性別分組。有單級分組和多級分組。
partitioningBy
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 20, 37, 49, 243, 30);

// partitioningBy
Map<Boolean, List<Integer>> collect1 = list.stream()
        .collect(Collectors.partitioningBy(value -> value > 20));
log.info(String.format("元素值是否大於20進行分組，結果為：%s", collect1));

collect1.forEach((key, value) -> {
    log.info(String.format("元素值是否大於20進行分組，結果為：%s：%s", key, value));
});

groupingBy

List<User> userList = Arrays.asList(
        new User(1, "xww", "女", 22),
        new User(2, "zgx", "男", 21),
        new User(3, "whb", "男", 23),
        new User(4, "gg", "男", 30),
        new User(5, "yda", "男", 22),
        new User(6, "bhm", "女", 23),
        new User(7, "lsn", "女", 22),
        new User(8, "ksj", "女", 22)
);

// groupingBy
Map<String, List<User>> collect2 = userList.stream()
        .collect(Collectors.groupingBy(User::getSex));
log.info(String.format("根據性別對用戶進行分組，結果為：%s", collect2));

collect2.forEach((key, user) -> {
    log.info(String.format("根據性別對用戶進行分組，結果為：%s：%s", key, user));
});

6.4 接合(joining)

joining可以將stream中的元素用特定的連接符（沒有的話，則直接連接）連接成一個字元串。

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 20, 37, 49, 243, 30);
String collect = list.stream()
        .map(Object::toString)
        .collect(Collectors.joining("——"));
log.info(String.format("joining測試結果為：%s", collect));

7.排序(sorted)

sorted，中間操作。有兩種排序：

  • sorted()：自然排序，流中元素需實現Comparable介面
  • sorted(Comparator com)：Comparator排序器自定義排序
List<User> userList1 = Arrays.asList(
        new User(1, "xw", "女", 22),
        new User(2, "zgx", "男", 21),
        new User(3, "whb", "男", 23),
        new User(4, "gg", "男", 30),
        new User(5, "yda", "男", 22),
        new User(6, "bhm", "女", 23),
        new User(7, "lsn", "女", 22),
        new User(8, "ksj", "女", 22)
);

// sorted
List<User> userList2 = userList1.stream()
        .sorted(Comparator.comparing(User::getAge))
        .collect(Collectors.toList());
log.info(String.format("按照年齡排序，結果為：%s", userList2));

// 從小到大，正序
List<String> userName1 = userList1.stream()
        .sorted(Comparator.comparing(User::getAge))
        .map(User::getName)
        .collect(Collectors.toList());
log.info(String.format("根據年齡從小到大排序：%s", userName1));

// 從大到小，倒序
List<String> userName2 = userList1.stream()
        .filter(user -> user.getSex().equals("男"))
        .sorted(Comparator.comparing(User::getAge).reversed())
        .map(User::getName)
        .collect(Collectors.toList());
log.info(String.format("男用戶根據年齡從大到小排序：%s", userName2));

8.提取/組合

流也可以進行合併、去重、限制、跳過等操作。

1.去重排序

List<Integer> list = Arrays.asList(1, 2, 4, 4, 10, 9, 6, 8, 6, 2, 3, 7, 5);
List<Integer> collect = list
        .stream()
        .distinct()
        .sorted(Comparator.comparing(Integer::intValue))
        .collect(Collectors.toList());
collect.forEach(x -> System.out.print(x+" ")); // 1 2 3 4 5 6 7 8 9 10

存在重覆數據的問題，這裡使用stream流的衍生功能，去除一個對象中的部分元素的重覆如下：

List<User> userList = Arrays.asList(
        new User(1, "xw", "女", 21),
        new User(2, "zgx", "男", 21),
        new User(3, "whb", "男", 23),
        new User(4, "gag", "男", 30),
        new User(4, "gbg", "男", 30),
        new User(4, "gcg", "女", 30),
        new User(5, "yda", "男", 22),
        new User(6, "bhm", "女", 23),
        new User(7, "lsn", "女", 22),
        new User(8, "ksj", "女", 22)
);
ArrayList<User> collect1 = userList.stream().collect(Collectors.collectingAndThen(
                        Collectors.toCollection(() -> new TreeSet<>(
                                Comparator.comparing(
                                        User::getId))), ArrayList::new));

多個欄位或者多個條件去重

ArrayList<User> collect2 = userList.stream().collect(Collectors.collectingAndThen(
                Collectors.toCollection(() -> new TreeSet<>(
                        Comparator.comparing(user->user.getName() + ";" + user.getId()))), ArrayList::new)

以上使用到了collectingAndThen()根據屬性進行去重的操作，進行結果集的收集，收集到結果集之後再進行下一步的處理。在這個去重操作中還用到了toCollection、TreeSet兩個操作。

public static<T,A,R,RR> Collector<T,A,RR> collectingAndThen(Collector<T,A,R> downstream,Function<R,RR> finisher)

看源碼中需要傳的參數有兩個，第一個參數是Collector的子類，所以Collectors類中的大多數方法都能使用，比如：toList(),toSet(),toMap()等，當然也包括collectingAndThen()。第二個參數是一個Function函數，也是去重的關鍵，用到的ArrayList::new調用到了ArrayList的有參構造。Function函數是R apply(T t)，在第一個參數downstream放在第二個參數Function函數的參數裡面，將結果設置為t。對於toCollection是一個通用的方法，滿足treeSet收集集合，再傳入需要根據某個屬性進行比較的比較器，就能達到去重的效果。

2.限制長度(limit)

List<Integer> list = Arrays.asList(1, 2, 7, 3, 2, 2, 3, 4, 5, 2, 5, 6, 7, 8, 9, 0, 12);
List<Integer> collect1 = list
        .stream()
        .distinct()
        .sorted(Comparator.comparing(Integer::intValue))
        .limit(6)
        .collect(Collectors.toList());
collect1.forEach(x -> System.out.print(x + " "));

3.跳過(skip)

// 跳過前幾項
List<Integer> list = Arrays.asList(1, 2, 7, 3, 2, 2, 3, 4, 5, 2, 5, 6, 7, 8, 9, 0, 12);
List<Integer> collect2 = list
        .stream()
        .distinct()
        .sorted(Comparator.comparing(Integer::intValue))
        .skip(3)
        .limit(6)
        .collect(Collectors.toList());
collect2.forEach(x -> System.out.print(x + " "));

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 多線程 & 反射 & 註解 & JDBC 核心點總結
    多線程 核心點：線程安全 創建線程的兩種方式 線程生命周期 獲取、修改線程名 獲取當前線程對象 靜態方法 sleep() 通過異常終止線程的睡眠 interrupt() 強行終止線程 合理終止線程的方式 瞭解（靜態方法，讓位 yield()；實例方法 join()，合併線程） 線程安全 同步非同步 線 ...
  • 有可能是學習Git命令最好的網站
    網站地址：https://learngitbranching.js.org/?locale=zh_CN 網站以沙盒闖關的方式學習Git各個命令，每次關卡都介紹本次要學習的Git指令，通過沙盒+命令行的方式來引導你通過已經學習到的Git指令來通過關卡。 看首頁，我們可以看到很多關卡，滑鼠放到關卡的數字 ...
  • day06-JavaScript03
    JavaScript03 11.DOM 官方文檔：https://www.w3school.com.cn/js/js_htmldom.asp 基本介紹： DOM全稱是Document Object Model，文檔對象模型。 當網頁被載入時，瀏覽器會創建頁面的文檔對象模型（Document Obje ...
  • 【HDLBits刷題筆記】12 More Circuits
    Rule90 第一次見這東西有點莫名其妙，但是其實看懂了之後就是左移和右移相異或，註意這裡使用的是邏輯右移，會自動補零，不能使用算數左移<<<。 module top_module( input clk, input load, input [511:0] data, output reg[511: ...
  • 關於Python封裝函數的幾道練習題
    1.封裝函數，可以判斷一個數字是否為偶數 def func(n): if n%2==0: print("%d是偶數"%n) else: print("%d是奇數"%n) func(11) # 11是奇數 2.封裝函數，可以實現1-n之間所有偶數的列印 def func(n): for i in ra ...
  • 程式員最浪漫的表白方式，將情書寫在她的照片里，Python簡直太厲害啦~
    這不光棍節快到了，表弟準備寫一封情書給他的女神，想在光棍節之前脫單。 為了提高成功率，於是跑來找我給他參謀參謀，本來我是不想理他的，不過誰讓他是我表弟呢（請我洗jio），於是教給他程式員的終極浪漫絕招，先假裝給女神拍照，然後再把情書寫到她的照片上列印出來送給她，嘿嘿~ 實現步驟 想要實現把情書寫在像 ...
  • 自從用了灰度發佈，睡覺真香！
    前言 大家好，我是棧長。 最近，棧長又參加了騰訊雲小伙伴邀請的Techo Day 技術開放日 2.0的線上活動，這一期又是乾貨滿滿，主要是雲原生和微服務方面的，比如：雲原生網關、容器、安全、雲監控、灰度發佈等等，這些內容都與我們現有的微服務系統息息相關。 令棧長印象最深刻的就是微服務灰度發佈這個主題 ...
  • 聊一聊安全且正確使用緩存的那些事 —— 關於緩存可靠性、關乎數據一致性
    在分散式系統盛行的今天，緩存充當著扛壓屏障的作用，一旦緩存出現問題，對系統影響也是致命的。本文我們一起聊聊如何安全且可靠的使用緩存，聊聊緩存擊穿、緩存雪崩、緩存穿透以及數據一致性、熱點數據淘汰機制等。 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類