常用API

最新推荐文章于 2022-10-10 15:34:40 发布

这知识不进我脑袋呀

最新推荐文章于 2022-10-10 15:34:40 发布

阅读量301

点赞数 1

分类专栏： java学习笔记文章标签： java

本文链接：https://blog.csdn.net/weixin_43876778/article/details/109690660

版权

java学习笔记专栏收录该内容

17 篇文章 1 订阅

订阅专栏

常用API

一、Object类

1.1 概述

java.lang.Object类是Java语言中的根类，每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。

如果一个类没有特别指定父类，那么默认则继承自Object类。例如：

public class MyClass /*extends Object*/ {
  	// ...
}

1.2 native本地方法

在Object类的源码中定义了native修饰的方法，native修饰的方法称为本地方法。

本地方法的特点：

被native修饰的方法，非Java语言编写，是由C++语言编写。
本地方法在运行时期进入本地方法栈内存，本地方法栈是一块独立内存的区域。
本地方法的意义是和操作系统进行交互。

private static native void registerNatives();
static {
    registerNatives(); //JVM注册在本地的操作系统上
}

当程序运行的时候，Object类会最先被加载到内存中。类进入内存后首先加载自己的静态成员，static代码块中调用了本地方法registerNatives()，和操作系统进行交互。

1.3 toString()方法

方法声明：public String toString()：返回该对象的字符串表示。

Object类toString()方法源码：

