JAVA基础篇——常用API二

已于 2023-12-13 20:29:04 修改
阅读量47 收藏
点赞数 1
分类专栏： JAVA基础篇 文章标签： java 开发语言
于 2023-12-13 14:56:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44689664/article/details/134972397
版权

十、常用API

不要重复造轮子

1. Object类

Java中所有类的对象都可以直接使用Object类中提供的一些方法。

常见方法：

public String toString()——返回对象的字符串表示形式

作用： 返回对象的字符串形式

意义： 让子类重写，以便返回子类对象的内容

public boolean equals(Object o)——判断两个对象是否相等

作用： 判断两个对象的地址是否相同

意义： 让子类重写，以便比较两个对象的内容是否相同

protected Object clone()——对象克隆

作用： 当某个对象调用这个方法时，这个方法会复制一个一摸一样的新对象返回

2. Objects类——工具类，有很多操作对象的静态方法以供使用，static实用 程序方法

常见方法：

public static boolean equals(Object a, Object b)——先做非空判断，再比较两个对象，内部做了非空校验

public static boolean isNull(Object obj)——判断对象是否为null，为null返回true

public static boolean nonNull(Object obj)——判断对象是否不为null，不为null返回true

public class Test {
    public static void main(String[] args) {
        String s1 = null;
        String s2 = "itheima";
        // System.out.println(s1.equals(s2)); // 会报空指针错误，调用不了了
        System.out.println(s2.equals(s1)); // false
        System.out.println(Objects.equals(s1, s2));  // false

        System.out.println(Objects.isNull(s1));  // true
        System.out.println(Objects.isNull(s2));  // false
        
        System.out.println(Objects.nonNull(s1));  // false
        System.out.println(Objects.nonNull(s2));  // true
    }
}

3. 包装类

把基本类型的数据包装成对象

泛型和集合中不支持基本数据类型，只支持引用数据类型。

数转字符串：包装类.toString(str)

字符串转数：包装类.valueOf(num)

public class Test {
    public static void main(String[] args) {
        // Integer a1 = new Integer(12); // 已过时
        Integer a2 = Integer.valueOf(12);
        System.out.println(a2);

        // 自动装箱机制：把基本类型的数据转换成对象
        Integer a3 = 12;

        // 自动拆箱：自动把包装类型的对象转换成对应的基本数据类型
        int a4 = a3;

        // 方法
        // 1. 把基本类型的数据转换成字符串
        Integer a = 23;
        String rs1 = Integer.toString(a);
        System.out.println(rs1 + 4);  // 234

        String rs2 = Objects.toString(23);
        System.out.println(rs2 + 1);  // 231

        // 更优雅的做法
        String rs3 = a + "";
        System.out.println(rs3 + 6);  // 236

        // 2. 把字符串类型的数值转换成对应的基本类型——重要
        String ageStr = "29";
//        int age = Integer.parseInt(ageStr);
        int age = Integer.valueOf(ageStr);
        System.out.println(age + 1);  // 30
    }
}

4. StringBuilder

可变的字符序列，字符串拼接、修改等（用来操作字符串的）

StringBuilder比String更适合做字符串的修改

常用方法：

  1. 构造器：
  • public StringBuilder()
  • public StringBuilder(String str)
  1. 方法：
  • public StringBulider append(任意类型)：添加数据并返回对象本身
  • public StringBulider reverse()：将对象的内容反转
  • public int length()：返回对象类型的长度
  • public String toString()：把StringBuilder转换为String
public class Test {
    public static void main(String[] args) {
        StringBuilder s = new StringBuilder();
        StringBuilder s1 = new StringBuilder("itheima");

        // 1. 拼接操作
        s1.append("黑马");
        s1.append('a');
        s1.append(888);
        System.out.println(s1);

        // 2. 反转操作
        s1.reverse();
        System.out.println(s1);

        // 3. 返回对象长度
        System.out.println(s1.length());

        // 4. 返回String类型的变量
        String s2 = s1.toString();
        System.out.println(s2);
    }
}

为什么操作字符串建议使用StringBuilder，而不是String？

  • String频繁拼接、修改使用StringBuilder，效率更高
  • 但是定义一些字符串变量的情况，String效率更高

5. StringBuffer

与StringBuilder用法一样，但是StringBuilder线程是不安全的，StringBuffer线程是安全的

