您现在的位置是：首页 > Java

当前栏目

java8 stream

源码

2023-03-02 11:10:41 时间

**stream是完全基于lambda表达式的**

### 文章目录 ###

*   *  1、在菜单里拿到卡路里低于400的食物并且排序后返回它的名字
     *   *  1.1、传统方法
         *  1.2、stream改造
     *  2、Stream知识点总结及源码阅读
     *   *  2.1、介绍
         *  2.2、streams与collection的不同
         *  2.3、stream只能被操作一次
         *  2.4、内部调用和外部调用的比较
         *  2.5、stream动作
     *  3、如何创建stream
     *   *  3.1、通过集合collection及其子类创建
         *  3.2、Stream.of
         *  3.3、Arrays.stream
         *  3.4、Files.lines(path)
         *  3.5、Stream.iterate
         *  3.6、Stream.generate
         *  3.7、Stream.generate自定义生成
     *  4、stream动作
     *   *  4.1、filter distinct skip limit
         *  4.2、map
         *  4.3、flatmap扁平化
         *  4.4、match
         *  4.5、find
         *  4.7、stream.reduce聚合根据给定的function
     *  5、NumericStream及和stream的相互转化
     *  6、综合练习
     *   *  Trader 交易员
         *  Transaction 交易

## 1、在菜单里拿到卡路里低于400的食物并且排序后返回它的名字 ##

menu 是一个 dish list  
dish是一个食物，它具体有卡路里、名称等属性

### 1.1、传统方法 ###

private static List<String> getDishNamesByCollections(List<Dish> menu) {
            List<Dish> lowCalories = new ArrayList<>();
    
            //filter and get calories less 400
            for (Dish d : menu) {
                if (d.getCalories() < 400)
                    lowCalories.add(d);
            }
    
            //sort
            Collections.sort(lowCalories, (d1, d2) -> Integer.compare(d1.getCalories(), d2.getCalories()));
    
            List<String> dishNameList = new ArrayList<>();
            for (Dish d : lowCalories) {
                dishNameList.add(d.getName());
            }
            return dishNameList;
        }

### 1.2、stream改造 ###

private static List<String> getDishNamesByStream(List<Dish> menu) {
            return menu.parallelStream().filter(d -> {
                        return d.getCalories() < 400;
                    }
            ).sorted(comparing(Dish::getCalories)).map(Dish::getName).collect(toList());
        }

代码量少了差不多一半

stream可以并行处理  
集合中的这个方法中的第一个参数可以将不同的列表分给不同的cpu  
![在这里插入图片描述][20190317121530693.png]  
用`jconsole`工具可以验证  
![在这里插入图片描述][2019031712190465.png]  
forkjoin是stream中并发处理最基本的东西

## 2、Stream知识点总结及源码阅读 ##

### 2.1、介绍 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70 2]

### 2.2、streams与collection的不同 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70 3]

### 2.3、stream只能被操作一次 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70 4]

Stream<Dish> stream = menu.stream();
            stream.forEach(System.out::println);
            stream.forEach(System.out::println); //第二次操作

![在这里插入图片描述][20190526120521239.png]

Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
    	at java.util.stream.AbstractPipeline.sourceStageSpliterator(AbstractPipeline.java:279)
    	at java.util.stream.ReferencePipeline$Head.forEach(ReferencePipeline.java:580)
    	at test.tetsa.main(tetsa.java:21)

### 2.4、内部调用和外部调用的比较 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70 5]  
和上面那个dvd的例子差不多

### 2.5、stream动作 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70 6]  
intermediate 每次会产生一个新的stream  
terminal operations 会中断stream

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70 7]

List<String> result = menu.stream().filter(d -> {
    
                System.out.println("filtering->" + d.getName());
                return d.getCalories() > 300;
            })
                    .map(d -> {
                        System.out.println("map->" + d.getName());
                        return d.getName();
                    })
                    .limit(3).collect(toList());
    
    
            System.out.println("=======================");
            System.out.println(result);

stream.foreach 就是一个中断动作

## 3、如何创建stream ##

### 3.1、通过集合collection及其子类创建 ###

/**
         * Generate the stream object from collection.
         * @return
         */
        private static Stream<String> createStreamFromCollection() {
            List<String> list = Arrays.asList("hello", "alex", "wangwenjun", "world", "stream");
            return list.stream();
        }

