JAVA语法糖

权限注解 OR

@RequiresPermissions(value = {"m-a", "m-b"}, logical = Logical.OR)

抛出空指针异常

Objects.requireNonNull(element, "没有找到指定的元素");

BeanUtils

BeanUtils.copyProperties(a, b); 

【1】a可以有b没有的属性，b也可以有a没有的属性；
【2】a中与b中相同的属性都会被替换，不管是否有值；
【3】a、 b中的属性要名字相同，才能被赋值，不然的话需要手动赋值；
【4】Spring的BeanUtils的CopyProperties方法需要对应的属性有getter和setter方法；
【5】如果存在属性完全相同的内部类，但是不是同一个内部类，即分别属于各自的内部类，则spring会认为属性不同，不会copy；
【6】spring 和 apache 的copy属性的方法源和目的参数的位置正好相反，导包和调用的时候都要注意一下。

Java生成随机字符串

org.apache.commons.lang3.RandomStringUtils

Java生成UUID

UUID.randomUUID().toString();

Lambda表达式

@FunctionalInterface // 标注这个接口为函数式接口。对于添加了该注解的方法，如果有多个抽象方法，将会直接报错
interface MyListener {
    void doSomething(String name);
    default void sayHi(){
        
    }
    static void sayHello(){
        
    }
    // 虽然函数式接口只能有一个抽象方法，但是不影响有默认方法和静态方法，因为这两种方法不是默认重写的，在Lambda表达式中应用是不会出错的
}

方法引用

如果我们需要的lambda是下面这种形式

((arg1,arg2，...) -> fun(arg1,arg2，...) )

举个例子

arg -> System.out.println(arg)

那么可以考虑直接使用方法引用

out::println(arg)

方法引用共四种类型，这里介绍两个

类型	示例
引用静态方法	ContainingClass::staticMethodName
引用某个对象的实例方法	containingObject::instanceMethodName

Optional类

public T orElseGet(Supplier<? extends T> other) {
    return value != null ? value : other.get();
}
// Supplier 供给者 意思是不给它参数，但它给返回值
// 根据Java传参规则，该方法中需传入Supplier<T>的子类    
// 根据通配符的含义，在本方法中，Supplier<T的子类> 是 Supplier<T> 的子类
// 本方法参数实际等同于 () -> {...; return t;}  t在此处指T的子类对象，下同。
    
public void ifPresent(Consumer<? super T> consumer) {
    if (value != null)
        consumer.accept(value);
}
// 如果存在则执行
// Comsumer 消费者 意思是给它参数，但它不给返回值
// 本方法参数实际等同于 t -> {...;}
// 注意链式编程一定是前后是同一个对象，且值在全局变量中

public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
    Objects.requireNonNull(mapper);
    if (!isPresent())
        return empty();
    else {
        return Optional.ofNullable(mapper.apply(value));
    }
}
// 映射成另一个Optional
// Function 函数 意思是给它t，它返回u
// 根据泛型函数的定义，此处U采用参数类型推断，因此什么都可以。
// 本方法参数实际等同于 t -> {...; return u;} u在此处指U的子类对象。

public Optional<T> filter(Predicate<? super T> predicate) {
    Objects.requireNonNull(predicate);
    if (!isPresent())
        return this;
    else
        return predicate.test(value) ? this : empty();
}
// 过滤出需要的Optional
// Predicate 断言 意思是给它t, 它断言是否正确
// 本方法参数实际等同于 t -> {...; return true/false;}

public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
    Objects.requireNonNull(mapper);
    if (!isPresent())
        return empty();
    else {
        return Objects.requireNonNull(mapper.apply(value));
    }
}
// 给t，返回Optional<U>
// 此处U采取类型推断

public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
    if (value != null) {
        return value;
    } else {
        throw exceptionSupplier.get();
    }
}
// 不给，返回x。 x此处指X的子类对象。
// X采取类型推断，但声明为<X extends Throwable>，所以X一定是Throwable的子类

Jsoup

Element element = new Element();
element.html(); //获取一个标签里面的元素
element.html(String html); //设置一个标签里面的元素
element.addClass(String); //添加cssClass
element.removeClass(String); //去除cssClass
element.attr(String, String); //添加属性
element.appendTo(Element e); //添加到另一个元素里 修改element，也会修改e

Document document = Jsoup.parse(html); 
document.outputSettings(new Document.OutputSettings().prettyPrint(false)); //取消格式化（删除换行符）
document.select(); //css选择器 返回Element
document.select("span"); //指定标签寻找
document.select("#mySpan"); //指定id寻找
document.select(".myClass"); //指定Class寻找
document.select("span[class=myClass]span[id=mySpan]"); //指定属性名属性值及标签寻找
document.select("span[^my]"); //指定属性名前缀寻找 ^类似于正则表达式的匹配头
document.select("span[class~=^my]"); //选择具有class属性,且属性值匹配正则表达式的元素
document.select("span[class^=my]"); //选择具有class属性,且属性值以my开头的元素
document.select("span[class$=my]"); //选择具有class属性,且属性值以my结尾的元素
document.select("span[class*=my]"); //选择具有class属性,且属性值包含my的元素
document.select("span p"); //查找span下的所有p元素
document.select("span > p"); //查找span下的直接p元素

Stream

Stream流处理完成后，除非排序，否则顺序不发生变化。

Stream<T> filter(Predicate<? super T> predicate);
// 过滤出满足predicate条件的
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
// 映射，改变流的对象类型
Stream<T> distinct();
// 去重
Stream<T> sorted(Comparator<? super T> comparator);
// 排序
Stream<T> peek(Consumer<? super T> action);
// 不影响流，对元素进行操作
void forEach(Consumer<? super T> action);
// 遍历
Optional<T> min(Comparator<? super T> comparator);
// 取最小值
Optional<T> max(Comparator<? super T> comparator);
// 取最大值
long count();
// 计数
Optional<T> findFirst();
// 找到第一个元素

深拷贝

System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
//src表示源数组,srcPos表示源数组要复制的起始位置,desc表示目标数组,destPos表示目标数组要复制的起始位置, length表示要复制的长度。

Collections.sort

让一个对象是 可比较的，那就需要该对象实现 Comparable 接口啦。然后重写里面的
compareTo()方法。

public int compareTo(Student o){} 这个方法，它返回三种 int 类型的值： 负整数，零 ，正整数。

如果当前对象调用compareTo与另一个对象比较，结果为负整数时，当前对象排在前面

Collections.sort(List<T> list);
//默认对T升序排序，调用T的compareTo方法。
Collections.sort(List<T> list, Comparator<? super T> c);
// 参数1为List, 参数2为Comparator接口
// Comparator接口可以写匿名类,自己实现关于T的compare方法
        new Comparator<T>() {
            @Override
            public int compare(T o1, T o2) {
                return o1-o2 ;
            }
        }
        // Comparator接口可以lambda
        (o1, o2) -> o1-o2;
        // Comparator接口可以用
        Comparator.comparing(Function<? super T, ? extends U> keyExtractor, 
                             Comparator<? super U> keyComparator); 
        // 参数1为要比较的key, 参数2为比较方式，相当于提前把需要比较的key提出来
        Comparator.comparing(T::key).reversed(); // 先以key排序,结果再进行逆序
        Comparator.comparing(T::key, Comparator.reverseOrder()); // 直接逆序排序

// 另外的排序，比如
list.sort(Comparator<? super E> c);
Stream.sorted(Comparator<? super T> comparator);
// 默认对原本的元素进行排序。如果参数为Comparator.reverseOrder(), 则默认使用原本元素的compareTo方法逆序排序。