public String toString() {
	return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

源码分析：

getClass().getName()返回类的全限定名字。
hashCode()方法返回int值，可以暂时理解为对象的内存地址。
Integer.toHexString()将int类型的值转成十六进制。
因此调用对象的toString()方法将看到内存的地址值。

创建Person类，并调用方法toString()

public static void main(String[] args){
    Person person = new Person();
    String str = person.toString();
    System.out.println(str);
    System.out.println(person);
}

通过程序运行，得到结论，在输出语句中打印对象，就是在调用对象的toString()方法。

toString()方法的重写

由于toString方法返回的结果是内存地址，而在开发中，内存地址并没有实际的应用价值，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。
toString()价值：返回类中的成员变量值

public class Person {  
    private String name;
    private int age;

    @Override
    public String toString() {
        return "Person"+name+":"+age;
    }
    // 省略构造器与Getter Setter
}

1.4 equals方法

方法声明：public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。

Object类equals()方法源码：

public boolean equals(Object obj) {
    return (this == obj);
}

源码分析：

this是当前对象，哪个对象调用的equals方法就表示哪个对象。
obj表述传递的参数，参数类型Object，可以传递任意类型对象。
this==obj 比较两个对象的内存地址是否相同

equals方法默认比较两个对象的内存地址是否相同，相同则返回true。

equals()方法的重写

实际应用中，比较内存地址是否相同并没有意义，我们可以定义对象自己的比较方式，比较对象中成员变量的值是否相同。需要对方法进行重写。

需求:重写equals()方法，比较两个对象中姓名和年龄是否相同，如果姓名和年龄都相同返回true，否则返回false。

public class Person {
    private String name;
    private int age;
    
    public boolean equals(Object obj){
        //判断两个对象地址若相同，即为同一个对象
        if(this == obj)
            return true;
        //obj对象为空，无需比较，返回false
        if(obj == null)
            return  false;
        //判断，obj是不是Perison对象obj如果是Person类型对象，则强制转换
        if(obj instanceof Person){
            //将子类放入obj，类型提升了，而age是子类特有的属性，所以需要强转成子类的类型！(多态)
            Person person = (Person)obj;
            //比较两个对象的name属性和age属性，如果相等，返回true
            return this.name.equals(person.name) && this.age == person.age;
        }
        return false;
    }
}

二、 Date类

java.util.Date类表示特定的瞬间，精确到毫秒。1000毫秒等于1秒。

2.1 Date类构造方法

Date类的构造方法有个特殊用法：该构造方法能输出能获得当前的时间

public Date()：从运行程序的此时此刻到时间原点经历的毫秒值,转换成Date对象，分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。时间跟随操作系统走
- Date对象(日期对象)：即国际规范的时间表示，如Thu Jan 01 08:00:00 CST 1970
public Date(long date)：传入毫秒值，返回该毫秒值所在的日期，其中1970.1.1.0：0：0是Java中的时间原点

public static void main(String[] args) {
	// 创建日期对象，把当前的时间
	System.out.println(new Date()); // Tue Jan 16 14:37:35 CST 2020
	// 创建日期对象，把当前的毫秒值转成日期对象
	System.out.println(new Date(0)); // Thu Jan 01 08:00:00 CST 1970
}

对象输出是具体的时间，说明Date类的toString被重写过。

2.2 Date类的常用方法

public long getTime() 把日期对象转换成对应的时间毫秒值。
public void setTime(long time) 把方法参数给定的毫秒值设置给日期对象。

 public static void main(String[] args) {
     //创建日期对象
     Date date = new Date();
     //public long getTime()获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
     System.out.println(date.getTime());
     //public void setTime(long time):设置时间，给的是毫秒值
     date.setTime(0);
     System.out.println(date);
 }

小结：日期对象(Date)和毫秒值的相互转换

日期是不能进行数学计算的，但是毫秒值可以，在需要对日期进行计算时，可以现将日期转成毫秒值后在进行计算。

日期对象转成毫秒值：
- Date date = new Date(); date.getTime()
- System.currentTimeMillis()
毫秒值转成日期对象：
- Date date = new Date(long 毫秒值)
- date.setTime(long 毫秒值)

三、 DateFormat类（日期格式化）

java.text.DateFormat 是日期/时间格式化子类的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。

格式化：按照指定的格式，把Date对象转换为String对象。
解析：按照指定的格式，把String对象转换为Date对象。

3.1 构造方法

由于DateFormat为抽象类，不能直接使用(不能创建对象)，所以需要常用的子类java.text.SimpleDateFormat。这个类需要一个模式（格式）来指定格式化或解析的标准。构造方法为：无参和有参

无参 public SimpleDateFormat( )：用默认的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
有参 public SimpleDateFormat(String pattern)：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。

参数pattern是一个字符串，代表日期时间的自定义格式。

常用的格式规则为：

标识字母（区分大小写）	含义
y	年
M	月
d	日
H	时
m	分
s	秒

备注：更详细的格式规则，可以参考SimpleDateFormat类的API文档。

3.2 转换方法

格式化：String format(Date date)传递日期对象，返回格式化后的字符串。

解析：Date parse(String str)传递字符串[如"2048-08-09 11:11:11"]，返回日期对象。

需求1：
通过无参构造的方式将国际规范的日期对象，转换成默认语言环境的日期格式
- 通过有参构造的方式将国际规范的日期对象，转换成国人熟悉的我国时间表示方法 [yyyy年MM月dd日 HH点mm分ss秒]

package date;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
    日期格式化：
        Date对象直接输出日期，不方便国人理解

       java.text.DateFormat 日期格式化
       是一个abstract修饰的抽象类，不能创建对象，但是可以创建他的子类对象
       SimpleDateFormat对象

       有子类对象 new SimpleDateFormat().方法()
       1.子类重写的
       2.父类中的非抽象方法

       要求：按照我们的预期去显示时期
       实现步骤：
        1.创建子类对象SimpleDateFormat
               在子类的构造方法中，需要传递格式化后的日期格式！
        2.对象调用方法 format(Date date)
            传递一个日期对象Date，返回一个格式化后的字符串
 */
public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException{
        //无参演示simpleDateFormat()
        //获取日期对象
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat();
        //规范成默认语言环境的日期格式符号
        String format = simpleDateFormat.format(date1);
        System.out.println(format);//20-11-9 下午3:56
      //解析成国际化日期格式
        Date parse = simpleDateFormat.parse("20-11-9 下午3:54");
      System.out.println(parse);//Mon Nov 09 15:54:00 CST 2020

        //有参演示simpleDateFormat(String pattern)
        //定义日期格式的字符串
        String str = "2020-11-7 18:06:30";
        //1.创建子类对象
        //日期格式注意：必须和要转的字符串格式一致，否则转不了
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //对象调用方法parse，传递字符串，返回日期对象
        Date date = sdf.parse(str);//方法有异常
        System.out.println(date);
    }
}