6. StringJoiner

原因： 拼接操作String太慢，StringBuilder太麻烦。

概念： 同上，但JDK8开始才有的

好处： 代码高效简洁

public class Test3 {
    public static void main(String[] args) {
        // 只有间隔符的构造器
        StringJoiner s = new StringJoiner(",");
        s.add("java1");
        s.add("java2");
        s.add("java3");
        System.out.println(s);  //java1,java2,java3

        // 有间隔符、开始符号、结束符号的有参构造器
        StringJoiner s1 = new StringJoiner(",", "[", "]");
        s1.add("y");
        s1.add("x");
        s1.add("g");
        System.out.println(s1.length());  // 7
        String s2 = s1.toString();
        System.out.println(s2);  //[y,x,g]

        // 调用方法
        System.out.println(getArrayData(new int[]{1, 2, 3}));
    }

    public static String getArrayData(int[] arr) {
        // 1. 判断arr是否为null
        if (arr == null) {
            return null;
        }
        StringJoiner ss = new StringJoiner(",", "[", "]");
        for (int i = 0; i < arr.length; i++) {
            ss.add(arr[i] + "");
        }
        return ss.toString();
    }
}

7. Math

数学工具类，对数据进行操作的静态方法

public class MathTest {
    public static void main(String[] args) {
        // abs()得到绝对值
        System.out.println(Math.abs(-12.3));
        System.out.println(Math.abs(1));

        // 向上取整
        System.out.println(Math.ceil(1.0));  // 1.0
        System.out.println(Math.ceil(1.00000001));  // 2.0

        // 向下取整
        System.out.println(Math.floor(4.9999));  // 4.0
        System.out.println(Math.floor(4.0000));  // 4.0

        // 四舍五入
        System.out.println(Math.round(3.49999));  // 3
        System.out.println(Math.round(3.50000));  // 4

        // 取最值
        System.out.println(Math.max(10, 20));  // 20
        System.out.println(Math.min(10, 20));  // 10

        // 取次方
        System.out.println(Math.pow(2, 3)); // 8.0

        // 取随机数,[0.0, 1.0)
        System.out.println(Math.random());  // 0.805434885364831
    }
}

8. System

代表程序所在的系统，也是一个工具类

public class SystemTest {
    public static void main(String[] args) {
        // 终止当前运行的Java虚拟机
        // System.exit(0);
        System.out.println("--");

        // 获取当前系统的时间，从1970年1月1日 0：0：0开始计算——前后计算差得到程序运行时间，程序性能分析
        long time = System.currentTimeMillis();
        System.out.println(time);
    }
}

9. Runtime

Java程序所在的运行环境

单例类：对外只需要一个对象

public class RuntimeTest {
    public static void main(String[] args) throws IOException, InterruptedException {
        // 得到运行时对象
        Runtime r = Runtime.getRuntime();
        // 终止当前运行的虚拟机，该参数用作状态代码。非零状态表示异常终止
//        r.exit(0);
        // 获取虚拟机能够使用的处理器数
        System.out.println(r.availableProcessors());  // 12
        // 获取虚拟机的内存总数,long字节
        System.out.println(r.totalMemory());
        // 返回Java虚拟机中的可用内存量
        System.out.println(r.freeMemory());
        // 启动某个程序，并返回代表该程序的对象
        Process p = r.exec("D:\\Zhiyun\\ZhiyunTranslator\\ZhiYunTranslator.exe");

        Thread.sleep(5000);

        p.destroy();
    }
}

10. BigDecimal

开发中经常遇到，要掌握

概念： 解决浮点运算时，会出现结果失真

