JAVASE基础模块四十七（Stream流补充）

最新推荐文章于 2024-10-16 10:13:45 发布
最新推荐文章于 2024-10-16 10:13:45 发布
阅读量294 收藏
点赞数
文章标签： java stream
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cx9977/article/details/108472442
版权

JAVASE基础模块四十七（Stream流补充）

Stream相关知识

Stream 的终止操作
	终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void 。

	1.查找与匹配
		allMatch(Predicate p)	检查是否匹配所有元素  比如判断 所有员工的年龄都是17岁 如果有一个不是,就返回false
		anyMatch(Predicate p)	检查是否至少匹配一个元素  比如判断是否有姓王的员工,如果至少有一个就返回true
		noneMatch(Predicate p)	检查是否没有匹配所有元素  employee.getSalary() < 3000; 每个员工的工资如果都高于3000就返回true 如果有一个低于3000 就返回false
		findFirst()		返回第一个元素  比如获取工资最高的人  或者 获取工资最高的值是
		findAny()		返回当前流中的任意元素   比如随便获取一个姓王的员工
		count()	返回流中元素总数  
		max(Comparator c)	返回流中最大值  比如:获取最大年龄值
		min(Comparator c)	返回流中最小值  比如:获取最小年龄的值
		forEach(Consumer c)	内部迭代(使用 Collection 接口需要用户去做迭代，称为外部迭代。相反，Stream API 使用内部迭代——它帮你把迭代做了)
	2.归约
		reduce(T iden, BinaryOperator b)  参1 是起始值, 参2 二元运算	可以将流中元素反复结合起来，得到一个值。返回 T  比如: 求集合中元素的累加总和 
		reduce(BinaryOperator b) 这个方法没有起始值	可以将流中元素反复结合起来，得到一个值。返回 Optional<T>  , 比如你可以算所有员工工资的总和
		备注：map 和 reduce 的连接通常称为 map-reduce 模式，因 Google 用它来进行网络搜索而出名。
	3.收集
		collect(Collector c)	将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
		Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到 List、Set、Map)。
		但是 Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下
	 4.Collectors 中的方法
		List<T> toList()		把流中元素收集到List   比如把所有员工的名字通过map()方法提取出来之后,在放到List集合中去

		Set<T>  toSet()		把流中元素收集到Set  比如把所有员工的名字通过map()方法提取出来之后,在放到Set集合中去

		Collection<T> toCollection()		把流中元素收集到创建的集合 比如把所有员工的名字通过map()方法提取出来之后,在放到自己指定的集合中去

		Long counting()		计算流中元素的个数

		Integer	summingInt()	对流中元素的整数属性求和

		Double averagingInt()		计算流中元素Integer属性的平均值

		IntSummaryStatistics summarizingInt()	收集流中Integer属性的统计值。

从DoubleSummaryStatistics 中可以获取最大值,平均值等
double average = dss.getAverage();
long count = dss.getCount();
double max = dss.getMax();
		String joining() 连接流中每个字符串  比如把所有人的名字提取出来,在通过"-"横杠拼接起来

		Optional<T> maxBy() 根据比较器选择最大值  比如求最大工资

		Optional<T> minBy() 根据比较器选择最小值  比如求最小工资

		归约产生的类型 reducing() 从一个作为累加器的初始值开始，利用BinaryOperator与流中元素逐个结合，从而归约成单个值
		
		转换函数返回的类型 collectingAndThen()		包裹另一个收集器，对其结果转换函数
		Map<K, List<T>> groupingBy() 根据某属性值对流分组，属性为K，结果为V  比如按照 状态分组
		Map<Boolean, List<T>> partitioningBy() 根据true或false进行分区 比如 工资大于等于6000的一个区,小于6000的一个区


**并行流与串行流
	并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。
	Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。
	Stream API 可以声明性地通过 parallel() 与sequential() 在并行流与顺序流之间进行切换。

收集

package New.X5;

import java.util.*;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;