需求2：将输入字符串形式的日期，解析成国际规范的日期对象

package date;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/*
    如果以任意字符串的形式提供日期，如何转成日期对象？ 通过SimpleDateFormat类的对象中的方法parse
    实现步骤：
        1.创建子类对象SimpleDateFormat
               在子类的构造方法中，需要传递格式化后的日期格式！
      2.对象调用方法 parse(String str)
            传递一个字符串形式的日期，返回Date对象
 */
public class SimpleDateFormatDemo02 {
    public static void main(String[] args) throws ParseException {
        //定义日期格式的字符串
        String str = "2020-11-7 18:06:30";
        //1.创建子类对象
        //日期格式注意：必须和要转的字符串格式一致，否则转不了
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //对象调用方法parse，传递字符串，返回日期对象
        Date date = sdf.parse(str);//方法有异常
        System.out.println(date);
    }
}

四、 Calendar日历类

4.1 概念

日历我们都见过

java.util.Calendar是日历类，在Date后出现，替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取。日历类就是方便获取各个时间属性的。

4.2 日历对象获取方式(非构造方法)

Calendar是抽象类，不能创建对象，需要使用子类对象。java.util.GregorianCalendar类是Calendar的子类，但是创建日历对象需要根据本地的时区，语言环境来创建，比较困难，Calendar抽象类提供了静态方法 getInstance()，此方法的返回值直接获取子类的对象。

public static Calendar getInstance()：使用默认时区和语言环境获得一个日历。

Calendar cal = Calendar.getInstance();

4.3 常用方法

public int get(int field)：返回给定日历字段的值。
public void set(int field, int value)：将给定的日历字段设置为给定值。
public abstract void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。
public Date getTime()：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。\

日历字段(field)：日历中包含的内容就是日历字段：年，月，日，时，分，秒… 这些字段在程序中都是int类型

4.4 日历字段

Calendar类中提供很多静态成员，直接类名调用，代表给定的日历字段：

字段值	含义
YEAR	年
MONTH	月（从0开始，可以+1使用）
DAY_OF_MONTH	月中的天（几号）
HOUR	时（12小时制）
HOUR_OF_DAY	时（24小时制）
MINUTE	分
SECOND	秒
DAY_OF_WEEK	周中的天（周几，周日为1，可以-1使用）

代码使用简单演示：

public static void main(String[] args) {
    // 创建Calendar对象
    Calendar cal = Calendar.getInstance();
    // 获取年
    int year = cal.get(Calendar.YEAR);
    //设置年份为2020年
    cal.set(Calendar.YEAR, 2020);
    //将年份修改为2000年
    cal.add(Calendar.YEAR,-20)     
    //将日历对象转换为日期对象
    Date d = cal.getTime();
    System.out.println(d);
}

4.5 Calendar类练习

案例需求

获取任意一年的二月有多少天
案例分析：
- 可以将日历设置到任意年的三月一日
- 向前偏移一天
- 获取偏移后的日历即可
代码实现

public static void main(String[] args) {
    //键盘录入任意的年份
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入年：");
    int year = sc.nextInt();

    //设置日历对象的年、月、日
    Calendar c = Calendar.getInstance();
    c.set(year, 2, 1);

    //3月1日往前推一天，就是2月的最后一天
    c.add(Calendar.DATE, -1);

    //获取这一天输出即可
    int date = c.get(Calendar.DATE);
    System.out.println(year + "年的2月份有" + date + "天");
}

六、 System

6.1 概述

java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作。System类私有修饰构造方法，不能创建对象，直接类名调用。