public class BigDecimalDemo1 {
    public static void main(String[] args) {
        // 浮点数运算失真，不是每种情况下都会失真??why
//        double a = 0.1;
//        double b = 0.3;
//        double c = a + b;
//        System.out.println(c);  // 0.4
        double a = 0.1;
        double b = 0.2;
        double c = a + b;
        System.out.println(c);  // 0.30000000000000004

        // 解决失真问题
        // 1. 先变成字符串，再封装成BigDecimal对象
//        BigDecimal a1 = new BigDecimal(Double.toString(a));
//        BigDecimal b1 = new BigDecimal(Double.toString(b));
        BigDecimal a1 = BigDecimal.valueOf(a);  // 相当于上一行代码的封装
        BigDecimal b1 = BigDecimal.valueOf(b);

//        // 计算+
//        BigDecimal c1 = a1.add(b1);
//        System.out.println(c1);  // 0.3

//        // 计算-
//        BigDecimal c1 = a1.subtract(b1);
//        System.out.println(c1);  // -0.1

//        // 计算*
//        BigDecimal c1 = a1.multiply(b1);
//        System.out.println(c1);  // 0.02

        // 计算/
        BigDecimal c1 = a1.divide(b1);
        System.out.println(c1);  // 0.5

        // 除不尽的情况
        BigDecimal i = BigDecimal.valueOf(0.1);
        BigDecimal j = BigDecimal.valueOf(0.3);
//        BigDecimal k = i.divide(j);  //Non-terminating decimal expansion; no exact representable decimal result.
//        BigDecimal k = i.divide(j, 2);  // 默认是向上取保留一位小数
        BigDecimal k = i.divide(j, 2, RoundingMode.HALF_UP);  // 四舍五入
        System.out.println(k);
        
        // 把BigDecimal转换成double
        double rs = k.doubleValue();
        System.out.println(rs);

    }
}

11. 传统时间

11.1 Date

系统当前的日期和时间

public class Test1Date {
    public static void main(String[] args) {
        // 创建一个Date的对象，代表当前系统时间信息
        Date d = new Date();
        System.out.println(d);

        // 拿到时间毫秒值
        long time = d.getTime();
        System.out.println(time);

        // 把时间毫秒值转化为日期对象
        time += 2 * 1000;
        Date d2 = new Date(time);
        System.out.println(d2);

        // 直接把日期对象的时间通过setTime方法进行修改
        Date d3 = new Date();
        d3.setTime(time);
        System.out.println(d3);
    }
}

11.2 SimpleDateFormat

把得到的时间格式化成用户喜欢的形式

public class Test2SimpleDateFormat {
    public static void main(String[] args) throws ParseException {
        // 1. 准备一些时间
        Date d = new Date();
        System.out.println(d);

        long time = d.getTime();
        System.out.println(time);

        // 2. 格式化日期对象——前端展示
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss EEE a");
        String rs1 = sdf.format(d);
        String rs2 = sdf.format(time);
        System.out.println(rs1);
        System.out.println(rs2);

        // 3. 把字符串时间解析成日期对象——后端分析
        String dateStr = "2022-12-12 12:12:12";
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d2 = sdf2.parse(dateStr);  // 时间格式
        System.out.println(d2);
        long time2 = da.getTime();  // 时间毫秒值
    }
}

11.3 Calender

代表的是系统此刻时间对应的日历

可以单独获取、修改时间中的年、月、日、时、分、秒

Calendar时一个抽象类，但是提供了获取日历对象的方法

public class Test4Calendar {
    public static void main(String[] args) {
        // 1. 得到系统此刻时间对应的日历对象
        Calendar now = Calendar.getInstance();  // 返回的是Calendar子类的实例
        System.out.println(now);  // 月份是从0开始计算的，要想得到现在的月份，要+1

        // 2. 获取日历中的某个信息
        int year = now.get(Calendar.YEAR);
        System.out.println(year);

        // 3.拿到日历中记录的日期对象
        Date d = now.getTime();
        System.out.println(d);

        // 4. 拿到时间毫秒值
        long time = now.getTimeInMillis();
        System.out.println(time);

        // 5. 修改日历中的某个信息
        now.set(Calendar.DAY_OF_YEAR, 100);  // 修改月份为10月份
        System.out.println(now);
    }
}

问题：修改了之后其他参数没变，按道理应该会发生相应的变化？？？？

12. JDK8新增的日期、时间

区别：

JDK8之前：

  • 设计不合理、使用不方便、很多被淘汰
  • 都是可变对象，修改后会丢失最开始的时间信息
  • 线程不安全
  • 只能精确到毫秒

JDK8之后：

  • 设计更合理、功能丰富、使用更方便
  • 都是不可变对象，修改后返回新的时间对象，不会丢失最开始的时间
  • 线程安全
  • 能精确到毫秒、纳秒

代替Calendar

12.1 LocalDate：年、月、日

12.2 LocalTime：时、分、秒

12.3 LocalDateTime：年、月、日 时、分、秒

  • public LocalDate toLocalDate()
  • public LocalTime toLocalTime()
  • public static LocalDateTime of(LocalDate date, LocalTime time)

