常用类的概述和使用
一、API的使用和常用包概述
1、常用包的名称和功能
- java.lang包 - 该包是Java语言的核心包，并且该包中的所有内容由Java虚拟机自动导入，如：System类、String类....
- java.util包 - 该包是Java语言的工具包，里面提供了大量工具类和集合类等。例如：Scanner类、Random类、List集合....
- java.io包 - 该包是java语言的输入输出包，里面提供了大量读写文件相关的类等。如：FileInputStream类、FileOutputStream类、....
- java.net包 - 该包是Java语言中的网络包，里面提供了大量的网络编程相关的类等。如：ServerSocke类、Socket类、...
- java.sql包 - 该包是Java语言中的数据包，里面提供了大量操作数据库的类和接口等。如：DriverManager类、Connection接口、....
- ... ...
- Java程序员在编程时可以使用大量类库，因此Java编程时需要记得很多，对编程能力本身要求不是特别高。
二、Object类的概念和构造方法
1、基本概念
- java.lang.Object类是Java语言中类层次结构的根类，也就是说任何一个类都是该类的直接或间接子类。
- 如果定义一个Java类时没有使用extends关键字声明其父类，则其父类为java.lang.Object类。
- Object类定义了“对象”的基本行为，被子类默认继承
2、常用方法
方法声明 功能介绍
Object() 使用无参方式构造对象
boolean equals(Object obj) 用于判断调用对象是否与参数对象相等。
该方法默认比较两个对象的地址是否相等，与 == 运算符的结果一致
若希望比较两个对象的内容，则需要重写该方法。
若该方法被重写后，则应该重写hashCode方法来保证结果的一致性。
in hashCode() 用于获取调用对象的哈希码值(内存地址的编号)。
若两个对象调用equals方法相等，则各自调用该方法的结果必须相同
若两个调用对象equals方法不相等，则各自调用该方法的结果应该不相同。
为了使得该方法与equals方法保持一致，需要重写该方法。
String toString() 用于获取调用对象的字符串形式
该方法默认返回的字符串为：包名.类名@哈希码值的十六进制
为了返回更有意义的数据，需要重写该方法
使用print或println打印引用或字符串拼接引用都会自动调用该方法
class<?>getClass() 用于返回调用对象执行时的Class实例，反射机制使用
package com.FirstStage.ThridModule;
/**
* 编程实现Student类的封装，特征：学号(id)和姓名，要求提供打印所有特征的方法。
* 编程实现StudentTest类，在main方法中使用有参方式构造两个Student类型的对象并打印特征。
*/
import java.util.Objects;
/**
* 题目拓展：
* 如何实现以姓名作为基准判断两个对象是否相等？以及以学号和姓名同时作为基准判断两个对象是
* 否相等？
*/
public class Student {
//用private关键字修饰成员变量表示私有
private int id;//声明id描述学号
private String name;//声明name描述姓名
//自定义构造方法
public Student() {
}
public Student(int id, String name) {
setId(id);
setName(name);
}
//自定义get、set方法获取私有变量，进行合理值判断
public int getId() {
return id;
}
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);
}
@Override
public int hashCode() {
return Objects.hash(id, name);
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", 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;
if (id != student.id) return false;
return name != null ? name.equals(student.name) : student.name == null;
}
@Override
public int hashCode() {
int result = id;
result = 31 * result + (name != null ? name.hashCode() : 0);
return result;
}*/
/**
* 为了比较两个对象的内容，也就是学号信息需要重写该方法
*/
/*@Override
public boolean equals(Object obj) {
//当调用对象不为空而参数对象为空时，则内容一定不相同
if (null == obj) {
return false;
}
//判断obj指向的对象是否为Student类型的对象，若是则条件成立，否则条件不成立
if (obj instanceof Student) {
Student ts = (Student)obj;
//以学号作为基准判断两个对象是否相等，int是基本数据类型，内存空间中放的是数据本身，使用==可以判断数据是否相同
// return this.getId() == ts.getId();
//以姓名作为基准判断两个对象是否相等，String是引用数据类型，内存空间放的是地址，是在判断地址是否相同
//也就是判断两个对象中姓名字符串的地址是否相同
//return this.getName() == ts.getName();
return this.getName().equals(ts.getName());
}
//否则类型不一致没有可比性，则内容一定不相同
return false;
}
//为了使得该方法的结构和equals方法的结果保持一致，从而满足Java官方的常规协定，需要重写改方法
@Override
public int hashCode() {
//return getId();//不在代表内存地址的编号
final int type = 12;
//return type*31 + getId();
//以姓名为基准判断两个对象是否相等
return type*31 + getName().hashCode();
}
*//**
* 为了返回更有意义的字符串数据，则需要重写该方法
*//*
@Override
public String toString() {
return "Student[id = " + getId() + ", name = " + getName() + "]";
}*/
//自定义成员方法打印所有特征
public void show() {
System.out.println("我叫：" + getName() + "，学号是：" + getId());
}
}
package com.FirstStage.ThridModule;
public class StudentTest {
public static void main(String[] args) {
//声明Student类型的引用指向该类型的对象
Student s1 = new Student(1001, "赵云");
s1.show();
Student s2 = new Student(1002, "诸葛亮");
s2.show();
// Student s2 = s1;//表示将s1的数值赋值给s3，两者指向同一个对象
//下面调用从Object类中继承下来的equals方法，该方法默认比较两个对象的地址，查看源码
boolean ia = s1.equals(s2);
System.out.println("ia = " + ia);
System.out.println(s1 == s2);
//Student s3 = s1;//表示将s1的数值赋值给s3，两者指向同一个对象
boolean ib = s1.equals(s2);
System.out.println("ib = " + ib);
System.out.println("----------------------------");
Student s4 = new Student(1001, "刘备");
//下面调用从Object方法中继承下来的hashCode方法，获取调用对象的哈希码值（内存地址编号）
//当Student类中重写hashCode方法后，则调用重写后的版本
int ic = s1.hashCode();
System.out.println("ic = " + ic);
int id = s4.hashCode();
System.out.println("id = " + id);
System.out.println("----------------------------");
//下面调用从Object类中继承下来的toString方法，获取对象的字符串形式：包名.类名@哈希码值的十六进制
//当Student类中重写toString方法后，则调用重写以后的版本：Student[id = 1001, name = 赵云]
String str1 = s1.toString();
System.out.println("str1 = " + str1);
System.out.println(s1);//当打印一个引用变量时会自动调用toString方法
String str2 = "Hello " + s1;
System.out.println(str2);
}
}
输出：
我叫：赵云，学号是：1001
我叫：诸葛亮，学号是：1002
ia = false
false
ib = false
----------------------------
ic = 1174708
id = 706279
----------------------------
str1 = Student{id=1001, name='赵云'}
Student{id=1001, name='赵云'}
Hello Student{id=1001, name='赵云'}
Process finished with exit code 0
三、包装类（熟悉）
1、包装类
1、包装类的概念
通常情况下基本数据类型的变量不是对象，为了满足万物皆对象的理念就需要对基本数据类型的变量进行打包封装处理变成对象，而负责将这些变量声明为成员变量进行对象化处理的相关类，叫做包装类。
如：
Person p = new Person();
int nun = 10;
2、包装类的分类
包装类 对应的基本数据类型
java.lang.Byte byte
java.lang.Short short
java.lang.Integer int
java.lang.Long long
java.lang.Float float
java.lang.Double Double
java.lang.Boolean boolean
java.lang.Character char
2、Integer类的概述
（1）基本概念
java.lang.Integer类内部包装了一个int类型的变量作为成员变量，主要用于实现对int类型的包装并提供int类型到String类之间的转换等方法。
（2）常用的常量
常量的类型和名称 功能介绍
public static final int MAX_VALUE 表示int类型可以描述的最大值，即2^31-1
public static final int MIN_VALUE 表示int类型可以描述的最小值，即-2^31
public static final int SIZE 表示int类型采用二进制补码形式的位数
public static final int BYTES 表示int类型所占的字节个数
public static final int Class<> TYPE 表示int类型的Class实例
（3）常用的方法
（4）装箱和拆箱的概念
- 在Java5发布之前使用包装类对象进行运算时，需要较为繁琐的“拆箱”和“装箱”操作；即运算前先将
包装类对象拆分为基本类型数据，运算后再将结果封装成包装类对象。 - 从Java5开始增加了自动拆箱和自动装箱的功能。
（5）自动装箱池
- 在Integer类的内部提供了自动装箱池技术，将-128到127之间的整数已经装箱完毕，当程序中使用该范围之间的整数时，无需装箱直接取用自动装箱池中的对象即可，从而提高效率。
package com.FirstStage.ThridModule;
public class IntegerTest {
public static void main(String[] args) {
//打印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("---------------------");
//使用构造方法来构造Integer类型的对象并打印
/*Integer it1 = new Integer(123);
System.out.println("it1 = " + it1);//自动调用toString方法
Integer it2 = new Integer(456);
System.out.println("it2 = " + it2);//自动调用toString方法*/
//上述方法已过时，建议使用valueOf方法取代之，相当于从int类型到integer类型的转换，叫做装箱
Integer it3 = Integer.valueOf(123);
System.out.println("it3 = " + it3);
Integer it4 = Integer.valueOf("456");
System.out.println("it4 = " + it4); //自动调用toString方法得到的String类型
//获取调用对象的整数数值，相当于从Integer类型到int类型的转换，叫做拆箱
int ia = it3.intValue();
int ib = it4.intValue();
System.out.println("获取到的整数数据是：" + ia);
System.out.println("获取到的整数数据是：" + ib);//得到int类型
System.out.println("--------------------------------");
//从java5开始增加了自动装箱和自动拆箱的机制
Integer it5 = 100;//直接通过赋值运算符实现自动装箱
int ic = it5; //直接通过赋值运算符实现自动拆箱
System.out.println("---------------------------------");
//装箱和拆箱的笔试考点
Integer it6 = 127;//128; //装箱相当于自动打包为对象
Integer it7 = 127;//128;
Integer it8 = new Integer(127);//new Integer(128);
Integer it9 = new Integer(127);//new Integer(128);
System.out.println(it6 == it7); //比较地址 128: false 127: true
System.out.println(it6.equals(it7));//比较内容 true
System.out.println(it8 == it9); //比较地址 false
System.out.println(it8.equals(it9));//比较内容 true
}
}
输出：
最大值是：2147483647
最小值是：-2147483648
所表示二进制的位数是：32
所占字节的个数是：4
对应int类型的Class实例是：int
---------------------
it3 = 123
it4 = 456
获取到的整数数据是：123
获取到的整数数据是：456
--------------------------------
---------------------------------
true
true
false
true
Process finished with exit code 0
3、Double类的概述
1、基本概念
- java.lang.Double类型内部包装了一个double类型的变量作为成员变量，主要用于实现对double类型的包装并提供double类型到String类之间的转换等方法。
2、常用的常量
3、常用的方法
扩展：
- java.lang.Number类是一个抽象类，是上述类的父类来描述所有类共有的成员。
package com.FirstStage.ThridModule;
public class DoubleTest {
public static void main(String[] args) {
//在Java5之前装箱和拆箱的实现
//实现了double类型到Double类型的转换，装箱
Double db1 = Double.valueOf(3.14);
System.out.println("db1 = " + db1);
//实现从Double类型到double类型的转换，拆箱
double d1 = db1.doubleValue();
System.out.println("d1 = " + d1);
System.out.println("--------------------------------");
//从Java5之后开始实现自动装箱和自动拆箱
Double db2 = 3.14;
double d2 = db2;
System.out.println("--------------------------------");
//实现静态方法和成员方法的使用
double d3 = Double.parseDouble("13.14");
System.out.println("d3 = " + d3);
//判断调用的数值是否是非数字，数字：false 非数字：true
System.out.println("db2对象的判断结果是：" + db2.isNaN());
Double db3 = Double.valueOf(0/0.0);
System.out.println("db2对象的判断结果是：" + db3.isNaN());
}
}
输出：
db1 = 3.14
d1 = 3.14
--------------------------------
--------------------------------
d3 = 13.14
db2对象的判断结果是：false
db2对象的判断结果是：true
Process finished with exit code 0
4、Boolean类的概述
1、基本概念
- java.langBoolean类型内部包装了一个boolean类型的变量作为成员变量，主要用于实现对boolean类型的包装并提供boolean类型到String类型之间的转换等方法。
2、常用的常量
3、常用的方法
package com.FirstStage.ThridModule;
public class BooleanTest {
public static void main(String[] args) {
//在Java5之前采用方法进行装箱和拆箱
//相当于从boolean类型到Boolean类型的转换，装箱
Boolean bo1 = Boolean.valueOf(true);
System.out.println("bo1 = " + bo1);
boolean b1 = bo1.booleanValue();
System.out.println("b1 = " + b1);
System.out.println("---------------------------");
//从Java5开始支持自动装箱和拆箱
Boolean bo2 = false;
boolean b2 = bo2;
System.out.println("b2 = " + b2);
System.out.println("---------------------------");
//实现从String类型到boolean类型的转换
//该方法执行的原理：只要参数数值不为true或者TRUE是，结果就是false，查手册和源码
boolean b3 = Boolean.parseBoolean("true");
System.out.println("b3 = " + b3);
}
}
输出：
bo1 = true
b1 = true
---------------------------
b2 = false
---------------------------
b3 = true
Process finished with exit code 0
5、Character类的概述
1、基本概念
- java.lang.Character类型内部包装了一个char类型的变量作为成员变量，主要用于实现对char类型的包装并提供字符类别的判断和转换等方法。
2、常用的常量
3、常用的方法
package com.FirstStage.ThridModule;
import java.util.SortedMap;
public class CharacterTest {
public static void main(String[] args) {
//在Java5之前调用方法实现装箱和拆箱机制
//相当于从char类型到Character类型的转换，装箱
Character ca1 = Character.valueOf('a');
System.out.println("ca1 = " + ca1);
//从Character类型到char类型的转换，拆箱
char c1 = ca1.charValue();
System.out.println("c1 = " + c1);
System.out.println("-----------------------------");
//从Java5开始支持自动装箱和拆箱
Character ca2 = 'b';
char c2 = ca2;
System.out.println("c2 = " + c2);
System.out.println("---------------------");
//实现字符类型的判断以及转换
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
}
}
输出：
ca1 = a
c1 = a
-----------------------------
c2 = b
---------------------
false
true
false
转换为大写字符是：B
转换为小写字符是：b
Process finished with exit code 0
6、包装类（Wrapper）的使用总结
-
基本数据类型转换为对应包装类的方式
调用包装类的构造方法或静态方法即可
-
获取包装类对象中基本数据类型变量的数值的方式
调用包装类中的xxxValue方法即可
-
字符串转换为基本数据类型的方式
调用包装类中parseXxx方法即可
四、数学处理类
1、Math类的概述
1、基本概念
- java.lang.Math类主要用于提供执行数学运算的方法，如：对数，平方根。
2、常用的方法
package com.FirstStage.ThridModule;
public class MathTest {
public static void main(String[] args) {
System.out.println("获取两个整数中最大值的结果是：" + Math.max(10, 20));//20
System.out.println("获取两个整数中最小值的结果是：" + Math.min(10, 20));//10
System.out.println("获取次方的结果是：" + Math.pow(2,3));//8.0
System.out.println("获取绝对值的结果是：" + Math.abs(-5));//5
System.out.println("进行四舍五入的结果是：" + Math.round(3.14));//3
System.out.println("该整数的平方根是：" + Math.sqrt(16));//4.0
System.out.println("生成的随机数是：" + Math.random());//随机数
}
}
输出：
获取两个整数中最大值的结果是：20
获取两个整数中最小值的结果是：10
获取次方的结果是：8.0
获取绝对值的结果是：5
进行四舍五入的结果是：3
该整数的平方根是：4.0
生成的随机数是：0.5123058898082853
Process finished with exit code 0
2、BigDecimal类的概述
1、基本概念
- 由于float类型和double类型在运算时可能会有误差，若希望实现精确运算则借助java.math.BigDecimal类型加以描述。
2、常用方法
package com.FirstStage.ThridModule;
import java.math.BigDecimal;
import java.math.RoundingMode;
public class BigDecimalTest {
public static void main(String[] args) {
//构造BigDecimal类型的两个对象
BigDecimal bd1 = new BigDecimal("5.2");
BigDecimal bd2 = new BigDecimal("1.3");
//使用构造完毕的对象实现加减乘除运算
System.out.println("实现加法运算的结果是" + bd1.add(bd2));
System.out.println("实现减法运算的结果是" + bd1.subtract(bd2));
System.out.println("实现乘法运算的结果是" + bd1.multiply(bd2));
System.out.println("实现除法运算的结果是" + bd1.divide(bd2));
System.out.println("---------------------------");
//实现精确运算
System.out.println(0.1 + 0.2);
BigDecimal bd3 = new BigDecimal("0.1");
BigDecimal bd4 = new BigDecimal("0.2");
System.out.println("实现精确运算的结果是：" + bd3.add(bd4));
System.out.println("实现精确运算的结果是" + bd3.subtract(bd4));
System.out.println("实现精确运算的结果是" + bd3.multiply(bd4));
System.out.println("实现精确运算的结果是" + bd3.divide(bd4));
System.out.println("----------------------------------");
//注意事项
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));
}
}
输出：
实现加法运算的结果是6.5
实现减法运算的结果是3.9
实现乘法运算的结果是6.76
实现除法运算的结果是4
---------------------------
0.30000000000000004
实现精确运算的结果是：0.3
实现精确运算的结果是-0.1
实现精确运算的结果是0.02
实现精确运算的结果是0.5
----------------------------------
除法运算的结果是：7
Process finished with exit code 0
3、BigInteger类的概念
1、基本概念
- 若希望表示比long类型范围还大的整数数据，则需要借助java.math.BigInteger类型描述。
2、常用的方法
package com.FirstStage.ThridModule;
import java.math.BigInteger;
public class BigIntegerTest {
public static void main(String[] args) {
//构造两个BigInteger类型的对象并指定初始值
BigInteger bi1 = new BigInteger("20");
BigInteger bi2 = new BigInteger("8");
//实现加减乘除取余操作并打印
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("-------------------------------------");
//一次性得到商和余数
BigInteger[] arr = bi1.divideAndRemainder(bi2);
for (int i = 0; i < arr.length; i++) {
System.out.println("下标为" + i + "的元素是：" + arr[i]);
}
}
}
输出：
实现加法运算的结果是：28
实现减法运算的结果是：12
实现乘法运算的结果是：160
实现除法运算的结果是：2
实现取余运算的结果是：4
-------------------------------------
下标为0的元素是：2
下标为1的元素是：4
Process finished with exit code 0
本文来自博客园，作者：寒露凝珠，转载请注明原文链接：https://www.cnblogs.com/china-soldier/p/14956622.html
