`

jdk8 + guava杂记

阅读更多

一. 函数式接口

所谓函数式接口,是指有且仅有一个抽象方法的接口,可包含其他default关键字定义的方法。

一般都会使用@FunctionalInterface来注解此接口。

 

常用的函数接口:

1. Predicate<T> 断言,一般用来判断是否满足某条件

2. Consumer<T> 接收一个参数,无返回值

3. Function<T,R> 接收T对象,返回R对象

4. Supplier<T> 类似工厂,调用时会返回一个指定类型的对象

5. UnaryOperator<T> 执行一元操作(与、或、非)

6. BinaryOperator<T,T> 接收两个参数,返回一个值

 

示例:

1. Predicate:

 

Predicate<String> predicate01 = (s) -> s.length() > 7;
Predicate<String> predicate02 = (s) -> s.contains("s");
assertTrue(predicate01.test("abcdefgh"));  //true
assertTrue(predicate01.and(predicate02).test("abcdefgh"));  //false
assertTrue(predicate01.and(predicate02).negate().test("abcdefgh"));  //true
assertTrue(predicate01.and(predicate02).test("abcdefghs")); //true
assertTrue(predicate01.or(predicate02).test("abcdefgh"));  //true
assertTrue(predicate01.or(predicate02).test("abs")); //true
assertTrue(Predicate.isEqual("asd").test("asd"));

 

 

2.  Consumer: 无返回值

 Consumer<String> c = s -> System.out.println(s.toUpperCase());
 c.accept("asdf");  //ASDF 

 

3. JDK中的Supplier接口,仅包含一个get()的抽象方法

  在guava中为Supplier类,提供更多的方法:

  如:每隔2分钟刷新一次delegate中的缓存

 Supplier<T> supplier = Suppliers.memoizeWithExpiration(t, 2, TimeUnit.SECONDS);

 

      4. UnaryOperator: 返回自身

  一元操作,即只有一个操作数,既是源又是目的,常用的如a++等类似的操作。即接收自己返回自己。

 

UnaryOperator<String> str = s -> s.toUpperCase();
System.out.println(str.apply("asdf"));  //ASDF

 

 

  6. BinaryOperator

 

BinaryOperator<Integer> bo = (x,y) -> (x*y);
System.out.println(bo.apply(1, 7));  //7

 

 

  

二、 目标类型的推断

即有时候不需要再去显式的声明泛型的参数类型,但程序依然需要经过类型检查来保证运行的安全,采用的是javac根据Lambda表达式的上下文进行推测得出的,

 

方法:public void save(Map<String, String> map){};
调用:save(new HashMap<>()); //此处没有指定泛型的类型,而是根据上下文推测得出

 

在方法重载的情况下,当lambda表达式作为参数时,推导其目标类型所遵循的规则:

1. 若只有一个可能的目标,则根据相应函数接口里的参数类型推导而出

2. 若有多个可能的目标类型,则由具体的那个类型推导而出。如String和Object中则推断为String类型

3. 若存在多个可能的目标类型,且具体的类型不明确,则需要人为指定目标类型

 

 

三、 jdk + guava中迭代器的区别大致描述

 

1)  jdk中的迭代器(全为接口类型)

public interface Iterable<T>: 为一个接口

拥有的方法:

Iterator<T> iterator(); 返回一个Iterator迭代器
default void forEach(Consumer<? super T> action): 循环

 

public interface Iterator<E>: 也为一个接口

拥有的方法:

boolean hasNext(); 检测是否有下一个元素
E next(); 获取下一个元素
default void remove(): 移除
default void forEachRemaining(Consumer<? super E> action): 循环

 

public interface Collection<E> extends Iterable<E>: 集合类接口

拥有方法:

int size();
boolean isEmpty();
Iterator<E> iterator();
boolean contains(Object o); 
boolean add(E e);
boolean remove(Object o);
default boolean removeIf(Predicate<? super E> filter)

 

2) guava中的迭代器

public final class Iterables: 为一个类

常用方法:

(1). public static <T> boolean addAll(Collection<T> addTo, Iterable elementsToAdd): 

Collection为jdk中的接口,Iterable也为jdk中的接口,即其内部也是通过

while (iterator.hasNext()) {addTo.add(iterator.next());}来迭代实现操作的。

 

(2). public static Iterable filter(Iterable<T> unfiltered, Predicate<? super T> predicate): 

    通过指定条件过滤出集合中的元素,其内部也是通过while + if中的断言条件来进行过滤。

    需要说明的是在filter中返回了一个AbstractIterator类对象。

public static Iterator<String> skipNulls(final Iterator<String> in) {
	    return new AbstractIterator<String>() {
	       protected String computeNext() {
	         while (in.hasNext()) {
                      String s = in.next();
                     if (s != null) {
                           return s;
                      }
                 }
                return endOfData();
            }
         };
      }}

 

    (3). public static <T> boolean any(Iterable<T> iterable, Predicate<? super T> predicate)

    迭代器中至少有一个元素满足条件才返回true,则否返回false

    

    (4). public static <T> boolean all(Iterable<T> iterable, Predicate<? super T> predicate)

    而all表示地阿尔代其中每一个元素都需要满足条件才会返回true,否则返回false

    

    (5). public static <T> T find(Iterable<T> iterable, Predicate<? super T> predicate)

    查找满足条件中的第一个元素

    

    (6). public static <T> T find(

      Iterable<? extends T> iterable, Predicate<? super T> predicate, @Nullable T defaultValue)

     查找满足条件中的第一个元素,当元素为Null时返回默认值

     

    (7). public static <T> Optional<T> tryFind(Iterable<T> iterable, Predicate<? super T> predicate)

     查找满足条件中的第一个元素,当元素为Null时返回Optional.<T>absent();而不至于由于返回Null而报错。

     

    (8). public static <T> int indexOf(Iterable<T> iterable, Predicate<? super T> predicate) 

    返回当前迭代的元素中,满足条件的那个元素的位置

    

    (9). public static <F, T> Iterable<T> transform(

      final Iterable<F> fromIterable, final Function<? super F, ? extends T> function)

     将集合中的迭代器经过function接口滤后

     示例: 

List<String> views = Lists.newArrayList("wsbs","xwzx","bmfw","wshd");
Iterables.limit(views.iterator(), 3); //此处编译报错是因为,此方法接收的参数为Iterable接口,而非Iterator类。其内部实现也是通过Iterators.limit(iterable.iterator(), limitSize);来操作的
Iterators.limit(views.iterator(), 3);

 

 

  

四、 外部迭代 + 内部迭代的区别

外部迭代即Iterators.limit(views.iterator(), 3);形式的迭代

而内部迭代则是通过Stream的方式来进行的迭代,整个迭代过程是在内部层实现的。

views.stream().filter(view -> view.equals("xwzx"))   //惰性求值
views.stream().filter(view -> view.equals("xwzx")).count();   //及早求值
views.stream().filter(view -> view.equals("xwzx")).collect(Collectors.toList());  //及早

 当返回值为一个Stream时属于惰性求值,而当返回另一个值或为空时为及早求值。

 

 

 

 

五、 常用的流操作

 

1、 stream的创建方式:

(1). 通过Stream.of()创建,如: 

    Stream.of("1a", "2w", "3w", "4e");

    Stream.of(Lists.newArrayList("1a", "2w", "3w", "4e"));  //也可传入一个数组

(2). generator生成无限长度流

    Stream.generate(Math::random).limit(5);

(3). iterate生成流,同generator一样都是无限长度的

 //xiaomiXIAOMI,其中xiaomi为原始的str

    Stream.iterate(str, item -> item.toUpperCase()).limit(7).distinct().

    forEach(System.out::print);

(4). 也可将数组转换成stream,Arrays.stream(数组),如:

    String[] numbers = {"wsbswsbs","xwzxzw","bmfwb","wshdwsh"};

Arrays.stream(numbers);

(5). 创建空的stream,如: 

    Stream.empty()

(6). 将集合类直接转成流,如list.stream(), list.parallelStream()用于并发

 

2.、stream的转换,类似于jquery的懒加载,访问时才进行动态计算。相比集合类来说,不用存储在内存中,可以少消耗资源。

(1). stream.collect(Collectors.toList()): 

    将流收集成一个list集合

(2). map: 

    用于将一种类型的值转换成另一种类型,将一个流转换成一个新的流

    views.stream().map(str -> str.charAt(1)).collect(Collectors.toList())

    .forEach(System.out::println);  

    其还有三个扩展的方法:

    mapToInt: 将原始流中的每个对象转换成int类型,如:取其长度...

    mapToLong: 同上类似

    mapToDouble: 同上类似  

 

(3). filter: 过滤出符合条件的元素 

(4). flatMap: 当需要同时处理多个集合时可使用

    List<String> together = Stream.of(views, Lists.newArrayList("1a", "2w", "3w", "4e"))

    .flatMap(List::stream)  //将多个集合转成流,并将底层元素抽出放在一起

    .filter(str -> str.contains("w")) //此处可直接使用String是因为上一步

    .collect(Collectors.toList());

    together.forEach(System.out::println);

 

(5). distinct(),去除重复

(6). peek: 生成一个包含原Stream的所有元素的新Stream,同时会提供一个Consumer函数,

    即可在不影响stream正常运行的状态下还可执行其他逻辑,如记录流中产生的数据到日志系统中。

(7). limit: 获取指定长度的流数据,同Iterators.limit原理一样,不用担心limit长度超过原始长度。

(8). skip: 即将流中的前n个元素跳过不要,若n大于原始流中数据的长度,则返回空的流(Stream.empty())

    或许可以使用.skip(n).limit(n)的方式来做假分页,一般用于排序之前。

 

3、 Stream聚合

(1). max: 最大值; min: 最小值。

    String string = Lists.newArrayList("1a7890", "2w", "3w", "4e").stream()

               .max(Comparator.comparing(String::length)).get();

System.out.println(string);  //1a7890

 

(2). reduce: 适合返回单个结果的情况

    //需要两个参数:

    //1. identity 即初始值

    //2. accumulator 累加器,其中有需要两个参数,如下的(sum, number)

    public int addUP(Stream<Integer> numbers){

     return numbers.reduce(0, (sum, number) -> sum + number);  

     //此处为累加,在不同业务上也可直接使用sum(),如下:

     // Integer totalAge = roster.stream().mapToInt(Person::getAge).sum(); 

    }

    

    //获取平均数

    list.stream().filter(p -> p.getGender() == Person.Sex.MALE)

    .mapToInt(Person::getAge).average().getAsDouble();

    

    //sum、min、max、average、字符串拼接(String::concat)都属于reduce的范畴

    

    //摘自官方文档

    The reduce operation always returns a new value. However, the accumulator function also

    returns a new value every time it processes an element of a stream. Suppose that you want 

    to reduce the elements of a stream to a more complex object, such as a collection. This 

    might hinder the performance of your application.

    可知,reduce操作每处理一个元素总是创建一个新值,在处理集合时不可能每次都去创建新集合,因此在这种情况下不可取

    

(3). collect: 收集器,处理各种复杂的搜索

    

参考: http://docs.oracle.com/javase/tutorial/collections/streams/reduction.html

 

 

 

六、 收集器

<R> R collect(Supplier<R> supplier,

                  BiConsumer<R, ? super T> accumulator,

                  BiConsumer<R, R> combiner);

          包含3个参数:

          supplier: 使用lambda表达式或方法引用来构造一个新的容器

          accumulator: 累加器,将Stream中的元素添加到容器中,无返回值

          combiner: 组合器,无返回值。Stream在执行过程中,因为是lazy模式,在最后一步聚合之前的每一步操作都是暂时放在一个map容器中,组合器就是用来将中间状态的多个结果合并成为一个。

                    

    中间过程包含如下:

    map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel(并行)、

    sequential、 unordered

    

    最终过程:

    forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、

    noneMatch、 findFirst、 findAny、 iterator

    

1. 转换成其他集合

  stream.collec(Collectors.toList())

  stream.collec(Collectors.toSet())

  stream.collec(Collectors.toCollection(ArrayList::new))

 

注:Collectors类中包含很多如下的static方法

2. 转换成值:maxBy、minBy

  List<String> views = Lists.newArrayList("wsbs","xafaswzx","b8fw","ad");

Optional<String> res = views.stream().collect(Collectors

                      .minBy(Comparator.comparing(String::length)));

System.out.println(res.get());  //ad

 

minBy的最终实现: (a, b) -> comparator.compare(a, b) <= 0 ? a : b

maxBy的最终实现: (a, b) -> comparator.compare(a, b) >= 0 ? a : b

  

3. 数据分块: partitioningBy

  List<String> views = Lists.newArrayList("wsbs","1232","b8fw","wsad");

Map<Boolean, List<String>> res = views.stream().collect(Collectors

                               .partitioningBy(str -> str.startsWith("ws")));

//{false=[1232, b8fw], true=[wsbs, wsad]}

 

4. 数据分组: groupingBy

  List<String> views = Lists.newArrayList("wsbs","xafaswzx","b8fw","ad");

Map<Integer, List<String>> res = views.stream().collect(Collectors

                                .groupingBy(String::length));

//{2=[ad], 4=[wsbs, b8fw], 8=[xafaswzx]}

 

5. 字符串

views.stream().collect(Collectors.joining(",", "[", "]"));  //wsbs,xwzx,bmfw,wshd

Collectors.joining中的参数为:连接符,前缀,后缀

 

6. 组合收集器: 同时使用多个收集器

 

7. Match匹配

   (1). allMatch:Stream 中全部元素符合传入的 predicate,返回 true

(2). anyMatch:Stream 中只要有一个元素符合传入的 predicate,返回 true

(3). noneMatch:Stream 中没有一个元素符合传入的 predicate,返回 true

 

List<String> views = Arrays.asList("wsbs","xwzx","bmfw","wshd");

views.stream().allMatch(str -> str.length()>5);   //false

views.stream().anyMatch(str -> str.length()>5);   //false

views.stream().noneMatch(str -> str.length()>5);  //true

 

8. findFirst: 返回 Stream 的第一个元素,或者空

 

9. parallel(并行):

使用Parallelism()来转换,其本质也是构建于Fork/Join的基础之上

Fork/Join原理(JDK7):

1. 把问题分解为子问题

2. 串行解决子问题从而得到部分结果(partial result)

3. 合并部分结果合为最终结果

 

10. Comparator.comparing()比较器:

   在一次比较完成后,还诶通过thenComparing进行再次比较。

   

11. mapping: 

   引自文档: ...mapping(Person::getLastName, toSet())

   即mapping操作可将左参数(lambda表达式)产生的数据动态记录到右参数(集合)中,其内部实现也是通过

   工厂容器 + 累加器 + 组合器来实现的。

   

12. summingInt: 将流中的数据转换成整型后求和

   Integer resInt = views.stream().collect(Collectors.summingInt(String::length));

System.out.println(resInt);  //15

若为summingLong,同样输出15

若为summingDouble,则输出15.0

 

13. averagingInt: 将流中的数据转换成整型后求平均数

   Double resInt = views.stream().collect(Collectors.averagingInt(String::length));

System.out.println(resInt);  //3.75

averagingDouble + averagingLong类似。

 

参考: https://docs.oracle.com/javase/8/docs/api/java/util/stream/Collectors.html

 

 

 

七、 使用stream执行某段逻辑,有时候可以逆向推导

如:找出一张专辑中所有长度大于1分钟的曲目名称。

1. 使用collect收集所有曲目名称

2. 从map中找出所有曲目名称

3. filter出所有长度大于1分钟的曲目

4. 获取专辑中所有的曲目,并转换成stream

 

 

 

八、 可使用lambda用作日志打印

Logger logger = new Logger();

logger.debug(() -> System.out.pringln("debug..."))

如业务需求,可使用peek方法将流中产生的数据记录在日志中

 

 

 

九、 基本类型

基本类型: int、long...

装箱:即将基本类型转换成对应的装箱类型(对象)。

拆箱:即将装箱类型转换成对应的基本类型。

 

命名规则:

(1). 若方法返回类型为基本类型,则在基本类型前加To。如:ToLongFunction -> 返回long类型

(2). 若参数为基本类型,则不需要添加前缀,直接类型名即可。如:LongFunction(long)

(3). 若高阶函数为基本类型,则需要添加后缀To再加基本类型。如:mapToInt

 

summaryStatistics()为对应Stream接口中对应的抽象方法,所返回的类型可以计算统计值

类似的返回类型:IntSummaryStatistics,DoubleSummaryStatistics,LongSummaryStatistics

 

示例:

List<String> views = Lists.newArrayList("wsbs","xwzx","bmfw","wshd");

IntSummaryStatistics intstream = views.stream().mapToInt(str -> str.length()).summaryStatistics();

System.out.println(intstream.getMax()); //4

System.out.println(intstream.getMin()); //4 

System.out.println(intstream.getSum()); //16

System.out.println(intstream.getCount()); //4

System.out.println(intstream.getAverage()); //4.0

 

 

 

十、 接口中使用default关键字定义方法: 

同时实现多个有default定义方法的接口

1. 接口中由default定义的方法没有方法体,实现类不需要重写,直接调用即可

2. 接口中非default定义的方法必须有方法体,且实现类需要重写此方法

 

//无论函数接口或非函数接口都可使用该形式来定义方法

default void chat(String str){

System.out.println("iphone chat..." + str);

}

 

public void chat(){

Iphone.super.chat("test"); //需要指定调用哪个父类的方法,此处调用Iphone类的方法

System.out.println("test...");

IMac.super.chat();

}

 

注意:

(1). 若子类中重写了父类的默认方法,在调用时则使用子类的重写方法,而不是父类中的默认方法。

(2). 若子接口继承了父接口,且两者都拥有同样的默认方法,则实现类(未重写)在调用时使用子接口中的默认方法

 

 

 

十一、 Optional 为null而生

可使用Optional.of()来创建Optional对象。

Optional obj = Optional.of("test");  //参数为null,则抛空指针异常

System.out.println(obj.get()); //test

 

//orElse表示当原值存在时则返回原值,若不存在则返回参数值

System.out.println(empty.orElse("t")); //t 

System.out.println(obj.orElse("t")); //test

 

 

 

十二、 方法引用

格式:ClassName::methodName (静态方法 + 实例方法 都可使用)

super::methodName (超类上的实例方法使用)

Class::new (创建新实例时可使用)

TypeName[]::new (创建新数组时可用,但感觉guava中创建集合的方式更好些)

示例:persons.stream().forEach(Person::getName);

 

 

 

十三、 元素顺序

有序集合:List、LinkedList、LinkedHashMap

无序集合:Set、HashSet、Map、HashMap、TreeMap

 

(1). filter、map、reduce在有序流上效率执行高些。

(2). 对于在有序流中消耗内存大的操作,可调用stream().unordered()方法来消除顺序。

(3). 需要注意的是,在并行流时,foreach不能保证按顺序执行,可使用stream().forEachOrdered方式

 

 

 

十四、 JDK中的StringJoiner类

常用方法:

(1). public StringJoiner(CharSequence delimiter, CharSequence prefix,

         CharSequence suffix)  //参数:连接符,前缀,后缀

        (2). public StringJoiner setEmptyValue(CharSequence emptyValue) //当出现空值时使用

        (3). public StringJoiner add(CharSequence newElement)  //连接

        (4). public StringJoiner merge(StringJoiner other)     //合并容器

    

    【StringBuilder + StringJoiner + Joiner的对比: 各有自己可用的时候】

    1. StringBuilder可逆序

    new StringBuilder().append("xiaomi").reverse();   //imoaix

    2. StringJoiner可直接添加前后缀

new StringJoiner(",", "[", "]").add("xiaomi").add("apple").add("yota2");  //[xiaomi,apple,yota2]

 

3. Joiner属于guava中的类,连接时可直接传入迭代器

Joiner.on(",").skipNulls().join(Lists.newArrayList("a",null,"c").iterator());  //a,c

                       

      

 

 

 

 

 

  

 

 

 

 

 

 

 

 

分享到:
评论

相关推荐

    jdk8+201+321

    jdk8+201+321,,,,jdk8+201+321,,,,jdk8+201+321,,,,jdk8+201+321,,,,jdk8+201+321,,,,jdk8+201+321,,,,jdk8+201+321,,,,jdk8+201+321,,,,jdk8+201+321,,,,jdk8+201+321,,,,jdk8+201+321,,,,jdk8+201+321,,,,jdk8+201...

    JDK1.8+API+中文文档+高清完整版+CHM.rar JDK1.8+API+中文文档+高清完整版+CHM.rar

    JDK1.8+API+中文文档+高清完整版+CHM.rar JDK1.8+API+中文文档+高清完整版+CHM.rar JDK1.8+API+中文文档+高清完整版+CHM.rar JDK1.8+API+中文文档+高清完整版+CHM.rar JDK1.8+API+中文文档+高清完整版+CHM.rar JDK...

    JDK8 + SpringBoot + Vue2 + uniapp + Mysql接入chatGTP实现聊天源码

    基于ChatGPT实现的微信小程序,适配H5和WEB端,支持打字效果输出流式输出,JDK8 + SpringBoot + Vue2 + uniapp + Mysql

    以电商项目为线索,快速掌握 JDK17 + springboot3 + springcloud Alibaba 专栏源码

    以电商项目为线索,快速掌握 JDK17 + springboot3 + springcloud Alibaba 专栏源码。 2 技术选型 JDK17 持久层: MyBatis-Plus 数据库: MySQL5.7 其他: SpringCloud Alibaba 技术栈 服务注册与发现:Nacos ...

    我的jdk1.8.0+++++++++++++++++++++++

    Java Development Kit (JDK) 1.8 是Oracle公司发布的Java编程环境的一个版本,它包含了开发和运行Java应用程序所需的所有工具。JDK是Java程序员的核心工具,提供了编译器、调试器、Java虚拟机(JVM)以及许多其他...

    JDK资源包合集(JDK6+JDK7+JDK8)

    本资源包集合包括了JDK6、JDK7和JDK8三个重要版本,分别代表了Java发展历程中的关键节点。 JDK6,也称为Java SE 6(标准版6),于2006年发布,是Java平台的一个重要里程碑。此版本引入了许多新特性,如改进的Swing...

    基于SSM+JDK1.8+tomcat7+maven3.6.0的 Web版在线聊天室源码+项目说明.zip

    【资源说明】 1、该资源包括项目的全部源码,下载可以直接使用! 2、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和...基于SSM+JDK1.8+tomcat7+maven3.6.0的 Web版在线聊天室源码+项目说明.zip

    jdk8+tomcat8.rar

    【标题】"JDK8与Tomcat8的整合与应用" 在Java开发中,JDK(Java Development Kit)是核心工具,它包含了编译、运行Java程序所需的所有组件。而Tomcat则是一款轻量级的Java应用服务器,常用于部署Web应用程序。本...

    CentOS8服务器配置(JDK1.8+Tomcat9+MySQL8.0+nginx)

    我安装的ContOS8(版本:CentOS-Stream-8-x86_64-20191219-dvd1)没有默认安装 检查是否预装jdk,如果有请先卸载: yum -y remove java 确认安装版本: 注意jdk版本,不要安装错了,同理你可以选择其他对应版本的...

    javajdk8+Jenkinswar包.zip

    Java JDK 8与Jenkins是两个在IT行业中广泛使用的工具,尤其在软件开发和持续集成/持续部署(CI/CD)流程中。JDK(Java Development Kit)是Java编程语言的开发环境,而Jenkins则是一款开源的持续集成服务器。 **...

    JDK+Maven+Tomcat+MySQL.zip

    JDK1.8+Tomcat8.5+Maven3.3.9+MySQL5.7,都是在Linux系统下搭建环境所需要的压缩包,需要的可以自行下载,配置详情,可以参看https://blog.csdn.net/weixin_40460171/article/details/106758629

    java64位环境打包 tomcat8+JDK8+Notepad++

    Java 64位环境搭建教程:Tomcat 8 + JDK 8 + Notepad++ 在IT领域,开发和部署Web应用程序通常需要一个稳定的运行环境。这个压缩包提供了在Windows 64位系统上快速构建这样的环境的组件:Tomcat 8、JDK 8和Notepad++...

    JDK8+Java+常用版本

    jdk8虽然出现很久了,但是可能我们还是有很多人并不太熟悉,本文主要就是介绍说明一些jdk8相关的内容。 主要会讲解: lambda表达式 方法引用 默认方法 Stream 用Optional取代null 新的日志和时间 ...

    SQL2019+JDK8+安装一条流

    标题“SQL2019+JDK8+安装一条流”指的是在计算机系统上同时安装SQL Server 2019和Java Development Kit (JDK) 8的过程,并期望这两个组件能够协同工作,可能用于开发和运行Java应用程序,尤其是那些与数据库交互的...

    基于jdk11/jdk8 + SpringBoot 开发, 是一个微服务中后台快速开发平台

    lamp-boot只是lamp项目的其中一个项目,她基于jdk11/jdk8 + SpringBoot 开发, 她是一个微服务中后台快速开发平台,可以通过插件无缝切换是否启用SaaS模式、通过配置切换SaaS模式采用独立数据库模式还是字段模式。...

    JDK + Tomcat + MySQL环境集成工具

    JDK版本的选择应与所使用的Java应用或框架兼容,例如,Java 8、Java 11或Java 17等。 Apache Tomcat,是一款开源的Java Servlet容器,实现了Java EE的Web应用服务规范,包括Servlet和JavaServer Pages(JSP)。...

    jmeter-5.4.3win10版本zip包-中文-需要jdk8+以上版本

    jmeter-5.4.3win10版本zip包-中文-需要jdk8+以上版本,旧版本可以从档案中获得。 jmeter与jdk版本匹配 首先jmeter要和jdk的版本对应,否则会报错 jmeter对应的就是1.8以上的jdk了,我的jdk是jdk1.8.0_261,jmeter是...

    dubbo监控中心jdk8+tomcat8

    dubbo监控中心jdk8+tomcat8最新dubbo代码编译,成功安装dubbo-admin http://111.231.233.152:8080/dubbo-admin/

    JTM——(jdk1.8+tomcat8.5+mysql)环境集成

    这是一个集成了jre,tomcat,mysql的绿色运行环境,解压之后就可以直接运行web(只要会点鼠标),不需要用户自己安装jre、tomcat、mysql,一键到位,看起来像是桌面程序的web应用.

Global site tag (gtag.js) - Google Analytics