Java中的一些类-CSDN博客

public class SystemTest {
    public static void main(String[] args) {
        //设定要被拷贝的数组;
        int[] a = {3,5,6,7};
        //创建一个空数组
        int[] b =new int[3];
        //调用System.arraycopy方法(被拷贝的数组,从第几位开始拷贝,拷贝到的数组,从第几位开始拷贝，拷贝的个数)
        //System.arraycopy(数据源数组,起始索引,目的地数组,起始数组，拷贝的个数);
        System.arraycopy(a,1, b ,0,3);
        //遍历一下
        System.out.println(b);
        for (int i = 0; i < b.length; i++) {
            System.out.println(b[i]);
        }

        /*-------------------------------------------*/
        //获取从1970年1月1日0时0分到现在为止的毫秒数
        System.out.println(System.currentTimeMillis());
    }
}

Math工具类，里面提供了一些公式用的方法；

BigDecimal类：保证小数精确运算的类

构造器：

BigDecimal b1 = new BigDecimal(String str);
BigDecimal b1 = BigDecimal.valueof(double d);
（不推荐使用）BigDecimal b1 = new BigDecimal(double d);

常用方法：add(),subtract(),multiply(),divide();

public static void main(String[] args) {
        //创建两个BigDecimal对象
       /* BigDecimal b3 = BigDecimal.valueOf(0.3);
        BigDecimal b4 =  BigDecimal.valueOf(0.1);*/
        BigDecimal b1 = new BigDecimal("0.5");
        BigDecimal b2 = new BigDecimal("0.6");

        //加减乘除运算;
        System.out.println(b1.add(b2));
        System.out.println(b1.subtract(b2));
        System.out.println(b1.multiply(b2));
        //对于除不尽的情况下，要指定进位模式
            //四舍五入
            System.out.println(b1.divide(b2, RoundingMode.HALF_UP));
            //进位
            System.out.println(b1.divide(b2, RoundingMode.UP));
            //舍去
            System.out.println(b1.divide(b2, RoundingMode.DOWN));

        //求绝对值，需要用到double这种类型，所以需要BigDecimal运算完之后再转换为double类型;
        BigDecimal result = b1.add(b2);
        //使用BigDecimal中的doubleValue()进行转换;
        double doubleValue = result.doubleValue();
        Math.abs(doubleValue);
    }

Arrays数组工具类

A常用方法:

Arrays.toString(数组) 不需要遍历了，直接转为字符串输出
Arrays.equals(数组1, 数组2) 比较两个一维数组中的值是否相同
Arrays.sort(数组);  对数组中的值进行升序排序
Arrays.binarySearch(数组, 要查找值) 使用二分法进行查找值所在的位置Arrays.stream(数组) 返回以指定数组作为源的顺序Stream 。

 public static void main(String[] args) {
        //Array数组工具类Arrays.equals(ints, int2)比较两个数据里面的值是否一致的方法;
        // 注意只能比较一维数组，因为二维数组里面存的是地址值
        int[] ints = {1,2,33,88,11,22,39};
        int[] int2 = {1,2,33,88,11,22,39};
        System.out.println(Arrays.equals(ints, int2));

        int[][] nums = {{0,3,59}, {5,0,9}, {10,12,13}};
        int[][] nums2 = {{0,3,59}, {5,0,9}, {10,12,13}};
        System.out.println(Arrays.equals(nums, nums2));//false
        //--------------------------------------------------------------------
        //Arrays.sort()是对以为数组进行升序排序
        Arrays.sort(ints);
        System.out.println(Arrays.toString(ints));
        //--------------------------------------------------------------------
        //Arrays.binarySearch(数组名, 查找值)是查找值在数组中的位置，如果结构为负数，则没找到
        //注意：使用的二分法进行的查找，所以必须要保证是排序过的数组，如果不是的话，会返回的索引有问题;
        System.out.println(Arrays.binarySearch(int2, 33));

    }

日期时间，时间格式化，时间工具类（详细见自己的资料)
1. JDK7及之前：Date,Calender,SimpleDateFormat类
2. JDK8及之后(推荐使用):
  日历类：LocalDate,LocalDateTime,LocalTime(线程安全，并且修改的话会提供一个新的日历类对象)
  日期格式化类:DateTimeFomatter
  时间类 (时间戳，时区，带时区的时间)Instant,ZoneID,ZoneDateTime
  工具类：Duration,Period,ChronoUnit
