Java SE(二)常用类
Object类
(一) 概述
Object是类层次结构的根类.每个类都使用Object作为超类.所有对象(包括数组)都实现
这个类的方法.随意定义一个类型,不手动显式定义其父类,那么这个类的父类就是Object类.
class Person{}
class Teacher extends Person{}
1) Teacher直接父类就是Person
2) 因为Person类没有手动定义任何父类, 默认的父类就是Object类
3) 类有多层继承性, 因此Object也是Teacher的父类
4) 所有类, 包括数组, 都可以使用Object类中方法功能
- 构造方法:
Object() : 空参构造中,第一行, 没有调用super(), 因为Object没有父类
用途:
创建Object类的对象的方法.
子类访问,所有子类都会直接或者间接的访问到这个顶层父类的构造方法.
package com.ujiuye.object;
// Person类的父类就是Object,Person对象就可以直接使用Object中继承到的方法功能
public class Person {
public static void main(String[] args) {
Person p = new Person();
Object obj = new Object();
}
}
toString方法
1.public String toString()
返回当前对象的字符串表示.默认Object类的toString方法,由
getClass().getName() + '@' + Integer.toHexString(hashCode())这几部分组成.
1)getClass().getName() 表示类的完全限定名.
2)hashCode() 表示根据内存地址通过哈希算法生成的哈希码值.
3)Integer.toHexString() 表示无符号十六进制的字符串表示形式.
2.对象返回这样一个地址值的字符串,没有什么意义,因此对于子类而言,需要重写父类的这个方法.
3.重写的原则:返回该对象中的所有成员变量的值(对象的属性)
4.快捷键生成:alt + insert -> 点击 toString方法
5.使用打印语句打印一个对象，其实打印的就是这个对象的toString()方法结果.
equals方法
1.public boolean equals(Object obj)
指示其他某个对象是否与此对象"相等".
2.对于任何非空引用值x和y,当且仅当x和y引用同一个对象时,此方法才返回true(x ==
y 具有值true).也就是在Object类型中,比较的是两个引用是否指向了同一个对象.如果
是,才返回true.相当于是在比较两个对象的地址值是否相同.
3.实际生活中,比较两个对象的内存地址,没有什么意义.因此在自定义的子类中,都要重
写这个方法.
4.重写原则:一般比较两个对象中的所有属性,是否全部相同.
5.快捷键生成:alt + insert -> 点击 equals() and hashCode()方法.
6.==和equals方法的区别:
1)比较内容的不同:
==可以比较任意数据类型,既可以比较基本数据类型,也可以比较引用数据类型.
equals方法只能比较引用数据类型.
2)比较规则不同:
==在比较基本类型的时候,比较的是数据的值,比较引用类型时,比较的是地址值.
equals方法在重写之前,比较的是两个对象的地址值,在重写之后,比较的属性值.
String类
-
String类概述: String类就是字符串类型,属于java.lang包,不需要导包.
-
String类代表字符串.Java程序中的所有字符串字面值(如"abc")都作为此类的实例实现.
-
在Java中只要使用双引号引用起来的任何数据它们都是String的一个对象.
-
字符串字面值属于常量,存储在方法区的常量池中,在创建之后就无法更改(是一个不可
变的字符序列).但是它们可以被共享.
private final char value[]; -
字符串在效果上,可以看做是字符数组,但实质上是字节数组.
String类的常用构造方法
字符串的常用方法
String类中的获取功能
1. length() : //获取到一个字符串中的字符个数(字符串的长度) , 返回值类型int
2. charAt(int index): //将字符串中指定的index索引位置上对应的字符获取到,返回值类型char
3. subString(int beginIndex): //截取出字符串的一部分,从beginIndex索引开始, 到最后的全部字符序列取出来, 返回值结果,新的字符串String
4. subString(int beginIndex, int endIndex) : //从beginIndex到endIndex-1之间的字符序列截取成一个新的字符串, 返回值结果String
//注意 : JDK的方法中, 如果是对于两个索引位置进行操作, 通常包括开始索引, 不包括结束索引
5. indexOf(String str) : //获取参数字符串str在方法调用字符串中第一次出现的索引位置
//返回值类型int, 如果没有找到参数str存在位置, 返回-1
6. indexOf(String str, int formIndex)://返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索, 返回值类型int, 如果没有找到参数str存在位置, 返回-1
7. lastIndexOf(String str) : //获取参数字符串str在方法调用字符串中最后一次出现的索引位置
//返回值类型int, 如果没有找到参数str存在位置, 返回-1
//注意 : indexOf 和 lastIndexOf方法中查找字符串的位置, 无论从哪里开始找, 参数字符串在原有字符串中的位置都不会发生变化
字符串的比较规则
public boolean equals(Object anObject):String类重写的方法,判断两个字符串的内容(字符序列)是否相等, 常用于比较字符串的内容是否相等
== : 在比较基本类型的时候,比较的是数据的值,比较引用类型时,比较的是地址值是否相等.
案例1:
分析以下程序,判断控制台上的输出结果是什么:
String s1 = "abc";
String s2 = "abc";
// 引用数据类型,通过new关键字新建, 都是在堆内存中开辟新的空间地址
String s3 = new String("abc");
String s4 = new String("abc");
System.out.println(s1 == s2); // true
System.out.println(s3 == s4); // false
System.out.println(s1.equals(s2)); // true
System.out.println(s3.equals(s4)); // true
String s5 = "a" + "b" + "c"; // 结果还是字符串常量”abc”,与s1指向同一块常量池空间
System.out.println(s1 == s5);// true
System.out.println(s1.equals(s5));// true
字符串的常用方法
String类的转换功能
1.byte[] getBytes()：将当前字符串，转成字节数组
2.char[] toCharArray()：将当前的字符串，转成字符数组
3.toUpperCase()：将当前的字符串，转成全大写形式
4.toLowerCase()：将当前的字符串，转成全小写形式
5.static valueOf家族：可以将任意数据类型的数据，转换成字符串
String类其他功能
1、replace(String oldStr, String newStr)：//将调用者中的老串替换成新串,返回值为替换后的新字符串
2、split(String regex): //将字符串按照参数字符串regex规则进行切割, 结果是一个String[]
3、trim()：//去掉字符串左右两边的空格、制表符
StringBuilder
1、StringBuilder是一个可变的字符序列，因为在类中提供了修改私有成员变量的方法
2、常用的方法是append和insert，就是在StringBuilder对象本身上，进行修改操作
3、StringBuilder底层和String类型一样，也是维护了一个字符数组，数组是私有的，外界无法直接访问，因此在StringBuilder或者String中对数组进行操作的公有方法的封装
4、String类型和StringBuilder的关系：都是用于描述字符串
-
String是不可变的字符序列，没有提供修改私有成员的方法；StringBuilder是可变的字符序列，因为提供了修改成员变量的方法；
-
String长度本身也不可以变化，StringBuilder长度可以变化，可以认为StringBuilder就像一个可以伸缩的容器，用于存储字符
总结 : StringBuilder的作用, 在进行大量的字符串拼接时, String类型的常量池空间过于浪费, StringBuilder可以节省内存空间
构造方法
1、构造方法作用：创建当前对象、将其他类型的数据，转换成当前类型
2、StringBuilder的构造方法：
StringBuilder()：创建一个生成器，初始容量为16个字符
StringBuilder(int capacity)：创建一个生成器，初始容量为capacity大小
StringBuilder(String str)：创建一个生成器，初始值就是str这些字符，初始大小是str+16
3、获取容积的方法：
capacity()：获取当前生成器的容器大小
length()：获取当前生成器中的实际字符个数
StringBuilder常用功能
添加功能
1、append(任意类型)：可以将任意数据类型，转成字符，添加到生成器中
insert(int index, 任意数据类型)：可以将任意数据类型，添加到指定的位置
删除功能
1、deleteCharAt(int index) ：删除指定索引的字符
2、delete(int startIndex, int endIndex)：删除指定范围的字符，被删除的部分包含头不包含尾
替换和反转功能
1、replace(int startIndex, int endIndex ,String str)：
将字符串缓冲区中的从start开始到end-1这部分内容，替换成str
2、reverse()：将原有字符序列进行反转
基本类型的包装类
概述
1.基本数据类型有八种，都是非常简单的数据类型
2.在这些类型中，只能表示简单的数据，不能包含一些操作数据的方法，没有办法存储描述这些数据的内容。需要准备一个引用数据类型，能将基本数据类型进行包装，提供一些操作基本类型的方法，定义一些描述数据的数据
基本类型的包装类：
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
Integer类型
1、各种包装类型的方法、特点基本相同，只要学习一个Integer类型，其他的也触类旁通。
2、Integer类型的对象中，维护了一个私有的成员变量，是一个int类型的字段（成员变量、属性），用于表示这个Integer对象要表示的数字。
3、提供了在int、Integer、String类型之间相互转换的方法
4、提供了一些常量
Integer的构造方法
1、Integer(int i)：将一个基本类型的int数，转换成Integer类型的对象
使用i给Integer对象中的成员变量赋值
2、Integer(String s)：将一个字符串类型的数字，转换成Integer类型的对象
转换的作用
Integer类型的成员方法
1、xxxValue()：//可以将Integer类型的对象，转成其他的基本数据类型：
例如：byteValue()、floatValue()
2、常用静态方法：
parseInt(String str)：//将str以十进制的方式解读为一个int数
parseInt(String str, int radix)：//radix进制所表示的str数据,解析为一个int十进制数字
toBinaryString(int i)：使用二进制的表示方式表示数字i
toOctalString(int i)：使用八进制的表示方式表示数字i
toHexString(int i)：使用十六进制的表示方式表示数字i
toString(int i, int radix)：使用指定的radix进制，表示数字i
valueOf(String str, int radix)：将str以指定的进制radix进行解析，封装为一个Integer
Integer类型的常量
1、MAX_VALUE：int类型的最大值
2、MIN_VALUE：int类型的最小值
3、SIZE：int类型在内存中的位数
4、TYPE：int类型在方法区中的字节码对象，int.class
public class IntegerVariable {
public static void main(String[] args) {
// 1. int类型的最大值
System.out.println(Integer.MAX_VALUE);// 2147483647
// 2. int类型的最小值
System.out.println(Integer.MIN_VALUE);// -2147483648
// 3. int类型在内存中占有的比特位数
// int--->4字节--->1字节 是连续的8个比特位 4 * 8 = 32
System.out.println(Integer.SIZE);// 32
// 4. Integer实际类型
System.out.println(Integer.TYPE);// int
}
}
自动装箱和拆箱（jdk1.5,必须掌握）
1、装箱和拆箱：
装箱：将基本数据类型，封装成包装类型的对象，这个过程就是装箱，使用构造方法即可
拆箱：从包装类型的对象中，将其包装的基本类型的数据取出，这个过程就是拆箱，使用intValue方法即可
2、自动装箱和拆箱(基本数据类型与其对应引用数据类型包装类之间, 不需要任何的方法和桥梁, 直接赋值, 直接计算)
自动装箱：可以直接使用基本类型的数据，给对应的引用数据类型包装类对象的变量赋值
自动拆箱：可以直接使用包装类对象，给基本类型的变量赋值；包装类对象直接进行算数运算；
public class 自动拆装箱 {
public static void main(String[] args) {
// 1. 自动装箱 : 基本直接变引用
Integer i = 10;
// 2. 自动拆箱 : 引用直接变基本
int j = i;
// 3. 自动拆装箱之后, 数据直接运行
/*
1) x可以直接使用int类型15赋值, 自动装箱
*/
Integer x = 15;
/*
1) x自动拆箱,变成基本数据类型int
2) 与int类型2进行运算, 15 + 2 = 17(int)
3) 将结果17,自动装箱, 赋值给变量x
*/
x = x + 2;
}
}
Math
1、两个常量
E：自然对数的底数，2.718
PI：圆周率
2、常用方法
abs(数字类型)，//返回该参数的绝对值
ceil(double d)，//返回d的向上取整
floor(double d)，//返回d的向下取整
max(int a, int b)，//返回a、b的较大值
min(int a, int b)，//返回a、b的较小值
pow(int a, int b)，//返回a的b次幂
random()，//返回0.000~0.999的随机数
round(double d)，//返回d四舍五入的结果
System类及其常用方法
实例化 : 实例化对象, 创建对象 , new 类型();
初始化 : 赋值
1、用于描述系统资源的类型，System是一个和系统相关的类，里面提供了一些系统常用的方法，例如调用垃圾回收机制，给出系统时间，关闭虚拟机等。该类不用创建对象，因为构造方法私有, 直接使用静态变量和静态方法即可
2、常用字段(静态常量)：
System.in：//标准输入流，默认关联到键盘上
举例 : Scanner sc = new Scanner(System.in);
//System.out：标准输出流，默认关联到控制台上
举例 : System.out.println(数据);
//System.err：标准错误输出流，默认关联到控制台上，用于打印错误信息，在eclipse中，使用该流打 印的内容是红色
举例 : 如果代码中发生异常, 那么使用System.err将异常信息进行输出
3、常用方法全部都是static修饰：
- currentTimeMillis()：
返回当前时间的毫秒值，表示的是从1970年1月1日0时0分0秒开始到现在经历的毫秒值，1s = 1000ms。应用：1、可以通过某些手段，将数字转换成时间对象、指定格式的字符串；2、可以通过计算两次的差值，来获取某段代码运行的时间
- static void exit(int status): 退出JVM虚拟机,零表示正常终止
大型数据类型
BigInteger类及其常用方法
-
概述: 我们所学的整数类型,正常情况下,一个数最大能存放在long类型的变量空间里,如果超出了long类型的范围,根本是无法保存的.为了解决这种问题,在java中引入了操作大整数的数据类型,这就是BigInteger.
-
BigInteger类常用构造方法
BigInteger(String val): 将指定字符串转换成BigInteger对象 BigInteger(String val,int radix): 根据指定的radix进制,将指定字符串转换成BigInteger对象
案例: 分别用BigInteger(String val)、 BigInteger(String val,int radix)构造方法创建BigInteger类型的对象.
- BigInteger类常用方法
- BigInteger abs(): 返回BigInteger对象的绝对值,返回值结果BigInteger
- BigInteger negate(): 取该对象的相反数
- BigInteger add(BigInteger val): 加法
- BigInteger subtract(BigInteger val): 减法
- BigInteger multiply(BigInteger val): 乘法
- BigInteger divide(BigInteger val): 除法
BigDecimal类及其常用方法(掌握)
-
概述: 我们所学的浮点数类型,有精度损失问题.为了解决这种问题,在java中引入了BigDecimal, 进行浮点类型精确计算
-
构造方法:
BigDecimal(double val): 将double类型的数据转换成BigDecimal对象
BigDecimal(String val): 将String类型的数据转换成BigDecimal对象
- BigDecimal类常用方法
BigDecimal add(BigDecimal augend): 加法
BigDecimal subtract(BigDecimal subtrahend): 减法
BigDecimal multiply(BigDecimal multiplicand): 乘法
BigDecimal divide(BigDecimal divisor): 除法
BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)
除法三个参数分别表示:除数、精确小数位、舍入模式
常用舍入模式:
BigDecimal.ROUND_UP 向上取整
BigDecimal.ROUND_FLOOR 向下取整法
BigDecimal.ROUND_HALF_UP 四舍五入
时间类
日期Date类型及其常用方法
-
概述: Date表示特定的瞬间,精确到毫秒.是java中提供的表示时间日期数据的对象,但是这个类,其中大部分的方法已经过时,由Calendar和DateFormat类代替.
-
Date类构造方法:
public Date(): //分配 Date 对象并初始化此对象,以表示分配它的时间(精确到毫秒)
public Date(long date): //分配 Date 对象并初始化此对象,以表示自从标准基准时间(称为"历元(epoch)",即 1970 年 1 月 1 日 00:00:00 GMT)以来的指定毫秒数
- Date类常用方法
long getTime():
返回自1970 年1月1日 00:00:00 GMT 以来此 Date 对象表示的毫秒数
void setTime(long time)
设置此Date对象,以表示 1970 年1月1日 00:00:00 GMT 以后 time 毫秒的对应时间点
import java.util.Date;
public class DateDemo {
public static void main(String[] args) {
// 1. 创建出一个日期对象
Date d = new Date();
System.out.println(d);// Thu Mar 25 13:58:52 GMT+08:00 2021
// 2021-03-25 13:58:52
// 2. Date(long time) : time表示毫秒值, 设置一个日期类型
// 具体时间 : 从1970年01-01,00:00:00 开始进行计算, time毫秒值对应的时间
Date d1 = new Date(1000);
System.out.println(d1);
// 3. getTime() : 表示Date日期对象,对应毫秒值对多少
System.out.println(d1.getTime());// 1000
System.out.println(d.getTime());// 1616652427902
System.out.println(System.currentTimeMillis());// 1616652427922
// 4. setTime(long time) : 表示将参数time毫秒值所表示的时间,设置给一个Date日期类型
// 相当于修改的概念
d.setTime(10000);
System.out.println(d);// Thu Jan 01 08:00:10 GMT+08:00 1970
}
}
SimpleDateFormat类及其常用方法
-
概述：简单的日期格式化类，提供了日期的格式化的方法
-
SimpleDateFormat类常用构造方法
1.SimpleDateFormat(): 用默认的模式和默认语言环境的日期格式创建对象
2.SimpleDateFormat(String pattern)
用给定的模式和默认语言环境的日期格式创建对象，
一般pattern传递的是 "yyyy-MM-dd HH:mm:ss"
例如：2021-03-02 16:48:22
-
SimpleDateFormat类常用方法
1) final String format(Date date): 将一个 Date 格式化为日期/时间字符串
2) Date parse(String source) throws ParseException:
从给定字符串解析文本,以生成一个日期
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDateFormatDemo {
public static void main(String[] args) throws ParseException {
// 1. 创建出日期的默认转换格式的
SimpleDateFormat sdf = new SimpleDateFormat();
System.out.println(sdf);
// 2. 创建出指定格式的日期转换
// SimpleDateFormat(String regexTime) : 参数就是目标日期表现格式的规则
// y--> 年份 M--->年中月份 d--->月中天数 H--->天中小数 m--->小时中的分钟
// s-->分钟中秒数
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(sdf1);
// 3. format(Date d) : 表示将参数d表示的时间格式,转换成对用的更容易看懂的字符串方法
String str = sdf.format(new Date());
System.out.println(str);// 21-03-25 下午 2:38
String str2 = sdf1.format(new Date());
System.out.println(str2);// 2021-03-25 14:39:59
// 4. Date parse(String time): 将字符串表示的时间,转换成一个Date日期类型
// 注意 : 提供的字符串的格式, 要与调用parse方法的SimpleDateFormat指定的格式一致
// parse方法会有一个异常处理信息, 不是所有的字符串都符合转换成Date时间的规则
Date d = sdf1.parse("2020-10-01 08:00:00");
System.out.println(d);// Thu Oct 01 08:00:00 GMT+08:00 2020
}
}
案例1: 计算一下你自己出现在地球多少天了(题目本质: 就是计算出两个日期之间所距离的天数)
分析:
毫秒值--->秒--->分钟--->小时--->天
- 定义出两个日期时间Date
- Date中getTime()能将一个日期对应的毫秒值获取到
- 今天的时间, Date d = new Date(); 获取到了
- 出生时间: 使用一个字符串”1995-01-01”--->Date日期(SimpleDateFormat parse)
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo01_计算出生天数 {
public static void main(String[] args) throws ParseException {
// 指定日期时间的格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
// 1. 获取到今天的日期
Date now = sdf.parse("2021-03-25");
// 2. 获取到出生日期
Date birth = sdf.parse("2021-03-01");
// 3. 计算出两个日期之间的毫秒值差值
long time = now.getTime() - birth.getTime();
// 4. 计算出毫秒值对应的天数
System.out.println(time / 1000 / 60 / 60 / 24);
/*
实际开发场景扩展 :
很多的统计类需求, 限制查询时间段,通常都是3个月为查询周期段
1) 查询的过程中, 需要客户输入 起始时间---终止时间
2) 终止时间不能大于当前时间
3) 起始时间不能大于终止时间
4) 终止时间与起始时间之间间隔不超过3个月; 中国月份角度分析, 连续的3个月, 最大92天
因此,验证结束与开始之间天数差值不能超过92
*/
}
}
Calendar类及其常用方法
-
概述: 在时间类中,有关于年、月、日、星期等日历字段之间的转换,已经废弃了.java中专门提供了一个Calendar类,用于对这些字段的操作. 因此Calendar：表示的是一个日历日期。
-
Calendar类及其常用方法:
static Calendar getInstance(): 使用默认时区和语言环境获得一个Calendar类对象 void set(int field,int value) 将给定的日历字段设置为给定值 例如 : Calender.YEAR 表示年, 在Calendar日历类的字段摘要中, 有对于时间划分的字段, 都是静态的, 类名直接调用即可 void set(int year, int month, int date) 设置日历字段的年月日 int get(int field): 返回给定日历字段的值 abstract void add(int field,int amount) 根据日历的规则,为给定的日历字段添加或减去指定的时间量。减去的amount写成负数。 final Date getTime() 返回一个表示此 Calendar 时间值(从历元至现在的毫秒偏移量)的 Date 对象
注意 : 日历类对象的输出结果,如下图
import java.util.Calendar;
import java.util.Date;
public class CalendarDemo {
public static void main(String[] args) {
// 1. 创建出一个日历类
// Calendar 静态方法 : getInstance(), 获取到一个日历类对象
// 当前系统时间
Calendar cal = Calendar.getInstance();
System.out.println(cal);
// 2. 通过get(int field) 得到日历中指定时间字段值
// 1) 获取年份
System.out.println(cal.get(Calendar.YEAR));
// 2) 获取月份
System.out.println(cal.get(Calendar.MONTH) + 1);
// 3) 获取月中日
System.out.println(cal.get(Calendar.DAY_OF_MONTH));
// 4) 一天中小时
System.out.println(cal.get(Calendar.HOUR_OF_DAY));
// 5) 小时中的分钟
System.out.println(cal.get(Calendar.MINUTE));
// 6) 分钟中的秒值
System.out.println(cal.get(Calendar.SECOND));
// 7) 星期
System.out.println(cal.get(Calendar.DAY_OF_WEEK)-1);
System.out.println("-------------------");
// 3. set(int field, int value)
// set(int year,int month, int day)
cal.set(Calendar.YEAR,2020);
System.out.println(cal.get(Calendar.YEAR));
cal.set(1999,4,13);
System.out.println(cal.get(Calendar.YEAR));
// 2) 获取月份
System.out.println(cal.get(Calendar.MONTH) + 1);
// 3) 获取月中日
System.out.println(cal.get(Calendar.DAY_OF_MONTH));
System.out.println("+++++++++++++++++");
// 4. add(int field, int count) : 表示对某一个日历中的字段修改多少偏移量
// 从而达到了修改日历时间效果
cal.add(Calendar.MONTH,-7);
System.out.println(cal.get(Calendar.YEAR));
// 2) 获取月份
System.out.println(cal.get(Calendar.MONTH) + 1);
// 3) 获取月中日
System.out.println(cal.get(Calendar.DAY_OF_MONTH));
// 5. Date getTime(): 将一个日历类型转换成日期类型
Date d = cal.getTime();
System.out.println(d);
}
}
NumberFormat类以及使用
-
概述: NumberFormat是所有数值格式的抽象基类.此类提供格式化和解析数值的接口,可用于格式化和解析任何语言环境的数值.
-
NumberFormat类常用方法
static final NumberFormat getInstance(): 返回当前默认语言环境的通用数值格式
static final NumberFormat getCurrencyInstance()
返回当前默认语言环境的货币格式
void setMaximumFractionDigits(int newValue)
设置数的小数部分所允许的最大位数
void setMaximumIntegerDigits(int newValue)
设置数的整数部分所允许的最大位数
final String format(double number)
格式化
import java.text.NumberFormat;
public class NumberFormatDemo {
public static void main(String[] args) {
// 1. 创建出一个数值格式化对象
NumberFormat nf = NumberFormat.getInstance();
// 3)void setMaximumFractionDigits(int newValue)
// 设置数的小数部分所允许的最大位数
//4)void setMaximumIntegerDigits(int newValue)
// 设置数的整数部分所允许的最大位数
//5)final String format(double number)
// 格式化
// 整数最大保留4位
nf.setMaximumIntegerDigits(4);
// 小数最大保留3位
nf.setMaximumFractionDigits(3);
String s = nf.format(1234.6789);
System.out.println(s);
NumberFormat nf1 = NumberFormat.getCurrencyInstance();
// 整数最大保留4位
nf1.setMaximumIntegerDigits(4);
// 小数最大保留3位
nf1.setMaximumFractionDigits(3);
String s1 = nf1.format(1234.6789);
System.out.println(s1);
}
}
Arrays工具类的使用
1. static void sort(Object[] a)
根据元素的自然顺序对指定对象数组按升序进行排序
2. static String toString(Object[] a)
返回指定数组内容的字符串表示形式
3. static int binarySearch(Object[] a,Object key)
方法的使用前提 : 要求数组中元素是升序排列, 且元素key只出现一次, 二分查找才是效率最高且是正确的
使用二分搜索法来搜索指定数组a中,获得key数值对用索引位置。
import java.util.Arrays;
public class ArraysDemo {
public static void main(String[] args) {
int[] arr = {1,2,-5,10,-20,30,70,15};
// [1, 2, -5, 10, -20, 30, 70, 15]
System.out.println(Arrays.toString(arr));
// 1. void sort(Object[] arr) : 将参数数组中的数据进行默认的升序排序(从小到大)
Arrays.sort(arr);
// 2. String toString(Object[] obj) : 将参数数组中每一个元素都获取到, 拼接成一个
// 字符串进行返回
String s = Arrays.toString(arr);
System.out.println(s);// [-20, -5, 1, 2, 10, 15, 30, 70]
// [-20, -5, 1, 2, 10, 12,15, 30, 70]
// 3. binarySearch(Object[] obj,Object key)
// 返回值结果为目标数据在数组红索引位置, 如果没有找到, 结果就是负数
int index = Arrays.binarySearch(arr,2);
System.out.println(index);// 3
int index1 = Arrays.binarySearch(arr,12);
System.out.println(index1);// -6
}
