java 入门篇(38) 其他一些类_supplierthrow

一、jdk1.8 新特性之Option类

1.1 概念

这是一个可以为null的容器对象，如果值存在则isPrresent()方法返回true，调用get()方法会返回该对象

1.2 常用方法

1.2.1 Optional.of()

• 作用：为非 null 的值创建一个 Optional。
• 说明：of 方法通过工厂方法创建 Optional 类。需要注意的是，创建对象时传入的参数不能为 null。如果传入参数为 null，则抛出 NullPointerException 。

public class Test1 {
    public static void main(String[] args) {
        //通过工厂模式创建实例
        Optional<Stu> stu = Optional.of(new Stu());
        //传入参数为 null，抛出 NullPointerException.
        Optional<Object> o = Optional.of(null);
        System.out.println(o);
        System.out.println(stu);
    }
}
1
2
3
4
5
6
7
8
9
10

1.2.2 Optional.ofNullable()

作用：为指定的值创建一个 Optional，如果指定的值为 null，则返回一个空的 Optional。
说明：ofNullable 与 of 方法相似，唯一的区别是可以接受参数为 null 的情况。

public class Test1 {
    public static void main(String[] args) {
        Optional<Object> o = Optional.ofNullable(null);
        System.out.println(o);
    }
}
1
2
3
4
5
6

结果：

Optional.empty
1

1.2.3 Optional.isPresent()

作用：判断预期值是否存在
说明：如果值存在返回 true，否则返回 false。

public class Test1 {
    public static void main(String[] args) {
        Optional<Stu> stu = Optional.of(new Stu("张三", "23"));
        Optional<String> s = Optional.of("");
        //调用get()返回已存在的值
        Stu stu2 = stu.get();
        System.out.println(stu2.getAge() + stu2.getName());
        System.out.println(s.isPresent());
        System.out.println(stu.isPresent());
    }
}
1
2
3
4
5
6
7
8
9
10
11

结果：

23张三
true
true
1
2
3

1.2.4 new Optional().get()

作用：如果 Optional 有值则将其返回，否则抛出 NoSuchElementException。
说明：上面的示例中，get 方法用来得到 Optional 实例中的值。

