一些常用类

7 9 9

已于 2023-08-03 18:04:35 修改

阅读量72

点赞数

分类专栏： java 文章标签： java 开发语言

于 2023-08-02 19:54:05 首次发布

本文链接：https://blog.csdn.net/quzhiyuan9/article/details/131773790

版权

java 专栏收录该内容

23 篇文章 1 订阅

订阅专栏

1. 静态方法和实例方法，实例变量

1.实例变量
实例变量是定义在类中的变量，在每个类的实例（对象）中都存在一份。它们用于存储对象的状态和属性。实例变量通常使用访问修饰符进行访问控制，可以被类中的任何方法访问和修改。

2.实例方法（Instance Methods）：

实例方法属于类的实例（对象）。
它必须通过类的实例进行调用。
实例方法可以访问和修改实例变量以及调用其他实例方法。
实例方法通常用于操作和处理类的实例的特定属性和行为。

静态方法

静态方法属于类本身，而不是类的实例。
它可以通过类名直接调用，而不需要创建类的实例。
静态方法不能访问实例变量，只能访问静态变量。
静态方法通常用于执行与类相关的操作，例如计算或工具方法，这些方法独立于类的实例。
在静态方法中，不能使用this关键字。

在这里插入图片描述
总结：
静态方法是属于类本身的方法，通过类名直接调用，不能访问实例变量。而实例方法则是属于类的实例的方法，需要通过类的实例进行调用，可以访问实例变量和其他实例方法。
这里就涉及到了封装

2.Integer 包装类

Integer是Java的一个包装类，用于操作基本数据类型int的对象表示。Integer类提供了许多有用的方法来处理整数，例如进行数值转换、比较和运算等。

以下是一些常用的Integer类的方法：

1.parseInt(String s)：将字符串参数s解析为一个有符号的十进制整数，并返回对应的int值。

String str = "123";
int num = Integer.parseInt(str); // num的值为123

2.toString(int i)：返回指定整数i的字符串表示。

int num = 456;
String str = Integer.toString(num); // str的值为"456"

3.valueOf(int i)：返回一个表示指定int值的Integer实例。

int num = 789;
Integer integer = Integer.valueOf(num);// 输出789

4.compareTo(Integer anotherInteger)：比较调用对象与另一个Integer对象的值。

Integer num1 = 100;
Integer num2 = 200;
int result = num1.compareTo(num2); // 如果num1小于num2，result为负数；如果相等，result为0；如果大于，result为正数

5.intValue()：以int类型返回此Integer对象的值。

Integer number = 123;
int value = number.intValue(); // value的值为123

请注意，Integer是一个不可变类，对其进行修改会创建一个新的Integer对象。如果需要频繁地进行整数操作，建议使用原始的int数据类型。

我们通常需要引用包装类Integer的情况有以下几种：

1.在使用集合框架时，集合类（如List、Set、Map）只能存储对象类型而不能直接存储基本数据类型。因此，如果要将一个整数添加到集合中，就需要使用Integer类将其包装起来，例如：

List<Integer> numbers = new ArrayList<>();
numbers.add(10);  // 自动装箱，将基本类型int转换为包装类Integer

2.在需要将整数作为方法参数或返回值时，由于方法参数和返回值只能是对象，因此需要使用Integer类进行包装和拆包操作，例如：

public Integer add(Integer a, Integer b) {
    return a + b;  // 自动拆箱和装箱，将Integer对象转换为int进行计算，并将结果再封装为Integer对象返回
}

3.在需要通过引用传递整数值时，Java是按值传递的，但通过将整数包装在Integer对象中，可以实现对整数值的引用传递，例如：

void modifyValue(Integer number) {
    number++;  // 自动拆箱、递增操作、自动装箱
}

Integer num = 5;
modifyValue(num);
System.out.println(num);  // 输出6，因为整数值被引用传递并修改了

4.在需要使用Integer类提供的一些便利方法时，例如进行整数的解析、字符串转换等操作。

3.String 类

String类：代表字符串。 Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。
String是一个final类，代表不可变的字符序列。
字符串是常量，用双引号引起来表示。它们的值在创建之后不能更改。
String对象的字符内容是存储在一个字符数组value[]中的。

