01_03_java基础 java类库的使用(上)

前言

文章内容输出来源：拉勾教育Java就业训练营

类库的使用

常用的类

包的名称和功能

• java.lang包 - 该包是Java语言的核心包，并且该包中的所有内容由Java虚拟机自动导入。如：System类、String类、…
• java.util包 - 该包是Java语言的工具包，里面提供了大量工具类以及集合类等。如：Scanner类、Random类、List集合、…
• java.io包 - 该包是Java语言中的输入输出包，里面提供了大量读写文件相关的类等。如：FileInputStream类、FileOutputStream类、…
• java.net包 - 该包是Java语言中的网络包，里面提供了大量网络编程相关的类等。
  如：ServerSocket类、Socket类、…
• java.sql 包 - 该包是Java语言中的数据包，里面提供了大量操作数据库的类和接口等。如：DriverManager类、Connection接口、…
  Java程序员在编程时可以使用大量类库，因此Java编程时需要记的很多，对编程能力本身要求不是
  特别的高。

Object 类

基本概念

• java.lang.Object类是Java语言中类层次结构的根类，也就是说任何一个类都是该类的直接或者间接子类。
• 如果定义一个Java类时没有使用extends关键字声明其父类，则其父类为 java.lang.Object 类。
• Object类定义了“对象”的基本行为, 被子类默认继承。

常用方法

• 声明方式：Object()
  功能介绍：使用无参方式构造对象
• 声明方式：boolean equals(Object obj)
  功能介绍：用于判断调用对象是否与参数对象相等。该方法默认比较两个对象的地址是否相等，与 == 运算符的结果一致若希望比较两个对象的内容，则需要重写该方法。若该方法被重写后，则应该重写hashCode方法来保证结果的一致性。

Student 类,用来测试继承根类Object的方法

import java.util.Objects;

public class Student extends Object{
    private int id; //用于描述学号的成员变量
    private String name; //用于描述姓名的成员变量

    public Student() {
    }

    public Student(int id, String name) {
        setId(id);
        setName(name);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        if (id > 0) {
            this.id = id;
        } else {
            System.out.println("学号不合理");
        }
    }

    /**
     *为了比较两个对象的内容，也就是学号信息需要重写该方法
     */
    // Student this = s1;
    // Object obj = s2;
    @Override
    public boolean equals(Object obj){
        // 当调用对象和参数对象指向同一个对象时，则内容一定相同
        if (this == obj) return true;
        // 当调用对象为不为空而参数对象为空时，则内容一定不相同
        if (null == obj) return false;
        // 判断obj指向的对象是否为Student类型的对象，若是则条件成立，否则条件不成立
        if (obj instanceof Student) {
            Student st = (Student) obj;
            return this.getId() == st.getId();
        }
        // 否则类型不一致没有可比性，则内容一定不相同
        return false;
    }
}

测试类StudentTest

public class StudentTest {

    public static void main(String[] args) {
        // 1.使用有参方式构造Student类型的两个对象并判断是否相等
        Student s1 = new Student(1001, "zhangsan");
        Student s2 = new Student(1001, "zhangsan");
        //  Student s2 = new Student(1002, "zhangfei");
        //   Student s3 =s1; //表示s3和s1都指向同一个对象

        // 下面调用从Object类中继承下来的equals方法，该方法默认比较两个对象的地址，可以查看源码验证
        // 当Student类中重写equals方法后，则调用重写以后的版本，比较内容
        boolean b1 = s1.equals(s2);//在源码是进行比较地址，this代表正在调用的对象
//        Student s3 = null; //当传入的值为空时，那么就直接返回false
//        boolean b1 = s1.equals(s3);//当调用对象和参数对象指向同一个对象
//        Student s3 = s1;//当调用对象和参数对象指向同一个对象
        System.out.println("b1 = " + b1); //false
        System.out.println(s1 == s2);//进行内存地址比较 false
        // System.out.println(s3 == s1);//由于内存地址相同 true

    }
}

• 声明方式：int hashCode()
  功能介绍：用于获取调用对象的哈希码值(内存地址的编号)。若两个对象调用equals方法相等，则各自调用该方法的结果必须相同若两个调用对象equals方法不相等，则各自调用该方法的结果应该不相同。为了使得该方法与equals方法保持一致，需要重写该方法。
  Student 类

 	/**
 	 * 为了使得该方法的结果与equals方法的结果保持一致，从而满足Java官方的常规协定，需要重写该方法
     */
    @Override
    public int hashCode() {
        //return getId(); // 不再代表内存地址的编号了
        final int type = 12;
        return type*31 + getId();
    }

测试类StudentTest

 // 下面调用从Object类中继承下来的hashCode方法，获取调用对象的哈希码值(内存地址的编号)
        // 当Student类中重写hashCode方法后，则调用重写以后的版本
        int ia = s1.hashCode();
        int ib = s2.hashCode();
        System.out.println("ia = " + ia);
        System.out.println("ib = " + ib);

• 声明方式：String toString()
  功能介绍：用于获取调用对象的字符串形式该方法默认返回的字符串为：包名.类名@哈希码值的十六进制为了返回更有意义的数据，需要重写该方法使用print或println打印引用或字符串拼接引用都会自动调用该方法
  Student 类

/**
  * 为了返回更有意义的字符串数据，则需要重写该方法
  */
@Override
    public String toString() {
        return "Student[id = " + getId() + ", name = " + getName() + "]";
    }

测试类StudentTest

System.out.println("----------------------------------------------------------");
// 下面调用从Object类中继承下来的toString方法，获取调用对象的字符串形式：包名.类名@哈希码值的十六进制
// 当Student类中重写toString方法后，则调用重写以后的版本：Student[id = 1001, name = zhangfei]
String str1 = s1.toString();
System.out.println("str1 = " + str1); // com.task11.Student@55d
System.out.println(s1); // 当打印一个引用变量时会自动调用toString方法
String str2 = "hello" + s1;
System.out.println("str2 = " + str2);
输出>>>
str1 = Student[id = 1001, name = zhangsan]
Student[id = 1001, name = zhangsan]
str2 = helloStudent[id = 1001, name = zhangsan]

• 声明方式：Class<?> getClass()
  功能介绍：用于返回调用对象执行时的Class实例，反射机制使用