常用方法

方法名	说明
public static long currentTimeMillis()	返回当前时间(以毫秒为单位)
public static void arrayCopy(Object src, int srcPos, Object dest, int destPos, int length)	从指定源数组中复制一个数组
public static void gc()	运行垃圾回收器。
public static void exit(int status)	终止当前运行的Java虚拟机，非零表示异常终止

6.2 练习：计算耗费时间

在控制台输出1-10000，计算这段代码执行了多少毫秒

/*使用System.currentTimeMillis()方法*/
public static void main(String[] args) {
    //获取当前时间毫秒值
    System.out.println(System.currentTimeMillis()); 
    //计算程序运行时间
    long start = System.currentTimeMillis();
        for (int i = 1; i <= 10000; i++) {
        	System.out.println(i);
        }
    long end = System.currentTimeMillis();
    System.out.println("共耗时毫秒：" + (end - start));
    }

6.3 arrayCopy方法：

Object src：要复制的数据源数组
int srcPost：数据源数组的开始索引
Object dest：复制后的目的数组
int destPos：目的数组开始索引
int length：要复制的数组元素的个数

6.4 练习：数组元素复制

将源数组中从1索引开始，复制3个元素到目的数组中

public static void main(String[] args){
    int[] src = {1,2,3,4,5};
    int[] dest = {6,7,8,9,0};
    //将源数组中从1索引开始，复制3个元素到目的数组中
    System.arraycopy(src,1,dest,0,3);
    for(int i = 0 ; i < dest.length;i++){
    System.out.println(dest[i]); //6,3,4,5,0
}

注意：将源数组内容复制给目标数组的时候，不会改变目标数组长度，如果目标数组长度太小不够源数组复制，会报错
int[] src = new int[]{1,2,3,4,5};
int[] dest = new int[]{6};
System.arraycopy(src,2,dest,1,3); 
//Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException
	at java.lang.System.arraycopy(Native Method)
	at system.SystemDemo.arrayCopyTest(SystemDemo.java:46)
	at system.SystemDemo.main(SystemDemo.java:31)

6.5 gc()方法

运行垃圾回收器，JVM将从堆内存中清理对象，清理对象的同时会调用对象的finalize()方法，JVM的垃圾回收器是通过另一个线程开启的，因此程序中的效果并不明显。

public class Person {
    protected void finalize() throws Throwable {
        System.out.println("对象被回收");
}

public static void main(String[] args){
	new Person();
	new Person();
	new Person();
	new Person();
	new Person();
	new Person();
	System.gc();
}

七、冒泡排序

数组的排序，是将数组中的元素按照大小进行排序，默认都是以升序的形式进行排序，数组排序的方法很多，我们讲解的是数组的冒泡排序。

排序，都要进行数组元素大小的比较，再进行位置的交换。冒泡排序法是采用数组中相邻元素进行比较换位。

7.1 冒泡排序图解

7.2 代码实现

public static void main(String[] args) {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {7, 6, 5, 4, 3};
        System.out.println("排序前：" + arrayToString(arr));
        // 这里减1，是控制每轮比较的次数
        for (int x = 0; x < arr.length - 1; x++) {
            // -1是为了避免索引越界，-x是为了调高比较效率
            for (int i = 0; i < arr.length - 1 - x; i++) {
                if (arr[i] > arr[i + 1]) {
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
        }
        System.out.println("排序后：" + arrayToString(arr));
    }
        //把数组中的元素按照指定的规则组成一个字符串：[元素1, 元素2, ...]
    public static String arrayToString(int[] arr) {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append(", ");
            }
        }
        sb.append("]");
        String s = sb.toString();
        return s;
    }

八、数组的二分查找法

所谓数组的二分查找法，对于一个有序数组，查找一个元素是否存在于数组中，如果存在就返回出现的索引，如果不存在就返回负数。

8.1 二分查找法图解

8.2 代码实现

 public static void main(String[] args) {
        int[] arr = {5,13,19,21,37,56,64,75,80,88,92};
        int key = 21;
        int index = binarySearch(arr, key);
        System.out.println(index);

    }
    public static int binarySearch(int[]arr,int key){
        //最小索引
        int low = 0;
        //最大索引
        int height = arr.length - 1;
        //初始化中间索引
        int mid = 0;
        //循环折半，最小索引小于等于最大索引时，才能折半
        while (low <= height){
            //折半，计算中间索引
            mid = (height + low) / 2;
            if(key > arr[mid]){
                //元素大于数组中间索引元素，移动最小索引
                low = mid + 1;
            }else if(key < arr[mid]){
                //元素小于数组中间索引元素，移动最大索引
                height = mid - 1;
            }else{
                //查询到元素，返回索引
                return mid;
            }
        }
        //循环查找结束后，找不到元素，返回-1
        return - 1;
    }

九、 Arrays

9.1 概述

java.util.Arrays 此类包含用来操作数组的各种方法，比如排序和搜索等。Arrays类私有修饰构造方法，无需创建对象，其所有方法均为静态方法，调用起来非常简单。

9.2 常用方法

方法名	说明
public static void sort(int[] a)	对指定的int数组进行升序排列
public static int binarySearch(int[] a,int key)	对数组进行二分查找法，找不到元素返回(-插入点)-1
public static String toString(int[] a)	将数组转成字符串（相当于遍历数组）

public static void main(String[] args){
	int[] arr = {5,1,9,2,33,18,29,51};
    //数组升序排列
    Arrays.sort(arr); 
    //数组转成字符串
    String arrStr = Arrays.toString(arr);
    System.out.println(arrStr); //[1, 2, 5, 9, 18, 29, 33, 51]
    //数组二分查找
    int index = Arrays.binarySearch(arr,9);
    System.out.println(index);
}

十、正则表达式

正则表达式是对字符串的一种处理技术，String，StringBuilder功能远远不够，所以需要正则表达式处理更加复杂的字符串

正则表达式是对字符串操作的一种规则，事先定义好一些字符串，这些字符串称为规则字符串，使用规则字符串表达一些逻辑功能。

例如：指定一个字符串xxx123@abc.com，判断出这个字符串是否符合电子邮件的规则。使用字符串String对象的方法是可以完成的，但是非常复杂，若使用正则表达式则会非常的简单实现。

API:java.util.regex.Pattern可以查找

10.1 正则规则1-字符类： [ ]一个范围

规则写法	规则含义
[abc]	a、b 或 c（简单类）
[^abc]	任何字符，除了 a、b 或 c（否定）
[a-zA-Z]	a 到 z 或 A到 Z，两头的字母包括在内（范围）
[0-9]	0到9，两头的数字包括在内（范围）
[a-zA-Z0-9]	a 到 z 或 A到 Z或0-9

10.2 正则规则2-预定义字符类

规则写法	规则含义
.	任何字符
\d	数字[0-9]
\D	非数字 `[^0-9]`
\w	单词字符 [a-zA-Z0-9_]
\W	非单词字符`[^a-zA-Z0-9_]`

10.3 正则规则3-数量词

规则写法	规则含义
X?	一次或一次也没有
X*	零次或多次
X+	一次或多次
X{n}	恰好 n 次
X{n,}	至少 n 次
X{n,m}	至少 n 次，但是不超过 m 次

10.4 正则练习-String类matches方法

正则表达式的匹配方法：boolean matches(String regex)传递正则表达式规则，检测字符串是否匹配正则表达式规则，匹配返回true。

需求：检查手机号，检查邮件地址。

分析：

手机号：只能1开头，第二位可以是345678任意一个，第三位开始全数字，总长11位。
邮件地址：@前面可以是数字，字母，下划线。@后面是字母和.。

public static void main(String[] args){
    //验证手机号码
    String tel = "13800138000";
    String telRegex = "1[345678][0-9]{9}";
    boolean flag = tel.matches(telRegex);
    System.out.println(flag);
    //验证邮件地址
    String email = "s_123456@sina.com.cn.";
    String emailRegex = "[a-zA-Z0-9_]+@([a-z]+\\.[a-z]+)+";
    flag = email.matches(emailRegex);
    System.out.println(flag);
}

10.5 正则练习-String类split方法

方法：String[] split(String regex)传递正则表达式规则，根据正则规则对字符串进行切割。

public static void main(String[] args){
    String str1 = "ab  a   bbb  abc   aa      c";
    //对空格进行切割
    String[] strArr =str1.split(" +");
    System.out.println(Arrays.toString(strArr));

    String str2 = "192.168.22.123";
    strArr = str2.split("\\.");
    System.out.println(Arrays.toString(strArr));
}

注意：输出数组元素时会看到存在一个多余空格，Arrays.toString()方法源码中追加的空格。

十一、 Math类

11.1 概述

java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，**私有构造方法，不会创建对象，其所有方法均为静态方法，**调用起来非常简单。

11.2 常用方法

方法名方法名	说明
public static int abs(int a)	返回参数的绝对值
public static double ceil(double a)	向上取整，返回大于或等于参数的最小double值，等于一个整数
public static double floor(double a)	向下取整，返回小于或等于参数的最大double值，等于一个整数
public static int round(float a)	按照四舍五入返回最接近参数的int
public static double pow(double a,double b)	幂运算，a的b次幂
public static double max(double a,double b)	返回两个 `double` 值中较大的一个
public static double min(double a,double b)	返回两个 `double` 值中较小的一个

十二、 BigInteger类

12.1 概述

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

12.2 构造方法

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

传递字符串，必须是数字格式，字符串理论上可以无限

12.3 常用方法

方法名	含义
add(BigInteger value)	返回其值为 `(this + val)` 的 BigInteger，超大整数加法运算
subtract(BigInteger value)	返回其值为 `(this - val)` 的 BigInteger，超大整数减法运算
multiply(BigInteger value)	返回其值为 `(this * val)` 的 BigInteger，超大整数乘法运算
divide(BigInteger value)	返回其值为 `(this / val)` 的 BigInteger，超大整数除法运算，除不尽取整数部分
mod(BigInteger value)	返回其值为 `(this% val`) 的 BigInteger,超大整数的取余运算。

public static void main(String[] args){
    BigInteger big1 = new BigInteger("987654321123456789000");
    BigInteger big2 = new BigInteger("123456789987654321");
    //加法运算
    BigInteger add = big1.add(big2);
    System.out.println("求和:"+add);
    //减法运算
    BigInteger sub = big1.subtract(big2);
    System.out.println("求差:"+sub);
    //乘法运算
    BigInteger mul = big1.multiply(big2);
    System.out.println("乘积:"+mul);
    //除法运算
    BigInteger div = big1.divide(big2);
    System.out.println("除法:"+div);
    //取模运算
    BigInteger mod = big1.mod(big2);
    System.out.println("取模:"+mod);
}

十三、 BigDecimal类

13.1 概述

java.math.BigDecimal类，不可变的、任意精度的有符号十进制数。该类可以实现超大浮点数据的精确运算！

13.2 构造方法

**public BigDecimal(String value)：**将 BigDecimal的十进制字符串表示形式转换为 BigDecimal。

13.3 常用方法

BigDecimal类的加法减法乘法与BigInteger类相同。

13.4 除法计算

BigDecimal类实现精确的浮点数除法运算，如果两个浮点除法计算后是无限循环，那么就会抛出异常。

除法运算方法：

BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)
- divesor：此 BigDecimal 要除以的值。
- scale：保留的位数
- roundingMode：舍入方式
舍入方式：BigDecimal类提供静态的成员变量来表示舍入的方式
- BigDecimal.ROUND_UP 向上加1。
- BigDecimal.ROUND_DOWN 直接舍去。
- BigDecimal.ROUND_HALF_UP 四舍五入。