其集合中的元素顺序保持一致

### 3.2、Stream.of ###

private static Stream<String> createStreamFromValues() {
            return Stream.of("hello", "alex", "wangwenjun", "world", "stream");
        }

### 3.3、Arrays.stream ###

private static Stream<String> createStreamFromArrays() {
            String[] strings = {"hello", "alex", "wangwenjun", "world", "stream"};
            return Arrays.stream(strings);
        }

### 3.4、Files.lines(path) ###

打印出 一个java文件

private static Stream<String> createStreamFromFile() {
            Path path = Paths.get("D:\\workspace\\w\\src\\main\\java\\test\\DateUtil.java");
            try (Stream<String> streamFromFile = Files.lines(path)) {
                streamFromFile.forEach(System.out::println);
                return streamFromFile;
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

### 3.5、Stream.iterate ###

public static void main(String[] args) {
            Stream<Integer> streamFromIterator = createStreamFromIterator();
            streamFromIterator.forEach(e-> System.out.println(e));
        }
        private static Stream<Integer> createStreamFromIterator() {
            Stream<Integer> stream = Stream.iterate(0, n -> n + 2).limit(10);
            return stream;
        }

从0、2、4一直打印  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70 8]  
如果不加limit 会产生一个无限的stream

### 3.6、Stream.generate ###

public static void main(String[] args) {
            Stream<Double> streamFromIterator = createStreamFromGenerate();
            streamFromIterator.forEach(e-> System.out.println(e));
        }
        private static Stream<Double> createStreamFromGenerate() {
            return Stream.generate(Math::random).limit(10);
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70 9]

### 3.7、Stream.generate自定义生成 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70 10]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70 11]  
![在这里插入图片描述][2019031821393261.png]  
![在这里插入图片描述][20190318214031669.png]

## 4、stream动作 ##

### 4.1、filter distinct skip limit ###

public class StreamFilter {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 6, 7, 7, 1);
        //过滤
        List<Integer> result = list.stream().filter(i -> i % 2 == 0).collect(toList());
        System.out.println(result);
        //去重
        result = list.stream().distinct().collect(toList());
        System.out.println(result);
        //跳过前5个元素
        result = list.stream().skip(5).collect(toList());
        System.out.println(result);
        //只取5个元素
        result = list.stream().limit(5).collect(toList());
        System.out.println(result);
    
    
        list.forEach(System.out::println);
    
        list.forEach(i -> System.out.println(i));
    
        list.forEach((Integer i) -> System.out.println(i));
        
        for (int i : list) {
            System.out.println(i);
        }
    }

### 4.2、map ###

源码

/**
         * Returns a stream consisting of the results of applying the given
         * function to the elements of this stream.
         *
         * <p>This is an <a href="package-summary.html#StreamOps">intermediate
         * operation</a>.
         *
         * @param <R> The element type of the new stream
         * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,
         *               <a href="package-summary.html#Statelessness">stateless</a>
         *               function to apply to each element
         * @return the new stream
         */
        <R> Stream<R> map(Function<? super T, ? extends R> mapper);

给一个t类型 返回一个r类型

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 6, 7, 7, 1);
            List<Integer> result = list.stream().map(i -> i * 2).collect(toList());
            System.out.println(result);

取dish的name

实例化一个list

private static List<Dish> listDish() {
            List<Dish> menu = Arrays.asList(
                    new Dish("pork", false, 800, Dish.Type.MEAT),
                    new Dish("beef", false, 700, Dish.Type.MEAT),
                    new Dish("chicken", false, 400, Dish.Type.MEAT),
                    new Dish("french fries", true, 530, Dish.Type.OTHER),
                    new Dish("rice", true, 350, Dish.Type.OTHER),
                    new Dish("season fruit", true, 120, Dish.Type.OTHER),
                    new Dish("pizza", true, 550, Dish.Type.OTHER),
                    new Dish("prawns", false, 300, Dish.Type.FISH),
                    new Dish("salmon", false, 450, Dish.Type.FISH));
            return menu;
        }

listDish().stream().map(d -> d.getName()).forEach(System.out::println);
     
     List<String> dishes = listDish().stream().map(d -> d.getName()).collect(toList());
     System.out.println(dishes);