• 扩展
  要注意引用数据类型的对比，内存空间中放的是地址，使用 == 判断的是地址是否相同
  例如：String类型 ，那么在String中是有重写方法equals，那么进行对比的话可以通过
  Student 类

return this.getName().equals(ts.getName()); // 比较姓名字符串的内容是否相同

包装类

包装类的概念

• 通常情况下基本数据类型的变量不是对象，为了满足万物皆对象的理念就需要对基本数据类型的变量进行打包封装处理变成对象，而负责将这些变量声明为成员变量进行对象化处理的相关类，叫做包装类。
  如：
  Person p = new Person();
  int num = 10;//这种基本类型应该来将不能算做是对象，当是我们可以创建一个类来进行对int这个基本类型进行包装

包装类	对应的基本类型
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

Integer类的概述

• 基本概念
  java.lang.Integer类内部包装了一个int类型的变量作为成员变量，主要用于实现对int类型的包装并提供int类型到String类之间的转换等方法
• 常用的常量

常量类型和名称	功能介绍
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 Class TYPE	表示int类型的Class实例

IntegerTest 类

public class IntegerTest {
    public static void main(String[] args) {

        // 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
    }
}
>>>
最大值是：2147483647
最小值是：-2147483648
所表示二进制的位数是：32
所占字节的个数是：4
对应int类型的Class实例是：int

• 常用的方法

方法声明	功能介绍
Integer(int value)	根据参数指定的整数来构造对象（已过时）
Integer(String s)	根据参数指定的字符串来构造对象 （已过时）
int intValue()	获取调用对象中的整数值并返回
static Integer valueOf(int i)	根据参数指定整数值得到Integer类型对象
boolean equals(Object obj)	比较调用对象与参数指定的对象是否相等
String toString()	返回描述调用对象数值的字符串形式
static int parseInt(String s)	将字符串类型转换为int类型并返回
static String toString(int i)	获取参数指定整数的十进制字符串形式
static String toBinaryString(int i)	获取参数指定整数的二进制字符串形式
static String toHexString(int i)	获取参数指定整数的十六进制字符串形式
static String toOctalString(int i)	获取参数指定整数的八进制字符串形式

IntegerTest 类

System.out.println("------------------------------------------------------");
        // 2.使用构造方法来构造Integer类型的对象并打印
        //Integer it1 = new Integer(123);
        //System.out.println("it1 = " + it1); // 自动调用toString方法   123
        //Integer it2 = new Integer("456");
        //System.out.println("it2 = " + it2); // 456
        // 上述方法已过时，建议使用valueOf方法取代之，相当于从int类型到Integer类型的转换，叫做装箱
        Integer it3 = Integer.valueOf(123);
        System.out.println("it3 = " + it3); // 123
        // 相当于从String类型到Integer类型的转换
        Integer it4 = Integer.valueOf("456");
        System.out.println("it4 = " + it4); // 456   自动调用toString方法得到的是String类型
        // 获取调用对象中的整数数值，相当于从Integer类型到int类型的转换，叫做拆箱
        int ia = it4.intValue();
        System.out.println("获取到的整数数据是：" + ia); // 456  得到的是int类型
        System.out.println("------------------------------------------------------");

• 装箱和拆箱的概念
  在Java5发布之前使用包装类对象进行运算时，需要较为繁琐的“拆箱”和“装箱”操作；即运算前先将包装类对象拆分为基本类型数据，运算后再将结果封装成包装类对象。
  从Java5开始增加了自动拆箱和自动装箱的功能。

IntegerTest 类

System.out.println("------------------------------------------------------");
        // 3.从Java5开始增加了自动装箱和自动拆箱的机制
        Integer it5 = 100;  // 直接通过赋值运算符实现自动装箱
        int ib = it5;       // 直接通过赋值运算符实现自动拆箱

• 自动装箱池
  在Integer类的内部提供了自动装箱池技术，将-128到127之间的整数已经装箱完毕，当程序中使用该范围之间的整数时，无需装箱直接取用自动装箱池中的对象即可，从而提高效率。

IntegerTest 类

 System.out.println("------------------------------------------------------");
        // 4.装箱和拆箱的笔试考点
        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);      // 比较地址  false  true  地址一样
        System.out.println(it6.equals(it7)); // 比较内容  true
        System.out.println(it8 == it9);      // 比较地址  false
        System.out.println(it8.equals(it9)); // 比较内容  true

• 静态方法的调用
  IntegerTest 类

  System.out.println("------------------------------------------------------");
        // 5.实现静态方法的调用
        int ic = Integer.parseInt("200");
        //int ic = Integer.parseInt("200a"); // 编译ok,运行发生NumberFormatException数字格式异常，因为有字母
        System.out.println("字符串转换为整数的结果是：" + ic); // 200
        System.out.println("根据参数指定的整数获取对应的十进制字符串是：" + Integer.toString(200));
        System.out.println("根据参数指定的整数获取对应的二进制字符串是：" + Integer.toBinaryString(200));
        System.out.println("根据参数指定的整数获取对应的十六进制字符串是：" + Integer.toHexString(200));
        System.out.println("根据参数指定的整数获取对应的八进制字符串是：" + Integer.toOctalString(200));
输出>>>
字符串转换为整数的结果是：200
根据参数指定的整数获取对应的十进制字符串是：200
根据参数指定的整数获取对应的二进制字符串是：11001000
根据参数指定的整数获取对应的十六进制字符串是：c8
根据参数指定的整数获取对应的八进制字符串是：310

Double类的概述

• Double类的基本概念
  java.lang.Double类型内部包装了一个double类型的变量作为成员变量，主要用于实现对double
  类型的包装并提供double类型到String类之间的转换等方法
• 常用的常量

常量类型和名称	功能介绍
public static final int SIZE	表示double类型的二进制位数
public static final int BYTES	表示double类型的字节个数
public static final Class TYPE	表示double类型的Class实例

功能和上面的Integer的常量调用方式是一样的。

• Double常用方法

方法声明	功能介绍
Double(double value)	根据参数指定的浮点数据来构造对象（已过时）
Double(String s)	根据参数指定的字符串来构造对象 （已过时）
double doubleValue()	获取调用对象中的浮点数据并返回
static Double valueOf(double d)	根据参数指定浮点数据得到Double类型对象
boolean equals(Object obj)	比较调用对象与参数指定的对象是否相等
String toString()	返回描述调用对象数值的字符串形式
static double parseDouble(String s)	将字符串类型转换为double类型并返回
boolean isNaN()	判断调用对象的数值是否为非数字

