JAVA基础知识学习笔记——BigInteger、BigDecimal、Arrays、包装类、String

一.BigInteger类

1.1 概述

java.math.BigInteger 类，不可变的任意精度的整数。如果运算中，数据的范围超过了long类型后，可以使用
BigInteger类实现，该类的计算整数是不限制长度的。

1.2 构造方法

BigInteger(String value) 将 BigInteger 的十进制字符串表示形式转换为 BigInteger。超过long类型的范围，已经不能称为数字了，因此构造方法中采用字符串的形式来表示超大整数，将超大整数封装成BigInteger对象。

1.3 成员方法

BigInteger类提供了对很大的整数进行加、减、乘、除的方法，注意：都是与另一个BigInteger对象进行运算。

方法声明	描述
add(BigInteger value)	返回其值为 (this + val) 的 BigInteger，超大整数加法运算
subtract(BigInteger value)	返回其值为 (this - val) 的 BigInteger，超大整数减法运算
multiply(BigInteger value)	返回其值为 (this * val) 的 BigInteger，超大整数乘法运算
divide(BigInteger value)	返回其值为 (this / val) 的 BigInteger，超大整数除法运算，除不尽取整数部分

/*
    java.math.BigInteger类
        不可变的任意精度的整数。可以操作超过long类型的整数
    构造方法:
        BigInteger(String val) 将 BigInteger 的十进制字符串表示形式转换为 BigInteger。
        参数:
            String val:传递一个字符串的整数 "1111111111111111111111111111111111111111111" 不限制长度
    成员方法:
        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。
 */
import java.math.BigInteger;

public class Demo01BigInteger {
    public static void main(String[] args) {
        //创建两个BigIteger对象
        BigInteger b1 = new BigInteger("14865435486468564564564315345");
        BigInteger b2 = new BigInteger("56418974564897987498648674489");

        //加法运算
        BigInteger sum = b1.add(b2);
        System.out.println("两个整数的和是："+ sum);

        //减法运算
        BigInteger sub = b2.subtract(b1);
        System.out.println("两个整数的差是：" + sub);

        //乘法运算
        BigInteger multiply = b1.multiply(b2);
        System.out.println("两个整数相乘是：" + multiply);

        //除法运算
        BigInteger divide = b2.divide(b1);
        System.out.println("两个整数的商是：" + divide);

    }
}
两个整数的和是：71284410051366552063212989834
两个整数的差是：41553539078429422934084359144
两个整数相乘是：838692626607201885582562991108561916110221821574052733705
两个整数的商是：3

二.BigDecimal类

import java.math.BigDecimal;

/*
    java.math.BigDecimal类
        用于浮点数(小数)的精确计算
        以后想进行小数的精确计算,不要使用float和double,使用BigDecimal类
    构造方法:
        BigDecimal(String val) 将 BigDecimal 的字符串表示形式转换为 BigDecimal。
        参数:
            String val:传递一个字符类型的小数  "1.1"
    成员方法:
        加法:BigDecimal add(BigDecimal augend) 返回一个 BigDecimal，其值为 (this + augend)
        减法:BigDecimal subtract(BigDecimal subtrahend) 返回一个 BigDecimal，其值为 (this - subtrahend)，
        乘法:BigDecimal multiply(BigDecimal multiplicand) 返回一个 BigDecimal，其值为 (this × multiplicand)，
        除法:BigDecimal divide(BigDecimal divisor) 返回一个 BigDecimal，其值为 (this / divisor)
                如果无法表示准确的商值（除法除不尽 10/3=3.3333333333333），则抛出 ArithmeticException。
            BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)
                返回一个 BigDecimal，其值为 (this / divisor)，其标度为指定标度。
                参数:
                    参数：
                        divisor - 此 BigDecimal 要除以的值。
                        scale - 保留的小数位数(2,3,4...)  3.33  3.333
                        roundingMode - 要应用的舍入模式。
                            BigDecimal.ROUND_HALF_UP:四舍五入模式  3.66666666==>3.67  3.333333==>3.3
 */