String 的内存结构

其字符串常量池也就是一个数组value,数组每个元素是一个链表,链表每个节点有三个域:
一个域存放字符串对象地址 ,一个域存放字符串对象的hash值 ,一个域存放下一个节点的地址

但是这个value是final修饰的再创建新的String对象还会生成新的value

请添加图片描述
当执行 new String(“abc”) 时，在堆（Heap）中和方法区（Method Area）中会发生以下变化：

1.堆中：在堆中会创建一个新的 String 对象。这个对象包含了一个名为 value 的字符数组，用于存储字符串的字符序列。对于 “abc” 这个字符串，会在堆中分配一个新的字符数组并将其初始化为 “abc” 的字符序列。String 对象本身保存了对堆中字符数组的引用。

2.方法区中：在方法区中，字符串常量池（String Pool）会存储字符串字面量。当执行 new String(“abc”) 时，首先会在字符串常量池中检查是否已经存在值为 “abc” 的字符串对象。如果不存在，就会在字符串常量池中创建一个新的字符串对象，并将其引用存储在堆中的 String 对象中。如果已经存在，则直接使用已有的字符串对象的引用。

总结起来，执行 new String(“abc”) 会在堆中创建一个新的字符串对象，并在方法区的字符串常量池中进行查找和创建，以确保字符串的唯一性。

在Java中，可以使用 String.intern() 方法将一个 String 对象与常量池中的字符串进行比较，并返回 true。

常用方法

nt length()：返回字符串的长度： return value.length
char charAt(int index)：返回某索引处的字符return value[index]
boolean isEmpty()：判断是否是空字符串： return value.length == 0
String toLowerCase()：使用默认语言环境，将 String 中的所有字符转换为小写
String toUpperCase()：使用默认语言环境，将 String 中的所有字符转换为大写
String trim()：返回字符串的副本，忽略前导空白和尾部空白
boolean equals(Object obj)：比较字符串的内容是否相同
boolean equalsIgnoreCase(String anotherString)：与equals方法类似，忽略大小写
String concat(String str)：将指定字符串连接到此字符串的结尾。等价于用“+”
int compareTo(String anotherString)：比较两个字符串的大小
String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列时，返回 true
int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引
int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引
int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索注： indexOf和lastIndexOf方法如果未找到都是返回-1
boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束
boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始
boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始
String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
String replace(CharSequence target, CharSequence replacement)：使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
String replaceAll(String regex, String replacement) ：使用给定的replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
String replaceFirst(String regex, String replacement) ：使用给定的replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。
String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。
String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。

StringBuffer和StringBuilder

可以解决String拼接的性能问题
可以扩容value数组

常用方法

StringBuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接
StringBuffer delete(int start,int end)：删除指定位置的内容
StringBuffer replace(int start, int end, String str)：把[start,end)位置替换为str
StringBuffer insert(int offset, xxx)：在指定位置插入xxx
StringBuffer reverse() ：把当前字符序列逆转 public int indexOf(String str)
public String substring(int start,int end)
public int length()
public char charAt(int n )
public void setCharAt(int n ,char ch)

StringBuffer和StringBuilder比较

StringBuilder 和 StringBuffer 非常类似，均代表可变的字符序列，而且提供相关功能的方法也一样
面试题：对比String、 StringBuffer、 StringBuilder
- String(JDK1.0)：不可变字符序列 final value[]
- StringBuffer(JDK1.0)：可变字符序列、效率低、线程安全
- StringBuilder(JDK 5.0)：可变字符序列、效率高、线程不安全

请添加图片描述

日期时间类

传统日期时间处理

1.System.currentTimeMillis()：时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数

Date

表示特定的瞬间，精确到毫秒，注意这个类包括上下文（时区）

构造器：
- Date()：使用无参构造器创建的对象可以获取本地当前时间。
- Date(long date) 构造函数创建一个 Date 对象，表示从格林威治时间（1970 年 1 月 1 日 00:00:00 GMT）开始算起的指定毫秒数的时间点。
常用方法
- getTime():返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
- toString():把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue,Wed, Thu, Fri, Sat)， zzz是时间标准。
- 其它很多方法都过时了。

