星尘linger_个人页

个人头像照片 星尘linger TA的个人档案
个人头像照片
0
514
0

个人介绍

暂无个人介绍

擅长的技术

获得更多能力
通用技术能力:
云产品技术能力:

暂时未有相关云产品技术能力~

阿里云技能认证

详细说明
  • 提交了问题 2020-04-02

    内容协作平台如何快速搭建云盘服务?

  • 提交了问题 2020-03-28

    弹性伸缩伸缩组有哪些API?

  • 提交了问题 2020-03-28

    弹性伸缩如何负载均衡实例?

  • 提交了问题 2020-03-28

    SAE访问请求响应不稳定,Spring Cloud应用第一次访问慢,第二次访问时很快,为什么?

  • 提交了问题 2020-03-28

    Serverless 应用引擎 命名空间和VPC API有哪些?

  • 提交了问题 2020-03-24

    如何处理使用桌面时较为卡顿?

  • 提交了问题 2020-03-24

    如何处理连接桌面时报错:NoMoreActiveSessions, InstanceNotRegis

  • 提交了问题 2020-03-24

    如何处理连接桌面时报错:找不到 ICAWebWrapper.msi?

  • 提交了问题 2020-03-24

    如何处理连接桌面时报错:客户端错误 0,套接字错误 10061 等等?

  • 提交了问题 2020-03-24

    如何处理客户端安装图形客户端时错误?

  • 提交了问题 2020-03-24

    云桌面镜像管理API有哪些?

  • 提交了问题 2020-03-24

    云桌面实例管理API有哪些?

  • 提交了问题 2020-03-24

    云桌面集群管理API有哪些?

  • 提交了问题 2020-03-24

    云桌面API公共参数有哪些?

  • 提交了问题 2020-03-24

    云桌面API调用方式有哪些?

  • 提交了问题 2020-03-24

    如何进行云桌面镜像管理?

  • 提交了问题 2020-03-24

    如何进行云桌面实例管理?

  • 提交了问题 2020-03-24

    如何进行云桌面集群管理?

  • 提交了问题 2020-03-24

    云桌面账号体系有哪些?

  • 提交了问题 2020-03-24

    云桌面应用场景有哪些?

  • 提交了问题 2020-03-24

    云桌面功能特性有哪些?

  • 提交了问题 2020-03-24

    为什么某些地域无法开通E-HPC集群?

  • 提交了问题 2020-03-24

    NAS挂载目录规则?

  • 提交了问题 2020-03-24

    为什么不能使用ECS管理控制台对E-HPC集群节点进行操作?

  • 提交了问题 2020-03-23

    如何避免 OperationDenied.NoStock ?

  • 提交了问题 2020-03-23

    是否支持数据持久化?

  • 提交了问题 2020-03-23

    如何解决 Back-off restarting failed container ?

  • 提交了问题 2020-03-23

    容器是否支持端口映射?

  • 提交了问题 2020-03-23

    如何从外网访问容器组?

  • 提交了问题 2020-03-23

    ECI是否可以和ECS共享NAS文件存储?

  • 提交了问题 2020-03-23

    Pod 显示已调度至 virtual-kubelet,但一直未成功是否支持私有镜像?

  • 提交了问题 2020-03-23

    kube-proxy、coredns 被调度到虚拟节点如何查看 vCPU / virtual nod

  • 提交了问题 2020-03-23

    如何接入监控和日志API?

  • 提交了问题 2020-03-23

    如何接入镜像缓存API?

  • 提交了问题 2020-03-23

    如何接入容器组API?

  • 回答了问题 2020-01-15

    【hi聊】2020新年展望:get程序员过年的正确姿势

    二姑妈:你这几年在外面是做什么工作的呀? 我:我是做开发的的。 二姑妈:什么开发? 我:计算机 二姑妈:我家里的电脑坏了,帮忙看看是什么问题 我:。。。

  • 提交了问题 2019-11-09

    mybatis 将id列表当成字符串传进去,查出来的数据都是0