public class Demo02BigDecimal {
    public static void main(String[] args) {
        /*
add(BigDecimal augend)
返回 BigDecimal ，其值是 (this + augend) ，其标为 max(this.scale(), augend.scale()) 。
divide(BigDecimal divisor, int scale, int roundingMode)（第一个参数被除数，第二个参数保留）
返回一个 BigDecimal ，其值为 (this / divisor) ，其比例为指定。


         */
        System.out.println(0.09 + 0.01);//0.09999999999999999
        System.out.println(1.0 - 0.32);//0.6799999999999999
        BigDecimal b1 = new BigDecimal("0.09");
        BigDecimal b2 = new BigDecimal("0.01");

        //加法运算
        BigDecimal sum = b1.add(b2);
        System.out.println(sum);

        //减法运算
        BigDecimal sub = b1.subtract(b2);
        System.out.println(sub);

        //除法运算
        BigDecimal divide = b1.divide(b2);
        System.out.println(divide);

        BigDecimal b3 = new BigDecimal("10");
        BigDecimal b4 = new BigDecimal("3");
//        BigDecimal div2 = b3.divide(b4);//ArithmeticException数学运算异常
        //BigDecimal divide(BigDecimal divisor, int scale(保留小数位),int roundingMode(四舍五入模式))
        BigDecimal div2 = b3.divide(b4,2,BigDecimal.ROUND_HALF_UP);
        System.out.println(div2);

        System.out.println("-------------");

        BigDecimal b5 = new BigDecimal("11");
        BigDecimal b6 = new BigDecimal("3");
        BigDecimal div3 = b5.divide(b6,3,BigDecimal.ROUND_HALF_UP);
    }
}

0.09999999999999999
0.6799999999999999
0.10
0.08
9
3.33
-------------

三.Arrays类

import java.util.Arrays;

/*
    java.util.Arrays:操作数组的工具类
        此类包含用来操作数组（比如排序和搜索）的各种方法。
        Arrays类中的方法都是静态的,可以通过类名.方法名(参数)直接使用
    Arrays类中的成员方法:
         static String toString(Object[] a) 返回指定数组内容的字符串表示形式。
            对数组进行遍历,把数组中的元素组合成一个字符串返回
         static void sort(Object[] a)
            根据元素的自然顺序对指定对象数组按升序进行排序。
 */
public class Demo01Arrays {
    public static void main(String[] args) {
        //定义一个int类型的数组
        int[] arr1 = {1,2,3,7,6,8,5,9,10,4};
        //遍历数组
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]);
        }
        System.out.println("----------------------------------");
        //使用Arrays数组工具类中的方法toString,把数组中的元素组合为字符串返回
        String s = Arrays.toString(arr1);
        System.out.println(s);//[1, 2, 3, 7, 6, 8, 5, 9, 10, 4]

        //使用Arrays数组工具类中的方法sort,对数组中的元素按照自然顺序进行升序排序
        System.out.println("排序前:"+Arrays.toString(arr1));//排序前:[1, 2, 3, 7, 6, 8, 5, 9, 10, 4]
        Arrays.sort(arr1);//升序排序
        System.out.println("排序后:"+Arrays.toString(arr1));//排序后:[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

        System.out.println("------------------------------------");
        String[] arr2 = {"aa","Ab","12","ab","cc","DD"};
        System.out.println("排序前:"+Arrays.toString(arr2));//排序前:[aa, Ab, 12, ab, cc, DD]
        Arrays.sort(arr2);//自然顺序 编码表的顺序(ASCII)
        System.out.println("排序后:"+Arrays.toString(arr2));//排序后:[12, Ab, DD, aa, ab, cc]
        System.out.println("------------------------------------");
        System.out.println('a'+0);//字符是可以直接参与计算的,把字符'a'转换为对应的编码值进行计算 97
        System.out.println('中'+0);//20013
    }
}

四.包装类

1.包装类中装箱和拆箱

package com.itheima.demo04Integer;