DoubleTest测试类

    public static void main(String[] args) {
        // 1.在Java5之前装箱和拆箱的实现
        // 实现了从double类型到Double类型的转换，装箱
        Double db1 = Double.valueOf(3.14);
        System.out.println("db1 = " + db1); // 3.14
        // 实现了从Double类型到double类型的转换，拆箱
        double d1 = db1.doubleValue();
        System.out.println("d1 = " + d1); // 3.14

        System.out.println("---------------------------------------------");
       Double db2 = 3.14;
        double d2 = db2;
        System.out.println("db2 = " + db2);
        System.out.println("d2 = " + d2);
        System.out.println("---------------------------------------------");
        // 3.实现静态方法和成员方法的调用
        double d3 = Double.parseDouble("13.14");
        System.out.println("d3 = " + d3); // 13.14
        System.out.println("db2对象的判断结果是：" + db2.isNaN()); // false 不是非数字
        Double db3 = Double.valueOf(0 / 0.0);
        System.out.println(0 / 0.0);
        System.out.println("db2对象的判断结果是：" + db3.isNaN()); // true  是非数字
    }
输出>>>
db1 = 3.14
d1 = 3.14
---------------------------------------------
db2 = 3.14
d2 = 3.14
---------------------------------------------
d3 = 13.14
db2对象的判断结果是：false
NaN
db2对象的判断结果是：true

• java.lang.Number类是个抽象类，是上述类的父类来描述所有类共有的成员。
  抽象类Number是表示数字值可转换为基本数据类型平台类的超类\父类byte,double,float,int,long和short 。
  子类有：Integer、Byte、 Double、 Long 、Short 、 Float

Boolean类的概述

• Boolean基本概念
  java.lang.Boolean类型内部包装了一个boolean类型的变量作为成员变量，主要用于实现对boolean类型的包装并提供boolean类型到String类之间的转换等方法。

• 常量

常量类型和名称	功能介绍
public static final Boolean FALSE	对应基值为false的对象
public static final Boolean TRUE	对应基值为true的对象
public static final Class TYPE	表示boolean类型的Class实例

• 方法

方法声明	功能介绍
Boolean(boolean value)	根据参数指定的布尔数值来构造对象（已过时）
Boolean(String s)	根据参数指定的字符串来构造对象 （已过时）
boolean booleanValue()	获取调用对象中的布尔数值并返回
static Boolean valueOf(boolean b)	根据参数指定布尔数值得到Boolean类型对象
boolean equals(Object obj)	比较调用对象与参数指定的对象是否相等
String toString()	返回描述调用对象数值的字符串形式
static boolean parseBoolean(String s)	将字符串类型转换为boolean类型并返回

BooleanTest测试类

public static void main(String[] args) {

        // 1.在Java5之前采用方法进行装箱和拆箱
        // 相当于从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.从Java5开始支持自动装箱和拆箱
        Boolean bo2 = false;
        boolean b2 = bo2;
        System.out.println("b2 = " + b2); // false

        System.out.println("----------------------------------------------");
        // 3.实现从String类型到boolean类型的转换
        //boolean b3 = Boolean.parseBoolean("112");
        // 该方法的执行原理是：只要参数数值不为true或者TRUE时，则结果就是false，查手册和源码
        boolean b3 = Boolean.parseBoolean("TRUE");
        System.out.println("b3 = " + b3); // true
    }
输出>>>
bo1 = true
b1 = true
----------------------------------------------
b2 = false
----------------------------------------------
b3 = true

Character类的概述

• Character基本概念
  java.lang.Character类型内部包装了一个char类型的变量作为成员变量，主要用于实现对char类型的包装并提供字符类别的判断和转换等方法。

• 常量

常量类型和名称	功能介绍
public static final int SIZE	表示char类型的二进制位数
public static final int BYTES	表示char类型的字节个数
public static final Class TYPE	表示char类型的Class实例

• 方法

方法声明	功能介绍
Character(char value)	根据参数指定的字符数据来构造对象（已过时）
char charValue()	获取调用对象中的字符数据并返回
static Character valueOf(char c)	根据参数指定字符数据得到Character类型对象
boolean equals(Object obj)	比较调用对象与参数指定的对象是否相等
String toString()	返回描述调用对象数值的字符串形式
static boolean isUpperCase(char ch)	判断参数指定字符是否为大写字符
static boolean isLowerCase(char ch)	判断参数指定字符是否为小写字符
static boolean isDigit(char ch)	判断参数指定字符是否为数字字符
static char toUpperCase(char ch)	将参数指定的字符转换为大写字符
static char toLowerCase(char ch)	将参数指定的字符转换为小写字符