public class ShouJi {
    public static void main(String[] args) {
        List<Emp> e = Arrays.asList(
                new Emp(101, "xxx", 21, 9988),
                new Emp(102, "ccc", 25, 7788),
                new Emp(103, "xcc", 23, 3388),
                new Emp(104, "ccx", 36, 6688),
                new Emp(105, "ooo", 45, 5588),
                new Emp(106, "ppp", 68, 4488),
                new Emp(106, "ppp", 68, 4488),
                new Emp(106, "ppp", 68, 4488),
                new Emp(107, "opp", 59, 5432),
                new Emp(108, "poo", 22, 6543)
        );
        List<String> e1 = e.stream().map(new Function<Emp, String>() {
            @Override
            public String apply(Emp emp) {
                return emp.getName();
            }
        }).collect(Collectors.toList());
        System.out.println(e1);

        Set<String> e2 = e.stream().map(new Function<Emp, String>() {
            @Override
            public String apply(Emp emp) {
                return emp.getName();
            }
        }).collect(Collectors.toSet());
        System.out.println(e2);

        LinkedHashSet<String> e4 = e.stream().map(new Function<Emp, String>() {
            @Override
            public String apply(Emp emp) {
                return emp.getName();
            }
        }).collect(Collectors.toCollection(LinkedHashSet::new));

        System.out.println(e4);
    }
}

运行结果：
[xxx, ccc, xcc, ccx, ooo, ppp, ppp, ppp, opp, poo]
[ppp, poo, ccc, xxx, xcc, ccx, ooo, opp]
[xxx, ccc, xcc, ccx, ooo, ppp, opp, poo]

collect功能

package New.X5;

import java.util.Arrays;
import java.util.Comparator;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.function.ToIntFunction;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Coll {
    public static void main(String[] args) {
        List<Integer> i = Arrays.asList(11, 22, 33, 44, 55, 66, 77, 88, 99);
        IntSummaryStatistics c1 = i.stream().collect(Collectors.summarizingInt(new ToIntFunction<Integer>() {
            @Override
            public int applyAsInt(Integer value) {
                return value;
            }
        }));
        long sum = c1.getSum();
        System.out.println(c1.getCount());
        System.out.println(c1.getAverage());
        System.out.println(c1.getMax());

        System.out.println(c1.getMin());
        System.out.println(sum);

        IntStream i1 = i.stream().mapToInt(new ToIntFunction<Integer>() {
            @Override
            public int applyAsInt(Integer value) {
                return value;
            }
        });
        System.out.println(i1.sum());

        Integer integer = i.stream().collect(Collectors.maxBy(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        })).get();
        System.out.println(integer);

    }
}


运行结果：
9
55.0
99
11
495
495
99

分组

package New.X5;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class FenZu {
    public static void main(String[] args) {
        List<Emp> e = Arrays.asList(
                new Emp(101, "xxx", 21, 9988,se.FREE),
                new Emp(102, "ccc", 25, 7788,se.MANG),
                new Emp(103, "xcc", 23, 3388,se.VOCATION),
                new Emp(104, "ccx", 36, 6688,se.FREE),
                new Emp(105, "ooo", 45, 5588,se.VOCATION),
                new Emp(106, "ppp", 68, 4488,se.MANG),
                new Emp(106, "ppp", 68, 4488,se.VOCATION),
                new Emp(106, "ppp", 68, 4488,se.MANG),
                new Emp(107, "opp", 59, 5432,se.VOCATION),
                new Emp(108, "poo", 22, 6543,se.MANG)
        );
        Map<se, List<Emp>> c = e.stream().collect(Collectors.groupingBy(new Function<Emp, se>() {
            @Override
            public se apply(Emp emp) {
                return emp.getE();
            }
        }));
        Set<Map.Entry<se, List<Emp>>> entries = c.entrySet();
        for (Map.Entry<se, List<Emp>> entry : entries) {
            System.out.println("【"+entry.getKey()+":】");
            for (Emp emp : entry.getValue()) {
                System.out.println(emp);
            }
           // System.out.println(entry.getKey()+":"+entry.getValue());
        }

    }
}

运行结果：
【FREE:】
Emp{num=101, name='xxx', age=21, money=9988.0, e=FREE}
Emp{num=104, name='ccx', age=36, money=6688.0, e=FREE}
【MANG:】
Emp{num=102, name='ccc', age=25, money=7788.0, e=MANG}
Emp{num=106, name='ppp', age=68, money=4488.0, e=MANG}
Emp{num=106, name='ppp', age=68, money=4488.0, e=MANG}
Emp{num=108, name='poo', age=22, money=6543.0, e=MANG}
【VOCATION:】
Emp{num=103, name='xcc', age=23, money=3388.0, e=VOCATION}
Emp{num=105, name='ooo', age=45, money=5588.0, e=VOCATION}
Emp{num=106, name='ppp', age=68, money=4488.0, e=VOCATION}
Emp{num=107, name='opp', age=59, money=5432.0, e=VOCATION}