public static void main(String[] args){
      BigDecimal big1 = new BigDecimal("3.125");
      BigDecimal big2 = new BigDecimal("1.582");
      //加法计算
      BigDecimal add = big1.add(big2);
      System.out.println("求和:"+add);
      //减法计算
      BigDecimal sub = big1.subtract(big2);
      System.out.println("求差:"+sub);
      //乘法计算
      BigDecimal mul = big1.multiply(big2);
      System.out.println("乘法:"+mul);
      //除法计算 循环结果 1.9753476611883691529709228824273
      // 1)四舍五入:BIGDecimal.ROUND_HALF_UP
      BigDecimal div1 = big1.divide(big2,2,BigDecimal.ROUND_HALF_UP);
      System.out.println(div1);//1.98
      // 2)直接舍入：BIGDecimal.ROUND_DOWN
      BigDecimal div2 = b1.divide(b2,2,BigDecimal.ROUND_DOWN);
      System.out.println(div2);//1.97  
      //3)向上进1:BIGDecimal.ROUND_UP
      BigDecimal div3 = b1.divide(b2,2,BigDecimal.ROUND_UP);
      System.out.println(div3);//1.98
 
}

十四、基本类型包装类

14.1 概述

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

基本类型	对应的包装类（位于java.lang包中）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