SimpleDateFormat

在这里插入图片描述

Date类的API不易于国际化，大部分被废弃了， java.text.SimpleDateFormat类是一个不与语言环境有关的方式来格式化和解析日期的具体类。
它允许进行格式化：日期 -> 文本、解析：文本 -> 日期
格式化：
- SimpleDateFormat() ：默认的模式和语言环境创建对象
- public SimpleDateFormat(String pattern)：该构造方法可以用参数pattern指定的格式创建一个对象
- public String format(Date date)：方法格式化时间对象date
解析：
- public Date parse(String source)：从给定字符串的开始解析文本，以生成一个日期。

    @Test
    public void test2() throws ParseException {
        Date date1 = new Date();
        System.out.println(date1);

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

        System.out.println(sdf.format(date1));

        String dateStr = "1970-01-1 08:0:0.0";
        Date date2 = sdf.parse(dateStr);
        //打印时间戳
        System.out.println(date2.getTime());


        String dateStr3 = "1970年01月1日";
        SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy年MM月dd日");
        Date date3 = sdf3.parse(dateStr3);
        //打印时间戳
        System.out.println(date3.getTime());

    }

Calander

场景：
- 比如得到一个日期的5个月后的时间
- 指定的年月日，时分秒对应的时间
- 得到一个时间的年，月，日，时分秒
Calendar是一个抽象基类，主用用于完成日期字段之间相互操作的功能。
获取Calendar实例的方法
- 使用Calendar.getInstance()方法
- 调用它的子类GregorianCalendar的构造器。
一个Calendar的实例是系统时间的抽象表示，通过get(int field)方法来取得想要的时间信息。比如YEAR、 MONTH、 DAY_OF_WEEK、 HOUR_OF_DAY 、MINUTE、 SECOND
- public void set(int field,int value)
- public void add(int field,int amount)
- public final Date getTime()
- public final void setTime(Date date)
注意:
- 获取月份时：一月是0，二月是1，以此类推， 12月是11
- 获取星期时：周日是1，周一是2 ，。。。。周六是7

    @Test
    public void test3() throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

        //产生
        Calendar c = Calendar.getInstance(); //当前时间new Date()

        //得到field
        System.out.println(c.get(Calendar.YEAR)); //得到年
        System.out.println(c.get(Calendar.MONTH)); //得到月 传统日期月从0开始，周从周日=1开始
        System.out.println(c.get(Calendar.DAY_OF_MONTH));
        System.out.println(c.get(Calendar.HOUR_OF_DAY));

        //设置field
        c.set(Calendar.MONTH, 0); //传统日期月从0开始
        System.out.println(sdf.format(c.getTime()));//得到date

        //减3个月
        c.add(Calendar.MONTH, -3);
        System.out.println(sdf.format(c.getTime()));//得到date


        //创建1970-1-1 8:0:0.0时间
        //方式1：
        String dateStr = "1970-01-1 08:0:0.0";
        //把字符串解析成日期,string->date
        Date date1 = sdf.parse(dateStr);
        System.out.println(date1.getTime());

        //方式2
        Calendar c2 = Calendar.getInstance();
        c2.set(1970, 0, 1,8,0,0);
        c2.set(Calendar.MILLISECOND, 0);
        System.out.println(sdf.format(c2.getTime()));


        //当前时间的4周后
        Calendar c3 = Calendar.getInstance(); //当前时间
        c3.add(Calendar.WEEK_OF_YEAR, 5);
        System.out.println(sdf.format(c3.getTime()));

    }

JDK8新日期API

Java 8中引入的java.time API 已经纠正了过去的缺陷，将来很长一段时间内它都会为我们服务。
Java 8 吸收了 Joda-Time 的精华，以一个新的开始为 Java 创建优秀的 API。新的 java.time 中包含了所有关于本地日期（LocalDate）、本地时间（LocalTime）、本地日期时间（LocalDateTime）、时区（ZonedDateTime）和持续时间（Duration）的类。历史悠久的 Date 类新增了 toInstant() 方法，用于把 Date 转换成新的表示形式。这些新增的本地化时间日期 API 大大简化了日期时间和本地化的管理。