diyi

package New.X5;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class First {
    public static void main(String[] args) {
        List<Emp> e = Arrays.asList(
                new Emp(101, "xxx", 21, 9988),
                new Emp(102, "ccc", 25, 7788),
                new Emp(103, "xcc", 23, 3388),
                new Emp(104, "ccx", 36, 6688),
                new Emp(105, "ooo", 45, 5588),
                new Emp(106, "ppp", 68, 4488),
                new Emp(106, "ppp", 68, 4488),
                new Emp(106, "ppp", 68, 4488),
                new Emp(107, "opp", 59, 5432),
                new Emp(108, "poo", 22, 6543)
        );
        Stream<Emp> s = e.stream();
        Optional<Emp> first = s.findFirst();
        Emp emp = first.get();
        System.out.println(emp);

        Stream<Emp> x = e.parallelStream().filter(new Predicate<Emp>() {
            @Override
            public boolean test(Emp emp) {
                return emp.getName().contains("x");
            }
        });
        Optional<Emp> any = x.findAny();
        Emp emp1 = any.get();
        System.out.println(emp1);

        long count = e.stream().count();
        System.out.println(count);

        long count1 = e.stream().distinct().count();
        System.out.println(count1);

        System.out.println(e.stream().max((o1, o2) -> (int) (o1.getMoney() - o2.getMoney())).get());


    }
}

运行结果：
Emp{num=101, name='xxx', age=21, money=9988.0, e=null}
Emp{num=103, name='xcc', age=23, money=3388.0, e=null}
10
8
Emp{num=101, name='xxx', age=21, money=9988.0, e=null}

规约

package New.X5;

import java.util.Arrays;
import java.util.List;
import java.util.function.BinaryOperator;
import java.util.function.Function;

public class GuiYue {
    public static void main(String[] args) {
        List<Emp> e = Arrays.asList(
                new Emp(101, "xxx", 21, 9988),
                new Emp(102, "ccc", 25, 7788),
                new Emp(103, "xcc", 23, 3388),
                new Emp(104, "ccx", 36, 6688),
                new Emp(105, "ooo", 45, 5588),
                new Emp(106, "ppp", 68, 4488),
                new Emp(106, "ppp", 68, 4488),
                new Emp(106, "ppp", 68, 4488),
                new Emp(107, "opp", 59, 5432),
                new Emp(108, "poo", 22, 6543)
        );
        Double aDouble = e.stream().map(new Function<Emp, Double>() {
            @Override
            public Double apply(Emp emp) {
                return emp.getMoney();
            }
        }).reduce(new BinaryOperator<Double>() {
            @Override
            public Double apply(Double aDouble, Double aDouble2) {
                return aDouble + aDouble2;
            }
        }).get();
        System.out.println(aDouble);
        List<Integer> i = Arrays.asList(11, 22, 33, 44, 55, 66, 77, 88, 99);

        Integer r = i.stream().reduce(0, new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer integer, Integer integer2) {
                return integer + integer2;
            }
        });
        System.out.println(r);
    }
}

运行结果：
58879.0
495

join

package New.X5;

import java.util.Arrays;
import java.util.List;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Join {
    public static void main(String[] args) {
        List<Emp> e = Arrays.asList(
                new Emp(101, "xxx", 21, 9988),
                new Emp(102, "ccc", 25, 7788),
                new Emp(103, "xcc", 23, 3388),
                new Emp(104, "ccx", 36, 6688),
                new Emp(105, "ooo", 45, 5588),
                new Emp(106, "ppp", 68, 4488),
                new Emp(106, "ppp", 68, 4488),
                new Emp(106, "ppp", 68, 4488),
                new Emp(107, "opp", 59, 5432),
                new Emp(108, "poo", 22, 6543)
        );
        String collect = e.stream().map(new Function<Emp, String>() {
            @Override
            public String apply(Emp emp) {
                return emp.getName();
            }
        }).collect(Collectors.joining( "-","【", "】"));
        System.out.println(collect);
       /* e.stream().map(new Function<Emp, Double>() {
            @Override
            public Double apply(Emp emp) {
                return emp.getMoney();
            }
        }).collect(Collectors.reducing(0,  {}))*/
    }
}


