ARTS是什么？

Algorithm：每周至少做一个LeetCode的算法题 Review：阅读并点评至少一篇英文文章 Tip：学习至少一个技术技巧 Share：分享一篇有观点和思考的技术文章

Algorithm

  1. /**
  2.  * @className: LeetCode07
  3.  * @description:
  4.  *给你一个字符串 s，由若干单词组成，单词之间用空格隔开。返回字符串中最后一个单词的长度。如果不存在最后一个单词，请返回 0 。
  5.  * 单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。
  6.  *
  7.  * 示例 1：
  8.  * 输入：s = "Hello World"
  9.  * 输出：5
  10.  *
  11.  * 示例 2：
  12.  * 输入：s = " "
  13.  * 输出：0
  14.  * @author: Miluo
  15.  * @date: 2021/4/12
  16.  **/
  17. public class LeetCode07 {
  18.     public int lengthOfLastWord(String s) {
  19.         String s1 = s.trim();
  20.         if (s == null || "".equals(s1)){
  21.             return 0;
  22.         }
  23.         if (s1.contains(" ")){
  24.             int i = s1.lastIndexOf(" ");
  25.             return s1.substring(i+1).length();
  26.         }else{
  27.             return s1.length();
  28.         }
  29.     }
  30. }

Review

Smart Developers Don’t Code
程序员不要重复造轮子，自己写可能有过度设计、不周全等问题，许多问题现在已经有完善的工具包可供使用，例如：Apache Camel

Camel是一个集成框架，旨在使项目集成更加高效。Camel项目于2007年初启动，现在已经成长为了一个成熟的开放源码项目，Camel使用Apache 2.0许可，具有健壮的社区。 Camel框架的核心是路由引擎，或者更准确地说，是路由引擎构建器。它允许你定义自己的路由规则，从哪个数据源接收消息、如何处理这些消息并将这些消息发送到目的地。使用Camel的集成语言，让你能够基于业务流程定义复杂的路由规则。Camel是不同系统之间的粘合剂。 Camel对系统集成的问题进行高度的抽象，你可以使用相同的API与不同的系统进行交互，即使这些系统使用的是不同协议、不同的数据类型。Camel的组件提供了针对不同协议和数据类型的API的接入，Camel支持超过280种协议和数据类型，可扩展、模块化的架构允许用户写出自己的实现来接入各类私有或共有协议。在这样的架构下，消除了不必要的转换，使Camel更快、更瘦。所以Camel非常适合嵌入任何需要的项目中。很多开源项目，如Apache ServiceMix、Karaf和ActiveMQ，都已经使用Camel作为集成工具。

Tip

Optional
根据Oracle文档，Optional是一个容器对象，可以包含也可以不包含非null值。Optional在Java 8中引入，目的是解决 NullPointerExceptions的问题

  1. /**
  2.  * @className OptionalTest
  3.  * @description 1.Optional.empty();
  4.  *              2.Optional.of();
  5.  *              3.Optional.ofNullable()
  6.  * @author Miluo
  7.  * @date 2021/4/12
  8.  **/
  9. public class CreateOptional {
  10.     //如果对象为空，请避免与Option.empty()返回的实例的{==}比较
  11.     //因为不能保证它是一个单例，反之，应该使用isPresent()
  12.     private static Optional method1(){
  13.         return Optional.empty();
  14.     }
  16.     //返回特定的非空值Optional
  17.     private static Optional method2(String test){
  18.         return Optional.of(test);
  19.     }
  21.     //静态方法需要一个非 null 参数:否则,将引发空指针异常
  22.     //因此，如果我们不知道参数是否为 null ，那就是我们使用 ofNullable 的时候
  23.     //如果参数为null，则生产一个空的Optional对象
  24.     private static Optional method3(String test){
  25.         return Optional.ofNullable(test);
  26.     }
  28.     public static void main(String[] args) {
  29.         //method1
  30.         System.out.println(method1());//Optional.empty
  31.         System.out.println(method1().isPresent());//false
  33.         //method2
  34.         System.out.println(method2(null));
  35.         System.out.println(method2(null).isPresent());
  36. /*        Exception in thread "main" java.lang.NullPointerException
  37.         at java.util.Objects.requireNonNull(Objects.java:203)
  38.         at java.util.Optional.<init>(Optional.java:96)
  39.         at java.util.Optional.of(Optional.java:108)
  40.         at miluo.optional.CreateOptional.method2(CreateOptional.java:40)
  41.         at miluo.optional.CreateOptional.main(CreateOptional.java:18)*/
  43.         System.out.println(method2("test"));//Optional[test]
  44.         System.out.println(method2("test").isPresent());//true
  46.         //method3
  47.         System.out.println(method3(null));//Optional.empty
  48.         System.out.println(method3(null).isPresent());//false
  50.         System.out.println(method3("test"));//Optional[test]
  51.         System.out.println(method3("test").isPresent());//true
  52.     }
  53. }
  1. /**
  2.  * @author Miluo
  3.  * @className CheckOptional
  4.  * @description 1.isPresent();
  5.  *
  6.  * @date 2021/4/12
  7.  **/
  8. public class CheckOptional {
  9.     public static void main(String[] args) {
  10.         Optional<Object> empty = Optional.empty();
  11.         Optional<String> test = Optional.of("test");
  13.         //Boolean isPresent()；判断Optional对象是否为空
  14.         System.out.println(empty.isPresent());//false
  15.         System.out.println(test.isPresent());//true
  17.         //如果有值存在，则执行Lambda表达式
  18.         test.ifPresent(s -> System.out.println(s.length()));//4
  20.     }
  21. }
  1. /**
  2.  * @author Miluo
  3.  * @className ValueOptional
  4.  * @description get(),orElse(),orElseGet()
  5.  * @date 2021/4/12
  6.  **/
  7. public class ValueOptional {
  8.     public static void main(String[] args) {
  9.         Optional<Object> empty = Optional.empty();
  10.         Optional<String> test = Optional.of("test");
  12.         //T get():获取Optional对象内的值
  13.         System.out.println(test.get()); //test
  14.             //如果Optional对象为null,get()会报错
  15.             //System.out.println(empty.get());
  16.             //Exception in thread "main" java.util.NoSuchElementException: No value present
  19.         //T orElse(T)
  20.         System.out.println(empty.orElse(print("empty orElse")));
  21.             //empty orElse方法执行
  22.             //empty orElse
  23.         System.out.println(test.orElse(print("test orElse")));
  24.             //test orElse方法执行
  25.             //test
  28.         //T orElseGet(Supplier<? extends T> other)
  29.         System.out.println(empty.orElseGet(() -> print("empty orElseGet")));
  30.             //empty orElseGet方法执行
  31.             //empty orElseGet
  32.         System.out.println(test.orElseGet(() -> print("test orElseGet")));
  33.             //test
  35.         //orElse()和orElseGet()的区别：
  36.         //无论Optional是否有值，且不管orElse()中的方法是否有需要都会执行，
  37.         //orElseGet()只有Optional对象为null时才执行
  38.         //默认情况下，每次使用orElseGet()更为有意义，除非默认对象已经构造并可以直接访问
  39.     }
  40.     private static String print(String str){
  41.         System.out.println(str+"方法执行");
  42.         return str;
  43.     }
  44. }

Share

应该成为专才还是通才