Collections集合工具类
1. 作用：此类仅包含对集合进行操作或返回集合的静态方法。它包含对集合进行操作的多态算法，“包装器”，它返回由指定集合支持的新集合，以及其他一些可能性和结束。
2. 简而言之这是一个对实现Collection接口的实现类的（集合）进行操作的工具类
3. 方法：
  1. Collections.addAll(集合名，元素1，元素2); 将所有指定的元素添加到指定的集合中。
  2. Collections.binarySearch(集合名,要查找的元素值);使用二进制搜索算法在指定列表中搜索指定对象。
  3. Collections.reverse(集合名);反转指定列表中元素的顺序。
Stream流
1. Stream是个接口，使用的话是使用他的实现类
2. Stream流的使用流程
  1. 数据源为集合或者数组，先在数据源中获取Stream流对象于数据源建立连接
  2. 调用中间方法(过滤，排序，去重等)
  3. 调用终结方法，获取结果

获取当前不同数据源的Stream流的方法

数组：使用Arrays.stream(数组名) 或 Stream.of(数组名)

继承Collection接口的List，Set 使用Collection中的stream()即可，比如(list.Stream()返回的是一个Stream对象，set同理)

继承Map接口的话可以转为set然后再调用set的stream()方法来获取Stream流。比如如果要键对值一起的话就map.entrySet().stream()，或者只要map的key的话，map.keySet().stream()；或者只要值的话就map.values().stream();

Stream流的常用中间方法

public static void main(String[] args) {

        List<Student> list = new ArrayList<>();
        list.add(new Student("张三",21,170.4));
        list.add(new Student("李四",20,160.0));
        list.add(new Student("王五",21,168.1));
        list.add(new Student("张老五",21,176.4));
        list.add(new Student("赵六",23,180.5));
        list.add(new Student("老七",21,176.4));
        list.add(new Student("张七",21,176.4));

        //根找出姓名中带有张的,并且字数为2个字的;可以先写一个匿名类，然后直接空格加回车用idea的自动转为lambda表达式
        list.stream().filter(student -> student.getName().contains("张") && student.getName().length() == 2).forEach(student -> System.out.println(student));
        System.out.println("-------------------");
        //根据年龄从大到小排列
        //list.stream().sorted((o1, o2) -> o2.getAge()- o1.getAge()).forEach(student -> System.out.println(student));
        //取出身高最矮的前3个人。使用limit() , 如果取后面的就用 .step(list.length()-3)开始
        //list.stream().sorted((o1, o2) -> Double.compare(o1.getHeight(),o2.getHeight())).limit(3).forEach(student -> System.out.println(student));
        //年龄在20岁之上的年龄，并且对身高去重
        list.stream().filter(student -> student.getAge()>20).map(Student::getHeight).distinct().forEach(student -> System.out.println(student));
    }

Stream流的常用终结方法（终结方法其实就是因为不会返回Stream对象，所以不能在后面再继续通过点来调用stream的方法了）

Stream流的常用终结方法之收集Stream流，也就是把Stream流收集到集合或数组中去;

   public static void main(String[] args) {

        List<Student> list = new ArrayList<>();
        list.add(new Student("张三",21,170.4));
        list.add(new Student("李四",20,160.0));
        list.add(new Student("王五",21,168.1));
        list.add(new Student("张老五",21,176.4));
        list.add(new Student("赵六",23,180.5));
        list.add(new Student("老七",21,176.4));
        list.add(new Student("张七",21,176.4));

        //找出身高为160.0的人的信息
      //返回的Optional是一个容器对象。可以避免在空集合上进行操作时出现异常。
        Optional<Student> min = list.stream().min((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight()));
        //调用Optional中的get方法获取到数据;
        Student student1 = min.get();
        System.out.println(student1);
        
        //找出超过170的学生并且返回一个list对象
        List<Student> collect = list.stream().filter(student -> student.getHeight() > 170.0).collect(Collectors.toList());
       // System.out.println(collect);
        //找出超过170的学生并且返回一个Map对象，其中，key为姓名，value为身高
        Map<String, Double> collect1 = list.stream().filter(student -> student.getHeight() > 170.0).collect(Collectors.toMap(student -> student.getName(), student -> student.getHeight()));
        //System.out.println(collect1);
    }