java.time – 包含值对象的基础包
java.time.chrono – 提供对不同的日历系统的访问
java.time.format – 格式化和解析时间和日期
java.time.temporal – 包括底层框架和扩展特性
java.time.zone – 包含时区支持的类

LocalDateTime

LocalDate、 LocalTime、 LocalDateTime 类是其中较重要的几个类，它们的实例是不可变的对象，分别表示使用 ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的本地日期或时间，并不包含当前的时间信息，也不包含与时区相关的信息。

LocalDate代表IOS格式（yyyy-MM-dd）的日期,可以存储生日、纪念日等日期。
LocalTime表示一个时间，而不是日期。
LocalDateTime是用来表示日期和时间的，这是一个最常用的类之一。

方法	方法描述
now() / * now(ZoneId zone)	静态方法，根据当前时间创建对象/指定时区的对象
of()	静态方法，根据指定日期/时间创建对象
getDayOfMonth()/getDayOfYear()	获得月份天数(1-31) /获得年份天数(1-366)
getDayOfWeek()	获得星期几(返回一个 DayOfWeek 枚举值)
getMonth()	获得月份, 返回一个 Month 枚举值
getMonthValue() / getYear()	获得月份(1-12) /获得年份
getHour()/getMinute()/getSecond()	获得当前对象对应的小时、分钟、秒
withDayOfMonth()/withDayOfYear()/ withMonth()/withYear()	将月份天数、年份天数、月份、年份修改为指定的值并返回新的对象
plusDays(), plusWeeks(), plusMonths(), plusYears(),plusHours()	向当前对象添加几天、几周、几个月、几年、几小时
minusMonths() / minusWeeks()/ minusDays()/minusYears()/minusHours()	从当前对象减去几月、几周、几天、几年、几小时

Instant

Instant：时间线上的一个瞬时点。这可能被用来记录应用程序中的事件时间戳。
在处理时间和日期的时候，我们通常会想到年,月,日,时,分,秒。然而，这只是时间的一个模型，是面向人类的。第二种通用模型是面向机器的，或者说是连续的。在此模型中，时间线中的一个点表示为一个很大的数，这有利于计算机处理。在UNIX中，这个数从1970年开始，以秒为的单位；同样的，在Java中，也是从1970年开始，但以毫秒为单位。
java.time包通过值类型Instant提供机器视图，不提供处理人类意义上的时间单位。 Instant表示时间线上的一点，而不需要任何上下文信息，例如，时区。概念上讲，它只是简单的表示自1970年1月1日0时0分0秒（ UTC）开始的秒数。因为java.time包是基于纳秒计算的，所以Instant的精度可以达到纳秒级。
(1 ns = 10-9 s) 1秒 = 1000毫秒 =10^6微秒=109纳秒

1.获取当前时间的 Instant 对象：

Instant now = Instant.now();

上述代码将返回当前系统时间的 Instant 对象。

2.解析字符串为 Instant 对象：

String timestamp = "2023-08-02T11:33:49Z";
Instant instant = Instant.parse(timestamp);

上述代码将一个符合 ISO 8601 格式的时间戳字符串解析为对应的 Instant 对象。

3.使用指定的时间戳创建 Instant 对象：

Instant instant = Instant.ofEpochMilli(1627868629000L);

上述代码将使用给定的毫秒数创建对应的 Instant 对象。

4.进行日期和时间的计算和比较：

Instant instant = Instant.now();
Instant later = instant.plusSeconds(60); // 加 60 秒
Instant earlier = instant.minus(Duration.ofMinutes(30)); // 减去 30 分钟

boolean isAfter = instant.isAfter(later); // 判断 instant 是否在 later 之后
boolean isBefore = instant.isBefore(earlier); // 判断 instant 是否在 earlier 之前