/*
    包装类:
        基本数据类型的值(int,double,char,boolean...),使用起来很方便,可以直接使用 10 1.1
        但是没有相关的方法,可以操作这些基本数据类型的值
        所以我们可以使用一个类,把这些基本数据类型的值包裹起来
        在类中定义一些方法,用于操作这些基本数据类型的值
        这个类叫包装类
    基本数据类型:4类8种
        byte    short   int     long    float   double  char        boolean
    基本数据类型对应的包装类: java.lang包
        Byte    Short   Integer Long    Float   Double  Character   Boolean
    java.lang.Integer类:
        Integer 类在对象中包装了一个基本类型 int 的值。
 */
public class Demo01Integer {
    public static void main(String[] args) {
        /*
            装箱:把基本类型的值装到包装类中 int-->Integer
            1.包装类中的构造方法:
                Integer(int value) 传递一个整数
                Integer(String s)  传递字符串类型的整数
            2.包装类中的静态方法:
                static Integer valueOf(int i)  传递一个整数
                static Integer valueOf(String s)  传递字符串类型的整数
            注意:
                两个传递字符串的方法,必须传递整数类型的字符串,否则会抛出异常 "123"  "aaa"
         */
        Integer in1 = new Integer(10);
        System.out.println(in1);//10 不是地址值,重写了Object类的toStirng方法
        Integer in2 = new Integer("10");
        System.out.println(in2);//10
        System.out.println("-------------------------");
        Integer in3 = Integer.valueOf(10);
        System.out.println(in3);//10
        Integer in4 = Integer.valueOf("10");
        System.out.println(in4);//10
        System.out.println("-------------------------");
        //Integer in5 = Integer.valueOf("a");//NumberFormatException(数字格式化异常): For input string: "a"
        Double d1 = Double.valueOf(5.5);
        System.out.println(d1);//5.5
        System.out.println("-------------------------");

        /*
            拆箱:在包装类对象中取出基本类型的值  Integer==>int
            Integer类中的方法
                int intValue()以 int 类型返回该 Integer 的值。
                long longValue() 以 long 类型返回该 Integer 的值。
         */
        int i = in1.intValue();
        System.out.println(i);//10
    }
}

2.自动装箱,自动拆箱(重点)

import java.util.ArrayList;

/*
    装箱:基本类型-->包装类
    拆箱:包装类-->基本类型
    自动装箱和自动拆箱:在JDK1.5以后,装箱和拆箱可以自动进行,不用我们手动转换
 */
public class Demo02Integer {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        //自动装箱:基本数据类型自动转换为Integer类型使用 list.add(1); 相当于 list.add(new Integer(1));
        list.add(new Integer(1));
        list.add(1);

        /*
            自动拆箱:Integer类型的数据直接可以变成int类型使用
            int i = list.get(0); 就相当于 int i = list.get(0).intValue();
         */
        //Integer in = list.get(0);//获取0索引处的元素
        int a = list.get(0).intValue();
        int b = list.get(0); //get方法取出的元素是Integer类型,默认会调用intValue方法,把Integer转换为int
    }
}

3.基本类型与字符串之间的转换(重点,经常使用)

/*
    基本类型与字符串之间的转换(重点,经常使用)
    1.基本数据类型==>字符串
        a.基本数据类型的值+"":工作中最常用  1+""--->"1"
        b.使用包装类Integer中的静态方法toString
            static String toString(int i) 返回一个表示指定整数的 String 对象。
        c.使用String类中的静态方法valueOf
            static String valueOf(int i) 返回 int 参数的字符串表示形式。
    2.字符串类型==>基本数据类型(非常重要)
         在每个包装类中都有一个parseXXX方法,可以把字符串格式的基本类型数据的值,转换为基本数据类型
            Integer类:  static int parseInt(String s)
            Double类:   static double parseDouble(String s)
            ...
         注意:
            1.除了Character类之外，其他所有包装类都具有parseXxx静态方法
            2.字符串必须传递基本数据类型的字符串,否则会抛出数字格式化异常  "100"  "aaa":异常
 */