CharacterTest测试类

  public static void main(String[] args) {

        // 1.在Java5之前调用方法实现装箱和拆箱机制
        // 相当于从char类型到Character类型的转换，装箱
        Character ca1 = Character.valueOf('a');
        System.out.println("ca1 = " + ca1); // a
        // 从Character类型向char类型的转换，拆箱
        char c1 = ca1.charValue();
        System.out.println("c1 = " + c1); // a

        System.out.println("----------------------------------------");
        // 2.从Java5开始支持自动装箱和拆箱
        Character ca2 = 'b';
        char c2 = ca2;
        System.out.println("c2 = " + c2); // b

        System.out.println("----------------------------------------");
        // 3.实现字符类型的判断以及转换
        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

包装类（Wrapper）的使用总结

• 基本数据类型转换为对应包装类的方式
  调用包装类的构造方法或静态方法即可
• 获取包装类对象中基本数据类型变量数值的方式
  调用包装类中的xxxValue方法即可
• 字符串转换为基本数据类型的方式
  调用包装类中的parseXxx方法即可

数学处理类

Math类的概述

• Math类的基本概念
  java.lang.Math类主要用于提供执行数学运算的方法，如：对数，平方根。

方法声明	功能介绍
static int max(int a, int b)	返回两个参数中的最大值
static int min(int a, int b)	返回两个参数中的最小值
static double pow(double a, double b)	返回第一个参数的幂
static int abs(int a)	返回参数指定数值的绝对值
static long round(double a)	返回参数四舍五入的结果
static double sqrt(double a)	返回参数的平方根
static double random()	返回0.0到1.0的随机数

    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  体现double类型
        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.6015173453743582

BigDecimal类的概述

• BigDecimal基本概念
  由于float类型和double类型在运算时可能会有误差，若希望实现精确运算则借助java.math.BigDecimal类型加以描述。
• 常用方法

方法声明	功能介绍
BigDecimal(String val)	根据参数指定的字符串来构造对象
BigDecimal add(BigDecimal augend)	用于实现加法运算
BigDecimal subtract(BigDecimal subtrahend)	用于实现减法运算
BigDecimal multiply(BigDecimal multiplicand)	用于实现乘法运算
BigDecimal divide(BigDecimal divisor)	用于实现除法运算

BigDecimalTest测试类

public static void main(String[] args) {

        // 1.构造BigDecimal类型的两个对象
        BigDecimal bd1 = new BigDecimal("5.2");
        BigDecimal bd2 = new BigDecimal("1.3");
        // 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("---------------------------------------------------------------");
        // 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("---------------------------------------------------------------");
        // 4.注意事项
        BigDecimal bd5 = new BigDecimal("2");
        BigDecimal bd6 = new BigDecimal("0.3");
        // System.out.println("除法运算的结果是："+bd5.divide(bd6));//报错java.lang.ArithmeticException:算数运行异常，2除以0.3是无法整除的，而且还是无限循环下去，所以报错
        //换种方式
        System.out.println("除法运算的结果是：" + bd5.divide(bd6, RoundingMode.HALF_UP)); // 7
    }
输出>>>
实现加法运算的结果是：6.5
实现减法运算的结果是：3.9
实现乘法运算的结果是：6.76
实现除法运算的结果是：4
---------------------------------------------------------------
0.30000000000000004
精确计算的结果是：0.3
---------------------------------------------------------------
除法运算的结果是：7

BigInteger类的概念

• BigIntegerl类的基本概念
  若希望表示比long类型范围还大的整数数据，则需要借助java.math.BigInteger类型描述。
• 常用方法

方法声明	功能介绍
BigInteger(String val)	根据参数指定的字符串来构造对象
BigInteger add(BigInteger val)	用于实现加法运算
BigInteger subtract(BigInteger val)	用于实现减法运算
BigInteger multiply(BigInteger val)	用于实现乘法运算
BigInteger divide(BigInteger val)	用于实现除法运算
BigInteger remainder(BigInteger val)	用于实现取余运算
BigInteger[] divideAndRemainder(BigInteger val)	用于实现取商和余数的运算

BigIntegerTest测试类

 public static void main(String[] args) {

        // 1.构造两个BigInteger类型的对象并指定初始值
        BigInteger bi1 = new BigInteger("20");
        BigInteger bi2 = new BigInteger("8");
        // 2.实现加减乘除取余操作并打印
        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.一次性得到商和余数
        BigInteger[] arr = bi1.divideAndRemainder(bi2);
        for (int i = 0; i < arr.length; i++) {
            System.out.println("下标为" + i + "的元素是：" + arr[i]); // 2 4
        }
    }
输出>>>
实现加法运算的结果是：28
实现减法运算的结果是：12
实现乘法运算的结果是：160
实现除法运算的结果是：2
实现取余运算的结果是：4
-----------------------------------------------------
下标为0的元素是：2
下标为1的元素是：4

String类的概述和使用

String类的概念（重点）

• java.lang.String类用于描述字符串，Java程序中所有的字符串字面值都可以使用该类的对象加以描述，如：“abc”。

• String类的定义 public final class Stringimplements java.io.Serializable, Comparable, CharSequence {}
  该类由final关键字修饰，表示该类不能被继承。

• 从jdk1.9开始该类的底层不使用char[]来存储数据，而是改成 byte[]加上编码标记，从而节约了一些空间。

• 该类描述的字符串内容是个常量不可更改，因此可以被共享使用。
  如：
  String str1 = “abc”; - 其中"abc"这个字符串是个常量不可改变。
  str1 = “123”; - 将“123”字符串的地址赋值给变量str1，改变str1的指向并没有改变指向的内容

常量池的概念

• 由于String类型描述的字符串内容是常量不可改变，因此Java虚拟机将首次出现的字符串放入常量池中，若后续代码中出现了相同字符串内容则直接使用池中已有的字符串对象而无需申请内存及创建对象，从而提高了性能。
  测试类，测试String的内存地址指向是否相同

  public static void main(String[] args) {
       // 1.验证一下常量池的存在
       // 到目前为止，只有String这个特殊类除了new的方式外还可以直接字符串赋值（包装类除外）
       String str1 = "a";
       String str2 = "a";
       System.out.println(str1 == str2); // 比较地址  true
   }
输出>>>
true

常用的构造方法（练熟、记住）

方法声明	功能介绍
String()	使用无参方式构造对象得到空字符序列
String(byte[] bytes, int offset, intlength)	使用bytes数组中下标从offset位置开始的length个字节来构造对象
String(byte[] bytes)	使用bytes数组中的所有内容构造对象
String(char[] value, int offset, intcount)	使用value数组中下标从offset位置开始的count个字符来构造对象
String(char[] value)	使用value数组中的所有内容构造对象
String(String original)	根据参数指定的字符串内容来构造对象，新创建对象为参数对象的副本

测试类

  public static void main(String[] args) {
 // 1.使用无参方式构造对象并打印
        String str1 = new String();
        // "" 表示空字符串对象，有对象只是里面没有内容
        // null 表示空，连对象都没有
        System.out.println("str1 = " + str1); // ""  自动调用toString方法
    	System.out.println("--------------------------------------");
        // 2.使用参数指定的byte数组来构造对象并打印
        // 'a' - 97
        byte[] bArr = {97, 98, 99, 100, 101};
        // 使用字节数组中的一部分内容来构造对象，表示使用数组bArr中下标从1开始的3个字节构造字符串对象
        // 构造字符串的思路：就是先将每个整数翻译成对应的字符，再将所有的字符串起来。
        // 98 - 'b'   99 - 'c'  100 - 'd'   => bcd
        String str2 = new String(bArr, 1, 3);
        System.out.println("str2 = " + str2); // bcd

        // 使用整个字节数组来构造字符串对象
        String str3 = new String(bArr);
        System.out.println("str3 = " + str3); // abcde

        System.out.println("--------------------------------------");
        // 3.使用字符数组来构造字符串对象
        char[] cArr = {'h', 'e', 'l', 'l', 'o'};
        // 使用字符数组中的一部分内容来构造对象
        // 思路：直接将字符串起来
        String str4 = new String(cArr, 2, 2);
        System.out.println("str4 = " + str4); // ll
        // 使用整个字符数组来构造对象
        String str5 = new String(cArr);
        System.out.println("str5 = " + str5); // hello

        System.out.println("--------------------------------------");
        // 4.使用字符串来构造字符串对象
        String str6 = new String("world");
        System.out.println("str6 = " + str6); // world
    }
输出>>>
str1 = 
--------------------------------------
str2 = bcd
str3 = abcde
--------------------------------------
str4 = ll
str5 = hello
--------------------------------------
str6 = world

• 面试考点，常量池和堆区的区别
  测试类

 public static void main(String[] args) {

        // 面试考点：请问下面的代码会创建几个对象？分别存放在什么地方？
        //String str1 = "hello";  // 1个对象  存放在常量池中
        //String str1 = new String("helo"); // 2个对象  1个在常量池中，1个在堆区

        // 2.常量池和堆区对象的比较
        String str1 = "hello";  // 常量池
        String str2 = "hello";  // 常量池
        String str3 = new String("hello"); // 堆区
        String str4 = new String("hello"); // 堆区

        System.out.println(str1 == str2);       // 比较地址  true
        System.out.println(str1.equals(str2));  // 比较内容  true
        System.out.println(str3 == str4);       // 比较地址  false
        System.out.println(str3.equals(str4));  // 比较内容  true
        System.out.println(str2 == str4);       // 比较地址  false
        System.out.println(str2.equals(str4));  // 比较内容 true

        System.out.println("-----------------------------");
        // 3.常量有优化机制，变量没有
        String str5 = "abcd";
        String str6 = "ab" + "cd";  // 常量优化机制  "abcd"
        System.out.println(str5 == str6); // 比较地址  true

        String str7 = "ab";
        String str8 = str7 + "cd"; // 没有常量优化
        System.out.println(str5 == str8); // 比较地址 false


    }
输出>>>
true
true
false
true
false
true
-----------------------------
true
false

常用的成员方法（练熟、记住）

方法声明	功能介绍
String toString()	返回字符串本身
byte[] getBytes()	将当前字符串内容转换为byte数组并返回
char[] toCharArray()	用于将当前字符串内容转换为char数组并返回方法声明 功能介绍

 public static void main(String[] args) {

        // 1.创建String类型的对象并打印
        String str1 = new String("world");
        System.out.println("str1 = " + str1); // world

        System.out.println("-----------------------------------------------");
        // 2.实现将String类型转换为byte数组类型并打印
        // 思路：先将字符串拆分为字符，将再每个字符转换为byte类型，也就是获取所有字符的ASCII
        byte[] bArr = str1.getBytes();
        for (int i = 0; i < bArr.length; i++) {
            System.out.println("下标为i的元素是：" + bArr[i]);
        }
        // 将byte数组转回String类型并打印
        String str2 = new String(bArr);
        System.out.println("转回字符串为：" + str2); // world

        System.out.println("-----------------------------------------------");
        // 3.实现将String类型转换为char数组类型并打印
        // 思路：将字符串拆分为字符并保存到数组中
        char[] cArr = str1.toCharArray();
        for (int i = 0; i < cArr.length; i++) {
            System.out.println("下标为" + i + "的字符是：" + cArr[i]);
        }
        // 将char数组转回String类型并打印
        String str3 = new String(cArr);
        System.out.println("转回字符串为：" + str3); // world
    }
 输出>>>
 str1 = world
-----------------------------------------------
下标为i的元素是：119
下标为i的元素是：111
下标为i的元素是：114
下标为i的元素是：108
下标为i的元素是：100
转回字符串为：world
-----------------------------------------------
下标为0的字符是：w
下标为1的字符是：o
下标为2的字符是：r
下标为3的字符是：l
下标为4的字符是：d
转回字符串为：world

方法声明	功能介绍
char charAt(int index)	方法charAt用于返回字符串指定位置的字符。
int length()	返回字符串字符序列的长度
boolean isEmpty()	判断字符串是否为空

  public static void main(String[] args) {

        // 1.构造String类型的对象并打印
        String str1 = new String("hello");
        System.out.println("str1 = " + str1); // hello
        // 2.获取字符串的长度和每个字符并打印
        System.out.println("字符串的长度是：" + str1.length()); // 5
        System.out.println("下标为0的字符是：" + str1.charAt(0)); // h
        System.out.println("下标为1的字符是：" + str1.charAt(1)); // e
        System.out.println("下标为2的字符是：" + str1.charAt(2)); // l
        System.out.println("下标为3的字符是：" + str1.charAt(3)); // l
        System.out.println("下标为4的字符是：" + str1.charAt(4)); // o
        //System.out.println("下标为5的字符是：" + str1.charAt(5)); // StringIndexOutOfBoundsException 字符串下标越界异常

        System.out.println("----------------------------------------------");
        // 3.使用for循环获取所有字符
        for (int i = 0; i < str1.length(); i++) {
            System.out.println("下标为" + i + "的字符是：" + str1.charAt(i)); // h e l l o
        }

        System.out.println("----------------------------------------------");
        // 4.判断字符串是否为空
        System.out.println(0 == str1.length()? "字符串为空": "字符串不为空"); // 不为空
        System.out.println(str1.isEmpty()? "字符串为空": "字符串不为空");     // 不为空

        System.out.println("----------------------------------------------");
        // 5.笔试考点
        // 使用两种方式实现字符串"12345"转换为整数12345并打印
        String str2 = new String("12345");
        // 方式一：调用Integer类中的parseInt()方法即可
        int ia = Integer.parseInt(str2);
        System.out.println("转换出来的整数是：" + ia); // 12345
        // 方式二：利用ASCII来实现类型转换并打印
        // '1' - '0' => 1  '2' - '0' => 2  ...
        int ib = 0;
        for (int i = 0; i < str2.length(); i++) {
            ib = ib*10 + (str2.charAt(i) - '0'); // 1 12 ...
        }
        System.out.println("转换出来的结果是：" + ib); // 12345

        System.out.println("----------------------------------------------");
        // 如何实现整数到字符串的转换
        //String str3 = String.valueOf(ib);
        String str3 = "" + ib; // 推荐使用
        System.out.println("str3 = " + str3); // 12345
    }
 输出>>>
 str1 = hello
字符串的长度是：5
下标为0的字符是：h
下标为1的字符是：e
下标为2的字符是：l
下标为3的字符是：l
下标为4的字符是：o
----------------------------------------------
下标为0的字符是：h
下标为1的字符是：e
下标为2的字符是：l
下标为3的字符是：l
下标为4的字符是：o
----------------------------------------------
字符串不为空
字符串不为空
----------------------------------------------
转换出来的整数是：12345
转换出来的结果是：12345
----------------------------------------------
str3 = 12345

测试题：
判断字符串“上海自来水来自海上”是否为回文并打印，所谓回文是指一个字符序列无论从左向右读
还是从右向左读都是相同的句子。

public static void main(String[] args) {
        // 1.创建字符串对象并打印
        String str1 = new String("上海自来水来自海上");
        System.out.println("str1 = " + str1); // 上海自来水来自海上   9
        // 2.判断该字符串内容是否为回文并打印
        for (int i = 0; i < str1.length()/2; i++) {
            if (str1.charAt(i) != str1.charAt(str1.length()-i-1)) {  //等同于将从数组中第一个数和最后一个数的对应的字符串进行判断，当i为0,那么最后一个数应当是str1.length()-1
                System.out.println(str1 + "不是回文！");
                return;  // 仅仅是用于实现方法的结束
            }
        }
        System.out.println(str1 + "是回文！");
    }
输出>>>
上海自来水来自海上是回文

方法声明	功能介绍
int compareTo(String anotherString)	用于比较调用对象和参数对象的大小关系
int compareToIgnoreCase(String str)	不考虑大小写，也就是’a’和’A’是相等的关系

测试类：

    public static void main(String[] args) {

        // 1.构造String类型的对象并打印
        String str1 = new String("hello");
        String str2 = new String("hlllo");
        System.out.println("str1 = " + str1); // hello

        // 2.使用构造好的对象与其它字符串对象之间比较大小并打印，
        //对比是前面的数去减去后面的数的值，并且是从byte数组中一个个对应取出进行对比，当出现不相同是，对第一个不相同的值进行减法运算，然后返回减法所得到的数值，对后面的不同值不做减法运算，
        System.out.println(str1.compareTo(str2));     // 'e' - 'l' => 101 - 108 => -7
        System.out.println(str1.compareTo("world"));  // 'h' - 'w' => 104 - 119 => -15
        System.out.println(str1.compareTo("haha"));   // 'e' - 'a' => 101 - 97  => 4
        System.out.println(str1.compareTo("hehe"));   // 'l' - 'h' => 108 - 104 => 4
        System.out.println(str1.compareTo("heihei")); // 'l' - 'i' => 108 - 105 => 3
        //当相同的对比完成，有一个数组已无多于的值，那么就进行数组长度的减法。
        System.out.println(str1.compareTo("helloworld")); // 长度： 5 - 10 => -5
        System.out.println(str1.compareToIgnoreCase("HELLO")); // 0
    }
 输出>>>
 str1 = hello
-7
-15
4
4
3
-5
0

方法声明	功能介绍
String concat(String str)	用于实现字符串的拼接
boolean contains(CharSequence s)	用于判断当前字符串是否包含参数指定的内容
String toLowerCase()	返回字符串的小写形式
String toUpperCase()	返回字符串的大写形式
String trim()	返回去掉前导和后继空白的字符串
boolean startsWith(String prefix)	判断字符串是否以参数字符串开头
boolean startsWith(String prefix, int toffset)	从指定位置开始是否以参数字符串开头
boolean endsWith(String suffix)	判断字符串是否以参数字符串结尾

测试类

 public static void main(String[] args) {

        // 1.构造String类型的对象并打印
        String str1 = new String("     Let Me Give You Some Color To See See!");
        System.out.println("str1 = " + str1); //      Let Me Give You Some Color To See See!

        // 2.实现各种成员方法的调用和测试
        boolean b1 = str1.contains("some");
        System.out.println("b1 = " + b1); // false  区分大小写
        b1 = str1.contains("Some");
        System.out.println("b1 = " + b1); // true

        System.out.println("----------------------------------------------");
        // 将所有字符串转换为大写  小写  以及去除两边的空白字符
        String str2 = str1.toUpperCase();
        System.out.println("str2 = " + str2); //    LET ME GIVE YOU SOME COLOR TO SEE SEE!
        System.out.println("str1 = " + str1); //    Let Me Give You Some Color To See See!   常量

        String str3 = str1.toLowerCase();
        System.out.println("str3 = " + str3); //    let me give you some color to see see!
        System.out.println("str1 = " + str1); //    Let Me Give You Some Color To See See!

        String str4 = str1.trim();
        System.out.println("str4 = " + str4); //Let Me Give You Some Color To See See!     奇点

        System.out.println("----------------------------------------------");
        // 判断字符串是否以...开头  以...结尾
        b1 = str1.startsWith("Let");
        System.out.println("b1 = " + b1); // false
        b1 = str1.startsWith(" ");
        System.out.println("b1 = " + b1); // true
        // 从下标5开始是否以"Let"开头
        b1 = str1.startsWith("Let", 5);
        System.out.println("b1 = " + b1); // true

        b1 = str1.endsWith("See");
        System.out.println("b1 = " + b1); // false
        b1 = str1.endsWith("See!");
        System.out.println("b1 = " + b1); // true
    }

方法声明	功能介绍
boolean equals(Object anObject)	用于比较字符串内容是否相等并返回
int hashCode()	获取调用对象的哈希码值
boolean equalsIgnoreCase(String anotherString)	用于比较字符串内容是否相等并返回，不考虑大小写，如：'A’和’a’是相等

模拟测试：
提示用户从键盘输入用户名和密码信息，若输入”admin”和”123456”则提示“登录成功，欢迎使
用”，否则提示“用户名或密码错误，您还有n次机会”，若用户输入三次后依然错误则提示“账户已
冻结，请联系客服人员！”
测试类

 public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        for (int i = 3; i > 0; i--) {
            // 1.提示用户从键盘输入用户名和密码信息并使用变量记录
            System.out.println("请输入您的用户名和密码信息：");
            String userName = sc.next();
            String password = sc.next();

            // 2.判断用户名和密码是否为"admin"和"123456"并给出提示
            //if ("admin".equals(userName) && "123456".equals(password)) {
            if ("admin".equalsIgnoreCase(userName) && "123456".equals(password)) { // 防止空指针异常
                System.out.println("登录成功，欢迎使用！");
                break;
            } //else {
            if (1 == i) {
                System.out.println("账户已冻结，请联系客服人员！");
            } else {
                System.out.println("用户名或密码错误，您还有" + (i - 1) + "次机会！");
            }
            //}
        }
        // 关闭扫描器
        sc.close();
    }