类名 对象名 = 类名.now()——>得到对象

LocalDate

public class Test1_LocalDate {
    public static void main(String[] args) {
        LocalDate ld = LocalDate.now();
        System.out.println(ld);

        // 获取日期对象中的信息  get开头
        int year = ld.getYear();  // 年
        int mouth = ld.getMonthValue();  // 月1-12
        int day = ld.getDayOfMonth();  // 日
        int dayOfYear = ld.getDayOfYear(); // 一年中的第几天
        int dayOfWeek = ld.getDayOfWeek().getValue(); // 星期几

        // 修改某个信息  with开头
        LocalDate ld2 = LocalDate.now();
        ld2 = ld.withYear(2099);
        System.out.println(ld);  // 2023-12-12
        System.out.println(ld2);  // 2099-12-12

        // 把某个信息加多少 plus开头
        LocalDate ld3 = LocalDate.now();
        ld3 = ld2.plusMonths(1);

        // 把某个信息减多少 minus开头

        // 获取指定日期的LocalDate对象 public static LocalDate of(int year, int month, int dayOfMonth)
        LocalDate ld4 = LocalDate.of(2099, 12, 13);
        System.out.println(ld4);

        // 判断两个日期对象是否相等，在前还是在后：equals、isBefore、isAfter
        System.out.println(ld.equals(ld2));
    }
}

12.4 ZoneId：时区

ZoneId：代表时区ID

世界标准时间（UTC）

中国标准时间：UTC+8

类型：

洲名/城市名：Asia/Shanghai

国家名/城市名：Americal/New_York

ZoneId是一个抽象类，调用ZoneId.systemDefault();

12.5 ZonedDateTime：带时区的时间

import java.time.Clock;
import java.time.ZoneId;
import java.time.ZonedDateTime;

public class Test4_ZoneId_ZoneIDDateTime {
    public static void main(String[] args) {
        // 获取系统默认时区
        ZoneId zoneId = ZoneId.systemDefault();
        System.out.println(zoneId);
        System.out.println(zoneId.getId());

        // Java支持的全部时区ID——类方法
        System.out.println(ZoneId.getAvailableZoneIds());

        // 把某个时区ID封装成ZoneID对象
        ZoneId zoneId1 = ZoneId.of("America/New_York");

        // 获取带时区的时间
        ZonedDateTime now = ZonedDateTime.now(zoneId1);
        System.out.println(now);

        // 获得UTC
        ZonedDateTime now1 = ZonedDateTime.now(Clock.systemUTC());
        System.out.println(now1);

        // 获得系统默认时区的时间
        ZonedDateTime now2 = ZonedDateTime.now();
        System.out.println(now2);

    }
}

代替Date

12.6 Instant：时间戳/时间线

代替SimpleDateFormat

可以精确到纳秒级。可以用来记录代码的执行时间，或者用于记录用户操作某个事件的时间点。

public class Test5_Instant {
    public static void main(String[] args) {
        // 创建
        Instant now = Instant.now();
        System.out.println(now);

        // 获取总秒数
        long second = now.getEpochSecond();
        System.out.println(second);

        // 获取不够1秒的纳秒数
        int nano = now.getNano();
        System.out.println(nano);
    }
}

12.7 DateTimeFormatter：用于时间的格式化和解析

其他补充SimpleDateFormat线程不安全

public class Test_DateTimeFormatter {
    public static void main(String[] args) {
        // 创建一个日期时间格式化器对象
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");

        // 对时间进行格式化
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);

        String rs = formatter.format(now);
        System.out.println(rs);
    }
}

12.8 Duration：时间间隔(时、分、秒、纳秒)

public class Test {
    public static void main(String[] args) {
        LocalDateTime start = LocalDateTime.of(2025, 11, 11, 11, 10, 10);
        LocalDateTime end = LocalDateTime.of(2025, 11, 11, 11, 11, 11);

        // 得到Duration对象
        Duration duration = Duration.between(start,end);

        // 获取间隔信息
        System.out.println(duration.toDays());
        System.out.println(duration.toHours());
    }
}

12.9 Period：时间间隔(年、月、日)

倒计时相关的需求

计算两个LocalDate对象相差的年数、月数、天数