表格中包装类用法都是一致的，以Integer举例，其他类比

14.2 Integer类构造方法

Integer类概述：包装一个对象中的原始类型 int 的值
构造方法

方法名	说明
public Integer(int value)	根据 int 值创建 Integer 对象(过时)
public Integer(String s)	根据 String 值创建 Integer 对象(过时)

注：实际中，构造方法传入字符串的情况比较多

静态构造方法

方法名	说明
public static Integer valueOf(int i)	返回表示指定的 int 值的 Integer 实例
public static Integer valueOf(String s)	返回一个保存指定值的 Integer 对象 String

注：静态方法valueOf建对象可以简化创建过程，直接静态调用

public static void main(String[] args) {
    //public Integer(int value)：根据 int 值创建 Integer 对象(过时)
    Integer i1 = new Integer(100);
    System.out.println(i1);

    //public Integer(String s)：根据 String 值创建 Integer 对象(过时)
    Integer i2 = new Integer("100");
    //Integer i2 = new Integer("abc"); //NumberFormatException
    System.out.println(i2);
    System.out.println("--------");

    //public static Integer valueOf(int i)：返回表示指定的 int 值的 Integer 实例
    Integer i3 = Integer.valueOf(100);
    System.out.println(i3);

    //public static Integer valueOf(String s)：返回一个保存指定值的Integer对象 String
    Integer i4 = Integer.valueOf("100");
    System.out.println(i4);
}