### 4.3、flatmap扁平化 ###

源码

* @param <R> The element type of the new stream
         * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,
         *               <a href="package-summary.html#Statelessness">stateless</a>
         *               function to apply to each element which produces a stream
         *               of new values
         * @return the new stream
         */
        <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

String[] words = {"Hello", "World"};
            //{h,e,l,l,o},{W,o,r,l,d}
            Stream<String[]> stream = Arrays.stream(words).map(w -> w.split(""));//Stream<String[]>
            stream.forEach(e-> System.out.println(Arrays.toString(e)));
            /*
            [H, e, l, l, o]
            [W, o, r, l, d]
       
            * */

//flatmap flat (扁平化)*/
            String[] words = {"Hello", "World"};
            //{h,e,l,l,o},{W,o,r,l,d}
            Stream<String[]> stream = Arrays.stream(words).map(w -> w.split(""));//Stream<String[]>
            //H,e,l,l,o,W,o,r,l,d
            Stream<String> stringStream = stream.flatMap(Arrays::stream);
            //这个flatMap会把s数组stream中数组扁平化为一个个元素的steam
            stringStream.distinct().forEach(System.out::println);

### 4.4、match ###

allMatch方法的源码

* @param predicate a <a href="package-summary.html#NonInterference">non-interfering</a>,
         *                  <a href="package-summary.html#Statelessness">stateless</a>
         *                  predicate to apply to elements of this stream
         * @return {@code true} if either all elements of the stream match the
         * provided predicate or the stream is empty, otherwise {@code false}
         */
        boolean allMatch(Predicate<? super T> predicate);

使用

public class StreamMatch {
    
        public static void main(String[] args) {
    
            Stream<Integer> stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7});
            
            boolean matched = stream.allMatch(i -> i > 10);//都满足
            System.out.println(matched);//false
    
            stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7});
            matched = stream.anyMatch(i -> i > 6);//只要有一个满足
            System.out.println(matched);//true
    
            stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7});
            matched = stream.noneMatch(i -> i < 0);//一个都不满足，没有一个条件小于0
            System.out.println(matched);//true
        }
    }

### 4.5、find ###

Optional是和空指针异常相关的一个类，很简单

public class StreamFind {
    
        public static void main(String[] args) {
            Stream<Integer> stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7});
    
            Optional<Integer> optional1 = stream.filter(i -> i % 2 == 0).findAny();//findAny() 拿出任意一个
            System.out.println(optional1.get());
    
            stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7});
            Optional<Integer> optional3 = stream.filter(i -> i < 10).findAny();
    
            System.out.println(optional3.orElse(-1));
    
            stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7});
    
            Optional<Integer> optional2 = stream.filter(i -> i % 2 == 0).findFirst();
    
            optional2.ifPresent(System.out::println);
    
            System.out.println(optional2.filter(i -> i == 2).get());
    
            int result = find(new Integer[]{1, 2, 3, 4, 5, 6, 7}, -1, i -> i < 10);
            System.out.println(result);
    
    
        }
    
        private static int find(Integer[] values, int defaultValue, Predicate<Integer> predicate) {
    
            for (int i : values) {
                if (predicate.test(i))
                    return i;
            }
    
            return defaultValue;
        }
    }

### 4.7、stream.reduce聚合根据给定的function ###

public static void main(String[] args) {
    
            Stream<Integer> stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7});
    
            Integer result = stream.reduce(0, Integer::sum); //求和 , 0 为开始计算的默认值
            System.out.println(result);
    
            stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7});
    
            stream.reduce((i, j) -> i + j).ifPresent(System.out::println);//不给默认值
    
    
            stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7});
    
            stream.reduce(Integer::max).ifPresent(System.out::println); //最大值
    
            stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7});
            stream.reduce(Integer::min).ifPresent(System.out::println); //最小值
    
            stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7});
            stream.reduce((i, j) -> i > j ? j : i).ifPresent(System.out::println);
    
    
            stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7});
            int result2 = stream.filter(i -> i % 2 == 0).reduce(1, (i, j) -> i * j);
            Optional.of(result2).ifPresent(System.out::println);
    
        }

reduce源码