public class Demo03Integer {
    public static void main(String[] args) {
        //1.基本数据类型==>字符串
        //a.基本数据类型的值+"":工作中最常用  1+""--->"1"
        String s1 = 1+"";
        System.out.println(s1+10);//110 字符连接

        //b.使用包装类Integer中的静态方法toString
        String s2 = Integer.toString(10);
        System.out.println(s2+10);//1010

        //c.使用String类中的静态方法valueOf
        String s3 = String.valueOf(100);
        System.out.println(s3+10);//10010

        //2.字符串类型==>基本数据类型(非常重要)
        int a = Integer.parseInt("100");
        System.out.println(a+100);//200

        double d = Double.parseDouble("1.1");
        System.out.println(d);//1.1

        int abc = Integer.parseInt("abc");//NumberFormatException: For input string: "abc"
    }
}

五.String类

1.String类的构造方法

/*
    java.lang.String类
        String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。
        字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享。
        字符串底层就是一个数组,数组被final修饰,数组的地址值不能改变,所以字符串就是一个常量
        private final char value[];
 */
public class Demo01String {
    public static void main(String[] args) {
        /*
            String类的构造方法:(IO流的时候用到) 扩展知识点,不作为强制掌握,了解即可
            String(String original)
            String(byte[] bytes) 通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
                根据编码表查询字节对应的编码,把字节转换为字符串  97-->a  65-->A
            String(byte[] bytes, int offset, int length)
            String(char[] value)
            String(char[] value, int offset, int count)
         */
        //String(String original)
        String s1 = new String("abc");
        System.out.println("s1:"+s1);//s1:abc

        //String(byte[] bytes) 根据编码表查询字节对应的编码,把字节转换为字符串  97-->a  65-->A
        byte[] bytes = {65,66,67,68,69};
        String s2 = new String(bytes);
        System.out.println("s2:"+s2);//s2:ABCDE

        /*
            String(byte[] bytes, int offset, int length) 把字节数组的一部分转换为字符串
            参数:
                int offset:数组的开始索引
                int length:转换的个数
         */
        //需求:把字节数组中的66和67,转换为字符串
        String s3 = new String(bytes,1,2);
        System.out.println("s3:"+s3);//s3:BC

        //String(char[] value) 把字符数组转换为字符串
        char[] chars = {'我','是','一','个','中','国','人'};
        String s4 = new String(chars);
        System.out.println("s4:"+s4);//s4:我是一个中国人

        //String(char[] value, int offset, int count) 把字符数组的一部分转换为字符串
        String s5 = new String(chars,4,3);
        System.out.println("s5:"+s5);//s5:中国人

        String s6 = "abc"; // 底层 new char[]{'a','b','c'}
        System.out.println("s6:"+s6);//s6:abc

        String s7 = "abc"; // 底层 new char[]{'a','b','c'}
        System.out.println("s7:"+s7);//s6:abc
    }
}

2.String类中常用的成员方法(重点)

import java.util.Arrays;
import java.util.Scanner;

