&&&&&总结&&&&&
1.常用的包(熟悉)
lang , util , io , net , sql ...
2.Object类(重点)
概念, equals(), hashCode(), toString(), ...
3. 包装类(熟悉)
概念, Integer类, Double类, Boolean类, Character类, ...
4. 常用的数学处理类(熟悉)
Math类, BigDecimal类, BigInteger类,
11. 常用的包(熟悉)
1.1 包的名称和功能
java.lang包,language,核心包,JVM自动导入,如System类,String类...
java.util包,utility,工具包,工具类集合类,如Scanner类,Random类,List集合... java.io包,input,output,输入输出包,读写文件,FileInputStream类,FileOutputSteam类... java.net包,网络包,网络编程,ServerSocket类,Socket类... java.sql包,数据包,操作数据库,DriverManager类,Connection接口,...
1.2 lang包 Object类 （重点）
11.2.1 概念
类Object是类层次结构的根。 每个类都有Object作为超类。 所有对象（包括数组）都实现此类的方法。 若定义一个Java类时未声明其父类,则其父类为Object类 本类定义了"对象"的基本行为,子类默认继承
11.2.2常用方法
11.2.2.1 equals和hashcode
equals方法在非null对象引用上实现等价关系(若为null,则引发空指针异常)
重写equals方法后需要覆盖hashCode方法(两个对象的equals结果为true, 则两个对象的hashCode要相同 )
11.2.2.2 toString
代码: Student类的封装, equals(), hashCode(), toString()方法的重写
package com.lagou.task11;
import java.util.Objects;
/**
* @author CH
* @date 2020/9/27 14:43
* Student类的封装, 方法的重写
*/
//子类可以继承父类的构造方法,私有方法以外的所有方法
public class Student {
private int id; //描述学号
private String name; //描述姓名
public int getId() {
return id;
}
public Student(int id, String name) {
setId(id);
setName(name);
}
public Student() {
}
public void setId(int id) {
if(id > 0) {
this.id = id;
} else {
System.out.println("学号不合理!");
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return id == student.id &&
Objects.equals(name, student.name); //这边调用的是Objects内的方法,方法内已判断空指针
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
@Override
public int hashCode() {
return Objects.hash(id, name);
}
/*//11.3//直接生成重写方法
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
if (id != student.id) return false;
return name != null ? name.equals(student.name) : student.name == null; //11.4//该行防止空指针异常
}
@Override
public int hashCode() {
int result = id;
result = 31 * result + (name != null ? name.hashCode() : 0);
return result;
}*/
/*public boolean equals(Object obj) { //equals源码
return (this == obj);
}*/
/**
* 1.为了比较两个对象的内容,也就是学号信息,需要重写该方法
*/
//this = s1;
//Object obj = s2; 多态
/* 11.1//
@Override
public boolean equals(Object obj) { //这里面参数this和obj在栈区开内存
// 3.//当调用对象和参数对象指向同一个对象时,内容一定相同
if(this == obj) return true;
// 2.//当调用对象不为空,参数对象为空时,一定不相同
if(null == obj) return false; //处理一下比较好
//判断obj指向的对象是不是Student类型的对象,是则条件成立,否则条件不成立
if(obj instanceof Student) {
Student ts = (Student)obj;
//10.2//以学号为基准判断两个对象是否相等 int是基本数据类型,内存空间中放的就是数据本身,使用 == 可以判断数据是否相同
//父类中没有getId(),因此要强转为子类
//10.1//return this.getId() == ts.getId();
//10.3//以姓名作为基准判断两个对象是否相等, String是引用数据类型,使用 == 是判断地址是否相同
//10.3//也就是判断两个对象中姓名字符串的地址是否相同,不够完美
//10.4//return this.getName() == ts.getName();
return this.getName().equals(ts.getName()); //10.5//比较姓名字符串的内容是否相同
}
//否则类型不一致没有可比性,则内容一定不相同
return false;
}
*/
/**
* 4.为了使得该方法的结果与equals方法的结果一直,从而满足Java官方的常规协定,需要重写该方法
*/
/* 11.2//
@Override
public int hashCode() {
//8.3//return getId(); //流氓手法,不再代表内存地址的编号了
int type = 12; //8.4//用这种手法修改
//10.6//return type*31 + getId();
return type * 31 + getName().hashCode(); //10.7//调用的是String类内重写的hashCode方法
}
*//**
* 9.1 为了返回更有意义的字符串数据,需要重写该方法
*//*
@Override
public String toString() {
return "Student[id = " + getId() + ",name = " + getName() + "]";
}*/
}
代码: Student类的测试
package com.lagou.task11;
/**
* @author CH
* @date 2020/9/27 14:47
*/
public class StudentTest {
public static void main(String[] args) {
//1.//使用有参方式构造Student对象,两个. 并判断是否相等
Student s1 = new Student(1001,"zhangfei");
//5.//Student s2 = new Student(1002,"guanyu");
Student s2 = new Student(1001,"guanyu");
//3.//Student s2 = s1; //3.//表示下面的s1和s2都指向同一地址,结果变成true
//4.//当Student类中重写equals方法后调用重写以后的版本,比较的是内容学号
//2.//调用继承自父类Object类的方法,默认比较两者地址,可以查看源码验证
//public boolean equals(Object obj)
//6.//boolean b1 = s1.equals(s2);
//7.//Student s3 = null;
//7.//boolean b1 = s1.equals(s3);
//8.2//Student s3 = s1;
//8.2//boolean b1 = s1.equals(s3);
boolean b1 = s1.equals(s2);
System.out.println("b1 = " + b1); //false true
System.out.println(s1 == s2); //比较地址false
System.out.println("------------------------------------------");
//8.1//调用从Object类中继承下来的hashCode方法,获取对象的哈希码值
//8.5//当Student类中重写hashCode方法后,则调用重写以后的版本
int ia = s1.hashCode();
int ib = s2.hashCode();
System.out.println("ia = " + ia); //ia = 1627960023 哈希码不相同,因为没
System.out.println("ib = " + ib); //ib = 357863579
System.out.println("------------------------------------------");
//9.1//下面调用从Object中继承下来的toString方法,获取调用对象的字符串形式: 包名.类名@哈希码值得十六进制
String str1 = s1.toString();
//9.2// System.out.println("str1 = " + str1); //com.lagou.task11.Student@55d
//9.3// 当Student类中重写toString方法后,则调用重写以后的版本 Student[id = 1001,name = zhangfei]
System.out.println("str1 = " + str1); //Student[id = 1001,name = zhangfei]
System.out.println(s1); //9.4//打印引用变量时,会自动调用toString方法
String str2 = "hello" + s1; //9.5// 打印时,或者字符串拼接时,都会自动调用该方法
System.out.println("str2 = " + str2);
}
}
11.3 包装类（熟悉）
11.3.1 包装类的概念
通常情况下基本数据类型的变量不是对象，为了满足万物皆对象的理念就需要对基本数据类型的变 量进行打包封装处理 变成对象，而负责将这些变量声明为成员变量进行对象化处理的相关类，叫做包装类。
如： Person p = new Person(); // 是对象
int num = 10; // 不是对象
11.3.2 包装类的分类
11.3.3 Integer类的概述
（1）基本概念
java.lang.Integer类内部包装了一个int类型的变量作为成员变量，
主要用于实现对int类型的包装并 提供int类型到String类之间的转换等方法。
（2）常用的常量
（3）常用的方法
（4）装箱和拆箱的概念
在Java5发布之前使用包装类对象进行运算时，需要较为繁琐的“拆箱”和“装箱”操作；即运算前先将 包装类对象拆分为基本类型数据，运算后再将结果封装成包装类对象。 从Java5开始增加了自动拆箱和自动装箱的功能。
（5）自动装箱池
在Integer类的内部提供了自动装箱池技术，将-128到127之间的整数已经装箱完毕，当程序中使用 该范围之间的整数时，无需装箱直接取用自动装箱池中的对象即可，从而提高效率。
代码: Integer类的 常量, 常用方法测试
{valueOf(), intValue(), parseInt(), equals() , 进制转换字符串}
package com.lagou.task11;
/**
* @author CH
* @date 2020/9/27 18:14
*/
public class IntegerTest {
public static void main(String[] args) {
//1.1//打印Integer类中常用的常量数值
System.out.println("最大值是 : " + Integer.MAX_VALUE); //2^31-1
System.out.println("最小值是: " + Integer.MIN_VALUE); //-2^31
System.out.println("所表示二进制的位数是: " + Integer.SIZE); //32
System.out.println("所占字节的个数是: " + Integer.BYTES); //4
System.out.println("对应int类型的Class实例是: " + Integer.TYPE); // int
System.out.println("-------------------------------------------------------");
//1.2//使用构造方法来构造Integer类型的对象
Integer it1 = new Integer(123);
System.out.println("it1 = " + it1); // 123 //1.3// 自动调用toString方法
Integer it2 = new Integer("456");
System.out.println("it2 = " + it2);
System.out.println("-------------------------------------------------------");
//1.4//上述方法已过时,建议使用valueof方法取代之,相当于int到Integer类型的转换 //1.7//叫做装箱
Integer it3 = Integer.valueOf(123);
System.out.println("it3 = " + it3); //123
Integer it4 = Integer.valueOf("456");
//1.5//从String类型到Integer类型的转换
System.out.println("it4 = " + it4); //456 得到String类型
//1.6//获取调用对象中的整数数值,相当于从Integer类型到int类型的转换 //1.7//叫做拆箱
int ia = it4.intValue();
System.out.println("获取到的整数数据是:" + ia); //456 得到int类型
System.out.println("-------------------------------------------------------");
//1.8//Java5开始,增加了自动装箱拆箱的机制
Integer it5 = 100; //1.8//直接通过赋值运算符实现自动装箱
int ib = it5; //1.8//直接通过赋值运算符实现自动拆箱
System.out.println("-------------------------------------------------------");
//1.9//装箱和拆箱的笔试考点
Integer it6 = 127; //128;
Integer it7 = 127; //128;
Integer it8 = new Integer(127); //1.10//new Integer(128);
Integer it9 = new Integer(127); //1.10//new Integer(128);
System.out.println(it6 == it7); //比较地址 false //1.10//true 地址是一样的 自动装箱池
System.out.println(it6.equals(it7)); //比较内容 true
System.out.println(it8 == it9); //比较地址 false
System.out.println(it8.equals(it9)); //比较内容 true
System.out.println("-------------------------------------------------------");
//1.11//实现静态方法的调用
int ic = Integer.parseInt("200"); //编译OK,运行发生NumberFormatException数字格式异常,因为有字母
//int ic = Integer.parseInt("200a"); //编译OK,运行发生NumberFormatException数字格式异常,因为有字母
System.out.println("字符串转换为整数的结果是:" + ic); //200
System.out.println("根据参数指定的整数获取对应的十进制字符串是: " + Integer.toString(200)); //200
System.out.println("根据参数指定的整数获取对应的二进制字符串是: " + Integer.toBinaryString(200)); //11001000
System.out.println("根据参数指定的整数获取对应的十六进制字符串是: " + Integer.toHexString(200)); //c8
System.out.println("根据参数指定的整数获取对应的八进制字符串是: " + Integer.toOctalString(200)); //310
}
}
11.3.4 Double类的概述
（1）基本概念
java.lang.Double类型内部包装了一个double类型的变量作为成员变量，主要用于实现对double 类型的包装并提供double类型到String类之间的转换等方法。
（2）常用的常量
（3）常用的方法
扩展： java.lang.Number类是个抽象类，是上述类的父类来描述所有类共有的成员。
代码: Double类的常用方法测试
{valueOf(), doubleValue(), parseDouble(), isNaN() }
package com.lagou.task11;
/**
* @author CH
* @date 2020/9/27 19:36
*/
public class DoubleTest {
public static void main(String[] args) {
//1.1// Java5之前装箱和拆箱
//1.2// 实现了double到 Double的转换 ,装箱
Double db1 = Double.valueOf(3.14);
System.out.println("db1 = " + db1); //3.14
//1.3// 实现了从Double到double类型的转换,拆箱
double d1 = db1.doubleValue();
System.out.println("d1 = " + d1);//3.14
System.out.println("-------------------------------------");
//2.1//从Java5开始,实现自动装箱拆箱
Double db2 = 3.14;
System.out.println("db2 = " + db2);//3.14
double d2 = db2;
System.out.println("d2 = " + d2);//3.14
System.out.println("-------------------------------------");
//3.1//实现静态方法和成员方法的调用
double d3 = Double.parseDouble("13.14");
System.out.println("d3 = " + d3);//13.14
System.out.println("db2对象的判断结果是: " + db2.isNaN()); // false //3.2//不是非数字
Double db3 = Double.valueOf(0/0.0);
System.out.println("db2对象的判断结果是: " + db3.isNaN()); // true //3.2//是非数字
}
}
11.3.5 Boolean类的概述
（1）基本概念
java.lang.Boolean类型内部包装了一个boolean类型的变量作为成员变量，
主要用于实现对 boolean类型的包装并提供boolean类型到String类之间的转换等方法。
（2）常用的常量
（3）常用的方法
代码: Boolean类的常用方法测试
{valueOf(), booleanValue(), parseBoolean() }
package com.lagou.task11;
/**
* @author CH
* @date 2020/9/27 21:47
*/
public class BooleanTest {
public static void main(String[] args) {
//1.1// Java5之前的装箱拆箱
//1.1// 从boolean到Boolean的转换, 装箱
Boolean bo1 = Boolean.valueOf(true);
System.out.println("bo1 = " + bo1); //true
boolean b1 = bo1.booleanValue();
System.out.println("b1 = " + b1); //true
System.out.println("-------------------------------------------");
//2.1//Java5 开始自动装箱拆箱
Boolean bo2 = false;
boolean b2 = bo2;
System.out.println("bo2 = " + bo2);
System.out.println("b2 = " + b2);
System.out.println("-------------------------------------------");
//3.1// 实现String到Boolean类型的转换
//Boolean b3 = Boolean.parseBoolean("123");
// 3.2// 该方法执行原理: 只要参数数值不为true或TRUE, 则结果均为false,
Boolean b3 = Boolean.parseBoolean("TRUE");
System.out.println("b3 = " + b3); //true
}
}
11.3.6 Character类的概述
（1）基本概念 java.lang.Character类型内部包装了一个char类型的变量作为成员变量，主要用于实现对char类型 的包装并提供字符类别的判断和转换等方法。
（2）常用的常量
（3）常用的方法
代码: Character类的常用方法测试
{valueOf(), charValue(), parseCharacter(), isUpperCase(), isLowerCase(), isDigit, toUpperCase(), toLowerCase() }
package com.lagou.task11;
/**
* @author CH
* @date 2020/9/27 22:00
*/
public class CharacterTest {
public static void main(String[] args) {
//1.1// Java5之前的装箱拆箱
//1.1// 相当于从char类型到Character类型的转换,装箱
Character ca1 = Character.valueOf('a');
System.out.println("ca1 = " + ca1); //a
//1.2// Character -> char
char c1 = ca1.charValue();
System.out.println("c1 = " + c1); //a
System.out.println("----------------------------------------");
//2.1// Java5之后的 装箱拆箱
Character ca2 = 'b';
char c2 = ca2;
System.out.println("ca2 = " + ca2); //b
System.out.println("c2 = " + c2); //b
System.out.println("----------------------------------------");
//3.1//实现字符类型的判断以及转换
System.out.println(Character.isUpperCase(c2)); //false
System.out.println(Character.isLowerCase(c2)); //true
System.out.println(Character.isDigit(c2)); //false
System.out.println("转换为大写字母是: " + Character.toUpperCase(c2)); //B
System.out.println("转换为小写字母是: " + Character.toLowerCase(c2)); //b
}
}
11.3.7 包装类（Wrapper）的使用总结
基本数据类型转换为对应包装类的方式
调用包装类的构造方法或静态方法即可 大类名 引用 = 大类名 . valueOf(参数);
获取包装类对象中基本数据类型变量数值的方式
调用包装类中的xxxValue方法即可 小类名 变量 = 引用 . 小类名Value();
字符串转换为基本数据类型的方式
调用包装类中的parseXxx方法即可 大类名 引用 = 大类名 . parse小类名(字符串);
11.4 数学处理类（熟悉）
11.4.1 Math类的概述
（1）基本概念
java.lang.Math类主要用于提供执行数学运算的方法，如：对数，平方根。
（2）常用的方法
代码: Math类中常用方法的测试
{ max(), min(), pow(), abs(), round(), sqrt(), random() }
package com.lagou.task11;
import com.lagou.task10.Man;
/**
* @author CH
* @date 2020/9/27 22:53
* 编程实现对Math类中常用方法的测试
*/
public class MathTest {
public static void main(String[] args) {
System.out.println("获取两个整数中最大值的结果是: " + Math.max(10, 20)); //20
System.out.println("两个整数中最小值: " + Math.min(10, 20)); //20
System.out.println("获取次方的结果是: " + Math.pow(2, 3)); //8.0 体现double类型
System.out.println("获取绝对值的结果是: " + Math.abs(-5)); //5
System.out.println("进行四舍五入的结果是: " + Math.round(3.14)); //3
System.out.println("该整数的平方根是: " + Math.sqrt(16)); //4.0 体现double类型
System.out.println("生成的随机数是: " + Math.random()); //随机数
}
}
11.4.2 BigDecimal类的概述
（1）基本概念
由于float类型和double类型在运算时可能会有误差，若希望实现精确运算则借助 java.math.BigDecimal类型加以描述。
（2）常用的方法
代码: BigDecimal类中常用方法的测试 精确运算及Rounding类中四舍五入测试
{ 构造, add, subtract, multiply, divide } , { RoundingMode.HALF_UP }
package com.lagou.task11;
import java.math.BigDecimal;
import java.math.RoundingMode;
/**
* @author CH
* @date 2020/9/28 10:37
*/
public class BigdecimalTest {
public static void main(String[] args) {
//1.1//构造BigDecimal类型的两个对象
BigDecimal bd1 = new BigDecimal("5.2"); //一定要注意这里有双引号
BigDecimal bd2 = new BigDecimal("1.3");
//1.2//使用构造完毕的对象实现加减乘除运算
System.out.println("实现加法运算的结果是: " + bd1.add(bd2)); //6.5
System.out.println("实现减法的运算结果是:" + bd1.subtract(bd2)); //3.9
System.out.println("实现乘法的运算结果是:" + bd1.multiply(bd2)); //6.76
System.out.println("实现除法的运算结果是:" + bd1.divide(bd2)); //4
System.out.println("---------------------------------------------------");
//1.3//实现精确运算
System.out.println(0.1 + 0.2); //0.30000000000000004
BigDecimal bd3 = new BigDecimal("0.1");
BigDecimal bd4 = new BigDecimal("0.2");
System.out.println("实现加法运算的结果是: " + bd3.add(bd4)); //0.3
System.out.println("---------------------------------------------------");
//1.4//注意事项
BigDecimal bd5 = new BigDecimal("2");
BigDecimal bd6 = new BigDecimal("0.3");
//System.out.println("实现除法的运算结果是:" + bd5.divide(bd6)); // 编译OK 运行发生 ArithmeticException,无法精确表示
System.out.println("实现除法的运算结果是:" + bd5.divide(bd6, RoundingMode.HALF_UP)); // 7 要使用math包的Rounding.HALF_UP
}
}
11.4.3 BigInteger类的概念
（1）基本概念
若希望表示比long类型范围还大的整数数据，则需要借助java.math.BigInteger类型描述。
（2）常用的方法
代码: BigInteger类中常用方法测试
{构造 add, subtract, multiply, divide, remainder, divideAndRemainder, }
package com.lagou.task11;
import java.math.BigInteger;
import java.util.Arrays;
/**
* @author CH
* @date 2020/9/28 11:03
*/
public class BigIntegerTest {
public static void main(String[] args) {
//1.1// 构造2对象,并初始值
BigInteger bi1 = new BigInteger("20");
BigInteger bi2 = new BigInteger("8");
//2.1// 实现加减乘除操作并打印
System.out.println("加法运算结果是: " + bi1.add(bi2)); //28
System.out.println("减法运算结果是: " + bi1.subtract(bi2)); //12
System.out.println("乘法运算结果是: " + bi1.multiply(bi2)); //160
System.out.println("除法运算结果是: " + bi1.divide(bi2)); //2
System.out.println("取余运算结果是: " + bi1.remainder(bi2)); //4
System.out.println("--------------------------------------------------");
//3.1// 一次性求商和取余
BigInteger[] arr = bi1.divideAndRemainder(bi2);
System.out.println(Arrays.toString(arr));
for(int i = 0; i < arr.length; i++) {
System.out.println("数组中第" + (i+1) + "个元素是:" + arr[i]);
}
}
}