14.3 Integer类常用方法

修饰/返回值	方法名	说明
static final	`MAX_VALUE`	最大取值范围
static final	`MIN_VALUE`	最小取值范围
static String	`toBinarySting(int 十进制)`	十进制转成二进制
static String	`toOctalSting(int 十进制)`	十进制转成八进制
static String	`toHexlSting(int 十进制)`	十进制转成十六进制
int	`intValue()` 注意这个不是静态的	将Integer对象转成int类型
static Integer	`valueof()`	将int转成Integer对象类型
static int	`parseInt(String str)`	将String转成int类型

注:加粗的在JavaWeb中常用，且后两个都是静态调用的!!其他的方法不太重要

14.4 装箱与拆箱

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：

装箱：从基本类型转换为对应的包装类对象。
拆箱：从包装类对象转换为对应的基本类型。

用Integer与 int为例：（看懂代码即可）

基本数值---->包装对象：静态调用Integer.valueOf(String str)

Integer i = new Integer(4);//使用构造函数函数
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法

包装对象---->基本数值

int num = Integer.parseInt("123");//将"123"转成int类型

14.5 自动装箱与自动拆箱

由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。例如：

//自动装箱，自动转成Integer对象。
//相当于Integer i = Integer.valueOf(4);
Integer i = 4;
//自动拆箱：自动将Integer转成int类型
//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后，再次装箱，把基本数值转成对象。
i = i + 5;