2020年04月

  • 04.13 13:54:39
    回答了问题 2020-04-13 13:54:39

    Java为何要使用线程池?

    "系统启动一个新线程的成本是比较高的,因为它涉及与操作系统交互。在这种情形下,使用线程池可以很好地提高性能,尤其是当程序中需要创建大量生存期很短暂的线程时,更应该考虑使用线程池。 与数据库连接池类似的是,线程池在系统启动时即创建大量空闲的线程,程序将一个Runnable对象或Callable对象传给线程池,线程池就会启动一个线程来执行它们的run()或call()方法,当run()或call()方法执行结束后,该线程并不会死亡,而是再次返回线程池中成为空闲状态,等待执行下一个Runnable对象的run()或call()方法。 除此之外,使用线程池可以有效地控制系统中并发线程的数量,当系统中包含大量并发线程时,会导致系统性能剧烈下降,甚至导致JVM崩溃,而线程池的最大线程数参数可以控制系统中并发线程数不超过此数。"

    踩0 评论0
  • 04.13 13:54:00
    回答了问题 2020-04-13 13:54:00

    Java JVM垃圾回收机制策略有哪些?

    Java JVM垃圾回收机制策略有四种:标记清除算法、复制算法、标记压缩算法和分代算法。

    踩0 评论0
  • 04.13 13:52:46
    回答了问题 2020-04-13 13:52:46

    Java JVM中垃圾回收机制原理是啥?

    不定时去堆内存中清理不可达对象。不可达的对象并不会马上就会直接回收, 垃圾收集器在一个Java程序中的执行是自动的,不能强制执行,即使程序员能明确地判断出有一块内存已经无用了,是应该回收的,程序员也不能强制垃圾收集器回收该内存块。程序员唯一能做的就是通过调用System.gc 方法来"建议"执行垃圾收集器,但其是否可以执行,什么时候执行却都是不可知的。

    踩0 评论0
  • 04.13 13:51:28
    回答了问题 2020-04-13 13:51:28

    Java线程会以什么样的方式结束,然后处于死亡状态?

    "线程会以如下3种方式结束,结束后就处于死亡状态。 run()或call()方法执行完成,线程正常结束。 线程抛出一个未捕获的 Exception或Error。 直接调用该线程的stop()方法来结束该线程——该方法容易导致死锁,通常不推荐使用。"

    踩0 评论0
  • 04.13 11:46:39
    回答了问题 2020-04-13 11:46:39

    【Java问答月】4月Java提问、答题有奖;24小时优先回答,不回答有礼物!

    参加活动2, 4月13号回答Java问题400道

    踩0 评论0
  • 04.12 22:51:19
    回答了问题 2020-04-12 22:51:19

    Java8流式操作中中间操作有哪些?

    "该操作会保持 stream 处于中间状态,允许做进一步的操作。它返回的还是的 Stream,允许更多的链式操作。常见的中间操作有: filter():对元素进行过滤; sorted():对元素排序; map():元素的映射; distinct():去除重复元素; subStream():获取子 Stream 等。"

    踩0 评论0
  • 04.12 22:50:44
    回答了问题 2020-04-12 22:50:44

    Java8流式操作中串行和并行的流有啥区别?

    流有串行和并行两种,串行流上的操作是在一个线程中依次完成,而并行流则是在多个线程上同时执行。并行与串行的流可以相互切换:通过 stream.sequential() 返回串行的流,通过 stream.parallel() 返回并行的流。相比较串行的流,并行的流可以很大程度上提高程序的执行效率。

    踩0 评论0
  • 04.12 22:50:20
    回答了问题 2020-04-12 22:50:20

    Java8集合之流式操作是啥?

    "Java 8 引入了流式操作(Stream),通过该操作可以实现对集合(Collection)的并行处理和函数式操作。根据操作返回的结果不同,流式操作分为中间操作和最终操作两种。最终操作返回一特定类型的结果,而中间操作返回流本身,这样就可以将多个操作依次串联起来。根据流的并发性,流又可以分为串行和并行两种。流式操作实现了集合的过滤、排序、映射等功能。 Stream 和 Collection 集合的区别:Collection 是一种静态的内存数据结构,而 Stream 是有关计算的。前者是主要面向内存,存储在内存中,后者主要是面向 CPU,通过 CPU 实现计算。"

    踩0 评论0
  • 04.12 22:49:57
    回答了问题 2020-04-12 22:49:57

    Java8接口中允许定义静态方法吗?

    "在接口中,还允许定义静态的方法。接口中的静态方法可以直接用接口来调用。 例如,下面接口中定义了一个静态方法 find,该方法可以直接用 StaticFunInterface .find() 来调用。 public interface StaticFunInterface { public static int find(){ return 1; } } public class TestStaticFun { public static void main(String[] args){ //接口中定义了静态方法 find 直接被调用 StaticFunInterface.fine(); } }"

    踩0 评论0
  • 04.12 22:49:23
    回答了问题 2020-04-12 22:49:23

    Java8接口中默认方法是啥?

    "Java 8 还允许我们给接口添加一个非抽象的方法实现,只需要使用 default 关键字即可,这个特征又叫做扩展方法。在实现该接口时,该默认扩展方法在子类上可以直接使用,它的使用方式类似于抽象类中非抽象成员方法。但扩展方法不能够重载 Object 中的方法。例如:toString、equals、 hashCode 不能在接口中被重载。 例如,下面接口中定义了一个默认方法 count(),该方法可以在子类中直接使用。 public interface DefaultFunInterface { //定义默认方法 count default int count(){ return 1; } } public class SubDefaultFunClass implements DefaultFunInterface { public static void main(String[] args){ //实例化一个子类对象,改子类对象可以直接调用父接口中的默认方法 count SubDefaultFunClass sub = new SubDefaultFunClass(); sub.count(); } }"

    踩0 评论0
  • 04.12 22:49:00
    回答了问题 2020-04-12 22:49:00

    Java如何检查是否是函数式接口?

    Lambda 表达式需要“函数式接口”的支持 函数式接口:接口中只有一个抽象方法的接口,称为函数式接口。 可以使用注解 @FunctionalInterface 修饰 可以检查是否是函数式接口

    踩0 评论0
  • 04.12 22:48:28
    回答了问题 2020-04-12 22:48:28

    Java8 Lambda表达式语法有哪些?

    "语法格式一:无参数,无返回值 () -> System.out.println(“Hello Lambda!”); 语法格式二:有一个参数,并且无返回值 (x) -> System.out.println(x) 语法格式三:若只有一个参数,小括号可以省略不写 x -> System.out.println(x) 语法格式四:有两个以上的参数,有返回值,并且 Lambda 体中有多条语句 Comparator com - (x, y) -> { System.out.println(“函数式接口”); return Integer.compare(x, y); }; 语法格式五:若 Lambda 体中只有一条语句, return 和 大括号都可以省略不写 - omparator com = (x, y) -> Integer.compare(x, y); 语法格式六:Lambda 表达式的参数列表的数据类型可以省略不写,因为JVM编译器通过上下- 文推断出,数据类型,即“类型推断” (Integer x, Integer y) -> Integer.compare(x, y);"

    踩0 评论0
  • 04.12 22:47:43
    回答了问题 2020-04-12 22:47:43

    Java8 Lambda表达式是什么?

    "Lambda 是一个匿名函数,我们可以把 Lambda表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格,使Java的语言表达能力得到了提升。 将 Lambda 表达式拆分成两部分: 左侧:Lambda 表达式的参数列表 右侧:Lambda 表达式中所需执行的功能, 即 Lambda 体"

    踩0 评论0
  • 04.12 22:47:19
    回答了问题 2020-04-12 22:47:19

    Java中如何进行正则表达式替换?

    "查找到子字符串后,一个常见的后续操作是替换。String有多个替换方法: public String replace(char oldChar, char newChar) public String replace(CharSequence target, CharSequence replacement) public String replaceAll(String regex, String replacement) public String replaceFirst(String regex, String replacement) 第一个replace方法操作的是单个字符,第二个是CharSequence,它们都是将参数看作普通字符。而replaceAll和replaceFirst则将参数regex看作正则表达式,它们的区别是, replaceAll替换所有找到的子字符串,而replaceFirst则只替换第一个找到的。"

    踩0 评论0
  • 04.12 22:46:45
    回答了问题 2020-04-12 22:46:45

    Java中如何进行正则表达式查找?

    "查找就是在文本中寻找匹配正则表达式的子字符串,,看个例子: public static void main(String[] args) { String regex = ""\d{4}-\d{2}-\d{2}""; Pattern pattern = Pattern.compile(regex); String str = ""today is 2017-06-02, yesterday is 2017-06-01""; Matcher matcher = pattern.matcher(str); while (matcher.find()) { System.out.println(""find "" + matcher.group() + "" position:"" + matcher.start()+""-""+matcher.end()); } } 代码寻找所有类似""2017-06-02""这种格式的日期,输出为: find 2017-06-02 position:9-19 find 2017-06-01 position:34-44 Matcher的内部记录有一个位置,起始为0, find方法从这个位置查找匹配正则表达式的子字符串,找到后,返回true,并更新这个内部位置,匹配到的子字符串信息可以通过如下方法获取: public String group():匹配到的完整子字符串 public int start():子字符串的起始位置 public int end():子字符串的结束位置"

    踩0 评论0
  • 04.12 22:45:36
    回答了问题 2020-04-12 22:45:36

    Java中如何进行正则表达式验证?

    "验证就是检验输入文本是否完整匹配预定义的正则表达式,经常用于检验用户的输入是否合法。String有如下方法:matches() String的matches实际调用的是Pattern的如下方法: public static boolean matches(String regex, CharSequence input) 这是一个静态方法,它的代码为: public static boolean matches(String regex, CharSequence input) { Pattern p = Pattern.compile(regex); Matcher m = p.matcher(input); return m.matches(); } 就是先调用compile编译regex为Pattern对象,再调用Pattern的matcher方法生成一个匹配对象Matcher, Matcher的matches方法返回是否完整匹配。"

    踩0 评论0
  • 04.12 22:45:07
    回答了问题 2020-04-12 22:45:07

    Java中如何进行正则表达式切分?

    "文本处理的一个常见需求是根据分隔符切分字符串,比如在处理CSV文件时,按逗号分隔每个字段,这个需求听上去很容易满足,因为String类有如下方法:sprint()。 不过,有一些重要的细节,我们需要注意。split将参数regex看作正则表达式,而不是普通的字符,如果分隔符是元字符,比如. $ | ( ) [ {^ ? * + \,就需要转义。比如按点号'.'分隔,需要写为: str.split(""\.""); Pattern也有split方法,与String方法的定义类似: 与String方法的区别如下。 1)Pattern接受的参数是CharSequence,更为通用,我们知道String、StringBuilder、StringBuffer、CharBuffer等都实现了该接口。 2)如果regex长度大于1或包含元字符,String的split方法必须先将regex编译为Pattern对象,再调用Pattern的split方法,这时,为避免重复编译,应该优先采用Pattern的方法。 3)如果regex就是一个字符且不是元字符,String的split方法会采用更为简单高效的实现,所以,这时应该优先采用String的split方法。"

    踩0 评论0
  • 04.12 22:44:28
    回答了问题 2020-04-12 22:44:28

    Java中如何表示正则表达式?

    正则表达式由元字符和普通字符组成,字符''是一个元字符,要在正则表达式中表示''本身,需要使用它转义,即'\'。在Java中,没有什么特殊的语法能直接表示正则表达式,需要用字符串表示,而在字符串中,''也是一个元字符,为了在字符串中表示正则表达式的'',就需要使用两个'',即'\',而要匹配''本身,就需要4个'',即'\\'。

    踩0 评论0
  • 04.12 22:44:06
    回答了问题 2020-04-12 22:44:06

    Java正则表达式环视边界匹配如何使用?

    "对于边界匹配,除了使用上面介绍的边界元字符,还有一种更为通用的方式,那就是环视。环视的字面意思就是左右看看,需要左右符合一些条件,本质上,它也是匹配边界,对边界有一些要求,这个要求是针对左边或右边的字符串的。根据要求不同,分为4种环视: 1)肯定顺序环视,语法是(? =...),要求右边的字符串匹配指定的表达式。比如表达式abc(?=def), (? =def)在字符c右面,即匹配c右面的边界。对这个边界的要求是:它的右边有def,比如abcdef,如果没有,比如abcd,则不匹配。 2)否定顺序环视,语法是(? ! ...),要求右边的字符串不能匹配指定的表达式。比如表达式s(? !ing),匹配一般的s,但不匹配后面有ing的s。注意:避免与排除型字符组混淆,比如s[^ing],s[^ing]匹配的是两个字符,第一个是s,第二个是i、n、g以外的任意一个字符。 3)肯定逆序环视,语法是(? <=...),要求左边的字符串匹配指定的表达式。比如表达式(?<=\s)abc, (? <=\s)在字符a左边,即匹配a左边的边界。对这个边界的要求是:它的左边必须是空白字符。 4)否定逆序环视,语法是(? <! ...),要求左边的字符串不能匹配指定的表达式。比如表达式(?<! \w)cat, (? <! \w)在字符c左边,即匹配c左边的边界。对这个边界的要求是:它的左边不能是单词字符。"

    踩0 评论0
  • 04.12 22:43:42
    回答了问题 2020-04-12 22:43:42

    Java正则表达式特殊边界匹配如何使用?

    在正则表达式中,除了可以指定字符需满足什么条件,还可以指定字符的边界需满足什么条件,或者说匹配特定的边界,常用的表示特殊边界的元字符有^、$、\A、\Z、\z和\b。默认情况下,^匹配整个字符串的开始,^abc表示整个字符串必须以abc开始。需要注意的是^的含义,在字符组中它表示排除,但在字符组外,它匹配开始,比如表达式^[^abc],表示以一个不是a、b、c的字符开始。默认情况下,$匹配整个字符串的结束,不过,如果整个字符串以换行符结束,$匹配的是换行符之前的边界,比如表达式abc$,表示整个表达式以abc结束,或者以abc\r\n或abc\n结束。以上^和$的含义是默认模式下的,可以指定另外一种匹配模式:多行匹配模式,在此模式下,会以行为单位进行匹配,^匹配的是行开始,$匹配的是行结束,比如表达式是^abc$,字符串是"abc\nabc\r\n",就会有两个匹配。

    踩0 评论0
  • 04.12 22:42:49
    回答了问题 2020-04-12 22:42:49

    Java正则表达式分组如何使用?

    "表达式可以用括号()括起来,表示一个分组,比如a(bc)d, bc就是一个分组。分组可以嵌套,比如a(de(fg))。分组默认都有一个编号,按照括号的出现顺序,从1开始,从左到右依次递增,比如表达式:a(bc)((de)(fg)) 字符串abcdefg匹配这个表达式,第1个分组为bc,第2个为defg,第3个为de,第4个为fg。分组0是一个特殊分组,内容是整个匹配的字符串,这里是abcdefg。分组匹配的子字符串可以在后续访问,好像被捕获了一样,所以默认分组称为捕获分组。关于如何在Java中访问和使用捕获分组,我们下节再介绍。可以对分组使用量词,表示分组的出现次数,比如a(bc)+d,表示bc出现一次或多次。"

    踩0 评论0
  • 04.12 22:42:17
    回答了问题 2020-04-12 22:42:17

    Java正则表达式量词如何使用?

    "量词指的是指定出现次数的元字符,有三个常见的元字符:+、、? : 1)+:表示前面字符的一次或多次出现,比如正则表达式ab+c,既能匹配abc,也能匹配abbc,或abbbc。 2):表示前面字符的零次或多次出现,比如正则表达式ab*c,既能匹配abc,也能匹配ac,或abbbc。 3)? :表示前面字符可能出现,也可能不出现,比如正则表达式ab? c,既能匹配abc,也能匹配ac,但不能匹配abbc。"

    踩0 评论0
  • 04.12 22:41:47
    回答了问题 2020-04-12 22:41:47

    Java正则表达式字符组如何使用?

    "字符组有多种,包括任意字符、多个指定字符之一、字符区间、排除型字符组、预定义的字符组等,下面具体介绍。 点号字符'.'是一个元字符,默认模式下,它匹配除了换行符以外的任意字符。 在单个字符和任意字符之间,有一个字符组的概念,匹配组中的任意一个字符,用中括号[]表示。 为方便表示连续的多个字符,字符组中可以使用连字符'-' 字符组支持排除的概念,在[后紧跟一个字符^ 在字符组中,除了^、-、[ ]、\外,其他在字符组外的元字符不再具备特殊含义,变成了普通字符,比如字符'.'和'*', [.*]就是匹配'.'或者'*'本身。"

    踩0 评论0
  • 04.12 22:40:33
    回答了问题 2020-04-12 22:40:33

    Java正则表达式单个字符如何使用?

    "大部分的单个字符就是用字符本身表示的,比如字符'0'、'3'、'a'、'马'等,但有一些单个字符使用多个字符表示,这些字符都以斜杠''开头,比如: 1)特殊字符,比如tab字符'\t'、换行符'\n'、回车符'\r'等。 2)八进制表示的字符,以\0开头,后跟1~3位数字,比如\0141,对应的是ASCII编码为97的字符,即字符'a'。 3)十六进制表示的字符,以\x开头,后跟两位字符,比如\x6A,对应的是ASCII编码为106的字符,即字符'j'。 4)Unicode编号表示的字符,以\u开头,后跟4位字符,比如\u9A6C,表示的是中文字符'马',这只能表示编号在0xFFFF以下的字符,如果超出0ⅩFFFF,使用\x{...}形式,比如\x{1f48e}。 5)斜杠\本身,斜杠\是一个元字符,如果要匹配它自身,使用两个斜杠表示,即'\'。 6)元字符本身,除了'',正则表达式中还有很多元字符,比如.、*、? 、+等,要匹配这些元字符自身,需要在前面加转义字符'',比如'.'。"

    踩0 评论0
  • 04.12 22:39:54
    回答了问题 2020-04-12 22:39:54

    Java正则表达式的语法组成部分有哪些?

    "❑ 单个字符; ❑ 字符组; ❑ 量词; ❑ 分组; ❑ 特殊边界匹配; ❑ 环视边界匹配。"

    踩0 评论0
  • 04.12 22:39:30
    回答了问题 2020-04-12 22:39:30

    Java 正则表达式是什么?

    正则表达式是一串字符,它描述了一个文本模式,利用它可以方便地处理文本,包括文本的查找、替换、验证、切分等。正则表达式中的字符有两类:一类是普通字符,就是匹配字符本身;另一类是元字符,这些字符有特殊含义,这些元字符及其特殊含义构成了正则表达式的语法。

    踩0 评论0
  • 04.12 22:29:45
    回答了问题 2020-04-12 22:29:45

    对SpringBoot的行为进行干预的配置方式有哪些?

    "简单来讲,我们可以将对SpringBoot的行为可以进行干预的配置方式划分为几类: 命令行参数(Command Line Args)。 系统环境变量(Environment Variables)。 位于文件系统中的配置文件。 位于classpath中的配置文件。 固化到代码中的配置项。 为了简化,其他比较少见场景的配置方式不在这里罗列。总的来说,以上几种方式按照优先级从高到低排列,高优先级方式提供的配置项可以覆盖或者优先生效,比如通过命令行参数传入的配置项会覆盖通过环境变量传入的同一配置项,当然也会覆盖其他后面几种方式给出的同一配置项。"

    踩0 评论0
  • 04.12 22:29:27
    回答了问题 2020-04-12 22:29:27

    Java SpringBoot对开发者有哪些影响?

    "SpringBoot微框架从两个主要层面影响Spring社区的开发者们: 1)基于Spring框架的“约定优先于配置(COC)”理念以及最佳实践之路。 2)提供了针对日常企业应用研发各种场景的spring-boot-starter自动配置依赖模块,如此多“开箱即用”的依赖模块,使得开发各种场景的Spring应用更加快速和高效。"

    踩0 评论0
  • 04.12 22:28:41
    回答了问题 2020-04-12 22:28:41

    Java SpringBoot如何调整自动配置的顺序?

    "在实现自动配置的过程中,除了可以提供基于条件的配置,我们还可以对当前要提供的配置或者组件的加载顺序进行相应调整,从而让这些配置或者组件之间的依赖分析和组装可以顺利完成。我们可以使用@org.springframework.boot.autoconfigure.AutoConfigureBefore或者@org.springframework.boot.autoconfigure.AutoConfigureAfter让当前配置或者组件在某个其他组件之前或者之后进行,比如,假设我们希望某些JMX操作相关的bean定义在MBeanServer配置完成之后进行,那么我们就可以提供一个类似如下的配置: @Configuration @AutoConfigureAfter(JmxAutoConfiguration.class) public class AfterMBeanServerReadyConfiguration(){ @Autowired JmxMBeanServer mBeanServer; // 通过@Bean添加必要的bean定义 }"

    踩0 评论0
  • 04.12 22:27:20
    回答了问题 2020-04-12 22:27:20

    Java SpringBoot如何实现基于条件的自动配置?

    "基于条件的自动配置来源于Spring框架中“基于条件的配置”这一特性。在Spring框架中,我们可以使用@Conditional这个Annotation配合@Configuration或者@Bean等Annotation来干预一个配置或者bean定义是否能够生效,其最终实现的效果或者语义类似于如下伪代码: if(符合@Conditional规定条件){ 加载当前配置或者注册当前bean定义; } 要实现基于条件的配置,我们只要通过@Conditional指定自己的Condition实现类就可以了(可以应用于类型Type的标注或者方法Method的标注): @Conditional({MyCondition1.class, MyCondition2.class}) 最主要的是,@Conditional可以作为一个Meta Annotation用来标注其他Annotation实现类,从而构建各色的复合Annotation,比如SpringBoot的autoconfigure模块就基于这一优良的革命传统,实现了一批这样的Annotation (位于org.springframework.boot.autoconfigure.condition包下):@Conditional On Class@Conditional On Bean@Conditional On Missing Class@Conditional On Missing Bean@Conditional On Property……有了这些复合Annotation的配合,我们就可以结合@EnableAuto-Configurationn实现基于条件的自动配置了。SpringBoot能够风靡,很大一部分功劳需要归功于它预先提供的一系列自动配置的依赖模块,而这些依赖模块都是基于以上@Conditional复合Annotation实现的,这也意味着所有的这些依赖模块都是按需加载的,只有符合某些特定条件,这些依赖模块才会生效,这也就是我们所谓的“智能”自动配置。"

    踩0 评论0
  • 04.12 22:25:53
    回答了问题 2020-04-12 22:25:53

    Java SpringBoot应用如何添加自定义的ApplicationListener?

    "如果我们要为SpringBoot应用添加自定义的ApplicationListener,有两种方式: 1)通过SpringApplication.addListeners(..)或者SpringApplication.setListeners(..)方法添加一个或者多个自定义的ApplicationListener; 2)借助SpringFactoriesLoader机制,在META-INF/spring.factories文件中添加配置;"

    踩0 评论0
  • 04.12 22:23:04
    回答了问题 2020-04-12 22:23:04

    Java Spring Application执行流程有哪些?

    "1)如果我们使用的是SpringApplication的静态run方法,那么,这个方法里面首先需要创建一个SpringApplication对象实例,然后调用这个创建好的SpringApplication的实例run方法。在SpringApplication实例初始化的时候,它会提前做几件事情:根据classpath里面是否存在某个特征类(org.springframework.web.context.ConfigurableWebApplicationContext)来决定是否应该创建一个为Web应用使用的ApplicationContext类型,还是应该创建一个标准Standalone应用使用的ApplicationContext类型。使用Spring Factories Loader在应用的classpath中查找并加载所有可用的ApplicationContext Initializer。使用Spring Factories Loader在应用的classpath中查找并加载所有可用的ApplicationListener。推断并设置main方法的定义类。 2)SpringApplication实例初始化完成并且完成设置后,就开始执行run方法的逻辑了,方法执行伊始,首先遍历执行所有通过SpringFactoriesLoader可以查找到并加载的SpringApplicationRunListener,调用它们的started()方法,告诉这些SpringApplicationRunListener, “嘿,SpringBoot应用要开始执行咯!”。 3)创建并配置当前SpringBoot应用将要使用的Environment(包括配置要使用的PropertySource以及Profile)。 4)遍历调用所有SpringApplicationRunListener的environmentPrepared()的方法,告诉它们:“当前SpringBoot应用使用的Environment准备好咯!”。 5)如果SpringApplication的showBanner属性被设置为true,则打印banner(SpringBoot1.3.x版本,这里应该是基于Banner.Mode决定banner的打印行为)。这一步的逻辑其实可以不关心,我认为唯一的用途就是“好玩”(Just For Fun)。 6)根据用户是否明确设置了applicationContextClass类型以及初始化阶段的推断结果,决定该为当前SpringBoot应用创建什么类型的ApplicationContext并创建完成,然后根据条件决定是否添加ShutdownHook,决定是否使用自定义的BeanNameGenerator,决定是否使用自定义的ResourceLoader,当然,最重要的,将之前准备好的Environment设置给创建好的ApplicationContext使用。 7)ApplicationContext创建好之后,SpringApplication会再次借助Spring-FactoriesLoader,查找并加载classpath中所有可用的ApplicationContext-Initializer,然后遍历调用这些ApplicationContextInitializer的initialize (applicationContext)方法来对已经创建好的ApplicationContext进行进一步的处理。 8)遍历调用所有SpringApplicationRunListener的contextPrepared()方法,通知它们:“SpringBoot应用使用的ApplicationContext准备好啦!” 9)最核心的一步,将之前通过@EnableAutoConfiguration获取的所有配置以及其他形式的IoC容器配置加载到已经准备完毕的ApplicationContext。 10)遍历调用所有SpringApplicationRunListener的contextLoaded()方法,告知所有SpringApplicationRunListener, ApplicationContext""装填完毕""! 11)调用ApplicationContext的refresh()方法,完成IoC容器可用的最后一道工序。 12)查找当前ApplicationContext中是否注册有CommandLineRunner,如果有,则遍历执行它们。 13)正常情况下,遍历执行SpringApplicationRunListener的finished()方法,告知它们:“搞定!”。(如果整个过程出现异常,则依然调用所有SpringApplicationRunListener的finished()方法,只不过这种情况下会将异常信息一并传入处理)。 至此,一个完整的SpringBoot应用启动完毕!"

    踩0 评论0
  • 04.12 22:22:31
    回答了问题 2020-04-12 22:22:31

    Java @ComponentScan应该如何理解?

    为啥说@Component Scan是可有可无的?因为原则上来说,作为Spring框架里的“老一辈革命家”, @Component Scan的功能其实就是自动扫描并加载符合条件的组件或bean定义,最终将这些bean定义加载到容器中。加载bean定义到Spring的IoC容器,我们可以手工单个注册,不一定非要通过批量的自动扫描完成,所以说@Component Scan是可有可无的。

    踩0 评论0
  • 04.12 22:22:08
    回答了问题 2020-04-12 22:22:08

    Java @EnableAutoConfiguration应该如何理解?

    @EnableAutoConfiguration其实也没啥“创意”,各位是否还记得Spring框架提供的各种名字为@Enable开头的Annotation定义?比如@EnableScheduling、@EnableCaching、@EnableMBeanExport等,@EnableAutoConfiguration的理念和“做事方式”其实一脉相承,简单概括一下就是,借助@Import的支持,收集和注册特定场景相关的bean定义:@Enable Scheduling是通过@Import将Spring调度框架相关的bean定义都加载到IoC容器。@Enable M Bean Export是通过@Import将JMX相关的bean定义加载到IoC容器。而@EnableAutoConfiguration也是借助@Import的帮助,将所有符合自动配置条件的bean定义加载到IoC容器,仅此而已!

    踩0 评论0
  • 04.12 22:21:29
    回答了问题 2020-04-12 22:21:29

    Java @Configuration应该如何理解?

    这里的@Configuration对我们来说并不陌生,它就是JavaConfig形式的Spring IoC容器的配置类使用的那个@Configuration,既然SpringBoot应用骨子里就是一个Spring应用,那么,自然也需要加载某个IoC容器的配置,而SpringBoot社区推荐使用基于JavaConfig的配置形式,所以,很明显,这里的启动类标注了@Configuration之后,本身其实也是一个IoC容器的配置类!很多SpringBoot的代码示例都喜欢在启动类上直接标注@Configuration或者@SpringBootApplication。

    踩0 评论0
  • 04.12 22:21:05
    回答了问题 2020-04-12 22:21:05

    Java @SpringBootApplication应该如何理解?

    "@SpringBootApplication是一个“三体”结构,实际上它是一个复合Annotation:虽然它的定义使用了多个Annotation进行元信息标注,但实际上对于SpringBoot应用来说,重要的只有三个Annotation,而“三体”结构实际上指的就是这三个Annotation:@Configuration@Enable Auto Configuration@Component Scan所以,如果我们使用如下的SpringBoot启动类,整个SpringBoot应用依然可以与之前的启动类功能对等: @Configuration @EnableAutoConfiguration @ComponentScan"

    踩0 评论0
  • 04.12 22:20:30
    回答了问题 2020-04-12 22:20:30

    Java中一个典型的SpringBoot应用长什么样子呢?

    "如果我们使用http://start.spring.io/创建一个最简单的依赖Web模块的SpringBoot应用,一般情况下,我们会得到一个SpringBoot应用的启动类,如下面代码所示: @SpringBootApplication public class StudyApplication { public static void main(String[] args) { SpringApplication.run(StudyApplication.class, args); } }"

    踩0 评论0
  • 04.12 22:19:57
    回答了问题 2020-04-12 22:19:57

    Java如何合理配置线程池?

    "CPU密集:CPU密集的意思是该任务需要大量的运算,而没有阻塞,CPU一直全速运行。 CPU密集任务只有在真正的多核CPU上才可能得到加速(通过多线程),而在单核CPU上,无论你开几个模拟的多线程,该任务都不可能得到加速,因为CPU总的运算能力就那些。 IO密集:IO密集型,即该任务需要大量的IO,即大量的阻塞。在单线程上运行IO密集型的任务会导致浪费大量的CPU运算能力浪费在等待。所以在IO密集型任务中使用多线程可以大大的加速程序运行,即时在单核CPU上,这种加速主要就是利用了被浪费掉的阻塞时间。"

    踩0 评论0
  • 04.12 22:19:37
    回答了问题 2020-04-12 22:19:37

    Java如何自定义线程线程池?

    "如果当前线程池中的线程数目小于corePoolSize,则每来一个任务,就会创建一个线程去执行这个任务; 如果当前线程池中的线程数目>=corePoolSize,则每来一个任务,会尝试将其添加到任务缓存队列当中,若添加成功,则该任务会等待空闲线程将其取出去执行;若添加失败(一般来说是任务缓存队列已满),则会尝试创建新的线程去执行这个任务; 如果队列已经满了,则在总线程数不大于maximumPoolSize的前提下,则创建新的线程 如果当前线程池中的线程数目达到maximumPoolSize,则会采取任务拒绝策略进行处理; 如果线程池中的线程数量大于 corePoolSize时,如果某线程空闲时间超过keepAliveTime,线程将被终止,直至线程池中的线程数目不大于corePoolSize;如果允许为核心池中的线程设置存活时间,那么核心池中的线程空闲时间超过keepAliveTime,线程也会被终止。 ThreadPoolExecutor executor = new ThreadPoolExecutor(1,2,60L, TimeUnit.MINUTES, new ArrayBlockingQueue<>(3)); for(int i = 0;i<10;i++){ executor.execute(() -> {

    });
    

    } executor.shutdown();"

    踩0 评论0
  • 04.12 22:19:10
    回答了问题 2020-04-12 22:19:10

    Java线程池原理是啥?

    提交一个任务到线程池中,线程池的处理流程如下: 1、判断线程池里的核心线程是否都在执行任务,如果不是(核心线程空闲或者还有核心线程没有被创建)则创建一个新的工作线程来执行任务。如果核心线程都在执行任务,则进入下个流程。 2、线程池判断工作队列是否已满,如果工作队列没有满,则将新提交的任务存储在这个工作队列里。如果工作队列满了,则进入下个流程。 3、判断线程池里的线程是否都处于工作状态,如果没有,则创建一个新的工作线程来执行任务。如果已经满了,则交给饱和策略来处理这个任务。

    踩0 评论0
  • 04.12 22:15:04
    回答了问题 2020-04-12 22:15:04

    Java线程池有哪些创建方式?

    "线程池四种创建方式 newCachedThreadPool:创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。 newFixedThreadPool:创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。 newScheduledThreadPool:创建一个定长线程池,支持定时及周期性任务执行。 newSingleThreadExecutor:创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。"

    踩0 评论0
  • 04.12 22:14:32
    回答了问题 2020-04-12 22:14:32

    Java如何使用BlockingQueue模拟生产者与消费者?

    " package com.stardust.study.demo.se.multithread;

    import org.apache.commons.lang3.StringUtils;

    import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger;

    public class ProductDemo { public static void main(String[] args) { BlockingQueue blockingQueue = new LinkedBlockingQueue<>(3); ProductThread productThread = new ProductThread(blockingQueue); ConsumerThread consumerThread = new ConsumerThread(blockingQueue); Thread p = new Thread(productThread); Thread c = new Thread(consumerThread); p.start(); c.start(); try { Thread.sleep(2 * 1000); productThread.stop(); } catch (InterruptedException e) { e.printStackTrace(); } } }

    class ProductThread implements Runnable{ private BlockingQueue blockingQueue; private AtomicInteger atomicInteger = new AtomicInteger(); private volatile boolean flag = true;

    ProductThread(BlockingQueue<String> blockingQueue){
        this.blockingQueue = blockingQueue;
    }
    
    @Override
    public void run() {
        System.out.println(""线程:"" + Thread.currentThread().getName() + "",生产者开始执行"");
        while (flag){
            String count = atomicInteger.incrementAndGet() + """";
            try {
                boolean offer = blockingQueue.offer(count, 2, TimeUnit.SECONDS);
                if(offer) {
                    System.out.println(""线程:"" + Thread.currentThread().getName() + "",生产者添加元素成功"");
                }else {
                    System.out.println(""线程:"" + Thread.currentThread().getName() + "",生产者添加元素失败"");
                }
            } catch (Exception e) {
    
            }
        }
        System.out.println(""线程:"" + Thread.currentThread().getName() + "",生产者结束执行"");
    }
    public void stop(){
        this.flag = false;
    }
    

    }

    class ConsumerThread implements Runnable{ private BlockingQueue blockingQueue; private volatile boolean flag = true;

    ConsumerThread(BlockingQueue<String> blockingQueue){
        this.blockingQueue = blockingQueue;
    }
    
    @Override
    public void run() {
        System.out.println(""线程:"" + Thread.currentThread().getName() + "",消费者开始执行"");
        while (flag){
            try {
                String count = blockingQueue.poll(2, TimeUnit.SECONDS);
                if(StringUtils.isBlank(count)) {
                    this.flag = false;
                    System.out.println(""线程:"" + Thread.currentThread().getName() + "",消费者超过两秒没有获取消息"");
                    return;
                }
                System.out.println(""线程:"" + Thread.currentThread().getName() + "",消费者成功获取消息:"" + count);
            } catch (Exception e) {
    
            }
        }
    }
    

    }"

    踩0 评论0
  • 04.12 22:13:54
    回答了问题 2020-04-12 22:13:54

    Java并发队列SynchronousQueue如何使用?

    SynchronousQueue队列内部仅允许容纳一个元素。当一个线程插入一个元素后会被阻塞,除非这个元素被另一个线程消费。

    踩0 评论0
  • 04.12 22:13:09
    回答了问题 2020-04-12 22:13:09

    Java并发队列PriorityBlockingQueue如何使用?

    PriorityBlockingQueue是一个没有边界的队列,它的排序规则和 java.util.PriorityQueue一样。需要注意,PriorityBlockingQueue中允许插入null对象。 所有插入PriorityBlockingQueue的对象必须实现 java.lang.Comparable接口,队列优先级的排序规则就是按照我们对这个接口的实现来定义的。 另外,我们可以从PriorityBlockingQueue获得一个迭代器Iterator,但这个迭代器并不保证按照优先级顺序进行迭代。 下面我们举个例子来说明一下,首先我们定义一个对象类型,这个对象需要实现Comparable接口:

    踩0 评论0
  • 04.12 22:12:27
    回答了问题 2020-04-12 22:12:27

    Java并发队列LinkedBlockingQueue如何使用?

    LinkedBlockingQueue阻塞队列大小的配置是可选的,如果我们初始化时指定一个大小,它就是有边界的,如果不指定,它就是无边界的。说是无边界,其实是采用了默认大小为Integer.MAX_VALUE的容量 。它的内部实现是一个链表。 和ArrayBlockingQueue一样,LinkedBlockingQueue 也是以先进先出的方式存储数据,最新插入的对象是尾部,最新移出的对象是头部。

    踩0 评论0
  • 04.12 22:11:57
    回答了问题 2020-04-12 22:11:57

    Java并发队列ArrayBlockingQueue如何使用?

    ArrayBlockingQueue是一个有边界的阻塞队列,它的内部实现是一个数组。有边界的意思是它的容量是有限的,我们必须在其初始化的时候指定它的容量大小,容量大小一旦指定就不可改变。 ArrayBlockingQueue是以先进先出的方式存储数据,最新插入的对象是尾部,最新移出的对象是头部。

    踩0 评论0
  • 04.12 22:11:34
    回答了问题 2020-04-12 22:11:34

    Java并发队列ConcurrentLinkedQueue如何使用?

    ConcurrentLinkedQueue : 是一个适用于高并发场景下的队列,通过无锁的方式,实现 了高并发状态下的高性能,通常ConcurrentLinkedQueue性能好于BlockingQueue.它 是一个基于链接节点的无界线程安全队列。该队列的元素遵循先进先出的原则。头是最先 加入的,尾是最近加入的,该队列不允许null元素。 ConcurrentLinkedQueue重要方法: add 和offer() 都是加入元素的方法(在ConcurrentLinkedQueue中这俩个方法没有任何区别) poll() 和peek() 都是取头元素节点,区别在于前者会删除元素,后者不会。

    踩0 评论0
  • 04.12 22:11:10
    回答了问题 2020-04-12 22:11:10

    Java阻塞队列与非阻塞队列的区别在哪?

    阻塞队列与普通队列的区别在于,当队列是空的时,从队列中获取元素的操作将会被阻塞,或者当队列是满时,往队列里添加元素的操作会被阻塞。试图从空的阻塞队列中获取元素的线程将会被阻塞,直到其他的线程往空的队列插入新的元素。同样,试图往已满的阻塞队列中添加新元素的线程同样也会被阻塞,直到其他的线程使队列重新变得空闲起来

    踩0 评论0
  • 04.12 22:10:07
    回答了问题 2020-04-12 22:10:07

    Java在并发队列上JDK提供了你哪些实现?

    在并发队列上JDK提供了两套实现,一个是以ConcurrentLinkedQueue为代表的高性能队 列非阻塞队列,一个是以BlockingQueue接口为代表的阻塞队列,无论哪种都继承自Queue。

    踩0 评论0
  • 04.12 22:09:27
    回答了问题 2020-04-12 22:09:27

    Java 计数信号量 Semaphore有啥作用?

    Semaphore是一种基于计数的信号量。它可以设定一个阈值,基于此,多个线程竞争获取许可信号,做自己的申请后归还,超过阈值后,线程申请许可信号将会被阻塞。Semaphore可以用来构建一些对象池,资源池之类的,比如数据库连接池,我们也可以创建计数为1的Semaphore,将其作为一种类似互斥锁的机制,这也叫二元信号量,表示两种互斥状态。

    踩0 评论0
正在加载, 请稍后...
暂无更多信息
  • 回答了问题 2020-04-13

    Java为何要使用线程池?

    "系统启动一个新线程的成本是比较高的,因为它涉及与操作系统交互。在这种情形下,使用线程池可以很好地提高性能,尤其是当程序中需要创建大量生存期很短暂的线程时,更应该考虑使用线程池。 与数据库连接池类似的是,线程池在系统启动时即创建大量空闲的线程,程序将一个Runnable对象或Callable对象传给线程池,线程池就会启动一个线程来执行它们的run()或call()方法,当run()或call()方法执行结束后,该线程并不会死亡,而是再次返回线程池中成为空闲状态,等待执行下一个Runnable对象的run()或call()方法。 除此之外,使用线程池可以有效地控制系统中并发线程的数量,当系统中包含大量并发线程时,会导致系统性能剧烈下降,甚至导致JVM崩溃,而线程池的最大线程数参数可以控制系统中并发线程数不超过此数。"

    踩0 评论0
  • 回答了问题 2020-04-13

    Java JVM垃圾回收机制策略有哪些?

    Java JVM垃圾回收机制策略有四种:标记清除算法、复制算法、标记压缩算法和分代算法。

    踩0 评论0
  • 回答了问题 2020-04-13

    Java JVM中垃圾回收机制原理是啥?

    不定时去堆内存中清理不可达对象。不可达的对象并不会马上就会直接回收, 垃圾收集器在一个Java程序中的执行是自动的,不能强制执行,即使程序员能明确地判断出有一块内存已经无用了,是应该回收的,程序员也不能强制垃圾收集器回收该内存块。程序员唯一能做的就是通过调用System.gc 方法来"建议"执行垃圾收集器,但其是否可以执行,什么时候执行却都是不可知的。

    踩0 评论0
  • 回答了问题 2020-04-13

    Java线程会以什么样的方式结束,然后处于死亡状态?

    "线程会以如下3种方式结束,结束后就处于死亡状态。 run()或call()方法执行完成,线程正常结束。 线程抛出一个未捕获的 Exception或Error。 直接调用该线程的stop()方法来结束该线程——该方法容易导致死锁,通常不推荐使用。"

    踩0 评论0
  • 回答了问题 2020-04-13

    【Java问答月】4月Java提问、答题有奖;24小时优先回答,不回答有礼物!

    参加活动2, 4月13号回答Java问题400道

    踩0 评论0
  • 回答了问题 2020-04-12

    Java8流式操作中中间操作有哪些?

    "该操作会保持 stream 处于中间状态,允许做进一步的操作。它返回的还是的 Stream,允许更多的链式操作。常见的中间操作有: filter():对元素进行过滤; sorted():对元素排序; map():元素的映射; distinct():去除重复元素; subStream():获取子 Stream 等。"

    踩0 评论0
  • 回答了问题 2020-04-12

    Java8流式操作中串行和并行的流有啥区别?

    流有串行和并行两种,串行流上的操作是在一个线程中依次完成,而并行流则是在多个线程上同时执行。并行与串行的流可以相互切换:通过 stream.sequential() 返回串行的流,通过 stream.parallel() 返回并行的流。相比较串行的流,并行的流可以很大程度上提高程序的执行效率。

    踩0 评论0
  • 回答了问题 2020-04-12

    Java8集合之流式操作是啥?

    "Java 8 引入了流式操作(Stream),通过该操作可以实现对集合(Collection)的并行处理和函数式操作。根据操作返回的结果不同,流式操作分为中间操作和最终操作两种。最终操作返回一特定类型的结果,而中间操作返回流本身,这样就可以将多个操作依次串联起来。根据流的并发性,流又可以分为串行和并行两种。流式操作实现了集合的过滤、排序、映射等功能。 Stream 和 Collection 集合的区别:Collection 是一种静态的内存数据结构,而 Stream 是有关计算的。前者是主要面向内存,存储在内存中,后者主要是面向 CPU,通过 CPU 实现计算。"

    踩0 评论0
  • 回答了问题 2020-04-12

    Java8接口中允许定义静态方法吗?

    "在接口中,还允许定义静态的方法。接口中的静态方法可以直接用接口来调用。 例如,下面接口中定义了一个静态方法 find,该方法可以直接用 StaticFunInterface .find() 来调用。 public interface StaticFunInterface { public static int find(){ return 1; } } public class TestStaticFun { public static void main(String[] args){ //接口中定义了静态方法 find 直接被调用 StaticFunInterface.fine(); } }"

    踩0 评论0
  • 回答了问题 2020-04-12

    Java8接口中默认方法是啥?

    "Java 8 还允许我们给接口添加一个非抽象的方法实现,只需要使用 default 关键字即可,这个特征又叫做扩展方法。在实现该接口时,该默认扩展方法在子类上可以直接使用,它的使用方式类似于抽象类中非抽象成员方法。但扩展方法不能够重载 Object 中的方法。例如:toString、equals、 hashCode 不能在接口中被重载。 例如,下面接口中定义了一个默认方法 count(),该方法可以在子类中直接使用。 public interface DefaultFunInterface { //定义默认方法 count default int count(){ return 1; } } public class SubDefaultFunClass implements DefaultFunInterface { public static void main(String[] args){ //实例化一个子类对象,改子类对象可以直接调用父接口中的默认方法 count SubDefaultFunClass sub = new SubDefaultFunClass(); sub.count(); } }"

    踩0 评论0
  • 回答了问题 2020-04-12

    Java如何检查是否是函数式接口?

    Lambda 表达式需要“函数式接口”的支持 函数式接口:接口中只有一个抽象方法的接口,称为函数式接口。 可以使用注解 @FunctionalInterface 修饰 可以检查是否是函数式接口

    踩0 评论0
  • 回答了问题 2020-04-12

    Java8 Lambda表达式语法有哪些?

    "语法格式一:无参数,无返回值 () -> System.out.println(“Hello Lambda!”); 语法格式二:有一个参数,并且无返回值 (x) -> System.out.println(x) 语法格式三:若只有一个参数,小括号可以省略不写 x -> System.out.println(x) 语法格式四:有两个以上的参数,有返回值,并且 Lambda 体中有多条语句 Comparator com - (x, y) -> { System.out.println(“函数式接口”); return Integer.compare(x, y); }; 语法格式五:若 Lambda 体中只有一条语句, return 和 大括号都可以省略不写 - omparator com = (x, y) -> Integer.compare(x, y); 语法格式六:Lambda 表达式的参数列表的数据类型可以省略不写,因为JVM编译器通过上下- 文推断出,数据类型,即“类型推断” (Integer x, Integer y) -> Integer.compare(x, y);"

    踩0 评论0
  • 回答了问题 2020-04-12

    Java8 Lambda表达式是什么?

    "Lambda 是一个匿名函数,我们可以把 Lambda表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格,使Java的语言表达能力得到了提升。 将 Lambda 表达式拆分成两部分: 左侧:Lambda 表达式的参数列表 右侧:Lambda 表达式中所需执行的功能, 即 Lambda 体"

    踩0 评论0
  • 回答了问题 2020-04-12

    Java中如何进行正则表达式替换?

    "查找到子字符串后,一个常见的后续操作是替换。String有多个替换方法: public String replace(char oldChar, char newChar) public String replace(CharSequence target, CharSequence replacement) public String replaceAll(String regex, String replacement) public String replaceFirst(String regex, String replacement) 第一个replace方法操作的是单个字符,第二个是CharSequence,它们都是将参数看作普通字符。而replaceAll和replaceFirst则将参数regex看作正则表达式,它们的区别是, replaceAll替换所有找到的子字符串,而replaceFirst则只替换第一个找到的。"

    踩0 评论0
  • 回答了问题 2020-04-12

    Java中如何进行正则表达式查找?

    "查找就是在文本中寻找匹配正则表达式的子字符串,,看个例子: public static void main(String[] args) { String regex = ""\d{4}-\d{2}-\d{2}""; Pattern pattern = Pattern.compile(regex); String str = ""today is 2017-06-02, yesterday is 2017-06-01""; Matcher matcher = pattern.matcher(str); while (matcher.find()) { System.out.println(""find "" + matcher.group() + "" position:"" + matcher.start()+""-""+matcher.end()); } } 代码寻找所有类似""2017-06-02""这种格式的日期,输出为: find 2017-06-02 position:9-19 find 2017-06-01 position:34-44 Matcher的内部记录有一个位置,起始为0, find方法从这个位置查找匹配正则表达式的子字符串,找到后,返回true,并更新这个内部位置,匹配到的子字符串信息可以通过如下方法获取: public String group():匹配到的完整子字符串 public int start():子字符串的起始位置 public int end():子字符串的结束位置"

    踩0 评论0
  • 回答了问题 2020-04-12

    Java中如何进行正则表达式验证?

    "验证就是检验输入文本是否完整匹配预定义的正则表达式,经常用于检验用户的输入是否合法。String有如下方法:matches() String的matches实际调用的是Pattern的如下方法: public static boolean matches(String regex, CharSequence input) 这是一个静态方法,它的代码为: public static boolean matches(String regex, CharSequence input) { Pattern p = Pattern.compile(regex); Matcher m = p.matcher(input); return m.matches(); } 就是先调用compile编译regex为Pattern对象,再调用Pattern的matcher方法生成一个匹配对象Matcher, Matcher的matches方法返回是否完整匹配。"

    踩0 评论0
  • 回答了问题 2020-04-12

    Java中如何进行正则表达式切分?

    "文本处理的一个常见需求是根据分隔符切分字符串,比如在处理CSV文件时,按逗号分隔每个字段,这个需求听上去很容易满足,因为String类有如下方法:sprint()。 不过,有一些重要的细节,我们需要注意。split将参数regex看作正则表达式,而不是普通的字符,如果分隔符是元字符,比如. $ | ( ) [ {^ ? * + \,就需要转义。比如按点号'.'分隔,需要写为: str.split(""\.""); Pattern也有split方法,与String方法的定义类似: 与String方法的区别如下。 1)Pattern接受的参数是CharSequence,更为通用,我们知道String、StringBuilder、StringBuffer、CharBuffer等都实现了该接口。 2)如果regex长度大于1或包含元字符,String的split方法必须先将regex编译为Pattern对象,再调用Pattern的split方法,这时,为避免重复编译,应该优先采用Pattern的方法。 3)如果regex就是一个字符且不是元字符,String的split方法会采用更为简单高效的实现,所以,这时应该优先采用String的split方法。"

    踩0 评论0
  • 回答了问题 2020-04-12

    Java中如何表示正则表达式?

    正则表达式由元字符和普通字符组成,字符''是一个元字符,要在正则表达式中表示''本身,需要使用它转义,即'\'。在Java中,没有什么特殊的语法能直接表示正则表达式,需要用字符串表示,而在字符串中,''也是一个元字符,为了在字符串中表示正则表达式的'',就需要使用两个'',即'\',而要匹配''本身,就需要4个'',即'\\'。

    踩0 评论0
  • 回答了问题 2020-04-12

    Java正则表达式环视边界匹配如何使用?

    "对于边界匹配,除了使用上面介绍的边界元字符,还有一种更为通用的方式,那就是环视。环视的字面意思就是左右看看,需要左右符合一些条件,本质上,它也是匹配边界,对边界有一些要求,这个要求是针对左边或右边的字符串的。根据要求不同,分为4种环视: 1)肯定顺序环视,语法是(? =...),要求右边的字符串匹配指定的表达式。比如表达式abc(?=def), (? =def)在字符c右面,即匹配c右面的边界。对这个边界的要求是:它的右边有def,比如abcdef,如果没有,比如abcd,则不匹配。 2)否定顺序环视,语法是(? ! ...),要求右边的字符串不能匹配指定的表达式。比如表达式s(? !ing),匹配一般的s,但不匹配后面有ing的s。注意:避免与排除型字符组混淆,比如s[^ing],s[^ing]匹配的是两个字符,第一个是s,第二个是i、n、g以外的任意一个字符。 3)肯定逆序环视,语法是(? <=...),要求左边的字符串匹配指定的表达式。比如表达式(?<=\s)abc, (? <=\s)在字符a左边,即匹配a左边的边界。对这个边界的要求是:它的左边必须是空白字符。 4)否定逆序环视,语法是(? <! ...),要求左边的字符串不能匹配指定的表达式。比如表达式(?<! \w)cat, (? <! \w)在字符c左边,即匹配c左边的边界。对这个边界的要求是:它的左边不能是单词字符。"

    踩0 评论0
  • 回答了问题 2020-04-12

    Java正则表达式特殊边界匹配如何使用?

    在正则表达式中,除了可以指定字符需满足什么条件,还可以指定字符的边界需满足什么条件,或者说匹配特定的边界,常用的表示特殊边界的元字符有^、$、\A、\Z、\z和\b。默认情况下,^匹配整个字符串的开始,^abc表示整个字符串必须以abc开始。需要注意的是^的含义,在字符组中它表示排除,但在字符组外,它匹配开始,比如表达式^[^abc],表示以一个不是a、b、c的字符开始。默认情况下,$匹配整个字符串的结束,不过,如果整个字符串以换行符结束,$匹配的是换行符之前的边界,比如表达式abc$,表示整个表达式以abc结束,或者以abc\r\n或abc\n结束。以上^和$的含义是默认模式下的,可以指定另外一种匹配模式:多行匹配模式,在此模式下,会以行为单位进行匹配,^匹配的是行开始,$匹配的是行结束,比如表达式是^abc$,字符串是"abc\nabc\r\n",就会有两个匹配。

    踩0 评论0
正在加载, 请稍后...
滑动查看更多
正在加载, 请稍后...
暂无更多信息