/*
    String类的常用成员方法:
        1.String concat(String str) 将指定字符串连接到此字符串的结尾。 把两个字符串连接到一起,返回一个新的字符串 "a"+"b"="ab"
        2.boolean contains(CharSequence s)  判断字符串中是否包含指定的字符串;包含返回true,不包含返回false
        2.boolean contains(String str)  判断字符串中是否包含指定的字符串;包含返回true,不包含返回false
        3.boolean endsWith(String suffix)  判断字符串是否以指定的字符串而结尾;是返回true,不是返回false
        4.boolean startsWith(String prefix) 判断字符串是否以指定的字符串而开头;是返回true,不是返回false
        5.int indexOf(String str)  从前往后在字符串中查找另外一个字符串,找到了返回字符串对应的索引,找不到返回-1
        6.int lastIndexOf(String str) 从后往前在字符串中查找另外一个字符串,找到了返回字符串对应的索引,找不到返回-1
            注意:
                如果大的字符串有重复的被查找的字符串,找到了第一个就不在找了
                "abcabcabcabcabAAAcabcabcabcabc"==>查找"abc"==>0  从前往后
                "abcabcabcabcabAAAcabcabcabcabc"==>查找"abc"==>24  从后往前
        7.String replace(CharSequence target, CharSequence replacement) 把字符串中所有的目标字符串,替换为新的字符串
        7.String replace(String target, String replacement) 把字符串中所有的目标字符串,替换为新的字符串
        8.String substring(int beginIndex) 从开始索引beginIndex开始截取字符串到字符串的末尾,截取一个新的字符串
        9.String substring(int beginIndex, int endIndex) 从开始索引beginIndex到结束索引endIndex截取字符串;包含头,不包含尾
        10.char[] toCharArray() 将此字符串转换为一个新的字符数组。
        11.byte[] getBytes()  查询系统默认的编码表把字符串转换为字节数组
        12.String toLowerCase()  把字符串中所有的英文字符转换为小写  "ABC123你好"==>"abc123你好"
        13.String toUpperCase()  把字符串中所有的英文字符转换为大写  "abc123你好"==>"ABC123你好"
        14.String trim()  去掉字符串两端的空格  "        abc  adfadsf      wwww      "==>"abc  adfadsf      wwww"
        15.String[] split(String regex)  根据指定的字符串对大的字符串进行切割,把大的字符串切割为多个小字符串,存储到一个数组中

        方法的参数:
            CharSequence s:是一个接口,String实现了CharSequence接口
            所以只要方法的参数是CharSequence接口,就可以直接传递字符串
 */
public class Demo02String {
    public static void main(String[] args) {
        show11();
    }