运行结果：
【xxx-ccc-xcc-ccx-ooo-ppp-ppp-ppp-opp-poo】

偶数奇数提取

package New.X5;

import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class OuShu {
    public static void main(String[] args) {
        List<Integer> i = Arrays.asList(11, 22, 33, 44, 55, 66, 77, 88, 99);
        List<Integer> c = i.stream().filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer % 2 == 0;
            }
        }).collect(Collectors.toList());
        System.out.println(c);

        long count = i.stream().map(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer integer) {
                return integer % 2 == 0 ? integer : null;
            }
        }).filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer != null;
            }
        }).count();
        System.out.println(count);

    }
}


运行结果：
[22, 44, 66, 88]
4

终止操作

package New.X5;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class ZhongZhi {
    public static void main(String[] args) {
        List<Emp> e = Arrays.asList(
                new Emp(101, "xxx", 21, 9988),
                new Emp(102, "ccc", 25, 7788),
                new Emp(103, "xcc", 23, 3388),
                new Emp(104, "ccx", 36, 6688),
                new Emp(105, "ooo", 45, 5588),
                new Emp(106, "ppp", 68, 4488),
                new Emp(106, "ppp", 68, 4488),
                new Emp(106, "ppp", 68, 4488),
                new Emp(107, "opp", 59, 5432),
                new Emp(108, "poo", 22, 6543)
        );
        Stream<Emp> s = e.stream();
        boolean b = s.allMatch(new Predicate<Emp>() {
            @Override
            public boolean test(Emp emp) {
                return emp.getMoney() > 10000;
            }
        });
        System.out.println(b);

        System.out.println(s.anyMatch(new Predicate<Emp>() {
            @Override
            public boolean test(Emp emp) {
                return emp.getMoney() > 10;
            }
        }));

        System.out.println(s.noneMatch(new Predicate<Emp>() {
            @Override
            public boolean test(Emp emp) {
                return emp.getMoney() > 10000;
            }
        }));

    }
}
enum se{
    FREE,MANG,VOCATION;
}
class Emp {
    private int num;
    private String name;
    private int age;
    private double money;
    private se e;

    public se getE() {
        return e;
    }

    public Emp() {
    }

    public Emp(int num, String name, int age, double money) {
        this.num = num;
        this.name = name;
        this.age = age;
        this.money = money;
    }