方法声明	功能介绍
int indexOf(int ch)	用于返回当前字符串中参数ch指定的字符第一次出现的下标
int indexOf(int ch, int fromIndex)	用于从fromIndex位置开始查找ch指定的字符
int indexOf(String str)	在字符串中检索str返回其第一次出现的位置，若找不到返回-1
int indexOf(String str, intfromIndex)	表示从字符串的fromIndex位置开始检索str第一次出现的位置
int lastIndexOf(int ch)	用于返回参数ch指定的字符最后一次出现的下标
int lastIndexOf(int ch, intfromIndex)	用于从fromIndex位置开始查找ch指定字符出现的下标
int lastIndexOf(String str)	返回str指定字符串最后一次出现的下标
int lastIndexOf(String str, intfromIndex)	用于从fromIndex位置开始反向搜索的第一次出现的下标。

测试类

   public static void main(String[] args) {

        // 1.构造String类型的对象并打印
        String str1 = new String("Good Good Study, Day Day Up!");
        System.out.println("str1 = " + str1); // Good Good Study, Day Day Up!

        // 2.实现字符串中指定字符和字符串的查找功能
        int pos = str1.indexOf('g');
        System.out.println("pos = " + pos); // -1  代表查找失败
        pos = str1.indexOf('G');
        System.out.println("pos = " + pos); // 0   该字符第一次出现的索引位置
        // 表示从下标0开始查找字符'G'第一次出现的索引位置，包含0
        pos = str1.indexOf('G', 0);
        System.out.println("pos = " + pos); // 0
        pos = str1.indexOf('G', 1);
        System.out.println("pos = " + pos); // 5

        System.out.println("--------------------");
        // 查找字符串
        pos = str1.indexOf("day");
        System.out.println("pos = " + pos); // -1
        pos = str1.indexOf("Day");
        System.out.println("pos = " + pos); // 17   字符串中第一个字符的下标
        pos = str1.indexOf("Day", 17);
        System.out.println("pos = " + pos); // 17   字符串中第一个字符的下标
        pos = str1.indexOf("Day", 18);
        System.out.println("pos = " + pos); // 21   字符串中第一个字符的下标

        System.out.println("--------------------");
        // 编写通用代码实现将字符串str1中所有"Day"出现的索引位置找到并打印出来
        pos = str1.indexOf("Day");
        while (-1 != pos) {
            System.out.println("pos = " + pos); // 17
            pos = str1.indexOf("Day", pos+1);
        }

        System.out.println("--------------------");
        // 优化一下
        pos = 0;
        while ((pos = str1.indexOf("Day", pos)) != -1) {
            System.out.println("pos = " + pos);
            pos += "Day".length();
        }

        System.out.println("--------------------");
        // 3.实现字符和字符串内容的反向查找
        pos = str1.lastIndexOf('G');
        System.out.println("pos = " + pos); // 5
        // 从下标5的位置开始反向查找
        pos = str1.lastIndexOf('G', 5);
        System.out.println("pos = " + pos); // 5

        pos = str1.lastIndexOf('G', 6);
        System.out.println("pos = " + pos); // 5

        pos = str1.lastIndexOf('G', 4);
        System.out.println("pos = " + pos); // 0

        System.out.println("--------------------");
        pos = str1.lastIndexOf("Day");
        System.out.println("pos = " + pos); // 21
        pos = str1.lastIndexOf("Day",  21);
        System.out.println("pos = " + pos); // 21
        pos = str1.lastIndexOf("Day", 20);
        System.out.println("pos = " + pos); // 17
        pos = str1.lastIndexOf("Day", 15);
        System.out.println("pos = " + pos); // -1
    }