自动装箱、自动拆箱依赖于javac进行编译上的优化

Integer i = 4; 编译器编译为 Integer i = Integer.valueOf(4);

i = i + 5; 编译器编译为Integer.valueOf(i.intValue() + 5);

14.5.1 自动装箱与自动拆箱在集合中的应用

 //集合中只允许添加引用数据类型，不允许存放基本数据类型
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(1); //自动装箱，相当于Integer i = 1；
        int ret = arrayList.get(0);//取出来的元素本应该是Integer类型，但是int类型却可以接收，因为自动拆箱
        System.out.println(ret);

14.5.2装箱拆箱的一个细节

 //装箱的内存问题
Integer a = new Integer(10);
Integer b = new Integer(10);
System.out.println(a==b); //==引用数据类型，比较地址
System.out.println(a.equals(b)); //比较对象中的数据

Integer aa = 200;
Integer bb = 200;
System.out.println(aa==bb); //==引用数据类型，比较地址 false
System.out.println(a.equals(b)); //比较对象中的数据   true

Integer aaa = 100; //byte字节 -128，128
Integer bbb = 100; //byte字节，不会new对象
System.out.println(aaa==bbb); //==引用数据类型，比较地址  true
System.out.println(a.equals(b)); //比较对象中的数据     true

14.6 基本类型与字符串之间的转换

在JavaWeb开发中，数据是用户从浏览器中输入的字符串，此时字符串和基本数据类型之间的转换就尤为重要

基本类型转换为String
- 转换方式
  - 方式一：直接在数字后加一个空字符串
  - 方式二：通过String类静态方法valueOf()
- 示例代码

    //int --- String
    int number = 100;
    //方式1
    String s1 = number + "";
    System.out.println(s1);
    //方式2:静态调用方便些
    //public static String valueOf(int i)
    String s2 = String.valueOf(number);
    System.out.println(s2);
    System.out.println("--------");
}

String转换成基本类型
- 转换方式
  
  方式一:通过String类静态方法parseInt(String str)
  
  方式二:调用Integer对象的方法intValue( )
- 示例代码

public static void main(String[] args) {
	//方式1:静态调用方便些
    int i1 = Integer.parseInt("123");
	System.out.println(i1+1);
    //方式2
    Integer i2 = new Integer("123");
    int i = i2.intValue();
    System.out.println(i2+1);//124
}

除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：

public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。
public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。
public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。
public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。
public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型。

回顾

能够说出Object类的特点
能够重写Object类的toString方法
能够重写Object类的equals方法
能够使用将日期格式化为字符串的方法
能够使用将字符串转换成日期的方法
能够使用日历对象的方法
能够使用Math类的方法
能够使用System类获取当前系统毫秒值
能够说出数组冒泡排序的原理
能够说出数组二分查找法的原理
能够使用String类的matches和split方法
能够使用Math类的方法
能够说出自动装箱、自动拆箱的概念
能够将基本类型转换为对应的字符串
能够将字符串转换为对应的基本类型
能够使用BigInteger类的加减乘除方法
能够使用BigDecimal类的除法运算

内容仅为自己学习过程的笔记,希望能帮助各位"赶路人"，不喜勿喷。有写的不清楚的地方可以评论督促我，看到会修改成更容易理解的。有帮助的话，点赞哦~

这知识不进我脑袋呀

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
常用API

04 【常用API】内容Object类日期类日期格式化日历类SystemArrays正则表达式Math类BigInteger类BigDecimal类基本类型包装类目标能够说出Object类的特点能够重写Object类的toString方法能够重写Object类的equals方法能够使用将日期格式化为字符串的方法能够使用将字符串转换成日期的方法能够使用日历对象的方法能够使用Math类的方法能够使用System类获取当前系统毫秒值能够说出数组冒
复制链接

扫一扫