Java-BigInteger，BigDecimal，Arrays，包装类，String类
回顾
Object类
toString: 默认返回包名.类名@地址值,重写之后返回对象的内容
equals: 默认比较两个对象的地址值,重写之后比较对象的内容
Date类:
public Date(); 当前时间
public Date(long millis);距离基准时间millis毫秒后的那个时间
DateFormat类:
public SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
格式化: public String format(Date d);
解析: public Date parse(String time);
Calendar类:
获取:Calendar cc = Calendar.getInstance();
方法:
public int get(int field);
public void add(int field,int value);
public void set(int field,int value);
Math类:
Math的方法都是静态的
public static double abs(double d);
public static double ceil(double d);
public static double floor(double d);
public static long round(double d);
public static double pow(double d,double d);
System类:
System类的方法也是静态,并且不能创建对象(System的构造方法私有化了)
System.exit(0); 退出JVM
System.currentTimeMillis(); 获取当前时间的毫秒值
System.arrayCopy(源数组,开始索引,目标数组,开始索引,复制的元素个数);
主要内容：
BigInteger 大整数计算
BigDecimal 高精度计算
Arrays 工具类(方法都是静态的)
包装类(八种基本类型对应的引用类型)
String类的常用方法
(类,抽象类,接口,多态)
1.BigInteger的介绍
用于大整数计算(理论整数的位数是不受限制的)
public BigInteger(String num); //创建一个大整数
BigInteger不能直接使用+-*/进行计算,而是用通过方法进行计算
public BigInteger add(BigInteger value); 求和
public BigInteger subtract(BigInteger value); 求差
public BigInteger multiply(BigInteger value); 求积
public BigInteger divide(BigInteger value); 求商
public class TestBigInteger {
public static void main(String[] args) {
//1.创建一个BigInteger
BigInteger b1 = new BigInteger("99999999999");
//2.计算
//求和
BigInteger add = b1.add(new BigInteger("111111111111"));
System.out.println(add);
//求差
BigInteger subtract = b1.subtract(new BigInteger("222222222222"));
System.out.println(subtract);
//求积
BigInteger multiply = b1.multiply(new BigInteger("33333333"));
System.out.println(multiply);
//求商,如果除不尽,那么不要小数部分
b1 = new BigInteger("10");
BigInteger divide = b1.divide(new BigInteger("3"));
System.out.println(divide);
}
} 2.BigDecimal类
做高精度的浮点数运算
public BigDecimal(double d);
public BigDecimal(String s); 【推荐】
BigDecimal不能直接使用+-*/进行计算,而是用通过方法进行计算
public BigDecimal add(BigDecimal value) 加法运算
public BigDecimal subtract(BigDecimal value) 减法运算
public BigDecimal multiply(BigDecimal value) 乘法运算
public BigDecimal divide(BigDecimal value) 除法运算(能除尽)
public BigDecimal divide(BigDecimal value,int 保留位数,RoundingMode.HALP_UP) 除法运算(不能除尽)
public class TestBigDecimal02 {
public static void main(String[] args) {
//1.创建一个BigDecimal
BigDecimal b1 = new BigDecimal("9.999999999");
//2.计算
//加法
BigDecimal add = b1.add(new BigDecimal("1.11111111111"));
System.out.println(add);
//减法
BigDecimal subtract = b1.subtract(new BigDecimal("2.222222222222"));
System.out.println(subtract);
//求积
BigDecimal multiply = b1.multiply(new BigDecimal("3.33333"));
System.out.println(multiply);
//求商,注意,如果除不尽,会抛出异常
b1 = new BigDecimal("1.1");
// BigDecimal divide = b1.divide(new BigDecimal("0.3"));
// System.out.println(divide);
//如果除不尽,我们可以使用divide的一个重载方法
//BigDecimal divide(BigDecimal divisor, int scale, int roundingMode):
// 除数 保留几位小数 取舍模式
BigDecimal divide = b1.divide(new BigDecimal("0.3"), 5, RoundingMode.HALF_UP);
System.out.println(divide);
}
}
如果是基本类型除法,能否进行指定小数位数的保留,可以的,使用System.out.printf(查看API)3.Arrays类
Arrays是专门操作数组的工具类(方法都是静态的)
public static void sort(int[] a); 对数组中的元素进行从小到大的排序
public static String toString(int[] a); 将一个数组的元素拼成一个大的字符串返回
public class TestArrays {
public static void main(String[] args) {
//1.sort 排序方法
int[] arr = {4,5,3,6,7,8,1,2,9};
Arrays.sort(arr);
//2.输出
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
//3.toString 将一个数组的所有元素拼成一个大的字符串返回
String arrStr = Arrays.toString(arr);
System.out.println(arrStr);
}
}
扩展:
sort方法对于数值类型数组排序时,按照数值的从小到大进行排序
sort方法对于char类型数组排序时,按照字符的码值从小到大进行排序
sort方法对于String类型数组排序时,首先比较首字母的码值,
如果相等再比较次字母的码值,依次类推,按照从小到到进行排序 4.包装类：
包装类就是基本类型对应的引用类型,全称叫基本数据类型的包装类(简称包装类)
八大基本类型每种都有其对应的包装类:
byte Byte
short Short
"char Character
"int Integer
long Long
float Float
double Double
boolean Boolean构造方法:
public Integer(int value);
public Integer(String value);
静态方法:
public static Integer valueOf(int value);
public static Integer valueOf(String value);
public class TestInteger {
public static void main(String[] args) {
//1.创建Integer对象
//构造方法
Integer i1 = new Integer(10);
System.out.println(i1);
Integer i2 = new Integer("99");
System.out.println(i2);
//静态方法
Integer i3 = Integer.valueOf(11);
System.out.println(i3);
Integer i4 = Integer.valueOf("88");
System.out.println(i4);
}
}拆箱，装箱
装箱: 把基本类型 --转成--> 对应包装类【重点】
拆箱: 包装类 --转回--> 对应的基本类型【重点】
比如:
Integer i1 = new Integer(10); 一种装箱操作
Integer i3 = Integer.valueOf(11); 一种装箱操作
int value = i1.intValue(); 一种拆箱操作 自动拆箱与装箱
在JDK1.5中,引入了自动拆装箱操作
Integer i = 10; //底层Integer.valueOf(11)自动帮助我们进行装箱操作
int value = i; //底层 i.intValue()自动帮助我们进行拆箱操作
思考题:以下代码进行几次自动装箱和自动拆箱操作??
Integer a = 10; // 装1
a++; // a = a + 1 拆1 装1
自动装箱几次? 2
自动拆箱几次? 1 基本类型 转成 String
int num = 10;
a.直接+一个""
String s = num + "";
b.通过String的静态方法valueOf
String s = String.valueOf(num); String 转成 基本类型
String num = "100";
第一种方式:
a.先使用Integer的构造方法
Integer i = new Integer(num);
b.接着调用intValue方法拆箱
int number = i.intValue();
c.或者不调用intValue自动拆箱即可
int number = i;
第二种方式:
直接调用包装类的parseXxx(String s)解析字符串的方法
int number = Integer.parseInt(num); 字符串无法解析成基本类型时的异常
public static void main(String[] args) {
//1.字符串
String num = "9999";
//2.使用Integer.parseInt方法解析
int number = Integer.parseInt(num);
System.out.println(number);
//3.如果num中的值无法解析成int,会抛出异常
num = "999我爱你";
//NumberFormatException 数字格式化异常
int result = Integer.parseInt(num);
System.out.println(result);
}5.String类常用方法
String的构造方法:
直接赋值:
String s = "java";
构造方法:
String s = new String("java");
char[] chs = {'j','a','v','a'};
String s = new String(chs);
byte[] bs = {97,98,99,100};
String s = new String(bs); // s字符串最终的内容是:"abcd"
//5.1 concat 拼接
//方法原型：public String concat (String str)
//5.2 contains 判断是否包含某个小字符串
//方法原型：public boolean contains (CharSequence s)
//5.3 endsWith 是否以xx结尾
//方法原型：public boolean endsWith(String suffix)
//5.4 startsWith 是否以xx开头
//方法原型：public boolean startsWith(String prefix)
//5.5 indexOf 查找目标字符串在当前字符串中第一次出现的索引
//方法原型：public int indexOf(String str)
//5.6 lastIndexOf 查找目标字符串在当前字符串中最后一次出现的索引
//方法原型：public int lastIndexOf(String str)
//5.7 replace 将当前字符串中的目标字符串,替换为另外一个字符串
//方法原型：public String replace(CharSequence s1,CharSequence s2)
//5.8 substring 截取子串
//方法原型：public String substring(int beginIndex)
//方法原型：public String substring(int beginIndex, int endIndex);(含头不含尾)
//5.9 toCharArray 将字符串转成char数组
//方法原型：public char[] toCharArray()
//5.10 toLowerCase 转成纯小写
//方法原型： public String toLowerCase()
//5.11 toUpperCase 转成纯大写
//方法原型：public String toUpperCase()
//5.12 trim 取出字符串两端的空格(不去除空间的空格)
//方法原型：public String trim()
//5.13 split 切割字符串,参数称为切割符
//方法原型：public String[] split(String regex)6.引用类型使用
主要是(普通类,抽象类,接口,以及多态)
基本类型,可以作为方法的参数和返回
public void show(int a){
}
public int method(){
}
普通类,也可以作为方法的参数和返回
public void show(Dog d){
}
public Dog method(){
}
抽象类,也可以作为方法的参数和返回
public void show(Animal a){
//Animal a = 任意一个子类对象
}
public Animal method(){
}
接口,也可以作为方法的参数和返回
public void show(Fable a){
//Flyable a = 该接口的某个实现类对象
}
public Flyable method(){
}
总结:
当基本类型作为方法的参数和返回值时,调用方法和返回数据时,返回该基本类型的值即可
当引用类型作为方法的参数和返回值时,调用方法和返回数据时,返回该引用类型的对象/子类对象/实现类对象
结论: 当方法的参数或者返回值是普通类时,我们要传入或者返回的是该类的对象
结论:当方法的参数或者返回值是抽象类时,我们要传入或者返回的是该抽象类的子类对象
结论:当方法的参数或者返回值是接口时,我们要传入或者返回的是该接口的实现类对象
7.基本类型可以作为类的成员变量的,其实引用类型也可以作为类的成员变量
结论: 当普通类作为成员变量,给该成员变量赋值时,赋值普通类的对象
总结: 当抽象类作为成员变量时,给该成员变量赋值,赋该抽象类的子类对象
结论: 当接口作为成员变量时,给该成员变量赋值,赋该接口的实现类对象
other===========other=============================================================
程序从控制台接收一个java文件的文件名，例如：test.java，TEST.java，tEst.JAVA，请编程实现以下功能：
获取，并打印文件名的第一个字符；
获取，并打印文件的后缀名(包括.符号)，例如：.java
无论原文件名什么样，最终将其转换为：Test.java的形式，打印转换后的文件名。
public static void main(String[] args) {
Scanner scn = new Scanner(System.in);
while (true){
System.out.println("请输入一个java文件名：");
String filename = scn.nextLine();
if (filename.contains(".")) {//进行判断是否包含.
//进行切割获取第一个字符
System.out.println("文件名的第一个字符为：" + filename.substring(0, 1));
//进行以 . 进行分割
String[] strA = filename.split("\\.");
//获取后缀名即数组元素里面最后一个
System.out.println("文件的后缀名为：" + "." + strA[strA.length - 1]);
//文件名整体变小写
filename = filename.toLowerCase();
//获取文件名第一个字符
String first = filename.substring(0, 1);
//获取文件名除第一个字符外的其他字符
String other = filename.substring(1, filename.length());
//对第一个字符进行转大写，并拼接字符
filename = first.toUpperCase() + other;
System.out.println("转换后的文件名为：" + "." + filename);
}else{
System.out.println("输入的格式不对" );
}
}
}
有以下数组定义：
int[] arr = {1,332,43,25,3324,34,335,4,45,2,43,52,54};
要求：
请打印数组所有元素
请对数组元素进行“升序”排序
请对排序后的数组再次打印。
public static void main(String[] args) {
int[] arr = {1,332,43,25,3324,34,335,4,45,2,43,52,54};
System.out.println("数组中所有元素为："+Arrays.toString(arr));
Arrays.sort(arr);
System.out.println("排序后数组中所有元素为："+Arrays.toString(arr));
}
有以下学员信息：
张三,男,20,79.5
李四,女,21,80.2
王五,男,22,77.9
周六,男,20,55.8
赵七,女,21,99.9
请定义学员类，属性：姓名、性别、年龄、分数
请编写测试类，创建5个对象，分别存储上述值，并计算5名学员的“平均分”(四舍五入到小数点后2位)。
public static void main(String[] args) {
Student st1 = new Student("张三","男",20,79.5);
Student st2 = new Student("李四","女",21,80.2);
Student st3 = new Student("王五","男",22,77.9);
Student st4 = new Student("周六","男",20,55.8);
Student st5 = new Student("赵七","女",21,99.9);
List sts = new ArrayList<>();
sts.add(st1);
sts.add(st2);
sts.add(st3);
sts.add(st4);
sts.add(st5);
BigDecimal sumScore = new BigDecimal(0.0);
for (Student stu: sts) {
BigDecimal bd = new BigDecimal(stu.getScore());
sumScore=sumScore.add(bd);
}
BigDecimal divNum = new BigDecimal(sts.size());
BigDecimal avgScore =sumScore.divide(divNum, 2, RoundingMode.HALF_UP);
System.out.println("总分为："+sumScore.doubleValue());
System.out.println("5名学员的“平均分”(四舍五入到小数点后2位)："+avgScore.doubleValue());
}
程序模拟一个论坛发帖的过程，请用户输入一个发帖内容，例如：
“积视普京了我特朗普将反恐文件风朗普积分哦忘记普京”
请定义一个关键字数组：
String[] keyArray = {“特朗普”,”普京”};
请将字符串中包含的数组中的关键字替换为*符号。
public static void replaceAllStr(){
String[] keyArray = {"特朗普","普京"};
Scanner scn = new Scanner(System.in);
while (true){
System.out.println("请发帖：");
String content = scn.nextLine();
for (int i=0;i