输出>>>
str1 = Good Good Study, Day Day Up!
pos = -1
pos = 0
pos = 0
pos = 5
--------------------
pos = -1
pos = 17
pos = 17
pos = 21
--------------------
pos = 17
pos = 21
--------------------
pos = 17
pos = 21
--------------------
pos = 5
pos = 5
pos = 5
pos = 0
--------------------
pos = 21
pos = 21
pos = 17
pos = -1

方法声明	功能介绍
String substring(int beginIndex, int endIndex)	返回字符串中从下标beginIndex（包括）开始到endIndex（不包括）
String substring(int beginIndex)	返回字符串中从下标beginIndex（包括）开始到字符串结尾的子字符串

测试类

public static void main(String[] args) {

        // 1.构造String类型的对象并打印
        String str1 = new String("Happy Wife, Happy Life!");
        System.out.println("str1 = " + str1); // Happy Wife, Happy Life!

        // 2.获取字符串中的一部分内容并打印
        // 表示从当前字符串中下标12开始获取子字符串
        String str2 = str1.substring(12);
        System.out.println("str2 = " + str2); // Happy Life!
        // 可以取到6但是取不到10
        String str3 = str1.substring(6, 10);
        System.out.println("str3 = " + str3); // Wife

        System.out.println("---------------------------------------------------------");
        // 3.获取输入字符串中从输入字符起的子字符串内容
        System.out.println("请输入一个字符串：");
        Scanner sc = new Scanner(System.in);
        String str4 = sc.next();
        System.out.println("请输入一个字符：");
        String str5 = sc.next();
        // 从str4中查找str5第一次出现的索引位置
        int pos = str4.indexOf(str5);
        System.out.println("pos = " + pos);
        // 根据该位置获取子字符串
        String str6 = str4.substring(pos+1);
        System.out.println("获取到的子字符串是：" + str6);
    }
 输出>>>
 str1 = Happy Wife, Happy Life!
