概述:
以前学习过好几个整数类型,但是之前学习的基本类型数据大小是有限制的。
BigInteger表示大整数,可以存储任意大小的整数。
构造方法:
方法 | 说明 |
---|---|
BigInteger(String value) | 可以把字符串整数变成对象 |
常用方法:
方法 | 说明 |
---|---|
add(BigInteger value) | 加法运算 |
subtract(BigInteger value) | 减法运算 |
multiply(BigInteger value) | 乘法运算 |
divide(BigInteger value) | 除法运算 |
代码示例:
import java.math.BigInteger;
public class Demo_BigInteger {
public static void main(String[] args) {
//超出了int的范围
//int a = 10000000000000;
//超出了long的范围
//long a = 100000000000000000000000L;
//基本数据类型才能使用 + - * / 这些运算符
//引用类型需要调用方法
//创建对象
BigInteger b1 = new BigInteger("123456789123456789123456789");
BigInteger b2 = new BigInteger("123456789123456789123456789");
//加法运算
//BigInteger b3 = b1.add(b2);
//System.out.println(b3);
System.out.println(b1.add(b2));
//减法运算
System.out.println(b1.subtract(b2));
//乘法运算
System.out.println(b1.multiply(b2));
//除法运算
System.out.println(b1.divide(b2));
}
}
执行结果:
246913578246913578246913578
0
15241578780673678546105778281054720515622620750190521
1
概述:
BigDecimal表示大小数。这个小数可以存储任意位数, 并且可以做精确小数计算。
构造方法:
方法 | 说明 |
---|---|
BigDecimal(double val) | 把小数数值变成BigDecimal对象 |
BigDecimal(String val) | 把字符串值变成BigDecimal对象 |
方法 | 说明 |
---|---|
BigDecimal add(BigDecimal value) | 加法运算 |
BigDecimal subtract(BigDecimal value) | 减法运算 |
BigDecimal multiply(BigDecimal value) | 乘法运算 |
BigDecimal divide(BigDecimal value) | 除法运算 |
BigDecimal divide(BigDecimal divisor, int scale, int roundingMode) | 除法运算(除不尽的情况) |
示例代码:
import java.math.BigDecimal;
import java.math.RoundingMode;
public class Demo_BigDecimal {
public static void main(String[] args) {
//double保存是有大小限制的
double d = 333333333333333.3333333333333333333333;
System.out.println(d);
//double的计算是不精确的
double d2 = 10.0;
double d3= 3.0;
System.out.println(d2 / d3); //3.3333333333333335
double d4 = 0.09;
double d5 = 0.01;
System.out.println(d4 + d5); //0.09999999999999999
//BigDecimal
//创建对象
//因为给的原始数据本来就是错的
//BigDecimal b1 = new BigDecimal(0.09);
//BigDecimal b2 = new BigDecimal(0.01);
//BigDecimal b1 = new BigDecimal(0.09+"");
//BigDecimal b2 = new BigDecimal(0.01+"");
BigDecimal b1 = new BigDecimal("0.09");
BigDecimal b2 = new BigDecimal("0.01");
//加法运算
System.out.println(b1.add(b2));
//减法运算
System.out.println(b1.subtract(b2));
//乘法运算
System.out.println(b1.multiply(b2));
//除法运算
System.out.println(b1.divide(b2));
//演示小数除不尽的问题
BigDecimal b3 = new BigDecimal("10.0");
BigDecimal b4 = new BigDecimal("3.0");
//除法运算
//因为结果是无限小数,无法表示所以报错了
//System.out.println(b3.divide(b4));
//解决办法
// BigDecimal divisor 除数
// int scale 保留小数位数
// RoundingMode roundingMode 保留方式 RoundingMode.HALF_UP四舍五入
System.out.println(b3.divide(b4,2, RoundingMode.HALF_UP));
}
}
执行结果:
3.333333333333333E14
3.3333333333333335
0.09999999999999999
0.10
0.08
0.0009
9
3.33
概述:
Arrays表示数组工具类。
工具类的所有成员全都是静态的,可以使用类名直接调用。
常用方法:
方法 | 说明 |
---|---|
static void sort(int[] a) | 对数组进行排序(从小到大) |
static String toString(int[] a) | 把数组转成字符串(方便打印) |
示例方法:
import java.util.Arrays;
public class Demo_Arrays {
public static void main(String[] args) {
//创建数组
int[] arr = {21,43,454,6,576,867,8,79,89};
//排序
Arrays.sort(arr);
//打印
System.out.println(Arrays.toString(arr));
}
}
执行结果:
[6, 8, 21, 43, 79, 89, 454, 576, 867]
为什么要有包装类?
在很多地方不能使用基本类型只能使用引用类型。基本类型里面没有属性也没有方法。
八种基本类型对应的包装类
基本类型 | 包装类 |
---|---|
byte | Byte |
short | Short |
int | Integer* |
long | Long |
float | Float |
double | Double |
char | Character |
boolean | Boolean |
方法 | 说明 |
---|---|
new Integer(int value) | 构造方法 |
new Integer(String s) | 构造方法 |
static Integer valueOf(String s) | 把字符串变成整数 |
static int parseInt(String s) | 把字符串变成整数 |
注意:上面的方法只有parseInt()常用,其他3个方法可以不记。。
代码演示
public class Demo_Integer方法 {
public static void main(String[] args) {
//new Integer(int value)构造方法
Integer i = new Integer(123);
//new Integer(String s)构造方法
Integer i2 = new Integer("123");
//static Integer valueOf(String s)把字符串变成整数
Integer i3 = Integer.valueOf("123");
//static int parseInt(String s)把字符串变成整数
int i4 = Integer.parseInt("123");
//上面四个方法不需要都记,只需要记住最后一个就可以了
}
}
装箱:
把【基本数据类型】变成对应的【包装类型】叫装箱。
拆箱:
把【包装类型】变成对应的【基本数据类型】叫拆箱。
代码演示:
public class Demo_装箱拆箱 {
public static void main(String[] args) {
Integer i1 = new Integer("123");
//自动拆箱
int t1 = i1;
//自动装箱
Integer i2 = 345;
//不需要记忆装还是拆,你只需要记住Integer和int的使用是完全一样等效的就可以了。
}
}
int转成String类型:
int a = 10;
//方式一:
String s = a + "";
//方式二:
String s = String.valueOf(a);
String转成int类型:
String s = "123";
//方式一:
int i = Integer.parseInt(s);
//方式二:
int i = Integer.valueOf(s);
注意:
String是java中最常用的类没有之一,String里面有很多常用方法,在基础班学过一些但是没有学完。
现在我们把之前的方法和新的方法一起重新学一遍。
方法 | 说明 |
---|---|
length() | 获取字符串的长度 |
charAt() | 根据索引获取一个字符 |
equals() | 判断两个对象的内容是否相同 |
concat() | 把两个字符串拼接成一个新字符串 |
contains() | 判断是否包含某个字符串 |
endsWith() | 判断是否以指定的字符串结尾 |
startsWith() | 判断是否以指定的字符串开头 |
indexOf() | 获取字符/字符串第一次出现的索引 |
lastIndexOf() | 获取字符/字符串最后一次出现的索引 |
replace() | 把旧的内容用新的内容替换 |
substring(int i,int j) | 截取字符串的一部分, 从i 开始到j 结束,包含头不包含尾 |
substring(int i) | 截取字符串的一部分, 从i 开始截取到最后 |
toCharArray() | 把字符串变成字符数组 |
getBytes() | 把字符串变成字节数组 |
toLowerCase() | 把字符串中的字母转成小写 |
toUpperCase() | 把字符串中的字母转成大写 |
trim() | 去掉字符串两端的空白 |
split() | 按照指定的字符串切割 |
equalsIgnoreCase() | 忽略大小写判断两个字符串是否相同 |
public class Demo01String常用方法 {
public static void main(String[] args) {
String s = "just do IT";
//length():获取字符串的长度
System.out.println(s.length()); //10
//charAt():获取指定索引处的字符
System.out.println(s.charAt(6)); //o
//equals():判断两个对象是否相同
System.out.println(s.equals("just do IT")); //true
System.out.println(s.equals("just do it")); //false
//equalsIgnoreCase():判断两个对象是否相同且忽略大小写
System.out.println(s.equalsIgnoreCase("just do it")); //true
}
}
public class Demo02String常用方法 {
public static void main(String[] args) {
String s = "石原里美新垣结衣";
//concat():把两个字符串拼接在一起
System.out.println(s.concat("柳岩")); //石原里美新垣结衣柳岩
//contains():判断字符串中是否包含某个字符串
System.out.println(s.contains("里美")); //true
System.out.println(s.contains("美柳")); //false
System.out.println(s.contains("衣")); //true
//endsWith():判断是否以指定字符串结尾
System.out.println(s.endsWith("结衣")); //true
System.out.println(s.endsWith("abc")); //false
//startsWith():判断是否以指定字符串开头
System.out.println(s.startsWith("石原里")); //true
//字符串一旦创建是不会更改的,我们看到改变的字符串都是一个新的别的对象
}
}
public class Demo03String常用方法 {
public static void main(String[] args) {
String s = "just do IT";
//indexOf(): 获取指定字符第一次出现的位置
System.out.println(s.indexOf('s')); //2
System.out.println(s.indexOf(' ')); //4
System.out.println(s.indexOf("do")); //5
System.out.println(s.indexOf("di")); //-1代表找不到
//lastIndexOf(): 获取指定字符最后一次出现的位置
System.out.println(s.lastIndexOf('s')); //2
System.out.println(s.lastIndexOf(' ')); //7
//replace():把旧字符串替换成新字符串
System.out.println(s.replace(" ","*")); //just*do*IT
System.out.println(s.replace("do"," ")); //just IT
}
}
import java.util.Arrays;
public class Demo04String常用方法 {
public static void main(String[] args) {
String s = "just do IT";
//substring(int i,int j):截取字符串的一部分,从i开始到j结束,包含开头不包含结尾
//截取出来的是2到4索引
System.out.println(s.substring(2,5)); // "st "
System.out.println(s.substring(5,7)); // "do"
System.out.println(s.substring(5,10)); // 虽然写了10,但是其实截取的是5-9 没有超出这个字符串的索引
//substring(int i): 截取字符串的一部分,从i开始截取到最后
System.out.println(s.substring(5)); // "do IT"
//toCharArray():把字符串转成字符数组,每一个字符是一个元素
char[] chars = s.toCharArray();
System.out.println("数组的长度" + chars.length); //10
//打印数组
System.out.println(Arrays.toString(chars)); //[j, u, s, t, , d, o, , I, T]
//getBytes():把字符串转成字节数组,每一个字节是一个元素
byte[] bytes = s.getBytes();
//打印数组
System.out.println(Arrays.toString(bytes)); //[106, 117, 115, 116, 32, 100, 111, 32, 73, 84]
// a ->97
// A ->65
// 0 ->48
}
}
public class Demo05常用方法 {
public static void main(String[] args) {
String s = "just do IT";
//toLowerCase():把字符串中的字母转成小写
System.out.println(s.toLowerCase()); //just do it
//toUpperCase():把字符串中的字母转成大写
System.out.println(s.toUpperCase()); //JUST DO IT
//trim():去掉字符串两端的空格和制表符
String s2 = " just do IT ";
System.out.println(s2.trim()); // "just do IT"
}
}
public class Demo06String常用方法 {
public static void main(String[] args) {
String s = "just do IT";
//split():切割字符串,参数位置传入切割的小字符串,把大字符串切成多个小段
//按照空格切,会切成3段
String[] arr = s.split(" ");
//打印数组
System.out.println(Arrays.toString(arr)); //[just, do, IT]
String s2 = "123,546,678,645";
String[] arr2 = s2.split(",");
System.out.println(Arrays.toString(arr2)); //[123, 546, 678, 645]
//不要使用.切割
//这个在后面要讲,在这里不浪费时间。
String s3 = "123.546.678.645";
String[] arr3 = s3.split(".");
System.out.println(Arrays.toString(arr3)); //[]
//接下来再说问题,你可以不记,很少见
//前面的符号会切割,后面的符号不会切割
String s4 = ",,123,546,678,645,,";
String[] arr4 = s4.split(",");
System.out.println(Arrays.toString(arr4)); //[, , 123, 546, 678, 645]
}
}
类作为方法参数实际接受的是类的对象
类作为方法的返回值实际返回的是类的对象
public class Demo类作为参数和返回值 {
public static void main(String[] args) {
//类作为方法的参数,实际传入的是类的对象
//调用
method(new Student());
}
//方法
public static void method(Student s){
}
//方法
//类作为方法的返回值类型,实际返回的是类的对象
public static Student method(){
Student s = new Student();
return s;
}
}
抽象类作为方法参数实际传入的是抽象类的子类对象
抽象类作为返回值类型实际返回的是抽象类的子类对象
public class Demo抽象类作为参数和返回值 {
public static void main(String[] args) {
//抽象类作为方法参数实际传入的是抽象类的子类对象
//调用
method(new Student());
}
//方法
public static void method(Person p){
}
//抽象类作为方法返回值实际返回的是抽象类的子类对象
//方法
public static Person method(){
return new Student();
}
}
接口作为参数实际传入的是接口的子类对象
接口作为返回值实际返回的是接口的子类对象
public class Demo接口作为参数和返回值 {
public static void main(String[] args) {
//接口作为方法的参数实际传入的是接口的子类对象
//调用方法
method(new Mouse());
}
//定义方法
public static void method(USB u){
}
//接口作为返回值类型实际返回的是接口的子类对象
//定义方法
public static USB method(){
return new Mouse();
}
}
public class Student {
//姓名
String name;
//年龄
int age;
//宠物
//以类作为成员变量
Pet p;
public Student() {
}
public Student(String name, int age, Pet p) {
this.name = name;
this.age = age;
this.p = p;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", p=" + p +
'}';
}
}
public class Demo {
public static void main(String[] args) {
//创建学生对象
Student s = new Student("柳岩",37,new Pet("狗狗",2));
//打印
System.out.println(s);
}
}
Student{name='柳岩', age=37, p=Pet{brand='狗狗', age=2}}
BigInteger【记功能】
可以保存无限大的整数。
BigDecimal【记功能】
可以保存无限大的小数,可以对小数做精确的计算。
Arrays
数组的工具类,和数组操作相关的方法。
方法:
sort():排序【记】
toString():把数组转成字符串【记】
包装类
方法:
Integer.parseInt():把字符串转成整数【记】
自动装箱自动拆箱
int-String互相转换:
int-->String:
方式一:String s = 123 + "";【记】
方式二:String s = String.valueOf(123);
String-->int:
方式一:int a = Integer.parseInt("123");【记】
方式二:int a = Integer.valueOf("123");
注意:
在八种包装类中,只有字符没有parseXXX()这个方法
String
所有的方法都会用到【记】
引用类型小结【不用记,看懂就行】