* @param accumulator an <a href="package-summary.html#Associativity">associative</a>,
         *                    <a href="package-summary.html#NonInterference">non-interfering</a>,
         *                    <a href="package-summary.html#Statelessness">stateless</a>
         *                    function for combining two values
         * @return an {@link Optional} describing the result of the reduction
         * @throws NullPointerException if the result of the reduction is null
         * @see #reduce(Object, BinaryOperator)
         * @see #min(Comparator)
         * @see #max(Comparator)
         */
        Optional<T> reduce(BinaryOperator<T> accumulator);

@FunctionalInterface
    public interface BinaryOperator<T> extends BiFunction<T,T,T>

@FunctionalInterface
    public interface BiFunction<T, U, R> {
    
        /**
         * Applies this function to the given arguments.
         *
         * @param t the first function argument
         * @param u the second function argument
         * @return the function result
         */
        R apply(T t, U u);

相当于 BiFunction<T, T, T> 的意思

**reduce 就是 这个 BiFunction<T, T, T> 进行元素聚合操作**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70 12]

## 5、NumericStream及和stream的相互转化 ##

减少内存  
将大于3的数字进行求和

Stream<Integer> stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7});
            IntStream intStream = stream.mapToInt(i -> i.intValue());
            //intStream.forEach(e-> System.out.println(e)); //打印出 1 -7
    
            //IntStream intStream1 = intStream.filter(i -> i > 3);
            //intStream1.forEach(e-> System.out.println(e)); //打印出 4 5 6 7
    
            //求和
            int result = intStream.filter(i -> i > 3).sum();
            System.out.println(result);// 22

也可以

Stream<Integer> stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5, 6, 7});
            IntStream intStream = stream.mapToInt(i -> i.intValue());
            int reduce = intStream.filter(i->i>3).reduce(0, Integer::sum);
            //int reduce1 = intStream.filter(i->i>3).reduce(0,(i,j)->i+j);
            System.out.println(reduce);//22

我们之所以将integer 类型转换为 int类型再处理  
是int类型4位共32个字节 占用内存更少  
为此java 提供了 NumericStream 进行拆箱

## 6、综合练习 ##

![在这里插入图片描述][20190319081203653.png]

### Trader 交易员 ###

public class Trader{
    
        private final String name;
        private final String city;
    
        public Trader(String n, String c){
            this.name = n;
            this.city = c;
        }
        public String getName(){
            return this.name;
        }
        public String getCity(){
            return this.city;
        }
        public String toString(){
            return "Trader:"+this.name + " in " + this.city;
        }
    }

### Transaction 交易 ###

public class Transaction {
        private final Trader trader;
        private final int year;
        private final int value;
    
        public Transaction(Trader trader, int year, int value) {
            this.trader = trader;
            this.year = year;
            this.value = value;
        }
    
        public Trader getTrader() {
            return this.trader;
        }
    
        public int getYear() {
            return this.year;
        }
    
        public int getValue() {
            return this.value;
        }
    
        public String toString() {
            return "{" + this.trader + ", " +
                    "year: " + this.year + ", " +
                    "value:" + this.value + "}";
        }
    }