str2 = Happy Life!
str3 = Wife
---------------------------------------------------------
请输入一个字符串：
qwer
请输入一个字符：
q
pos = 0
获取到的子字符串是：wer

正则表达式的概念

• 正则表达式本质就是一个“规则字符串”，可以用于对字符串数据的格式进行验证，及匹配、查找、替换等操作。该字符串通常使用^运算符作为开头标志，使用$运算符作为结尾标志，当然也可以省略。

正则表达式的规则（了解）

正则表达式	说明
[abc]	可以出现a、b、c中任意一个字符
[^abc]	可以出现任何字符，除了a、b、c的任意字符
[a-z]	可以出现a、b、c、……、z中的任意一个字符
[a-zA-Z0-9]	可以出现az、AZ、0~9中任意一个字符

正则表达式	说明
.	任意一个字符（通常不包含换行符）
\d	任意一个数字字符，相当于[0-9]
\D	任意一个非数字字符
\s	空白字符，相当于[\t\n\x0B\f\r]
\S	非空白字符
\w	任意一个单词字符，相当于[a-zA-Z_0-9]
\W	任意一个非单词字符

正则表达式	说明
X?	表示X可以出现一次或一次也没有，也就是0 ~ 1次
X*	表示X可以出现零次或多次，也就是0 ~ n次
X+	表示X可以出现一次或多次，也就是1 ~ n次
X{n}	表示X可以出现恰好 n 次
X{n，}	表示X可以出现至少 n 次，也就是>=n次
X{n，m}	表示X可以出现至少 n 次，但是不超过 m 次，也就是>=n并且<=m次