Duration duration = Duration.between(instant, later); // 计算两个 Instant 之间的时间差
long seconds = duration.getSeconds(); // 获取时间差的秒数
上述代码演示了如何使用 Instant 进行日期和时间的加减、比较以及计算时间差等操作。

需要注意的是，Instant 是基于 UTC（协调世界时）的时间表示，不包含时区信息。如果需要考虑时区，可以使用 ZonedDateTime 类。

DateTimeFormatter

DateTimeFormatter 是 Java 8 引入的日期和时间 API (java.time.format 包) 中的一个类，用于将日期和时间对象格式化为字符串，或者将字符串解析为日期和时间对象。

DateTimeFormatter 提供了一种灵活且线程安全的方式来定义日期时间的格式。你可以使用它来指定自定义的日期时间格式，例如年份、月份、日期、小时、分钟、秒等。

下面是一些使用 DateTimeFormatter 的示例：

1.格式化日期时间对象为字符串：

LocalDateTime dateTime = LocalDateTime.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String formattedDateTime = dateTime.format(formatter);
System.out.println(formattedDateTime);

上述代码将当前的日期时间对象转换为指定格式的字符串，输出类似于 “2023-08-02 11:37:26” 的格式。

2.解析字符串为日期时间对象：

String dateString = "2023-08-02";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
LocalDate date = LocalDate.parse(dateString, formatter);
System.out.println(date);

上述代码将符合指定格式的日期字符串解析为对应的 LocalDate 对象。

3.使用预定义的日期时间格式：

ZonedDateTime dateTime = ZonedDateTime.now();
DateTimeFormatter formatter = DateTimeFormatter.ISO_OFFSET_DATE_TIME;
String formattedDateTime = dateTime.format(formatter);
System.out.println(formattedDateTime);

上述代码使用预定义的 ISO_OFFSET_DATE_TIME 格式来格式化当前的日期时间对象为字符串。

DateTimeFormatter 还支持各种其他格式选项，例如时区的处理、12 小时制和24 小时制等。

这只是一些 DateTimeFormatter 的基本用法示例，你可以根据需要进行更多的定制和配置，以满足特定的日期时间格式化或解析要求。

    @Test
    public void test5() throws ParseException {
        //得到当前时间
        //LocalDateTime：(UTC)日期时间，理解成Date + Calander
        //LocalDate：日期
        //LocalTime：时间
        LocalDateTime l1 = LocalDateTime.now();
        System.out.println("l1 = " + l1);

        //得到field
        System.out.println(l1.getMonth().getValue()); //新时间api，月从1开始
        System.out.println(l1.getYear());
        System.out.println(l1.get(ChronoField.HOUR_OF_DAY)); //时

        //设置field,支持chain方法链,设置1月1日
        LocalDateTime l2 = l1.withMonth(1).withDayOfMonth(1);
        System.out.println(l2);

        //加3个月,加3周
//        l2.plusMonths(3).plus(3, ChronoUnit.WEEKS)
        LocalDateTime l3 = l2.plusMonths(3).plusWeeks(3);
        System.out.println(l3);

        //减3月
        LocalDateTime l4 = l3.minusMonths(3);
        System.out.println(l4);

        //创建1970-1-1 8:0:0.0时间
        LocalDateTime l5 = LocalDateTime.of(1970, 1, 1, 0, 0, 0, 0);
        System.out.println(l5);

        //时间戳操作 Instant
        Instant i1 = l5.toInstant(ZoneOffset.UTC); //得到utc时间的Instant
        System.out.println(i1.toEpochMilli());

//        ZoneOffset.getAvailableZoneIds().forEach(s -> System.out.println(s));

        LocalDateTime l6 = LocalDateTime.of(1970, 1, 1, 8, 0, 0, 0);
        Instant i2 = l6.toInstant(ZoneOffset.ofHours(8)); //得到东8区的Instant
        System.out.println(i2.toEpochMilli()); //utc时间的1970.1.1.0点,北京时间的8点，是时间戳的0

        //格式化
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日HH时mm分ss秒.SSS");
        System.out.println(formatter.format(LocalDateTime.now()));
//        formatter.parse() //解析一个时间

    }