    public Emp(int num, String name, int age, double money, se e) {
        this.num = num;
        this.name = name;
        this.age = age;
        this.money = money;
        this.e = e;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "num=" + num +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", money=" + money +
                ", e=" + e +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Emp emp = (Emp) o;
        return num == emp.num &&
                age == emp.age &&
                Double.compare(emp.money, money) == 0 &&
                name.equals(emp.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(num, name, age, money);
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }
}

待续…

弎屲
关注
Java 语言概述 -- Java 语言的介绍、现在、过去与将来
栗筝i的博客
06-09 4061
Java 语言是于 1991 年由 Sun（Sun Microsystems，美国）公司的 詹姆斯·高斯林（James Gosling）团队研发的一门面向对象的编程语言。最初命名为 Oak，并于 1995 年更名为 Java 后开始推广。如今，随着互联网的崛起，Java 已经成为目前世界上最流行、最重要的计算机编程语言之一。Java 作为一门面向对象的高级编程语言，在设计之初，借鉴了多种编程语言的特性和理念。
Javase三月
weixin_44901257的博客
05-06 2252
2.28 五分钟爬虫 蚂蚁学 fstring 简单使用 f-string用大括号 {} 表示被替换字段，其中直接填入替换内容： >>> name = 'Eric' >>> f'Hello, my name is {name}' 'Hello, my name is Eric' 学习的excel的网站 数据导入——》数据——》自网站——》属性——》导入 headfirstjava 有成千上百个文件怎么提交？ 把所有文件包装进依据pkzip 格式来存档的Java Arc
java sse spring_SpringBoot服务端主动推送SSE
weixin_32836713的博客
02-24 444
长时间和后台保持通讯的有三种方式，分别是ajax的setInterval()，和websocket，已经SSE。ajax长时间和合同保持通讯太占内存。websocket可以进行服务端和后台双向通讯。SSE只能进行服务器往前端单向传送数据。服务端接口写法import java.text.DecimalFormat;import org.springframework.web.bind.annotat...
SSE推送技术
玩转Java
05-31 3332
SSE超简单的推送方案
用JAVA实现sse客户端
hydhyd212的博客
10-08 6993
废话少说，直接上代码。 sseClient package com.hyd.sse.client; import java.io.BufferedInputStream; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStream...
springboot中如何用stream流的方式给实体类中的多个字段赋值代码实例？
gb4215287的博客
11-30 783
springboot中如何用stream流的方式给实体类中的多个字段赋值代码实例？
使用java 8 流(Stream)操作两个集合求并集，交集，补集
qq_41505160的博客
03-03 1万+
一、基础的数据类型 如String 两个集合 List<String> A = new ArrayList<>(); A.add("1"); A.add("2"); A.add("3"); A.add("4"); List<String> B = new ArrayList<>(); B.add("3"); B.add("4"); B.add("5"); B.add("6"); B.add("7"); 1. 求并集 A.addAll(B); List<
2022年JavaScript与JavaSE基础教学
2. **JavaSE的学习重点**：在2022年，学习JavaSE重点在于理解并掌握Java 8及以上版本的新特性，包括Lambda表达式、Stream API、新的日期时间API等。 3. **JVM（Java虚拟机）**：JVM是运行Java字节码的虚拟机，它...
JAVASE相关知识点
weixin_43132031的博客
07-21 1088
涵盖了java大部分基础知识
Java学习路线图，全套Java基础视频教程
sebeefe的博客
08-01 1473
扎实的技术基础功+真实项目实战经验，才是好就业的关键。不止于此，黑马程序员帮助已就业学员继续提升！技术的提升永无止步，碎片时间学习进行各种技术强化以上Java学习路线图均有课程+源码+笔记+资料。更多提升课程访问底部，即可获取持续成长技能！...
Java8 Stream常用操作实例
BlueKitty的博客
12-25 2381
package com.xbz.java8.demo; import java.io.*; import java.lang.management.ManagementFactory; import java.lang.management.RuntimeMXBean; import java.lang.reflect.Array; import java.nio.charset.Standa...
Java8新特性之Stream介绍
fiveSix
01-14 2553
文章目录一、Stream简介二、Stream的构成及操作类型1、Stream构成2、操作类型三、Stream常用属性1、collect 收集属性2、map / flatMap 映射转换3、filter 过滤属性4、forEach / peek 遍历属性5、reduce 聚合属性6、sorted 排序属性7、match 匹配属性 一、Stream简介 Stream 作为 Java 8 的一大亮点，它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念。 Java
java+8+stream+赋值_Java8 Stream 使用
weixin_39640395的博客
02-27 7387
Stream 接口所在包：import java.util.stream.Stream;A sequence of elements supporting sequential and parallel aggregate operations.Stream 是元素的集合，类似Iterator支持顺序和并行的聚合操作Iterator VS StreamIterator，用户只能一个一个的遍历元素并...
补充内容：Stream
形容的博客
12-29 429
Java 补充内容 本系列为本人学习情况记录，部分资料来自老师课件或书籍摘录。 一、流的概述 1.1 简介 Stream 将要处理的元素看成是一种流，在流的过程中，借助 Stream API 对流中的元素进行操作，如：筛选、排序、聚合等 1.2 流的特点 1、Stream 不存储数据，而是按照特定的规则对数据进行计算 2、Stream 【通常】不会改变数据源，而是会产生一个新的集合或值 3、惰性求值，在流的中间处理过程中，不会立即执行，而是对操作进行了记录，需要到终止操作时才会进行实际运算 二、流
Java 8 新特性-菜鸟教程 (5) -Java 8 Stream
dengkuituo0680的博客
04-17 442
Java 8 Stream Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。 Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。 Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。 这种风格将要处理的元素集合看作一种流， 流在...
项目中的基础知识
早上真起不来的博客
07-15 507
yml中mytesthttps使用${添加链接描述添加链接描述​httpshttpshttpshttpshttps。
java利用stream流查出符合某个条件的list，并且进行赋值
热门推荐
张伟光
03-30 4万+
List<WorkHandoverModel>workHandoverList2=workHandoverList.stream().filter(item->item.getIsDelete().equals(0)).collect(Collectors.toList());//获取list中符合没有删除的工作交接的list List<WorkHandoverMode...
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 323
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 391
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值