public class Test1 {
    public static void main(String[] args) {
        try {
            Optional<String> s = Optional.of(null);
            System.out.println(s.get());
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11

1.2.5 Optional.ifPresent()

作用：如果 Optional 实例有值则为其调用 consumer，否则不做处理
说明：要理解 ifPresent 方法，首先需要了解 Consumer 类。简答地说，Consumer 类包含一个抽象方法。该抽象方法对传入的值进行处理，但没有返回值。Java8 支持不用接口直接通过 lambda 表达式传入参数，如果 Optional实例有值，调用 ifPresent()可以接受接口段或 lambda 表达式.

public class Test1 {
    public static void main(String[] args) {
        Optional<Stu> stu = Optional.of(new Stu("张三", "23"));
        stu.ifPresent(new Consumer<Stu>() {
            @Override
            public void accept(Stu stu) {
                System.out.println("你好呀");
            }
        });
        System.out.println(stu.get().getName());

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

1.2.7 Optional.orElse()

作用：如果有值则将其返回，否则返回指定的其它值。
说明：如果 Optional 实例有值则将其返回，否则返回 orElse 方法传入的参数。示例如下：

public class Test1 {
    public static void main(String[] args) {
        Optional<String> stu = Optional.ofNullable(null);
        System.out.println(stu.orElse("为空"));
    }
}

1
2
3
4
5
6
7
8

结果：

为空
1

1.2.8 Optional.orElseGet()

作用：如果有值则将其返回，否则返回指定的其它值。
说明：orElseGet 与 orElse 方法类似，区别在于得到的默认值。orElse 方法将传入的字符串作为默认值，orElseGet方法可以接受 Supplier 接口的实现用来生成默认值

public class Test1 {
    public static void main(String[] args) {
        Optional<String> stu = Optional.ofNullable(null);
        System.out.println(stu.orElseGet(() -> {
            return "你好";
        }));
    }
}
1
2
3
4
5
6
7
8

结果：

你好
1

1.2.9 Optional.orElseThrow()

作用：如果有值则将其返回，否则抛出 supplier 接口创建的异常。
说明：在 orElseGet 方法中，我们传入一个 Supplier 接口。然而，在 orElseThrow 中我们可以传入一个 lambda表达式或方法，如果值不存在来抛出异常

public class Test1 {
    public static void main(String[] args) {
        Optional<String> stu = Optional.ofNullable(null);
        try {
            String s = stu.orElseThrow(new Supplier<Throwable>() {
                @Override
                public Throwable get() {
                    return new Throwable("出现异常");
                }
            });
        } catch (Throwable throwable) {
            System.out.println(throwable.getMessage());
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

结果：

出现异常
1

1.2.10 Optional.map()

作用：如果有值，则对其执行调用 mapping 函数得到返回值。如果返回值不为 null，则创建包含 mapping 返回值的 Optional 作为 map 方法返回值，否则返回空 Optional。
说明：map 方法用来对 Optional 实例的值执行一系列操作。通过一组实现了 Function 接口的lambda 表达式传入操作。

    public static void main(String[] args) {
        Optional<String> stu = Optional.ofNullable("hello world");
        Optional<String> s = stu.map((value) -> value.toUpperCase());
        System.out.println(s.orElse("scsdssd"));
    }
}
1
2
3
4
5
6

结果：

HELLO WORLD
1

1.2.11 Optional.flatMap()

作用：如果有值，为其执行 mapping 函数返回 Optional 类型返回值，否则返回空 Optional。flatMap 与 map(Funtion）方法类似，区别在于 flatMap 中的 mapper 返回值必须是 Optional。调用结束时，flatMap 不会对结果用 Optional 封装。
说明：flatMap 方法与 map 方法类似，区别在于 mapping 函数的返回值不同。map 方法的 mapping 函数返回值可以是任何类型 T，而 flatMap 方法的 mapping 函数必须是 Optional。

public class Test1 {
    public static void main(String[] args) {
        Optional<String> stu = Optional.ofNullable("hello world");
        Optional<String> s = stu.flatMap((value) -> Optional.of(value.toUpperCase()));
        System.out.println(s.get());
    }
}
1
2
3
4
5
6
7

结果：

HELLO WORLD
1

1.2.12 Optional.filter()

作用：如果有值并且满足断言条件返回包含该值的 Optional，否则返回空 Optional。
说明：filter 个方法通过传入限定条件对 Optional 实例的值进行过滤。这里可以传入一个 lambda 表达式。对于filter 函数我们应该传入实现了 Predicate 接口的 lambda 表达式。

public class Test1 {
    public static void main(String[] args) {
        Optional<String> stu = Optional.ofNullable("hello");
        Optional<String> s = stu.filter((value) -> value.length() > 6);
        System.out.println(s.orElse("字符串的长度没有超过6个"));
    }
}
1
2
3
4
5
6
7

结果：

字符串的长度没有超过6个
1

二、 Arrays类

2.1 概念

此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。 除非特别注明，否则如果指定数组引用为 null，则此类中的方法都会抛出 NullPointerException。

2.2 常用方法

2.2.1 public static List asList(T… a)

• 返回一个受指定数组支持的固定大小的列表。（对返回列表的更改会“直接写”到数组。）此方法同 Collection.toArray() 一起，充当了基于数组的 API 与基于 collection 的 API 之间的桥梁。返回的列表是可序列化的，并且实现了 RandomAccess。
  此方法还提供了一个创建固定长度的列表的便捷方法，该列表被初始化为包含多个元素

public class Test1 {
    public static void main(String[] args) {
        List<String> strings = Arrays.asList("张三", "李四", "王五");
        Iterator<String> iterator = strings.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}
1
2
3
4
5
6
7
8
9

结果：

张三
李四
王五
1
2
3

2.2.2 public static int binarySearch(byte[] a,byte key)

• 使用二分搜索法来搜索指定的 byte 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过 sort(byte[]) 方法）。如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。

public class Test1 {
    public static void main(String[] args) {
        int[] ints = new int[]{2,3,4,7};
        System.out.println(Arrays.binarySearch(ints, 3));
    }
}
1
2
3
4
5
6

结果：

1
1

2.2.3 public static int[] copyOf(int[] original,int newLength)

• 复制指定的数组，截取或用 false 填充（如有必要），以使副本具有指定的长度。对于在原数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效而在原数组无效的所有索引，副本将包含 false。当且仅当指定长度大于原数组的长度时，这些索引存在。

public class Test1 {
    public static void main(String[] args) {
        int[] ints = new int[]{2,3,4,7};
        int[] ints2 = Arrays.copyOf(ints, 4);
        for(int i : ints2){
            System.out.print(i + " ");
        }
    }
}
1
2
3
4
5
6
7
8
9

2.2.4 public static boolean[] copyOfRange(boolean[] original,int from,int to)

• 将指定数组的指定范围复制到一个新数组。该范围的初始索引 (from) 必须位于 0 和 original.length（包括）之间。original[from] 处的值放入副本的初始元素中（除非 from == original.length 或 from == to）。原数组中后续元素的值放入副本的后续元素。该范围的最后索引 (to) （必须大于等于 from）可以大于 original.length，在这种情况下，false 被放入索引大于等于 original.length - from 的副本的所有元素中。返回数组的长度为 to - from。

2.2.5 public static boolean equals(int[] a,int[] a2)

• 如果两个指定的 int 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。此外，如果两个数组引用都为 null，则认为它们是相等的。

2.2.6 public static void sort(int[] a)

• 对指定的 int 型数组按数字升序进行排序。该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的 Engineering a Sort Function", Software-Practice and Experience Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。

2.2 7 public static String toString(boolean[] a)

• 返回指定数组内容的字符串表示形式。字符串表示形式由数组的元素列表组成，括在方括号（"[]"）中。相邻元素用字符 ", "（逗号加空格）分隔。这些元素通过 String.valueOf(boolean) 转换为字符串。如果 a 为 null，则返回 “null”。

三、StringUtils类

3.1 介绍

StringUtils 方法的操作对象是 Java.lang.String 类型的对象，是 JDK 提供的 String 类型操作方法的补充，并且是 null 安全的(即如果输入参数 String 为 null 则不会抛出 NullPointerException ，而是做了相应处理，例如，如果输入为 null 则返回也是 null 等，具体可以查看源代码)。

3.2 常用方法

3.2.1 public static boolean isEmpty(String str)

判断某字符串是否为空，为空的标准是 str==null 或 str.length()==0

3.2.2 public static boolean isBlank(String str)

判断某字符串是否为空或长度为0或由空白符(whitespace) 构成

3.2.3 public static String trim(String str)

去掉字符串两端的控制符(control characters, char <= 32) , 如果输入为 null 则返回null

3.2.4 public static String strip(String str)

去掉字符串两端的空白符(whitespace) ，如果输入为 null 则返回 null

3.2.5 public static int indexOf(String str, char searchChar)

• 返回字符 searchChar 在字符串 str 中第一次出现的位置。
  如果 searchChar 没有在 str 中出现则返回-1，
  如果 str 为 null 或 “” ，则也返回-1

3.2.6 public static int ordinalIndexOf(String str, String searchStr, int ordinal)

返回字符串 searchStr 在字符串 str 中第 ordinal 次出现的位置。

3.3 参考

Java之StringUtils的常用方法

四、java中其他工具类

4.1 参考

java中常用工具类整合