与传统日期类转换

在这里插入图片描述

System类

System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。
由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和成员方法都是static的，所以也可以很方便的进行调用。
成员变量
- System类内部包含in、 out和err三个成员变量，分别代表标准输入流(键盘输入)，标准输出流(显示器)和标准错误输出流(显示器)。
成员方法
- native long currentTimeMillis()：该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。
- void exit(int status)：该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。
- void gc()：该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收，则取决于系统中垃圾回收算法的实现以及系统执行时的情况。
- String getProperty(String key)：该方法的作用是获得系统中属性名为key的属性对应的值。系统中常见的属性名以及属性的作用

Runtime类

addShutdownHook(Thread hook) 方法是Java中 Runtime 类的一个方法，它用于向Java虚拟机注册一个钩子线程（hook thread）。当虚拟机要关闭时，会先执行这个钩子线程，然后再真正关闭。

方法签名如下：

public void addShutdownHook(Thread hook)

参数说明：

hook：要注册的钩子线程。可以通过创建一个Thread对象，并将其传递给此方法。
使用 addShutdownHook() 方法，可以在Java虚拟机关闭之前执行一些操作，比如释放资源、保存数据等。钩子线程在虚拟机关闭时会被启动并运行，虽然不能保证钩子线程的完整执行，但可以作为释放资源和清理操作的一个机会。

需要注意以下几点：

钩子线程应该尽量快速地完成，而不要阻塞或无限期地运行。
注册的钩子线程不能被移除或修改。
如果虚拟机已经在关闭过程中，则尝试添加新的钩子线程将抛出IllegalStateException异常。

BigInteger

Integer类作为int的包装类，能存储的最大整型值为231-1， Long类也是有限的，最大为263-1。如果要表示再大的整数，不管是基本数据类型还是他们的包装类都无能为力，更不用说进行运算了。
java.math包的BigInteger可以表示不可变的任意精度的整数。 BigInteger 提供所有 Java 的基本整数操作符的对应物，并提供java.lang.Math 的所有相关方法。另外， BigInteger 还提供以下运算：模算术、 GCD 计算、质数测试、素数生成、位操作以及一些其他操作。
构造器 BigInteger(String val)：根据字符串构建BigInteger对象
常用方法
- public BigInteger abs()：返回此 BigInteger 的绝对值的 BigInteger。
- BigInteger add(BigInteger val) ：返回其值为 (this + val) 的 BigInteger
- BigInteger subtract(BigInteger val) ：返回其值为 (this - val) 的 BigInteger
- BigInteger multiply(BigInteger val) ：返回其值为 (this * val) 的 BigInteger
- BigInteger divide(BigInteger val) ：返回其值为 (this / val) 的 BigInteger。整数相除只保留整数部分。
- BigInteger remainder(BigInteger val) ：返回其值为 (this % val) 的 BigInteger。
- BigInteger[] divideAndRemainder(BigInteger val)：返回包含 (this / val) 后跟(this % val) 的两个 BigInteger 的数组。
- BigInteger pow(int exponent) ：返回其值为 (thisexponent) 的 BigInteger

public class BigIntegerDemo {

    @Test
    public void test1() {
        System.out.println(Integer.MAX_VALUE);

        Integer i1 = 2147483647;

//        Integer i2 = 2147483648;

        BigInteger i3= new BigInteger("10");
        System.out.println(i3);

        BigInteger i4 = new BigInteger("15");



        BigInteger i5 = i3.add(i4);
        System.out.println(i5);

        BigInteger[] arrs = i3.divideAndRemainder(new BigInteger("3"));

        System.out.println(Arrays.toString(arrs));

    }
}

BigDecimal

一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中，要求数字精度比较高，故用到java.math.BigDecimal类。
BigDecimal类支持不可变的、任意精度的有符号十进制定点数。
构造器
- public BigDecimal(double val)
- public BigDecimal(String val)
常用方法
- public BigDecimal add(BigDecimal augend)
- public BigDecimal subtract(BigDecimal subtrahend)
- public BigDecimal multiply(BigDecimal multiplicand)
- public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)