java学习记录十二:权限修饰符,代码块,java内部类
- 一、权限修饰符
- 二、代码块
- 三、Object类
- 四、Objects类
- 五、native方法
- 六、Date类
- 六、DateFormat类
- 七、Calendar类
- 八、Math类
- 一、解释
- 九、System类
- 十、BigInteger类
- 十一、BigDecimal类
- 十二、Arrays类
- 十三、包装类
- 十四、Integer类
- 十四、装箱和拆箱
- 十五、字符串和基本类型之间的转换
一、权限修饰符
一、解释
在Java中提供了四种访问权限,使用不同的访问权限修饰符修饰时,被修饰的内容会有不同的访问权限。
- public:公共的
- protected:受保护的
- (空的):默认的
- private:私有的
二、不同权限的访问能力
public | protected | (空的) | private | |
---|---|---|---|---|
同一类中 | √ | √ | √ | √ |
同一包中(子类与无关类) | √ | √ | √ | |
不同包的子类 | √ | √ | ||
不同包中的无关类 | √ |
可见,public具有最大权限。private则是最小权限。
编写代码时,如果没有特殊的考虑,建议这样使用权限:
- 成员变量使用
private
,隐藏细节。 - 构造方法使用
public
,方便创建对象。 - 成员方法使用
public
,方便调用方法。
二、代码块
一、构造代码块
一.解释
- 格式: {}
- 位置: 类中,方法外
- 执行: 每次在调用构造方法的时候,就会执行,在调用构造方法之前执行
- 使用场景: 统计创建了多少个该类对象
二.写法
public class Person{
{
构造代码块执行了
}
}
二、静态代码块
一、解释
- 格式:static{}
- 位置: 类中,方法外
- 执行: 当类被加载的时候执行,并只执行一次
- 使用场景: 例如加载驱动,这种只需要执行一次的代码就可以放在静态代码块中
二、写法
public class Person {
static {
System.out.println("Person 静态代码块");
}
{
System.out.println("Person 构造代码块");
}
public Person(){
System.out.println("Person 构造方法");
}
}
三、局部代码块
一、解释
- 格式:{}
- 位置: 方法中
- 执行: 调用方法,执行到局部代码块的时候就执行
- 使用场景: 节省内存空间,没有多大的意义
二、写法
public class Test {
public static void main(String[] args) {
System.out.println("开始");
{
int num1 = 10;
System.out.println("局部代码块");
}// 把局部代码块中的变量占用的空间会释放
System.out.println("结束");
}
}
三、Object类
一、解释
java.lang.Object`类是Java语言中的根类,即所有类的父类。如果一个类没有特别指定父类,那么默认则继承自Object类。根据JDK源代码及Object类的API文档,Object类当中包含的方法有11个。-java中所有的类都是直接或者间接继承Object类,也就意味着,java中所有的类都拥有Object类中的那11个方法。每个类的构造方法默认会调用父类的空参构造方法。
二、Object类常用方法
一、toString方法
一、解释
返回该对象的字符串表示,其实该字符串内容就是:对象的类型名+@+内存地址值。由于toString方法返回的结果是内存地址,而在开发中,经常需要按照对象的属性得到相应的字符串表现形式,因此也需要重写它。
二、写法
// 创建Object对象
Object obj = new Object();
System.out.println(obj.toString());// java.lang.Object@50cbc42f
System.out.println(obj);// java.lang.Object@50cbc42f
三、特点
- toString方法返回的字符串内容格式为: 类的全路径+@+十六进制数的地址值
- 直接打印对象名,其实就是打印对象调用toString方法返回的字符串内容
- 要是一个类toString打印的不是地址值,而是内容,说明该类重写了toString方法
四、重写toString方法
class Person{
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override//重写需要加上这个注解
public String toString() {
// 使用快捷键生成默认格式(alt+insert)
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
二、equals方法
一、解释
指示其他某个对象是否与此对象“相等”,Object类的equals()方法默认实心是==比较,也就是比较2个对象的地址值,对于我们来说没有用,如果希望进行对象的内容比较,即所有或指定的部分成员变量相同就判定两个对象相同,则可以覆盖重写equals方法。
二、写法
// 创建Object类对象
Object obj1 = new Object();
Object obj2 = new Object();
System.out.println(obj1 == obj2);// false
System.out.println(obj1.equals(obj2));// false 执行代码:obj1 == obj2
三、Object类equals方法的特点
- Object类的equals()方法默认比较的是2个对象的地址值是否相等(==比较)
- 由于java中所有类都是继承Object类,所以如果类中没有重写equals方法,默认就是地址值比较,String类就重写了equals方法,比较的是内容
- 如果希望进行对象的内容比较,即所有或指定的部分成员变量相同就判定两个对象相同,则可以重写equals方法,
二、重写equals方法
class Person {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
/*@Override
//形参多态,只要参数数据类型是父类类型,就可以使用所有的子类类型
public boolean equals(Object obj) {
// 自定义比较规则
//这边要向下转型,不然不能使用子类独有的成员。即obj.age访问报错。
//这里就是多态的弊端,所以要向下转型。出现多态就i要考虑到弊端。
//转型前最好判断一下是不是这个子类类型。
Person p = (Person) obj;
//这里age的== 是int的==比较的是值,name是String类型,==比较的是地址值,所以要用equals,比较的是值。
return this.age == p.age && this.name.equals(p.name);
}*/
// 快捷键重写equals方法 alt+insert-->选择`equals() and hashCode()`进行自动代码生成。
@Override
public boolean equals(Object o) {
// 如果2个对象的地址值相同,就直接返回true,结束方法
if (this == o) return true;
// 如果传入的对象为null,就直接返回false,结束方法
// 如果2个对象的类型不一致,就直接返回false,结束方法
//getClass获取对象的类
if (o == null || this.getClass() != o.getClass()) return false;
// 来到这里,说明要比较的2个对象地址值不同,并且一定是Person类型
Person person = (Person) o;// 向下转型
// 比较所有属性是否相同
return age == person.age &&
Objects.equals(name, person.name);
}
四、Objects类
一、解释
java.util.Objects
类是JDK7添加了一个Objects工具类,它提供了一些方法来操作对象,它由一些静态的实用方法组成,这些方法是null-save(空指针安全的)或null-tolerant(容忍空指针的),用于计算对象的hashCode、返回对象的字符串表示形式、比较两个对象。在比较两个对象的时候,Object的equals方法容易抛出空指针异常,而Objects类中的equals方法就优化了这个问题
二、写法
//public static boolean equals(Object a, Object b):判断两个对象是否相等。
//源码
public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}
public class Test {
public static void main(String[] args) {
String name1 = "张三";
String name2 = new String("张三");
String name3 = null;
System.out.println(name1);// 张三
System.out.println(name2);// 张三
// 比较name1和name2字符串内容是否相同
//System.out.println(name1.equals(name2));// true
//System.out.println(name3.equals(name1));// 空指针异常NullPointerException,因为null不能调用方法
System.out.println(Objects.equals(name1, name2));// true
//这时候使用Objects.equals就不会报空指针异常,可以比较null值。
System.out.println(Objects.equals(name3, name1));// false
}
}
五、native方法
一、解释
在Object类的源码中定义了 native 修饰的方法, native 修饰的方法称为本地方法。这种方法是没有方法体的,我们查看不了它的实现,它是用来和其他编程语言进行交互的方法,当我们需要访问C或C++的代码时,或者访问操作系统的底层类库时,可以使用本地方法实现。也就意味着Java可以和其它的编程语言进行交互。本地方法的作用: 就是当Java调用非Java代码的接口。方法的实现由非Java语言实现,比如C或C++。
六、Date类
一、解释
java.util.Date类 表示一个日期和时间,内部精确到毫秒。
二、构造方法
1.无参构造方法
- public Date()`:从运行程序的此时此刻到时间原点经历的毫秒值,转换成Date对象,分配Date对象并初始化此对象,以表示分配它的时间(精确到毫秒)。使用无参构造,可以自动设置当前系统时间的毫秒时刻;指定long类型的构造参数,可以自定义毫秒时刻。
2.有参构造方法
- public Date(long date):将指定参数的毫秒值date,转换成Date对象,分配Date对象并初始化此对象,以表示自从标准基准时间(称为“历元(epoch)”,即1970年1月1日00:00:00 GMT)以来的指定毫秒数,即写多少就是距离1970年1月1日00:00:00 GMT)偏差多少的时间。1000毫秒等于1秒。
三、时间定义
1.标准时间
叫世界协调时间/格林威治时间,又称为“历元(epoch)”,即1970年1月1日00:00:00 GMT
2.中国时间
是东八区时间,比标准时间快8小时,叫1970年1月1日00:00:00 CST
1.中国人:一个星期的第一天是星期一,外国人:一个星期的第一天是星期天
2.日历对象中的月份是: 0-11
四、写法
// 创建当前统时间对应的日期对象
Date date1 = new Date();
System.out.println(date1);// Thu Sep 10 11:21:00 CST 2020
//在使用println方法时,会自动调用Date类中的toString方法。Date类对Object类中的toString方法进行了覆盖重写,所以结果为指定格式的字符串
// 创建以标准基准时间为基准 指定偏移1000毫秒
Date date2 = new Date(1000);
System.out.println(date2);// Thu Jan 01 08:00:01 CST 1970
// 创建日期对象,表示1970年1月1日07:59:59
Date date3 = new Date(-1000);
System.out.println(date3);// Thu Jan 01 07:59:59 CST 1970
五、Date类常用方法
1.获取当前日期对象距离标准基准时间的毫秒值。
//public long getTime():获取当前日期对象距离标准基准时间的毫秒值。
// 创建当前统时间对应的日期对象
Date date1 = new Date();
System.out.println(date1);// Thu Sep 10 11:29:00 CST 2020
// 创建以标准基准时间为基准 指定偏移1000毫秒
Date date2 = new Date(1000);// 设置距离标准基准时间的毫秒值为1000
System.out.println(date2);// Thu Jan 01 08:00:01 CST 1970
// 获取当前日期对象距离标准基准时间的毫秒值。
System.out.println(date1.getTime());// 1599708576604
System.out.println(date2.getTime());// 1000
2.设置当前日期对象距离标准基准时间的毫秒值.也就意味着改变了当前日期对象
// public void setTime(long time) 设置当前日期对象距离标准基准时间的毫秒值.也就意味着改变了当前日期对象
// 创建当前统时间对应的日期对象
Date date1 = new Date();
System.out.println(date1);// Thu Sep 10 11:29:00 CST 2020
// 创建以标准基准时间为基准 指定偏移1000毫秒
Date date2 = new Date(1000);// 设置距离标准基准时间的毫秒值为1000
System.out.println(date2);// Thu Jan 01 08:00:01 CST 1970
// 修改date1距离标准基准时间的毫秒值为2000
date1.setTime(2000);
System.out.println(date1);// Thu Jan 01 08:00:02 CST 1970
date2.setTime(2000);
System.out.println(date2);// Thu Jan 01 08:00:02 CST 1970
3.测试此日期是否在指定日期之后或者之前
//public boolean after(Date when) 测试此日期是否在指定日期之后。
public boolean before(Date when) 测试此日期是否在指定日期之前。
// 创建当前统时间对应的日期对象
Date date1 = new Date();
System.out.println(date1);// Thu Sep 10 11:29:00 CST 2020
// 创建以标准基准时间为基准 指定偏移1000毫秒
Date date2 = new Date(1000);// 设置距离标准基准时间的毫秒值为1000
System.out.println(date2);// Thu Jan 01 08:00:01 CST 1970
// 修改date1距离标准基准时间的毫秒值为2000
date1.setTime(2000);
System.out.println(date1);// Thu Jan 01 08:00:02 CST 1970
date2.setTime(2000);
System.out.println(date2);// Thu Jan 01 08:00:02 CST 1970
// 创建当前统时间对应的日期对象
Date date3 = new Date();
System.out.println("date3表示的日期是否在date1之前:"+date3.before(date1));// false
System.out.println("date3表示的日期是否在date1之后:"+date3.after(date1));// true
六、DateFormat类
一、解释
java.text.DateFormat` 是日期/时间格式化子类的抽象类,我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。
- 格式化:按照指定的格式,把Date对象转换为String对象。
- 解析:按照指定的格式,把String对象转换为Date对象。
由于DateFormat为抽象类,不能直接使用,所以需要常用的子类java.text.SimpleDateFormat
。这个类需要一个模式(格式)来指定格式化或解析的标准。
二、构造函数
public SimpleDateFormat(String pattern)`:用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。参数pattern是一个字符串,代表日期时间的自定义格式。
常用的格式规则为:
标识字母(区分大小写) | 含义 |
---|---|
y | 年 |
M | 月 |
d | 日 |
H | 时 |
m | 分 |
s | 秒 |
三、构造函数写法
// 创建当前日期对象
Date date1 = new Date();
// 创建日期格式化对象,并且指定日期格式
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 格式化,日期格式随便指定
四、DateFormat类的常用方法
1.将Date对象格式化为字符串
//public String format(Date date)`:将Date对象格式化为字符串。
// 创建当前日期对象
Date date1 = new Date();
// 创建日期格式化对象,并且指定日期格式
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 格式化,日期格式随便指定
// 使用日期格式化对象,把日期对象转换为String对象
String dateStr = sdf1.format(date1);
System.out.println(dateStr);// 2020-09-10 12:02:56
2.将字符串解析为Date对象
//public Date parse(String source)`:将字符串解析为Date对象。
// 创建字符串对象
String str = "2020年09月09日 12时00分00秒";
// 创建日期格式化对象,并且指定日期格式
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");// 解析,日期格式要和字符串日期格式一样
// 解析
Date date = sdf2.parse(str);
System.out.println(date);// Wed Sep 09 12:00:00 CST 2020
七、Calendar类
一、解释
java.util.Calendar类表示一个“日历类”,可以进行日期运算。它是一个抽象类,不能创建对象,我们可以使用它的子类:java.util.GregorianCalendar类。
二、获取GregorianCalendar对象
1.直接创建GregorianCalendar对象
GregorianCalendar cal = new GregorianCalendar()
2.通过Calendar的静态方法getInstance()方法获取GregorianCalendar对象
// 创建当前时间的日历对象
Calendar cal = Calendar.getInstance();
System.out.println(cal);
/*
三、Calendarl类常用方法
1.获取当前日期的日历对象
//public static Calendar getInstance()` 获取当前日期的日历对象
// 创建当前时间的日历对象
Calendar cal = Calendar.getInstance();
System.out.println(cal);
/*
2.获取某个字段的值
/*public int get(int field)` 获取某个字段的值。
参数field:表示获取哪个字段的值,可以使用Calender中定义的常量来表示
Calendar.YEAR : 年
Calendar.MONTH :月
Calendar.DAY_OF_MONTH:月中的日期
Calendar.HOUR:小时
Calendar.MINUTE:分钟
Calendar.SECOND:秒
Calendar.DAY_OF_WEEK:星期*/
// 创建当前时间的日历对象
Calendar cal = Calendar.getInstance();
/// 获取cal日历对象年字段的值
int year = cal.get(Calendar.YEAR);
System.out.println(year);// 2020
// 获取cal日历对象月字段的值
int month = cal.get(Calendar.MONTH);
System.out.println(month);// 8
3.设置某个字段的值
//public void set(int field,int value)设置某个字段的值
// 创建当前时间的日历对象
Calendar cal = Calendar.getInstance();
// 设置cal日历对象中年字段的值为2030年
cal.set(Calendar.YEAR,2030);
System.out.println(cal.get(Calendar.YEAR));// 2030
// 为cal日历对象的年字段的值+2
cal.add(Calendar.YEAR,2);
System.out.println(cal.get(Calendar.YEAR));// 2032
4.为某个字段增加/减少指定的值
//public void add(int field,int amount)为某个字段增加/减少指定的值
// 创建当前时间的日历对象
Calendar cal = Calendar.getInstance();
// 为cal日历对象的年字段的值+2
cal.add(Calendar.YEAR,2);
System.out.println(cal.get(Calendar.YEAR));// 2032
// 为cal日历对象的年字段的值-1
cal.add(Calendar.YEAR,-1);
System.out.println(cal.get(Calendar.YEAR));// 2031
System.out.println(cal.get(Calendar.MONTH));// 8
5.使用给定的 Date 设置此 Calendar 的时间
//public void setTime(Date date) 使用给定的 Date 设置此 Calendar 的时间。
// 创建当前时间的日历对象
Calendar cal1 = Calendar.getInstance();// 2020年09月10日
// 需求: 获取1998年10月10日对应的日历对象
String birthdayStr = "1998年10月10日";
// 把字符串的日期转换为Date类型的日期
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
Date birthdayDate = sdf.parse(birthdayStr);
// 调用cal的setTime方法,把日期对象传入
cal1.setTime(birthdayDate);
System.out.println("年:"+cal1.get(Calendar.YEAR));// 1998
System.out.println("月:"+(cal1.get(Calendar.MONTH)+1));// 10
System.out.println("日:"+cal1.get(Calendar.DAY_OF_MONTH));// 10
6.判断此 Calendar 表示的时间是否在指定 Object 表示的时间之前或之后,返回判断结果。
//boolean before(Object when) `判断此 Calendar 表示的时间是否在指定 Object 表示的时间之前,返回判断结果。
//boolean after(Object when) 判断当前日历对象的时间是否在指定日历对象时间之后
// 创建当前时间的日历对象
Calendar cal1 = Calendar.getInstance();// 2020年09月10日
// 需求: 获取1998年10月10日对应的日历对象
String birthdayStr = "1998年10月10日";
// 把字符串的日期转换为Date类型的日期
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
Date birthdayDate = sdf.parse(birthdayStr);
// 调用cal的setTime方法,把日期对象传入
cal1.setTime(birthdayDate);
// 创建当前时间的日历对象
Calendar cal2 = Calendar.getInstance();// 2020年09月10日
System.out.println("cal1表示的时间是否在cal2表示的时间之前:"+cal1.before(cal2));// true
System.out.println("cal1表示的时间是否在cal2表示的时间之后:"+cal1.after(cal2));// false
八、Math类
一、解释
- java.lang.Math(类): Math类包含执行基本数字运算的方法。
- 它不能创建对象,它的构造方法被“私有”了。因为他内部都是“静态方法”,通过“类名”直接调用即可。
二、Math常用方法
/* public static int abs(int a) 获取参数a的绝对值:
public static double ceil(double a) 向上取整 例如:3.14 向上取整4.0
public static double floor(double a) 向下取整 例如:3.14 向下取整3.0
public static double pow(double a, double b) 获取a的b次幂
public static long round(double a) 四舍五入取整 例如:3.14 取整3 3.56 取整4
public static int max(int a, int b) 返回两个 int 值中较大的一个。
public static int min(int a, int b) 返回两个 int 值中较小的一个。*/
System.out.println("10的绝对值:"+Math.abs(10));// 10
System.out.println("-10的绝对值:"+Math.abs(-10));// 10
System.out.println("3.14向上取整:"+Math.ceil(3.14));// 4.0
System.out.println("3.54向上取整:"+Math.ceil(3.54));// 4.0
System.out.println("-3.54向上取整:"+Math.ceil(-3.54));// -3.0
System.out.println("==================================");
System.out.println("3.14向下取整:"+Math.floor(3.14));// 3.0
System.out.println("3.54向下取整:"+Math.floor(3.54));// 3.0
System.out.println("-3.54向下取整:"+Math.floor(-3.54));// -4.0
System.out.println("==================================");
System.out.println("2的3次幂:"+Math.pow(2,3));// 8.0
System.out.println("==================================");
System.out.println("3.14四舍五入取整:"+Math.round(3.14));// 3
System.out.println("3.54四舍五入取整:"+Math.round(3.54));// 4
System.out.println("-3.54四舍五入取整:"+Math.round(-3.54));// -4
System.out.println("==================================");
System.out.println("获取10和20的最大值:"+Math.max(10,20));// 20
System.out.println("获取10和20的最小值:"+Math.min(10,20));// 10
九、System类
一、解释
java.lang.System`类中提供了大量的静态方法,可以获取与系统相关的信息或系统级操作。
二、System类常用方法
1.终止当前运行的Java虚拟机,非零表示异常终止
//public static void exit(int status) 终止当前运行的Java虚拟机,非零表示异常终止
System.out.println("开始");
System.out.println("执行");
//System.exit(0);// 程序正常退出
//System.exit(-1);// 程序非正常退出
2.返回当前时间距离标准基准时间的毫秒值(以毫秒为单位)
//public static long currentTimeMillis() 返回当前时间距离标准基准时间的毫秒值(以毫秒为单位)
// 获取当前时间距离标准基准时间的毫秒值
Date date = new Date();
System.out.println(date.getTime());
System.out.println(System.currentTimeMillis());
3.拷贝数组中的元素到另一个数组
/*public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
拷贝数组中的元素到另一个数组
参数1src: 源数组
参数2srcPos:源数组要拷贝的元素的起始索引(从哪个索引位置开始拷贝)
参数3dest: 目标数组
参数4destPos:目标数组接收拷贝元素的起始索引(从哪个索引位置开始接收)
参数5length:需要拷贝多少个元素(拷贝多少个)*/
// 拷贝数组元素到另一个数组中
int[] arr1 = {1,2,3,4,5,6,7,8};
int[] arr2 = {10,20,30,40,50,60,70,80};
// 需求:把arr1中的3,4,5,6,7元素拷贝到arr2数组中,使得arr2数组变成{10,3,4,5,6,7,70,80};
System.arraycopy(arr1,2,arr2,1,5);
十、BigInteger类
一、解释
java.math.BigInteger 类,不可变的任意精度的整数。如果运算中,数据的范围超过了long类型后,可以使用
BigInteger类实现,该类的计算整数是不限制长度的。
二、构造方法
BigInteger(String value) 将 BigInteger 的十进制字符串表示形式转换为 BigInteger。超过long类型的范围,已经不能称为数字了,因此构造方法中采用字符串的形式来表示超大整数,将超大整数封装成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,超大整数除法运算,除不尽取整数部分 |
// 创建一个BigInteger类的对象,表示一个无限大的整数
BigInteger b1 = new BigInteger("1000000000000000000000");
BigInteger b2 = new BigInteger("1223435453543654354354");
// b1 + b2
BigInteger res1 = b1.add(b2);
System.out.println("b1 + b2 = "+res1);// 2223435453543654354354
// b1 - b2
BigInteger res2 = b1.subtract(b2);
System.out.println("b1 - b2 = " + res2);// -223435453543654354354
// b1 * b2
BigInteger res3 = b1.multiply(b2);
System.out.println("b1 * b2 = "+res3);// 1223435453543654354354000000000000000000000
// b1 / b2
BigInteger res4 = b1.divide(b2);
System.out.println("b1 / b2 = " + res4);// 0 10/3=3
// int a = 1000000000000;// 编译报错,因为超出了int类型所能表示的数据范围
// long l = 1000000000000000000000L;// 编译报错,因为超出了long类型所能表示的数据范围
}
十一、BigDecimal类
一、解释
表示超大小数,解决小数运算问题,有些小数运算有精度问题。对于浮点运算,不要使用基本类型,而用"BigDecimal类型。dobule类型的数据封装成BigDecimal还是有精度问题建议用字符串包装。
二、构造方法
1.将double类型的数据封装为BigDecimal对象
//BigDecimal(double val):将double类型的数据封装为BigDecimal对象
BigDecimal b1 = new BigDecimal(0.09);
2.将 BigDecimal 的字符串表示形式转换为 BigDecimal
//BigDecimal(String val) 将 BigDecimal 的字符串表示形式转换为 BigDecimal
BigDecimal b1 = new BigDecimal("0.09");
3.区别
第一种方法还是有可能存在精度问题,推荐使用第二种。
三、BigDecimal类常用方法(加、减、乘、除)
方法声明 | 描述 |
---|---|
public BigDecimal add(BigDecimal value) | 加法运算 |
public BigDecimal subtract(BigDecimal value) | 减法运算 |
public BigDecimal multiply(BigDecimal value) | 乘法运算 |
public BigDecimal divide(BigDecimal value) | 除法运算 |
注意:对于divide方法来说,如果除不尽的话,
就会出现java.lang.ArithmeticException异常。此时可以使用divide方法的另一个重载方法;
BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode):
divisor:除数对应的BigDecimal对象;
scale:精确的位数;
roundingMode取舍模式 RoundingMode枚举: RoundingMode.HALF_UP 四舍五入
igDecimal b1 = new BigDecimal("0.09");
BigDecimal b2 = new BigDecimal("0.01");
BigDecimal res1 = b1.add(b2);
System.out.println("res1:"+res1);// 0.10
// 减法运算:
BigDecimal b3 = new BigDecimal("1.0");
BigDecimal b4 = new BigDecimal("0.32");
BigDecimal res2 = b3.subtract(b4);
System.out.println("res2:"+res2);// 0.68
// 乘法运算
BigDecimal b5 = new BigDecimal("1.015");
BigDecimal b6 = new BigDecimal("100");
BigDecimal res3 = b5.multiply(b6);
System.out.println("res3:"+res3);// 101.500
// 除法运算
BigDecimal b7 = new BigDecimal("1.301");
BigDecimal b8 = new BigDecimal("100");
BigDecimal res4 = b7.divide(b8);
System.out.println("res4:"+res4);// 0.01301
// 加法运算: 有问题的
BigDecimal b9 = new BigDecimal(0.09);
BigDecimal b10 = new BigDecimal(0.01);
BigDecimal res5 = b9.add(b10);
System.out.println("res5:"+res5);// res5:0.0999999999999999968774977432417472300585359334945678710937
// 除法运算: 有问题的
/*BigDecimal b11 = new BigDecimal("10");
BigDecimal b12 = new BigDecimal("3");
BigDecimal res6 = b11.divide(b12);// 报异常
System.out.println("res6:"+res6);*/
/*BigDecimal b13 = new BigDecimal("20");
BigDecimal b14 = new BigDecimal("3");
BigDecimal res7 = b13.divide(b14);// 报异常
System.out.println("res7:"+res7);*/
// 注意:对于divide方法来说,如果除不尽的话,
// 就会出现java.lang.ArithmeticException异常。此时可以使用divide方法的另一个重载方法;
BigDecimal b11 = new BigDecimal("10");
BigDecimal b12 = new BigDecimal("3");
BigDecimal res6 = b11.divide(b12,2, RoundingMode.HALF_UP);
System.out.println("res6:"+res6);// 3.33
BigDecimal b13 = new BigDecimal("20");
BigDecimal b14 = new BigDecimal("3");
BigDecimal res7 = b13.divide(b14,3,RoundingMode.HALF_UP);
System.out.println("res7:"+res7);// 6.667
// System.out.println(0.09+0.01);// 期望: 0.10 实际:0.09999999999999999
// System.out.println(1.0 - 0.32);// 期望; 0.68 实际:0.6799999999999999
// System.out.println(1.015 * 100);// 期望:101.500 实际:101.49999999999999
// System.out.println(1.301 / 100);// 期望:0.01301 实际:0.013009999999999999
}
十二、Arrays类
一、解释
java.util.Arrays类:该类包含用于操作数组的各种方法(如排序和搜索)
二、常用方法
1.按照数字顺序排列指定的数组
//public static void sort(int[] a):按照数字顺序排列指定的数组
int[] arr = {12,334,53,543,43,32};
System.out.println("排序之前的数组:"+Arrays.toString(arr));//[12, 334, 53, 543, 43, 32]
// 对arr数组中的元素进行升序排序
Arrays.sort(arr);
System.out.println("排序之后的数组:"+Arrays.toString(arr));//[12, 32, 43, 53, 334, 543]
2.返回指定数组的内容的字符串表示形式
区分静态的tostring和非静态的tostring()
//public static String toString(int[] a):返回指定数组的内容的字符串表示形式
int[] arr = {12,334,53,543,43,32};
System.out.println("排序之前的数组:"+Arrays.toString(arr));//[12, 334, 53, 543, 43, 32]
// 对arr数组中的元素进行升序排序
Arrays.sort(arr);
System.out.println("排序之后的数组:"+Arrays.toString(arr));//[12, 32, 43, 53, 334, 543]
十三、包装类
一、解释
ava提供了两个类型系统,基本类型与引用类型,使用基本类型在于效率,然而很多情况,会创建对象使用,因为对象可以做更多的功能,如果想要我们的基本类型像对象一样操作,就可以使用基本类型对应的包装类,对基本数据类型进行包装成对象,然后进行操作。
二、包装类分类
基本类型 | 对应的包装类(位于java.lang包中) |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
char | Character |
boolean | Boolean |
十四、Integer类
一、解释
将int类型的基本类型,包装成一个对象类型,为Integer类型。
二、构造方法
1.根据int值创建
//public Integer(int value):根据 int 值创建 Integer 对象(过时)
Integer i1 = new Integer(10);// i1对象表示的整数就是10
2.根据字符串类型创建
//public Integer(String s):根据 String 值创建 Integer 对象(过时)
Integer i3 = new Integer("100");// i3对象表示的整数就是100
三、常用方法
1.返回表示指定的 int 值的 Integer 实例
//public static Integer valueOf(int i):返回表示指定的 int 值的 Integer 实例
Integer i2 = Integer.valueOf(10);// i2对象表示的整数就是10
2.返回保存指定String值的 Integer 对象
//public static Integer valueOf(String s):返回保存指定String值的 Integer 对象
Integer i4 = Integer.valueOf("100");// i4对象表示的整数就是100
3.Integer 对象转int基本类型
Integer i1 = new Integer(10);// i1对象表示的整数就是10
// Integer--->int
int num1 = i1.intValue();
十四、装箱和拆箱
一、解释
基本类型与对应的包装类对象之间,来回转换的过程称为”装箱“与”拆箱“
- 装箱:从基本类型转换为对应的包装类对象。
- 拆箱:从包装类对象转换为对应的基本类型。
二、自动装箱与拆箱
由于我们经常要做基本类型与包装类之间的转换,从Java 5(JDK 1.5)开始,基本类型与包装类的装箱、拆箱动作可以自动完成。
// int--->Integer
///手动装箱,这里也可直接int接收。
Integer i1 = new Integer(10);// i1对象表示的整数就是10
Integer i2 = Integer.valueOf(10);// i2对象表示的整数就是10
//所有包装类都有valueOf方法转对应的包装类型。
// 手动拆箱
// Integer--->int
int num1 = i1.intValue();
int num2 = i2.intValue();
// 自动装箱
Integer i3 = 10;
// 自动拆箱
int num3 = i3;
可以将“包装类”和“基本类型”混合使用,比较方便
十五、字符串和基本类型之间的转换
区分包装类和基本数据类型,字符串是引用数据类型。它和其它基本类型的转换又不一样。
一、基本类型转String
1.直接在数字后加一个空字符串
//int --- String
int number = 100;
//方式1
String s1 = number + "";
System.out.println(s1);
2.通过String类静态方法valueOf()
int number = 100;
//public static String valueOf(int i)
String s2 = String.valueOf(number);
System.out.println(s2);
二、String类型转基本类型
除了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基本类型。
以Integer类为例
// 基本类型--->字符串:
String str1 = 100 + "";// str1字符串的内容:"100"
String str2 = String.valueOf(100);// str2字符串的内容: "100"
// 字符串--->基本类型:
int num1 = Integer.parseInt(str1);
int num2 = Integer.parseInt(str2);
System.out.println(num1+num2);// 200
如果字符串参数的内容无法正确转换为对应的基本类型,则会抛出java.lang.NumberFormatException
异常。