public class Test8_Duration {
    public static void main(String[] args) {
        LocalDate start = LocalDate.of(2029, 8, 10);
        LocalDate end = LocalDate.of(2029, 8, 15);

        // 创建Period对象，封装两个日期对象
        Period period = Period.between(start, end);

        // 获取时间差
        System.out.println(period.getYears());
        System.out.println(period.getMonths());
        System.out.println(period.getDays());
    }
}

13. Arrays类

概念： 用来操作数组的工具类

public class ArraysTest1 {
    public static void main(String[] args) {
        // toString()返回数组的内容
        int[] arr = {10, 20, 30, 40, 50};
        System.out.println(Arrays.toString(arr));

        // copyOfRange(数组， 起始索引，结束索引)——包前不包后
        int[] arr1 = Arrays.copyOfRange(arr, 0, 3);
        System.out.println(Arrays.toString(arr1));

        // copyOf(数组, 新数组的长度)，长度可以比新数组长，也可以比新数组短
        int[] arr2 = Arrays.copyOf(arr, 10);
        System.out.println(Arrays.toString(arr2));

        // 把数组中的元数据改为新数据又存进去setAll(double[] array, IntToDoubleFunction generator)
        double[] prices = {99.8, 128, 100};
        Arrays.setAll(prices, new IntToDoubleFunction() {
            @Override
            public double applyAsDouble(int value) {
                return prices[value] * 0.8;
            }
        });
        System.out.println(Arrays.toString(prices));


        // 对数组进行排序（默认是升序排序）
        Arrays.sort(prices);
        System.out.println(Arrays.toString(prices));

    }
}

如果数组中存储的是对象，应该如何进行排序？

在类中使用Comparable接口，重写compareTo()方法

public static void sort(T[] arr, Comparator<? duper T> c)

自定义排序规则时，需要遵循的官方约定：

  • 如果认为左边对象 大于 右边对象 应该返回正整数
  • 如果认为左边对象 小于 右边对象 应该返回负整数
  • 如果认为左边对象 等于 右边对象 应该返回0整数

14. 正则表达式

概念： 由一些特定的字符组成，代表的是一个规则——更简单，更便捷

作用：

  • 用来校验数据格式是否合法
  • 在一段文本中查找满足要求的内容
  • 用于搜索替换、分割内容

案例：

public class RegexTest1 {
    public static void main(String[] args) {
        // 需求：校验QQ号码是否正确，要求全部都是数字，长度是6-20之间，不能以0开头
        System.out.println(check(null));
        System.out.println(check("28256"));
        System.out.println(check("2825625257"));
        System.out.println(check("02825625257"));
        System.out.println(check("a2825625257"));

    }
    public static boolean check(String qq) {
        return qq != null && qq.matches("[1-9]\\d{5,19}");
    }
}

String匹配正则表达式的规则：

在这里插入图片描述

[内容]——只能用于匹配单个字符

.——可以匹配任意字符

在Java中，\由特殊用途，会把后面的一起当整体看，所以如果是\，转义回去

\\d

(?i)——忽略大小写：“abc”.matches(“(?i)abc”)

|——或

()——分组：括号内的内容出现一次或两次，可以加数量词

利用正则表达式查找内容：

  • 定义爬取规则，String类型
  • 把正则表达式封装成Pattern对象
  • 通过Pattern对象获取查找内容的匹配器对象
  • 用匹配器对象在数据中不断寻找
String regex = "(1[3-9]\ \d{9})|(\\w{2,}@\\w{2,20}(\ \.\\w{2,20}){1,2})"

Pattern pattern = Pattern.compile(regex);

Matcher matcher = pattern.matcher(data);

if (matcher.find()) {

	String s = matcher.group();

}

利用正则表达式替换、分割内容：

public class RegexTest2 {
    public static void main(String[] args) {
        // 去掉字符串中重复的字
        String s1 = "我我我喜喜喜喜欢编程程程程";
        System.out.println(s1.replaceAll("(.)\\1+", "$1"));  // 我喜欢编程
        System.out.println(s1);  // 我我我喜喜喜喜欢编程程程程

        String s2 = "古力娜扎aa888马儿扎哈bb222迪丽热巴";
        String[] s = s2.split("\\w+");
        System.out.println(Arrays.toString(s));

    }
}

15. 异常

异常就是代表程序出现的问题