Optional类：主要用作方法返回类型，其中明确需要表示“无结果”，并且使用null可能导致错误。类型为Optional变量本身不应该是null ; 它应始终指向Optional实例。

在Java中的使用场景主要是为了处理可能为空的值，从而避免空指针异常。以下是一些常见的使用场景：

        方法返回值：当一个方法可能返回空值时，可以使用Optional作为返回类型，明确告诉调用者返回值可能为空，从而避免在调用时忽略空值的可能性。

        避免空指针异常：在访问可能为空的对象或属性时，可以使用Optional来避免直接调用可能导致空指针异常的方法或属性。

        集合操作：在使用Stream API对集合进行操作时，使用Optional可以避免在空集合上进行操作时出现异常。

        配置读取：在读取配置或属性文件时，使用Optional可以更容易地处理缺少或无效的配置项。

数据库查询：当执行数据库查询时，查询结果可能为空，可以使用Optional来处理查询结果。

        函数式编程：在函数式编程中，Optional可以被用来表示可能的结果，从而允许更灵活的处理函数调用链。

        外部API调用：当调用外部API并且返回值可能为空时，使用Optional可以提醒开发者注意处理可能的空值情况。

尽管Optional可以有效地避免空指针异常，但在使用时也需要注意一些事项：

        不应该将Optional用作字段或方法参数的类型，因为它可能会使代码变得复杂。Optional应该主要用于方法返回值和集合操作。
        不要滥用Optional，如果一个方法很少会返回空值，那么不一定非要将其返回类型声明为Optional。
        使用ifPresent、orElse、orElseGet等方法时，不要在回调中执行会抛出异常的操作。
        总之，Optional适用于那些可能为空的场景，可以提高代码的安全性和可读性，但需要谨慎使用，避免过度使用或不必要地增加代码复杂性。

---------------------------------------------------------------------------------------

在Java中，Optional类提供了许多用于处理可能为空值的情况的方法。以下是一些常用的Optional方法：

    get()：获取包装在Optional对象中的实际值。如果Optional对象为空，会抛出NoSuchElementException异常。

    of(T value)：创建一个包含给定值的Optional对象。如果提供的值为null，则会抛出NullPointerException。

    ofNullable(T value)：创建一个包含给定值的Optional对象。如果提供的值为null，则创建一个空的Optional对象。

    empty()：创建一个空的Optional对象。

    isPresent()：检查Optional对象是否包含值。返回true如果存在值，否则返回false。

    ifPresent(Consumer<? super T> consumer)：如果Optional对象包含值，执行提供的操作。

    orElse(T other)：如果Optional对象为空，返回提供的默认值，否则返回包含的值。

    orElseGet(Supplier<? extends T> other)：如果Optional对象为空，通过提供的供应函数生成一个值，否则返回包含的值。

    orElseThrow(Supplier<? extends X> exceptionSupplier)：如果Optional对象为空，通过提供的异常供应函数抛出一个异常，否则返回包含的值。

    map(Function<? super T, ? extends U> mapper)：对Optional中的值进行映射操作，返回一个新的Optional对象。

    flatMap(Function<? super T, Optional<U>> mapper)：对Optional中的值进行映射操作，返回一个新的Optional对象，其中包含另一个Optional。

    filter(Predicate<? super T> predicate)：如果Optional对象包含值且满足给定条件，返回原始Optional对象，否则返回一个空的Optional对象。

    这些方法可以让你更方便地处理可能为空的值，同时避免空指针异常。在使用Optional时，根据情况选择合适的方法来处理包含和不包含值的情况。

二，一般用不到的类

Scanner类获取键盘输入的类 Scanner sc = new Scanner(System.in） , 方法 sc.nextInt()等
JFrame 窗体类(一般用不到)
1. JLabel (String text) 带有文本的JLabel组件
2. JLabel(Icon image)带有图片的JLabel组件
3. JButton(String message) 按钮组件,参数为按钮上的信息