正则表达式相关的方法

方法名称	方法说明
boolean matches(String regex)	判断当前正在调用的字符串是否匹配参数指定的正则表达式规则

测试题：
使用正则表达式描述一下银行卡密码的规则：要求是由6位数字组成。
使用正则表达式描述一下QQ号码的规则：要求是由非0开头的5~15位数组成。
使用正则表达式描述一下手机号码的规则：要求是由1开头，第二位数是3、4、5、7、8中的一位，总共11位
描述身份证号码的规则：总共18位，6位数字代表地区，4位数字代表年，2位数字代表月，2位数字代表日期， 3位数字代表个人，最后一位可能数字也可能是X。

    public static void main(String[] args) {

        // 1.定义描述规则的正则表达式字符串并使用变量记录
        // 正则表达式只能对数据格式进行验证，无法对数据内容的正确性进行检查，内容的正确性检查需要后台查询数据库
        // 描述银行卡密码的规则：由6位数字组成
        //String reg = "^[0-9]{6}$";
        //String reg = "[0-9]{6}";
        //String reg = "\\d{6}";
        // 使用正则表达式描述一下QQ号码的规则：要求是由非0开头的5~15位数字组成。
        //String reg = "[1-9]\\d{4,14}";
        //使用正则表达式描述一下手机号码的规则：要求是由1开头，第二位数是3、4、5、7、8中的一位，总共11位
        //String reg = "1[34578]\\d{9}";
        //描述身份证号码的规则：总共18位，6位数字代表地区，4位数字代表年，2位数字代表月，2位数字代表日期， 3位数字代表个人，
        // 最后一位可能数字也可能是X。
        String reg = "(\\d{6})(\\d{4})(\\d{2})(\\d{2})(\\d{3})([0-9|X])";
        // 2.提示用户从键盘输入指定的内容并使用变量记录
        Scanner sc = new Scanner(System.in);
        while(true) {
            //System.out.println("请输入您的银行卡密码：");
            //System.out.println("请输入您的QQ号码：");
            //System.out.println("请输入您的手机号码：");
            System.out.println("请输入您的身份证号码：");
            String str = sc.next();

            // 3.判断用户输入的字符串内容是否满足指定的规则并打印
            if (str.matches(reg)) {
                //System.out.println("银行卡密码的格式正确！");
                System.out.println("输入字符串的格式正确！");
                break;
            } else {
                //System.out.println("银行卡密码的格式错误！");
                System.out.println("输入字符串的格式错误！");
            }
        }
    }
输出>>>
请输入您的身份证号码：
110101199003070310
输入字符串的格式正确！

方法名称	方法说明
String[] split(String regex)	参数regex为正则表达式，以regex所表示的字符串为分隔符，将字符串拆分成字符串数组
String replace(char oldChar, char newChar)	使用参数newChar替换此字符串中出现的所有参数
oldChar String replaceFirst(String regex,String replacement)	替换此字符串匹配给定的正则表达式的第一个子字符串
String replaceAll(String regex,String replacement)	将字符串中匹配正则表达式regex的字符串替换成replacement

测试类

public static void main(String[] args) {

        // 1.准备一个字符串对象并打印
        String str1 = "1001,zhangfei,30";
        System.out.println("str1 = " + str1); // 1001,zhangfei,30
        // 2.按照逗号对字符串内容进行切割
        String[] sArr = str1.split(",");
        for (int i = 0; i < sArr.length; i++) {
            System.out.println("下标为" + i + "的字符串是：" + sArr[i]); // 1001 zhangfei 30
        }

        System.out.println("--------------------------------------------------------------");
        // 3.准备一个字符串内容并进行替换
        String str2 = "我的小名叫大帅哥";
        // 将字符串中所有的字符'我'替换为'你'
        String str3 = str2.replace('我', '你');
        System.out.println("str2 = " + str2); // 我的小名叫大帅哥
        System.out.println("str3 = " + str3); // 你的小名叫大帅哥
        // 将字符串中所有的字符'大'替换为'小'
        String str4 = str3.replace('大', '小');
        System.out.println("str4 = " + str4); // 你的小名叫小帅哥
        // 将字符串中所有的字符'小'替换为'大'
        String str5 = str4.replace('小', '大');
        System.out.println("str5 = " + str5); // 你的大名叫大帅哥

        System.out.println("--------------------------------------------------------------");
        // 4.准备一个字符串进行字符串内容的替换
        String str6 = "123abc456def789ghi";
        // 将第一个数字字符串替换为"#"
        String str7 = str6.replaceFirst("\\d+", "#");
        System.out.println("替换第一个字符串后的结果是：" + str7); // #abc456def789ghi
        // 将所有字母字符串替换为"$$$"
        String str8 = str7.replaceAll("[a-z]+", "A");
        System.out.println("str8 = " + str8); // #A456A789A

    }

下一阶段学习连接

java基础 日期类 java类库的使用(中)