public class StreamInAction {
        public static void main(String[] args) {
    
            Trader raoul = new Trader("Raoul", "Cambridge");
            Trader mario = new Trader("Mario", "Milan");
            Trader alan = new Trader("Alan", "Cambridge");
            Trader brian = new Trader("Brian", "Cambridge");
    
            List<Transaction> transactions = Arrays.asList(
                    new Transaction(brian, 2011, 300),
                    new Transaction(raoul, 2012, 1000),
                    new Transaction(raoul, 2011, 400),
                    new Transaction(mario, 2012, 710),
                    new Transaction(mario, 2012, 700),
                    new Transaction(alan, 2012, 950)
            );
    
    
            //1. Find all transactions in the year 2011 and sort them by value (small to high).
            List<Transaction> result = transactions.stream().filter(transaction -> transaction.getYear() == 2011)
                    .sorted(Comparator.comparing(Transaction::getValue))
                    .collect(toList());
    
            System.out.println(result);
    
    
            //2.What are all the unique cities where the traders work?
            transactions.stream().map(t -> t.getTrader().getCity())
                    .distinct().forEach(System.out::println);
            System.out.println("==================");
    
            //3.Find all traders from Cambridge and sort them by name.
            transactions.stream().map(Transaction::getTrader)
                    .filter(t -> t.getCity().equals("Cambridge"))
                    .distinct()
                    .sorted(Comparator.comparing(Trader::getName))
                    .forEach(System.out::println);
    
            //4.Return a string of all traders’ names sorted alphabetically
    
            String value = transactions.stream().map(t -> t.getTrader().getName())
                    .distinct()
                    .sorted()
                    .reduce("", (name1, name2) -> name1 + name2);
            System.out.println(value);
    
    
            //5. Are any traders based in Milan?
    
            boolean liveInMilan1 = transactions.stream().anyMatch(t -> t.getTrader().getCity().equals("Milan"));
            boolean liveInMilan2 = transactions.stream().map(Transaction::getTrader).anyMatch(t -> t.getCity().equals("Milan"));
    
            System.out.println(liveInMilan1);
            System.out.println(liveInMilan2);
    
            //6.Print all transactions’ values from the traders living in Cambridge.
    
            transactions.stream().filter(t -> t.getTrader().getCity().equals("Cambridge"))
                    .map(Transaction::getValue)
                    .forEach(System.out::println);
    
    
            //7.What’s the highest value of all the transactions?
            Optional<Integer> maxValue = transactions.stream().map(Transaction::getValue).reduce((i, j) -> i > j ? i : j);
            System.out.println(maxValue.get());
    
            //8.Find the transaction with the smallest value.
            Optional<Integer> minValue = transactions.stream().map(Transaction::getValue).reduce(Integer::min);
            System.out.println(minValue.get());
        }
    
    }

[20190317121530693.png]: /images/20220307/bb12b7fec9984463a992fa80d3b988ae.png
[2019031712190465.png]: /images/20220307/10581c0a19144a6ca3c895506739c11e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70]: /images/20220307/be91c49f34484b76bf0679b5a4916ca5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70 1]: /images/20220307/3177e2c484064da88ae5c708a2080e54.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70 2]: /images/20220307/7094f8542e564661af8235b223c3bec2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70 3]: /images/20220307/efde936125fe48c285926ebb9696f56e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70 4]: /images/20220307/c0d33a072ee9458eb02617f4409ae19b.png
[20190526120521239.png]: /images/20220307/27c09990f7564ad599956a34526da8f3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70 5]: /images/20220307/d49140f11db541b4bacb9b0162c4ee9c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70 6]: /images/20220307/7272c5eb3d2d43b094ea5555f9568edc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70 7]: /images/20220307/d31fbe91afd043f99847e52c5cf4ebfd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70 8]: /images/20220307/36431d299a474e77a0ea3105dc9b9970.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70 9]: /images/20220307/049a1022fda94ce0bb26e766a24bcb4c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70 10]: /images/20220307/892c4ce90e9e4f8dbd9b8651a27a5bc6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70 11]: /images/20220307/a6ee8b7288f645519e77622332fd62ac.png
[2019031821393261.png]: /images/20220307/f5c4a5843f144ed496e22793772ab6f4.png
[20190318214031669.png]: /images/20220307/c8dbfcdb25464bb6b26c848547e91370.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VvdGFpbA_size_16_color_FFFFFF_t_70 12]: /images/20220307/4e9f1923e3704383898b2abd89b62068.png
[20190319081203653.png]: /images/20220307/84c4321d54bd4637ba270814c63f3c3e.png

猜你喜欢

SQL递归查询知多少
ABP入门系列（7）——分页实现
TempData知多少
Ajax.BeginForm()知多少
Asp.net mvc 知多少（二）
ABP入门系列（6）——定义导航菜单
Asp.net mvc 知多少（三）
Asp.net mvc 知多少（一）
ABP入门系列（17）——使用ABP集成的邮件系统发送邮件
ABP入门系列（5）——展现层实现增删改查
ABP入门系列（4）——创建应用服务
ABP入门系列（3）——领域层定义仓储并实现
ABP入门系列（2）——领域层创建实体
ABP入门系列（1）——通过模板创建MAP版本项目
ABP入门系列目录——学习Abp框架之实操演练
个人笔记(路由、网络相关)
个人笔记(vue篇)
怎么去水印不伤原图？这个去水印方法值得收藏！
羊了个羊，通关秘籍！
实用 | 盘点抓包修改响应结果的 2 种方式！

zl程序教程

当前栏目

java8 stream

相关文章