异常的体系：

  1. 异常的祖宗类：Java.lang.Throwable
  2. 直接子类：
  • Error——系统级别的错误，面向的是sun公司，不是面向程序员的
  • Exception——异常，程序可能出现的问题，通常用Exception以及它的孩子来封装程序出现的问题

Exception分类：

  • 运行时异常： 运行时才会出现的异常
  • 编译时异常： 编译阶段就会出现错误提醒
public class ExceptionTest1 {
    public static void main(String[] args) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//        try {
            Date d = sdf.parse("2020-11-22 10:12");
//        } catch (ParseException e) {
//            e.printStackTrace();
//        }
    }
}

自定义异常：

try——内部存放程序运行的代码

catch——可以输出信息，也可以进行修复操作

throws——不建议抛具体的异常，全部用Exception；运行时才抛出的异常不用throws

自己定义的异常类要继承RuntimeException

异常处理：

开发中处理方式：

  • 捕获异常，记录异常并响应合适的信息给用户
  • 捕获异常，尝试重新修复
小鱼0135
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java开发指南——Servlet和JSP篇
02-17
Java在Web应用程序开发方面的巨大潜力已日趋明显，其具有多线程执行，内存管理，面向对象性和强大的...本书首先介绍Servlet API，JSP API基础知识，接着讲解如何进行对话跟踪盒调试，以及XML盒使用企业JavaBeans……
学通Java的24堂课
01-17
第1部分 基础篇 第1堂课 java概述 3 视频讲解：31分钟 1.1 java简介 4 1.1.1 java发展历史 4 1.1.2 java的几个版本 5 1.1.3 java应用领域 6 1.1.4 java项目成功案例 6 1.1.5 怎样学好java 8 1.2 环境搭建 8...
Java2游戏编程.pdf
01-31
第1篇 步入Java丛林：从Java2 API开始 第1章 Java2软件开发工具包 1.1 Java简史 1.2 为什么在游戏中使用Java 1.3 为Java准备系统 1.3.1 安装Java SDK 1.3.2 编译和运行Java程序 1.3.3 使用命令行 1.3.4 使用集成开发...
Java典型模块
02-25
第1篇 Java开发必备基础 第1章 搭建Java开发环境 1.1 Java的过去、现在和未来 1.1.1 Java的历史 1.1.2 Java的语言特点 1.1.3 Java API简介 1.1.4 Java未来发展 1.2 Java程序设计环境 1.2.1 命令行工具——JDK 6.0 ...
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 997
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 794
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 293
【代码】Java手动启动jar包。
java调用cmd执行命令
weixin_45210565的博客
05-28 259
3、exec(String command, String[] envp) ，在调用外部程序之前设置系统环境变量，该变量仅供command入参使用，envp每个元素为一个系统环境变量，并且字符串格式为“环境变量名=环境变量值”。2、exec(String[] cmdArray) ，调用外部程序，入参cmdArray的元素将组合成为一条完整的外部可执行程序的启动路径或命令。1、exec(String command) ，调用外部程序，入参command为外部可执行程序的启动路径或命令。
java多线程创建方式
weixin_57763462的博客
05-28 1076
这种方式是通过创建一个实现了Runnable接口的类，并实现run()方法来创建线程。然后将这个类的对象作为参数传递给Thread类的构造器，并调用Thread对象的start()方法来启动线程。这种方式是通过创建一个实现了Callable接口的类，实现call()方法，并使用FutureTask或者ExecutorService来创建线程。这种方式的优点在于，由于Java不支持多重继承，如果你的类需要继承其他类，那么实现Runnable接口将是唯一的选择。// 在这里定义线程的执行逻辑。
Java面向数据编程1.1版本
极道Jdon的技术博客
05-28 509
虽然将所有这些方法都集中在 Item 上似乎是合理的，因为它们都与购买流程交互，但增加了 predictLowStock（与基于机器学习的预购系统交互）、registerForRecommendations（另一个 ML 系统，这次是物品建议）和 reportPurchase（登记潜在危险物品的购买），让我们怀疑所有这些操作是否真的属于同一个接口。：这是不同上下文场景的方式，放在Item一个类或接口中肯定不对，如同学生借书，将借书这个动作建模在学生这个类或接口一样，借书时一种具体场景。
Redis学习笔记【基础篇】
qq_42192253的博客
05-30 1029
这样以来，我们就可以把不同类型的数据区分开了。从而避免了key的冲突问题。HSET key field value：添加或者修改hash类型key的field的值。获取sorted set 中的指定元素的排名：ZRANK key member。HGET key field：获取一个hash类型key的field的值。通过给key添加前缀加以区分，不过这个前缀不是随便加的，有一定的规范。HMSET：批量添加多个hash类型key的field的值。HMGET：批量获取多个hash类型key的field的值。
C语言基础——数组
2302_80177460的博客
05-27 1067
C语言基础——字符串与数组及部分操作符-CSDN博客），这里再简单说明一下吧。我们都知道，如果我们在C语言中想要创建很多个变量，如果是一个一个创建的话那效率太低下了，这个时候或许会有人想到用循环来搞定，但是我们再细想想，如果用循环来表示的话我们应该把这组数据储存在哪里呢，如果只是创建一个变量的话那么后一次循环会覆盖掉前一次循环，但是如果创建很多个变量的话又不好在循环之中插入，这个时候我们便可以使用我们心心念念的数组啦。我们这一章节就来具体看看数组到底是什么吧。
SpringCloud-OpenFeign
qq_74748121的博客
05-30 563
OpenFeign早期版本（例如要求服务提供方在1秒内处理业务逻辑并返回响应。如果超过1秒没有返回，OpenFeign会直接报错，不会等待服务执行。随着版本的更新，OpenFeign已经对此做出了调整或优化（例如 2021.0.1）。超时报错如下：修改超时时间：1.在远程调用方的 application.yml 中配置，指定某个服务提供方的调用超时时间feign:client:config:product: # 服务名connect-timeout: 5000 # 配置指定服务连接超时时间。
Java入门基础教程-字面量、变量、关键字与标识符
码客笔记
05-27 164
变量是存储数据值的容器，其值可以在程序执行过程中被修改。变量有一个名字（即标识符），并且总是与特定的数据类型相关联。在Java中，变量的声明和初始化是分开的，但也可以同时进行。大家不要被这个词搞晕了，它其实很简单，我们知道计算机是来处理数据的，字面量其实就是告诉程序员数据在程序中的书写格式。所谓标志符其实就是我们自己取的名字。像前面我们取的类名，变量名其实都是标志符。如何识别那些单词是关键字？
【JAVA |String类】JAVA中的String类常见用法详解
YKX0000的博客
05-30 899
在JAVA中的字符串存储是可以直接使用String这个引用数据类型，不像C语言表示字符串只能使用字符数组或者字符指针，使我们操作起来更方便，更符合不符合面相对象的思想。
继承与无参构造器
2301_79842503的博客
05-30 228
在Java中，当你创建一个子类的实例时，如果子类构造函数没有显式地调用父类的构造函数，那么编译器会自动插入一个对父类无参构造函数的调用（如果父类中存在这样的构造函数）。这是Java中构造函数链式调用的一个基本规则，确保父类在子类之前被正确初始化。这个过程是Java中对象初始化的一个重要部分，确保在子类访问或修改从父类继承的任何状态之前，父类已经完成了其自己的初始化。的构造函数内部，你输出了"Student()无参构造器后执行了"，这是在。的构造函数执行之后发生的。的构造函数执行之前，编译器会自动先调用。
Servlet搭建博客系统
Smarmot的博客
05-31 635
现在我们可以使用Servlet来搭建一个动态(前后端可以交互)的博客系统.(使用Hexo只能实现一个纯静态的网页,即只能在后台自己上传博客)
Java实现AES，DES，RSA加密
编写博客，学习交流
05-29 414
这个标准用来替代原先的DES,AES加密过程涉及到4种操作，分别是字节替代、行移位、列混淆和轮密钥加。解密过程分别为对应的逆操作。由于每一步操作都是可逆的，按照相反的顺序进行解密即可恢复明文。加解密中每轮的密钥分别由初始密钥扩展得到。算法中16个字节的明文、密文和轮密钥都以一个4x4的矩阵表示。
java项目启动报错
Januea的博客
05-28 279
java项目启动报错
groovy 字符串截取最后一个_Java基础篇——字符串详解
06-03
def str = "Java_基础篇——字符串详解" def lastIndex = str.lastIndexOf("_") def result = str.getAt(lastIndex+1..-1) println result ``` 输出结果为： ``` 字符串详解 ``` 这段代码首先使用 lastIndexOf() ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值