1 Object类
Object类是Java中所有类的祖宗类,因此,Java中所有类的对象都可以直接使用Object类中提供的一些方法
总结一下Object的toString方法和equals方法
public String toString()
返回对象的字符串表示形式。默认的格式是:“包名.类名@哈希值16进制”
【子类重写后,返回对象的属性值】
public boolean equals(Object o)
判断此对象与参数对象是否"相等"。默认比较对象的地址值,和"=="没有区别
【子类重写后,比较对象的属性值】
对象克隆:复制一个一模一样的新对象出来
浅克隆:拷贝出的新对象,与原对象中的数据一模一样(引用类型拷贝的只是地址)
深克隆:对象中基本类型的数据直接拷贝。对象中的字符串数据拷贝的还是地址。对象中包含的其他对象,不会拷贝地址,会创建新对象
2 Objects类
Objects是一个工具类,提供了一些方法可以对任意对象进行操作。主要方法如下
为什么要使用Objects类提供的equals方法来比较两个对象:更安全。
3 基本类型包装类
Java中的8种基本数据类型还不是对象,所以要把它们变成对象,变成对象之后,可以提供一些方法对数据进行操作。
自动装箱:基本数据类型可以自动转换为包装类型。
自动拆箱:包装类型可以自动转换为基本数据类型。
可以把基本类型的数据转换成字符串类型
public static String toString(double d)
public String toString()
可以把字符串类型的数值转换成数值本身对应的数据类型
public static int parseInt(String s)
public static Integer valueOf(String s)
4 StringBuilder、StringBuffer
-
StringBuilder代表可变字符串对象,相当于是一个容器,它里面的字符串是可以改变的,就是用来操作字符串的。
-
好处:StringBuilder比String更合适做字符串的修改操作,效率更高,代码也更加简洁。
对于字符串相关的操作,如频繁的拼接、修改等,建议用StringBuidler?
String 是不可变字符串、频繁操作字符串会产生很多无用对象,性能差。
StringBuilder:是内容可变的字符串、拼接字符串性能好、代码优雅。
注意:如果操作字符串较少,或者不需要操作,以及定义字符串时,则用String
注意:StringBuffer的用法与StringBuilder是一模一样的,但 StringBuilder是线程不安全的 StringBuffer是线程安全的
5 StringJoiner类
JDK8开始才有的,跟StringBuilder一样,也是用来操作字符串的,也可以看成是一个容器,创建之后里面的内容是可变的。
下面演示一下StringJoiner的基本使用
public class Test{
public static void main(String[] args){
StringJoiner s = new StringJoiner(",");
s.add("java1");
s.add("java2");
s.add("java3");
System.out.println(s); //结果为: java1,java2,java3
//参数1:间隔符
//参数2:开头
//参数3:结尾
StringJoiner s1 = new StringJoiner(",","[","]");
s1.add("java1");
s1.add("java2");
s1.add("java3");
System.out.println(s1); //结果为: [java1,java2,java3]
}
}
使用StirngJoiner改写前面把数组转换为字符串的案例
public class Test{
public static void main(String[] args){
String str = getArrayData( new int[]{11,22,33});
System.out.println(str);
}
//方法作用:将int数组转换为指定格式的字符串
public static String getArrayData(int[] arr){
//1.判断数组是否为null
if(arr==null){
return null;
}
//2.如果数组不为null,再遍历,并拼接数组中的元素
StringJoiner s = new StringJoiner(", ","[","]");
for(int i=0; i<arr.length; i++){
//加""是因为add方法的参数要的是String类型
s.add(String.valueOf(arr[i]));
}
//3、把StringJoiner转换为String,并返回。
return s.toString();
}
}
6Math类
Math是数学的意思,该类提供了很多个进行数学运算的方法,如求绝对值,求最大值,四舍五入等
public class MathTest {
public static void main(String[] args) {
// 目标:了解下Math类提供的常见方法。
// 1、public static int abs(int a):取绝对值(拿到的结果一定是正数)
// public static double abs(double a)
System.out.println(Math.abs(-12)); // 12
System.out.println(Math.abs(123)); // 123
System.out.println(Math.abs(-3.14)); // 3.14
// 2、public static double ceil(double a): 向上取整
System.out.println(Math.ceil(4.0000001)); // 5.0
System.out.println(Math.ceil(4.0)); // 4.0
// 3、public static double floor(double a): 向下取整
System.out.println(Math.floor(4.999999)); // 4.0
System.out.println(Math.floor(4.0)); // 4.0
// 4、public static long round(double a):四舍五入
System.out.println(Math.round(3.4999)); // 3
System.out.println(Math.round(3.50001)); // 4
// 5、public static int max(int a, int b):取较大值
// public static int min(int a, int b):取较小值
System.out.println(Math.max(10, 20)); // 20
System.out.println(Math.min(10, 20)); // 10
// 6、 public static double pow(double a, double b):取次方
System.out.println(Math.pow(2, 3)); // 2的3次方 8.0
System.out.println(Math.pow(3, 2)); // 3的2次方 9.0
// 7、public static double random(): 取随机数 [0.0 , 1.0) (包前不包后)
System.out.println(Math.random());
}
}
7 System类
这是系统类,提供了一些获取获取系统数据的方法。比如获取系统时间
public class SystemTest {
public static void main(String[] args) {
// 1、public static void exit(int status):
// 终止当前运行的Java虚拟机。
// 该参数用作状态代码; 按照惯例,非零状态代码表示异常终止。
System.exit(0); // 人为的终止虚拟机。(不要使用)
// 2、public static long currentTimeMillis():
// 获取当前系统的时间
// 返回的是long类型的时间毫秒值:指的是从1970-1-1 0:0:0开始走到此刻的总的毫秒值,1s = 1000ms
long time = System.currentTimeMillis();
System.out.println(time);
for (int i = 0; i < 1000000; i++) {
System.out.println("输出了:" + i);
}
long time2 = System.currentTimeMillis();
System.out.println((time2 - time) / 1000.0 + "s");
}
}
8 Runtime类
可以用来获取JVM的一些信息,也可以用这个类去执行其他的程序
public class RuntimeTest {
public static void main(String[] args) throws IOException, InterruptedException {
// 1、public static Runtime getRuntime() 返回与当前Java应用程序关联的运行时对象。
Runtime r = Runtime.getRuntime();
// 2、public void exit(int status) 终止当前运行的虚拟机,该参数用作状态代码; 按照惯例,非零状态代码表示异常终止。
// r.exit(0);
// 3、public int availableProcessors(): 获取虚拟机能够使用的处理器数。
System.out.println(r.availableProcessors());
// 4、public long totalMemory() 返回Java虚拟机中的内存总量。
System.out.println(r.totalMemory()/1024.0/1024.0 + "MB"); // 1024 = 1K 1024 * 1024 = 1M
// 5、public long freeMemory() 返回Java虚拟机中的可用内存量
System.out.println(r.freeMemory()/1024.0/1024.0 + "MB");
// 6、public Process exec(String command) 启动某个程序,并返回代表该程序的对象。
// r.exec("D:\\soft\\XMind\\XMind.exe");
Process p = r.exec("QQ");
Thread.sleep(5000); // 让程序在这里暂停5s后继续往下走!!
p.destroy(); // 销毁!关闭程序!
}
}
9 BigDecimal
用于解决浮点型运算时,出现结果失真的问题,常用于金融银行等系统开发
public class Test2 {
public static void main(String[] args) {
// 目标:掌握BigDecimal进行精确运算的方案。
double a = 0.1;
double b = 0.2;
// 1、把浮点型数据封装成BigDecimal对象,再来参与运算。
// a、public BigDecimal(double val) 得到的BigDecimal对象是无法精确计算浮点型数据的。 注意:不推荐使用这个,
// b、public BigDecimal(String val) 得到的BigDecimal对象是可以精确计算浮点型数据的。 可以使用。
// c、public static BigDecimal valueOf(double val): 通过这个静态方法得到的BigDecimal对象是可以精确运算的。是最好的方案。
BigDecimal a1 = BigDecimal.valueOf(a);
BigDecimal b1 = BigDecimal.valueOf(b);
// 2、public BigDecimal add(BigDecimal augend): 加法
BigDecimal c1 = a1.add(b1);
System.out.println(c1);
// 3、public BigDecimal subtract(BigDecimal augend): 减法
BigDecimal c2 = a1.subtract(b1);
System.out.println(c2);
// 4、public BigDecimal multiply(BigDecimal augend): 乘法
BigDecimal c3 = a1.multiply(b1);
System.out.println(c3);
// 5、public BigDecimal divide(BigDecimal b): 除法
BigDecimal c4 = a1.divide(b1);
System.out.println(c4);
// BigDecimal d1 = BigDecimal.valueOf(0.1);
// BigDecimal d2 = BigDecimal.valueOf(0.3);
// BigDecimal d3 = d1.divide(d2);
// System.out.println(d3);
// 6、public BigDecimal divide(另一个BigDecimal对象,精确几位,舍入模式) : 除法,可以设置精确几位。
BigDecimal d1 = BigDecimal.valueOf(0.1);
BigDecimal d2 = BigDecimal.valueOf(0.3);
BigDecimal d3 = d1.divide(d2, 2, RoundingMode.HALF_UP); // 0.33
System.out.println(d3);
// 7、public double doubleValue() : 把BigDecimal对象又转换成double类型的数据。
//print(d3);
//print(c1);
double db1 = d3.doubleValue();
double db2 = c1.doubleValue();
print(db1);
print(db2);
}
public static void print(double a){
System.out.println(a);
}
}
应该如何把浮点型转换成BigDecimal的对象?
BigDecimal b1 = BigDecimal.valueOf(0.1)
10 Arrays类
Arrays是操作数组的工具类,它可以很方便的对数组中的元素进行遍历、拷贝、排序等操作
public class ArraysTest1 {
public static void main(String[] args) {
// 1、public static String toString(类型[] arr): 返回数组的内容
int[] arr = {10, 20, 30, 40, 50, 60};
System.out.println(Arrays.toString(arr));
// 2、public static 类型[] copyOfRange(类型[] arr, 起始索引, 结束索引) :拷贝数组(指定范围,包前不包后)
int[] arr2 = Arrays.copyOfRange(arr, 1, 4);
System.out.println(Arrays.toString(arr2));
// 3、public static copyOf(类型[] arr, int newLength):拷贝数组,可以指定新数组的长度。
int[] arr3 = Arrays.copyOf(arr, 10);
System.out.println(Arrays.toString(arr3));
// 4、public static setAll(double[] array, IntToDoubleFunction generator):把数组中的原数据改为新数据又存进去。
double[] prices = {99.8, 128, 100};
// 0 1 2
// 把所有的价格都打八折,然后又存进去。
Arrays.setAll(prices, new IntToDoubleFunction() {
@Override
public double applyAsDouble(int value) {
// value = 0 1 2
return prices[value] * 0.8;
}
});
System.out.println(Arrays.toString(prices));
// 5、public static void sort(类型[] arr):对数组进行排序(默认是升序排序)
Arrays.sort(prices);
System.out.println(Arrays.toString(prices));
}
}
使用自然排序让Student类实现Comparable接口,同时重写compareTo方法。Arrays的sort方法底层会根据compareTo方法的返回值是正数、负数、还是0来确定谁大、谁小、谁相等,比较排序在调用Arrays.sort(数组,Comparator比较器);
时,除了传递数组之外,传递一个Comparator比较器对象。Arrays的sort方法底层会根据Comparator比较器对象的compare方法方法的返回值是正数、负数、还是0来确定谁大、谁小、谁相等
/*
04、分析以下需求并完成代码
阅读代码,通过自然排序完成:按照语文成绩升序排列,语文成绩相同,则按继续比英语成绩
将自然排序相关代码注释,然后通过比较器排序完成:按照年龄升序排列,年龄相同比姓名
遍历集合,打印对象属性查看结果
*/
public class Demo04 {
private static Student[] stus = new Student[6];
static {
stus[0] = new Student("zhangsan", 17, 99, 77);
stus[1] = new Student("lisi", 21, 85, 86);
stus[2] = new Student("wangwu", 20, 75, 94);
stus[3] = new Student("zhaoliu", 17, 75, 95);
stus[4] = new Student("qianqi", 19, 66, 44);
stus[5] = new Student("yanzu", 18, 75, 86);
}
public static void main(String[] args) {
//3、通过比较器排序完成:按照年龄升序排列,年龄相同比姓名
Arrays.sort(stus, (o1, o2) -> {
// 按照年龄升序排列,年龄相同比姓名
int result = o1.getAge() - o2.getAge();
if (result == 0) {
result = o1.getName().compareTo(o2.getName());
}
return result;
});
//2、遍历集合,打印对象属性查看结果
for (Student student : stus) {
System.out.println(student);
}
}
}
//1、通过自然排序完成:按照语文成绩升序排列,语文成绩相同,则按继续比英语成绩(注释掉再写比较器排序)
//阅读其他代码,完成就javabean的编写
// 如果一个类的元素要想要能够进行自然排序,就必须实现自然排序接口
class Student implements Comparable<Student> {
private String name;
private int age;
private int chinese;
private int english;
public Student(String name, int age, int chinese, int english) {
this.name = name;
this.age = age;
this.chinese = chinese;
this.english = english;
}
public int compareTo(Student s) {//按照语文成绩升序排列,语文成绩相同,则按继续比英语成绩
if (this.chinese == s.chinese) {
return this.english - s.english;
} else {
return this.chinese - s.chinese;
}
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public int getChinese() {
return chinese;
}
public int getEnglish() {
return english;
}
public String toString() {
return "Student{" + "name='" + name + '\'' + ", age=" + age + ", chinese=" + chinese + ", english=" + english
+ '}';
}
}