    /*
        15.String[] split(String regex)  根据指定的字符串对大的字符串进行切割,把大的字符串切割为多个小字符串,存储到一个数组中
     */
    private static void show11() {
        String s = "aa bb cc dd ee";
        String[] arr1 = s.split(" ");//根据空格把字符串切割为5部分,存储到字符串数组中返回
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]);
        }

        String ss = "aa,bb,cc,dd,ee";
        String[] arr2 = ss.split(",");//根据逗号把字符串切割为5部分,存储到字符串数组中返回
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
        String sss = "username=张三,password=1234,age=18,sex=男";
        String[] arr3 = sss.split(",");
        for (int i = 0; i < arr3.length; i++) {
            System.out.println(arr3[i]);
        }
    }

    /*
        判断用户注册的用户名是否存在,在判断时候,一般都会先去掉用户名两端的空格
     */
    private static void show10() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要注册的用户名:");
        String username = sc.nextLine();
        System.out.println(username);

        if("jack".equals(username.trim())){
            System.out.println("您输入的用户名已经被注册!");
        }else{
            System.out.println("您输入的用户名可以使用!");
        }
    }

    /*
        14.String trim()  去掉字符串两端的空格  "        abc  adfadsf      wwww      "==>"abc  adfadsf      wwww"
     */
    private static void show09() {
        String s = "        abc  adfadsf      wwww      ";
        String ss = s.trim();
        System.out.println(ss);//abc  adfadsf      wwww
    }

    /*
        12.String toLowerCase()  把字符串中所有的英文字符转换为小写  "ABC123你好"==>"abc123你好"
        13.String toUpperCase()  把字符串中所有的英文字符转换为大写  "abc123你好"==>"ABC123你好"
     */
    private static void show08() {
        String s = "ABC123你好";
        String s1 = s.toLowerCase();
        System.out.println(s1);//abc123你好

        String s2 = "abc123你好";
        String s3 = s2.toUpperCase();
        System.out.println(s3);//ABC123你好
    }

    /*
        10.char[] toCharArray() 将此字符串转换为一个新的字符数组。
        11.byte[] getBytes()  查询系统默认的编码表把字符串转换为字节数组
     */
    private static void show07() {
        String s = "abcde";
        char[] chars = s.toCharArray();
        System.out.println(Arrays.toString(chars));//[a, b, c, d, e]

        byte[] bytes = s.getBytes();
        System.out.println(Arrays.toString(bytes));//[97, 98, 99, 100, 101]
    }

    /*
        8.String substring(int beginIndex) 从开始索引beginIndex开始截取字符串到字符串的末尾,截取一个新的字符串
        9.String substring(int beginIndex, int endIndex) 从开始索引beginIndex到结束索引endIndex截取字符串;包含头,不包含尾
     */
    private static void show06() {
        String s = "你若安好,便是晴天!";
        //对s进行截取,只要"便是晴天!"
        String sub1 = s.substring(5);
        System.out.println(sub1);//便是晴天!

        String sub2 = s.substring(5, 10);
        System.out.println(sub2);//便是晴天!
    }

    /*
        7.String replace(CharSequence target, CharSequence replacement) 把字符串中所有的目标字符串,替换为新的字符串
        7.String replace(String target, String replacement) 把字符串中所有的目标字符串,替换为新的字符串
        此方法用于过滤关键字
     */
    private static void show05() {
        String s = "abc你好,abc我好,abc大家好,abc才是真的好!";
        //把字符串中的abc替换为@_@
        String r = s.replace("abc", "@_@");
        System.out.println(r);//@_@你好,@_@我好,@_@大家好,@_@才是真的好!
    }

    /*
        5.int indexOf(String str)  从前往后在字符串中查找另外一个字符串,找到了返回字符串对应的索引,找不到返回-1
        6.int lastIndexOf(String str) 从后往前在字符串中查找另外一个字符串,找到了返回字符串对应的索引,找不到返回-1
     */
    private static void show04() {
        String s = "abc你好,abc我好,abc大家好,abc才是真的好!";
        //在字符串s中查找abc
        int index1 = s.indexOf("abc");
        System.out.println("index1:"+index1);//index1:0

        int index2 = s.lastIndexOf("abc");
        System.out.println("index2:"+index2);//index2:19

        System.out.println(s.indexOf("你好"));//3
        System.out.println(s.lastIndexOf("你好"));//3

        System.out.println(s.indexOf("小明"));//-1
        System.out.println(s.lastIndexOf("小明"));//-1
    }

    /*
        3.boolean endsWith(String suffix)  判断字符串是否以指定的字符串而结尾;是返回true,不是返回false
        4.boolean startsWith(String prefix) 判断字符串是否以指定的字符串而开头;是返回true,不是返回false
     */
    private static void show03() {
        String s1 = "Hello.java";
        //判断字符串s1是否是以.java结尾
        boolean b1 = s1.endsWith(".java");
        System.out.println("b1:"+b1);//b1:true

        //判断字符串s1是否是以.class结尾
        boolean b2 = s1.endsWith(".class");
        System.out.println("b2:"+b2);//b2:false

        //判断字符串s1是否是以Hello开头
        boolean b3 = s1.startsWith("Hello");
        System.out.println("b3:"+b3);

        //判断字符串s1是否是以hello开头
        boolean b4 = s1.startsWith("hello");
        System.out.println("b4:"+b4);
    }

    /*
        2.boolean contains(CharSequence s)  判断字符串中是否包含指定的字符串;包含返回true,不包含返回false
        2.boolean contains(String str)  判断字符串中是否包含指定的字符串;包含返回true,不包含返回false
     */
    private static void show02() {
        String s = "你好,我好,大家好,才是真的好!";
        boolean b1 = s.contains("大家好");
        System.out.println("b1:"+b1);//b1:true

        boolean b2 = s.contains("hello");
        System.out.println("b2:"+b2);//b2:false
    }

    /*
        1.String concat(String str) 将指定字符串连接到此字符串的结尾。 把两个字符串连接到一起,返回一个新的字符串 "a"+"b"="ab"
     */
    private static void show01() {
        String s1 = "你好";
        String s2 = "我好";
        String concat = s1.concat(s2);
        System.out.println(concat);//你好我好

        String s3 = s1+s2;
        System.out.println(s3);//你好我好
    }
}