【学习笔记】| Java常用类_java 一个类有什么-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_50481461/article/details/114005029

常用类

类的五大成员（属性、方法、构造器、代码块、内部类）

1、内部类

成员内部类、静态内部类、局部内部类、匿名内部类

概念：在一个类的内部再定义一个完整的类

特点：

编译之后可生成独立的字节码文件
内部类可直接访问外部类私有成员（成员方法、成员变量），而不破坏封装
可为外部类提供必要的内部功能组件

class Outer{
    class Inner{
        
    }
}
//编译后会生成两个class文件，内部类会加上一个＄符号
Outer$Inner.class //内部类
Outer.class

成员内部类

在类的内部定义，与实例变量、实例方法同级别的类
成员内部类：在类的成员的位置，和成员变量以及成员方法所在的位置是一样的
外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象
当外部类、内部类存在重名属性时，会优先访问内部类属性
成员内部类里不能定义静态成员、可以包含静态常量(final)

// 外部类
public class Outer{
  //实例变量
  private String name = "张三";
  private int age = 20;
  //内部类
  class Inner{
    private String address = "北京";
    private String phone = "110";
    private String name = "李四";
    
    //方法
    public void show(){
      //打印外部类属性 此时有重名属性name
      sout(Outer.this.name); // 张三
      sout(Outer.this.age);
      //打印内部类中的属性
      sout(this.name); // 李四
      sout(this.address);
      sout(this.phone);
    }
  }
  //成员方法
  public void method(){
      sout("method");
  }
}

// 测试类
public class Test{
  psvm(String[] args){
    // 创建外部类对象
    Outer outer = new Outer();
    // 创建内部类对象
    Inner inner = outer.new Inner();
    
    //一步到位
    Inner inner = new Outer().new Inner();
                            
    inner.show();
  }
}

静态内部类

不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员

// 外部类
public class Outer{
  //实例变量
  private String name = "xxx";
  private int age = 20;
  
  // 静态内部类，和外部类相同
  static class Inner{
    private String address = "上海";
    private String phone = "111";
    // 静态成员
    private static int count = 1000;
    
    //方法
    public void show(){
      // 调用外部类的属性
      // 1. 先创建外部类对象
      Outer outer = new Outer();
      // 2. 调用外部类对象的属性
      sout(outer.name);
      sout(outer.age);
      // 调用静态内部类的属性和方法
      sout(address);
      sout(phone);
      // 调用静态内部类的静态属性
      sout(Inner.count);
    }
  }
}

// 测试类
public class Test{
  psvm(String[] args){
    // 直接创建静态内部类对象
    Outer.Inner inner = new Outer.Inner();
                     
    inner.show();
  }
}

局部内部类

定义在外部类方法中，作用范围和创建对象范围仅限于当前方法
局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final
限制类的使用范围

// 外部类
public class Outer{
  //实例变量
  private String name = "刘德华";
  private int age = 35;
  
  //方法
  public void show(){
    // 定义局部变量
    String address = "sz";
    
    // 局部内部类：注意不能加任何访问修饰符
    class Inner{
      private String phone = "11234";
      private String email = "ldh@qq.com";
      
      public void show2(){
        // 访问外部类的属性
        sout(name); // 相当于 Outer.this.name
        sout(age);
        // 访问内部类的属性
        sout(this.phone);
        sout(this.email);
        
        // 访问局部变量 jdk1.7要求必须常量final、jdk1.8自动添加final
        sout(address);
      }
    }
    // 创建局部内部类对象
    Inner inner = new Inner();
    inner.show2();
  }
}

// 测试类
public class Test{
  psvm(String[] args){
    // 创建外部类对象
    Outer outer = new Outer();
                     
    outer.show();
  }
}

匿名内部类

可以把匿名内部类看成是一个没有名字的局部内部类
定义在方法中
必须在定义匿名内部类的时候创建他的对象
必须继承一个父类或者实现一个接口

格式：

new 类/接口(){

如果是创建了继承这个类的子类对象，我们可以重写父类的方法

如果是创建了实现这个接口的子类对象，我们必须要实现该接口的所有方法

}；

原理：而是创建了继承这个类的子类对象或者是创建了实现这个接口的子类对象

匿名内部类：

package com.cly.demo;

public class InnerDemo {
    public static void main(String[] args) {
        Outer o=new Outer();
        o.method();
    }
}

interface Inner{
    public void function();
}
class Outer{
    public void method(){
        /*匿名内部类，写法一：
        new Inner(){
            @Override
            public void function() {
                System.out.println("function 1");
            }
        }.function();在method方法中function()前面的点之前是匿名内部类，后面的function相当于调用了匿名内部类里的function方法！*/
        //匿名内部类写法二：这种写法像执行几遍就i.几遍就行了
        Inner i=new Inner() {
            @Override
            public void function() {
                System.out.println("function 2");
            }
        };
        i.function();
        i.function();
        i.function();

    }
}

匿名内部类应用的场景：(匿名内部类作为参数进行传递)

package com.cly.demo;

public interface Animal {
    public abstract void eat();
}

package com.cly.demo;

public class Dog implements Animal {

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

package com.cly.demo;

public class Cat implements Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

package com.cly.demo;

public class InnerDemo01 {
    public static void main(String[] args) {
        /*
        写法一：
        method(new Dog());
        method(new Cat());*/
        //写法二：
         method(new Animal() {
            @Override
            public void eat() {
                System.out.println("猫吃鱼");
            }
        });
    }
    public static void method(Animal a){
        a.eat();
    }
}
/*
狗吃骨头
猫吃鱼*/

Object类

超类、基类，所有类的直接或间接父类，位于继承树的最顶层
任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承
Object类中所定义的方法，是所有对象都具备的方法
Object类型可以存储任何对象
- 作为参数，可接受任何对象
- 作为返回值，可返回任何对象

getClass()方法

public final Class<?> getClass(){}
返回引用中存储的实际对象类型
应用：通常用于判断两个引用中实际存储对象类型是否一致

package com.cly.scanner;

public class Student {
    private String name;
    private int age;

    public Student() {

    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}

测试类：

package com.cly.scanner;

public class TestStudent {
    public static void main(String[] args) {
        Student s1=new Student("刘德华",22);
        Student s2=new Student("周星驰",23);
        //判断s1和s2是不是同一个类型
        Class class1=s1.getClass();
        Class class2=s2.getClass();
        if (class1==class2){
            System.out.println("属于同一个类型");
        }else{
            System.out.println("不属于同一个类型");
        }
		System.out.println("---------2hashCode---------");
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        // 自然不同
        Student s3 = s1; 
        System.out.println(s3.hashCode());
        // 此时s3的hashCode与s1相同
        System.out.println("---------3toString---------");
        System.out.println(s1.toString());
        System.out.println(s2.toString());	
        System.out.println("---------4equals---------");
        System.out.println(s1.equals(s2));
    }
}

hashCode()方法

public int hashCode(){}
返回该对象的哈希码值
哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的值
一般情况下相同对象返回相同哈希码

在上面的测试类中
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
// 自然不同
Student s3 = s1; // 此时s3的hashCode与s1相同

toString()方法

public String toSring(){}
返回该对象的字符串表示（表现形式）
可以根据程序需求覆盖该方法，如：展示对象各个属性值

// 直接打印包+类名+哈希值
// 重写 alt + enter + s
package com.cly.demo;

public class ObjectDemo {
    public static void main(String[] args) {
        Student s=new Student();
        System.out.println(s.toString());//重写前输出：com.cly.demo.Student@2b316b76
                                         //重写后输出：Student{name='张三', age=22}
    }
}
class Student /*extends Object*/{
    String name="张三";
    int age=22;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

equals()方法

public boolean equals(Object obj){}
默认实现为(this == obj), 比较两个对象地址是否相同
Object中的equals方法实际上是对对象的地址进行比较判断，判断两个对象是否是同一个地址。
可进行覆盖，比较两个对象的内容是否相同

// 判断两个对象是否相等
sout(s1.equals(s2)); // false

Student s4 = new Strudent("小明", 17);
Student s5 = new Strudent("小明", 17);
sout(s4.equals(s5)); // false 堆中地址不同

// 重写 改变其比较内容
/*
步骤  1. 比较两个应用是否指向同一个对象
     2. 判断obj是否为null
     3. 判断两个引用指向的实际对象类型是否一致
     4. 强制类型转换
     5. 依次比较各个属性值是否相同
*/
@override
public boolean equals(Object obj){
  // 1.
  if(this == obj){
    return true;
  }
  // 2.
  if(obj == null){
    return false;
  }
  // 3.同一个类的字节码文件是一样的，看是否为同一个类。如果类都不一样就不用比成员了！
  // if(this.getClass() == obj.getClass()){
  //
  // }
  // instanceof 它的作用是测试它左边的对象是否是它右边的类的实例
  if(obj instanceof Student){
    // 4.强制类型转换
    Student s = (Student)obj;
    // 5. 比较属性
    if(this.name.equals(s.getName()) && this.age == s.getAge()){
      return true;
    }
  }
  return false;
}

获取字节码对象的方式

package com.cly.demo;

public class Teacher {
    private String name;
    private int age;

    public Teacher() {
    }

    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package com.cly.demo;
/*
获取字节码对象的方式
我要获取字节码对象做什么用呢？
反射：
    反射就需要用到字节码对象，可以通过字节码对象获取任意一个类的任意一个方法，
也可以通过字节码对象获取任意一个对象的成员变量中的值。
因为字节码对象是根据字节码文件class文件，创建出来的，所以，有了她想干嘛就干嘛。
所以，现在就先做一个了解，知道怎么获取字节码对象
总结：
    获取一个类的字节码对象有三种方式
    如果你能直接创建对象，就可以使用方式1获取。
    如果你不能直接创建对象，可以使用方式2 方式3
    方式3 更为灵活因为她的参数是一个字符串，要获取哪个就直接输入上哪个就ok了
    非常方便（在实际开发中我们可以把这个放入到配置文件中，如果我想换一个类，直接更改配置文件就可以，代码不用修改）

*/

public class ClassDemo {
    public static void main(String[] args) throws ClassNotFoundException {
        //方式1 通过Object类的getClass()方法获取
        Teacher t=new Teacher();
        Class c=t.getClass();
        System.out.println(c);//class com.cly.demo.Teacher===全路径类名
        //方式2 通过类名调用属性class来获取
        Class c2=Teacher.class;
        System.out.println(c2);
        //方式3 通过Class这个类的静态方法forName()来获取
        Class c3=Class.forName("com.cly.demo.Teacher");
        System.out.println(c3);

    }
}

finalize()方法

当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列
垃圾对象：没有有效引用指向此对象时，为垃圾对象
垃圾回收：由GC销毁垃圾对象，释放数据存储空间
自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象
手动回收机制：使用System.gc();通知JVM执行垃圾回收

@Override
protected void finalize() throws Throwable{
  sout(this.name + "对象被回收了");
}

psvm(String[] args){
  Student s1 = new Student("aaa", 29); // 不是垃圾
  new Student("bbb", 30); // 是辣鸡 会被回收
  //回收垃圾
  System.gc();
  sout("回收垃圾"); 
  // 打印出 “回收垃圾 
  //        bbb对象被回收了”
}

2、包装类

java封装出包装类的一个背景

在实际程序使用中，程序界面上用户输入的数据都是以字符串类型进行存储的。而程序开发中，我们需要把字符串数据，根据需求转换成指定的基本数据类型，如年龄需要转换成int类型，考试成绩需要转换成double类型等。那么，想实现字符串与基本数据之间转换怎么办呢？

Java中提供了相应的对象来解决该问题，基本数据类型对象包装类：java将基本数据类型值封装成了对象。封装成对象有什么好处？可以提供更多的操作基本数值的功能。

基本数据类型所对应的引用数据类型
Object 可统一所有数据，包装类的默认值是null

基本数据类型	包装类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

其中需要注意int对应的是Integer，char对应的Character，其他6个都是基本类型首字母大写即可。

包装类的常用方法

JAVA 是一种面向对象语言，JAVA 中的类把方法与数据连接在一起，构成了自包含式的处理单元。但在 JAVA 中不能定义基本类型（primitive type)对象，为了能将基本类型视为对象进行处理，并能连接相关的方法，JAVA 为每个基本类型都提供了包装类。如 int 型数值的包装类 Integer，boolean 型数值的包装类 Boolean 等，这样便可以把这些基本类型转换为对象来处理了。下面将介绍 JAVA 中提供的各种包装类。

Integer

java.lang 包中的 Integer 类、Long 类和 Short 类，分别将基本类型 int、 long 和 short 封装成一个类。由于这些类都是 Number 的子类，区别就是封装不同的数据类型，其包含的方法基本相同，下面以 Integer 类为例介绍：
Integer 类在对象中包装了一个基本类型 int 的值。该类的对象包含一个 int 类型的字段。此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，同时还提供了处理 int 类型时非常有用的其他一些常量和方法。

构造方法有两种

以 int 型变量作为参数创建 Integer 对象，实例代码如下：
Integer number=new Integer(7);
以 String 型变量作为参数创建 Integer 对象，实例代码如下：
Integer number=new Integer(“7”);

常用方法

Integer的常用方法
在这里插入图片描述

常用的常量

MAX_VALUE: 表示 int 型可取的最大值
MIN_VALUE: 表示 int 型可取的最小值
SIZE：表示以二进制补码形式表示 int 值的位数
TYPE: 表示基本类型 Class
实例示例如：
int maxint = Integer.MAX_VALUE;
int minint = Integer.MIN_VALUE;
int intsize = Integer.SIZE;

System.out.println("int 类型可取的最大值"+maxint); 
System.out.println("int 类型可取的最小值"+minint);
System.out.println("int 类型的二进制位数"+intsize);
//
int类型可取的最大值 2147483647
int类型可取的最小值 -2147483648
int类型的二迸制位数 32

Boolean

Boolean 类将基本类型为 boolean 的值包装在一个对象中。一个 Boolean 类型的对象只包含一个类型为 boolean 的字段。此外，此类还为 boolean 和 String 的相互转换提供了许多方法，并提供了处理 boolean 时非常有用的其他一些常量和方法。

构造方法

创建一个表示 value 参数的 boolean 对象，实例如下：
Boolean b = new Boolean(true);
以 String 变量作为参数，创建 boolean 对象。此时，如果传入的字符串不为 null，且忽略大小写后的内容等于”true”,则生成 Boolean 对象值为 true，反之为 false.

Boolean b1 = new Boolean("ok");
System.out.println(b1);
Boolean b2 = new Boolean("TRUE");
System.out.println(b2);
//out
false
true

常用方法

Boolean 类的常用方法
在这里插入图片描述
其中 booleanValue()的功能是：将 booleanValue 对象的值以对应的boolean 值返回。

Boolean b1 = new Boolean("OK");
Boolean b2 = new Boolean(false);
//out
flase
flase

常用的常量

TRUE:对应基值 true 的 Boolean 对象；
FALSR:对应基值 false 的 Boolean 对象；
TYPE:表示基本类型 Class 实例

Byte

Byte 类将基本类型为 byte 的值包装在一个对象中，一个 byte 类型的对象只包含一个类型为 byte 的对象。此外，该类还为 byte 和 String 之间相互转换提供方法，并提供了一些处理 byte 时非常有用的常量。

构造方法

Byte 类提供了两种构造方法的重载形式来创建 BYTE 类对象：
Byte（byte value) 通过这种方法创建的 byte 对象，可表示指定的 byte值。

byte mybyte = 45;
Byte b = new Byte(mybyte);

Byte(String str) 通过这种方法创建的 byte 对象，可表示 String 参数指定的 byte 值
Byte mybyte = new Byte(“12”)

常用方法

byte的常用方法
在这里插入图片描述

常用常量

MIN_VALUE: 最小值
MAX_VALUE: 最大值
SIZE: 二进制
TYPE: 表示基本类型 byte 的 class 实例

Character

Character 类在对象中包装一个基本类型为 char 的值。一个 Character 对象包含类型为 char 的单个字段。

构造方法

Character 类的构造方法的语法如下：
Character（char value)

常用方法

Character 类的常用方法
在这里插入图片描述

Character mychar1=new Character('A');
Character mychar2=new Character('a');
System.out.println(mychar1+"是大写字母吗 "+Character.isUpperCase(mychar1)); 
System.out.println(mychar2+"是小写字母吗 "+Character.isLowerCase(mychar2));
//out
A是大写字母呀true
a是小写字母呀true

Double

Double 和 Float 包装类是对 double、float 基本类型的封装，他们都是 Number 类的子类，又都是对小数进行操作，所以常用基本方法相同， Double 类在对象中包装一个基本类型为 double 的值，每个 double 类都包含一个 double 类型的字段。

构造方法

Double 类提供了两种构造方法来获得 Double 类对象

Double（double value): 基于 double 参数创建 Double 类对象；
Double（String str): 构造一个新分配的 Double 对象，表示用字符串表示的 Double 类型的浮点值.

常用方法

Double 类的常用方法
在这里插入图片描述

Number

抽象类 Number 是父类，Number 的子类必须提供将表示的数值转换成 byte、double/float/long/int/short 的方法。Number 类的方法被 Number 的各子类所实现，常用方法如下：
Number 类的方法
在这里插入图片描述

public class InterDemo {
    public static void main(String[] args) {
        Integer i = new Integer("10");
        System.out.println(i);//10


        int a = i.intValue();
        System.out.println(a + 10 );//20


        int b = Integer.parseInt("20");
        System.out.println(b + 30);//50



        Integer i2 = new Integer(40);
        String s = i2.toString();
        System.out.println(s);//40


        String s2 = Integer.toString(50);
        System.out.println(s2);//50
    }
}

类型转换与装箱拆箱

基本类型转换成引用类型就是装箱

引用类型转换成基本类型就是拆箱

8种包装类提供不用类型间的转换方式
1. Number父类中提供的6个共性方法
2. parseXXX( )静态方法
3. valueOf( )静态方法
注意：需保证类型兼容，否则抛出NumberFormatException异常

psvm(String[] args){
  // 装箱， 基本类型 → 引用类型
  // 基本类型
  int num1 = 18;
  // 使用Integer类创建对象
  Integer integer1 = new Integer(num1);
  Integer integer2 = Integer.valueOf(num1);
  
  // 拆箱， 引用类型 → 基本类型
  Integer integer3 = new Integer(100);
  int num2 = integer3.intValue();
  
  // 上述为jdk1.5之前方法，之后提供了自动装箱拆箱
  int age = 30;
  // 自动装箱
  Integer integer4 = age;
  // 自动拆箱
  int age2 = integer4;
  
  // 基本类型和字符串之间转换
  // 1. 基本类型转成字符串
  int n1 = 100;
  // 1.1 使用+号
  String s1 = n1 + "";
  // 1.2 使用Integer中的toString()方法
  String s2 = Integer.toString(n1);
  String s2 = Integer.toString(n1, x); // x为进制要求
  
  // 2. 字符串转成基本类型
  String str = "150";
  // 使用Integer.parseXXX();
  int n2 = Integer.parseInt(str);
  
  // boolean 字符串形式转成基本类型，"true" ---> true 非“true ———> false
  String str2 = "true";
  boolean b1 = Boolean.parseBoolean(str2);
}

整数缓冲区

Java预先创建了256个常用的证书包装类型对象
在实际应用当中，对已创建的对象进行复用

psvm(String[] args){
  // 面试题
  Integer integer1 = new Integer(100);
  Integer integer2 = new Integer(100);
  sout(integer1 == integer2); // false
  
  Integer integer3 = 100;// 自动装箱
  // 相当于调用 Integer.valueOf(100);
  Integer integer4 = 100;
  sout(integer3 == integer4); // true
  
  Integer integer5 = 200;// 自动装箱
  Integer integer6 = 200;
  sout(integer5 == integer6); // false
  
  // 因为缓存区数组 [-128, 127] 在这之内地址一样
}

3、常用类

String()类

字符串是常量，创建之后不可改变
字符串字面值存储在字符串池中，可以共享。常量池就在方法区中
String s = "Hello";产生一个对象，字符串池中存储
String s = new String("Hello"); 产生两个对象，堆、池各一个

package com.cly.scanner;

public class Demo {
    public static void main(String[] args) {
        String name="hello";//"hello"常量存储在字符串池中
        name="zs";//"zs"赋值给name变量，给字符串赋值时，并没有修改数据，而是重新开辟一个空间。
        //那么此时的hello就变成垃圾了，当垃圾回收器执行的时候hello数据就被清理了
        String name2="zs";
        //此时name 和 name2指向的是同一个zs地址值是一样的，此时也就是实现了数据的共享

        //字符串的另一种创建方式
        String str=new String("java是最好的语言");
        String str2=new String("java是最好的语言");
        System.out.println(str==str2);//false
        System.out.println(str.equals(str2));//true
    }
}

String常用方法：

// 1. length(); 返回字符串长度
// 2. charAt(int index); 返回某个位置的字符
// 3. contains(String str); 判断是否包含某个字符串

String content = "java是最好的语言, java no1";
sout(content.length()); // 10
sout(content.charAt(content.length() - 1)); // 言
sout(content.contains("java")); // true

// 4. toCharArray(); 返回字符串对应数组 
// 5. indexOf(); 返回子字符串首次出现的位置
// 6. lastIndexOf(); 返回字符串最后一次出现的位置

sout(Arrays.toString(content.toCharArray()));
sout(content.indexOf("java")); // 0
sout(content.indexOf("java", 4)); // 从索引4开始找 返回12
sout(content.lastIndexOf("java")); // 12

// 7. trim(); //去掉字符串前后空格
// 8. toUpperCase(); toLowerCase(); 转换大小写
// 9. endWith(str); startWith(str);  判断是否以str 结尾、开头

String ct = " hello world ";
sout(ct.trim()); // "hello world"
sout(ct.toUpperCase()); // HELLO WORLD
sout(ct.toLowerCase()); // hello world
sout(ct.endWith("world")); // true
sout(ct.startWith("hello")) // true
  
// 10. replace(char old, char new); 用新的字符或字符串替换旧的字符或字符串
// 11. split(); 对字符串拆分

sout(content.replace("java", "php")); // php是最好的语言, php no1

String say = "java is the best language";
String[] arr = arr.say.split(" "); // "[ ,]+" 表示空格 逗号切分 +号表示切分可以多个 比如多个空格
sout(arr.length); // 5
for(String string : arr){
  sout(string);
}
// 打印出 
//java
//is
//the 
//best
//language

// 补充两个equals/compareTo();比较大小
String s1 = "hello";
String s2 = "HELLO";
sout(s1.equalsIgnoreCase(s2));// 忽略大小写比较true

// compareTo(); 两字符不同时比较字符字典序的ascii码
// 字符相同时比较长度 返回差值

案例演示

需求：

已知String str = “this is a text”;
将str中的单词单独获取
将str中的text替换成practice
在text前面插入一个easy
将每个单词的首字母改为大写

psvm(String[] args){
  String str = "this is a text";
  // 2. 
  String[] arr = str.split(" ");
  for(String s : arr){
    sout(s);
  }
  // 3.
 String str2 = str.replace("text", "practice");
  // 4. 
  String str3 = str.replace("text", "easy text");
  // 5. 
  for(int i = 0; i < arr.length; i ++){
    char first = arr[i].charAt(0);
    char upperfirst = Character.toUpperCase(first);//把第一个字符转换成大写
    String new = upperfirst + arr[i].substring(1);
      //substring() 这个方法是截取字符串的方法
  }
}

可变字符串（StringBuffer StringBuilder类）

StringBuffer : 可变长字符串，运行效率慢、线程安全
StringBuilder : 可边长字符串、运行快、线程不安全

效率都比String高且节省内存

psvm(String[] args){
  // StringBuffer 和 StringBuilder 用法一致
  StringBuffer sb = new StringBuffer();
  // 1. append(); 追加
  sb.append("java no1");
  // 2. insert(); 添加、插入
  sb.insert(0, "在第一个位置插入");
  // 3.replace(); 替换
  sb.replace(0, 2, str); //指定位置的替换
  // 4. delete(); 删除
  sb.delete(0, 5); // 左闭右开
  // 5. 清空
  sb.delete(0, sb.length());
}

案例：

//验证StringBuilder效率高于String
package com.cly.scanner;

public class Demo9 {
    public static void main(String[] args){
        //开始时间
        long start=System.currentTimeMillis();
        /*String string="";
        for (int i = 0; i < 99999; i++) {
            string+=i;
        }
        System.out.println(string);*/
        StringBuilder sb=new StringBuilder();
        for (int i = 0; i < 99999; i++) {
            sb.append(i);
        }
        System.out.println(sb.toString());
        long end=System.currentTimeMillis();
        System.out.println("用时："+(end-start));//String时候用时：10692，StringBuilder时候用时：30
    }
}

BigDecimal类

位置 java.math 包中
作用精确计算浮点数
创建方式 BigDecimal bd = new BigDecimal("1.0");

BigDecimal bd1 = new BigDecimal("1.0"); // 需用字符串
BigDecimal bd2 = new BigDecimal("0.9");
// 减法
BigDecimal r1 = bd1.subtract(bd2);
sout(r1); // 0.1

// 加法
BigDecimal r2 = bd1.add(bd2);

//乘法
BigDecimal r3 = bd1.multiply(bd2);

// 除法 (1.4-0.5)/0.9
BigDecimal r4 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"), x, BigDecimal.ROUND_HALF_UP); 
//除不尽时 x填保留位数 后面为四舍五入之意

Date类

Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代

时间单位：1s = 1,000ms = 1,000,000 μs = 1,000,000,000 = ns

package com.cly.scanner;
/*
Date():创建的是一个表示当前系统时间的Date对象
Date(long date):根据“指定时间”创建Date对象，指定时间就是传递一个毫秒值，得到一个从1970-1-1（代表0），加上我们传进去的毫秒值，就等于你指定的日期。
*/
import java.util.Date;

public class Demo10 {
    public static void main(String[] args) {
        //今天
        Date date=new Date();
        System.out.println(date.toString());//Tue Feb 23 21:50:26 CST 2021
        System.out.println(date.toLocaleString());//2021-2-23 21:50:26
        //昨天
        Date date1=new Date(date.getTime()-60*60*24*1000);
        System.out.println(date1.toLocaleString());//2021-2-22 21:53:29
        /*
        Date的常用用法，一般我们使用Date类做这两种操作：
        1.毫秒值====Date对象
        	返回值void，参数long
        	void setTime(long time)
        	Date(long date)
        2.Date对象====毫秒值
        	获取
        	long getTime();
        */
        Date date2=new Date();
        System.out.println(date2.getTime());//1616825764665
        date2.setTime(1616825764665L);
        System.out.println(date2.toLocaleString());//2021-3-27 14:16:04
        
        //方法after before
        Date1.after(Date2),当Date1大于Date2时，返回TRUE，当小于等于时，返回false;
		Date1.before(Date2)，当Date1小于Date2时，返回TRUE，当大于等于时，返回false;
		如果业务数据存在相等的时候，而且相等时也需要做相应的业务判断或处理时，请注意。
		如果有这样的需求，在某个日期内的业务check，那么你需要使用: ! Date1.after(Date2)

        boolean b=date.after(date1);
        System.out.println(b);        //  true

        boolean b1=date1.after(date);
        System.out.println(b1);       //  false
        
        //比较compareTo();
        方法用于将 Number 对象与方法的参数进行比较,可用于比较 Byte, Double, Integer, Float, Long 或 Short 类型的参数
        int d=date.compareTo(date1);
        System.out.println(d);      //1
        
        //equals();比较是否相等
        boolean b2=date.equals(date1);
        System.out.println(b2); //false
    }
}

package com.cly.demo;

/*通过Date这个类，我们可以输出毫秒值，但是数据太大了不容易看懂，
我们使用toLocaleString()方法可以转成具体的时间，但是已经过时
了所以Java给我们推荐了另外一个类
DateFormat:
        text包下的, text包下的类大部分都是用于格式化
        DateFormat类就是用于格式化时间的，格式化就是以我们想要的格式进行显示
如何使用这个类？
        DateFormat类是一个抽象类，抽象类不能够直接创建对象，所以我们就要使用他的子类SimpleDateFormat
*/

import java.text.SimpleDateFormat;
import java.util.Date;

public class SystemDemo {
    public static void main(String[] args) {
        //使用默认模式进行对象的构建
        SimpleDateFormat sdf=new SimpleDateFormat();
        //创建日期对象
        Date date=new Date();
        //格式化：把日期对象转换成字符串
        String s= sdf.format(date);
        System.out.println(s);//21-3-27 下午2:35
        //解析：把字符串转成日期对象
        Date d=sdf.parse("2021-3-27 下午14:32");
        System.out.println(d);//Sun Mar 28 02:32:00 CST 2021
    }
}

package com.cly.demo;


import java.text.SimpleDateFormat;
import java.util.Date;

public class SystemDemo {
    public static void main(String[] args){
        //使用指定的模式来进行对象的构建
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日");
        //格式化
        Date date=new Date();
        String s=sdf.format(date);
        System.out.println(s);//2021年03月27日
        //解析
        Date d=sdf.parse("2021年03月27日");
        System.out.println(d.toLocaleString());//2021-3-27 0:00:00
    }
}

package com.cly.demo;


import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class SystemDemo {
    public static void main(String[] args) throws ParseException {
        //使用指定的模式来进行对象的构建
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        //格式化
        Date date=new Date();
        String s=sdf.format(date);
        System.out.println(s);
        //解析
        Date d=sdf.parse("2021年03月27日 14:46:52");
        System.out.println(d.toLocaleString());
    }
}
//2021年03月27日 14:47:26
//2021-3-27 14:46:52

小案例：

package com.cly.demo;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

//求出你来到这个世界上多少年了？
public class SimpleDateFormatTest {
    public static void main(String[] args) throws ParseException {
        //出生日期
        String birthday="1998-10-05";
        //今天日期
        String now="2021-3-27";
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");

        //将字符串转成日期对象
        Date d1=sdf.parse(birthday);
        Date d2=sdf.parse(now);
        //将日期转换成long类型
        long l=d1.getTime();
        long l2=d2.getTime();
        System.out.println((l2-l)/1000/60/60/24/365);//22
    }
}

Calendar类

Calendar(抽象类)提供了获取或设置各种日历字段的方法
构造方法 protected Calendar(); 由于是protected 所以无法直接创建
用于替代Date类的使用。它里面提供了很多功能来单独获取日历的某个数据

方法名	说明
static Calendar getInstance()	使用默认时区和区域获取日历
void set(int year, int month, int date, int hourofday, int minute, int second)	设置日历的年、月、日、时、分、秒
int get(int field)	返回给定日历字段的值。字段比如年、月、日
void setTime(Date date)	用给定的date设置此日历时间
Date getTime()	返回一个date表示此日历的时间
void add(int field, int amount)	按照日历的规则，给指定字段添加或减少时间量
long getTimeInMilles()	毫秒为单位返回该日历的时间值

package com.cly.scanner;

import java.util.Calendar;

public class Demo11 {
    public static void main(String[] args) {
        // 1. 创建 Calendar 对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis());
        // 2. 获取时间信息
        // 获取年
        int year = calendar.get(Calendar.YEAR);
        // 获取月 从 0 - 11月份
        int month = calendar.get(Calendar.MONTH);
        // 日
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        // 小时
        int hour = calendar.get(Calendar.HOUR_OF_DAY);//HOUR 12小时取值 HOUR_OF_DAY 24小时取值
        // 分钟
        int minute = calendar.get(Calendar.MINUTE);
        // 秒
        int second = calendar.get(Calendar.SECOND);
        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+"："+minute+":"+second);
        //修改时间
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(Calendar.DAY_OF_MONTH, 5);
        System.out.println(calendar2.getTime().toLocaleString());
        // 4. add修改时间
        calendar2.add(Calendar.HOUR, 1); // x为正就加 负就减
        System.out.println(calendar2.getTime().toLocaleString());
        // 5. 补充方法
        int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);// 月数最大天数
        int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);

        System.out.println(max);//28
        System.out.println(min);//1
    }
}
/*
2021-2-23 22:23:32
1614090212208
2021年2月23日22：23:32
2021-2-5 22:23:32
2021-2-5 23:23:32
28
1
*/

SimpleDateFormat类

SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类
进行格式化（日期→文本）、解析（文本→日期）
常用的时间模式字母

字母	日期或时间	示例
y	年	2019
08	年中月份	08
d	月中天数	10
H	一天中小时（0-23）	22
m	分钟	16
s	秒	59
S	毫秒	356

psvm(String[] args){
  // 1. 创建对象
  SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH-mm-ss");
  // 2. 创建Date
  Date date = new Date();
  // 格式化date（日期→字符串）
  String str = sdf.format(date);
  sout(str);//输出的是现在的时间
  // 解析（字符串→时间）
  Date date2 = sdf.parse("1948/03/12");
  sout(date2); 
}

System类

System类特点:
System类lang包下，使用这个类不需要导包
system类被final修饰，不能被继承，不能有子类
System类是一个工具类，构造方法被private修饰不能被实例化，也就是不能创建对象，可以通过类名直接调用成员
System类中包含了一些有用的类字段．什么是类字段?字段就是成员变量
被static修饰的成员变量被所有的对象所共享，随着类的加载而加载，所以也称被static修饰的成员变量为类字段(需要记住，企业开发中经常定义这种类字段)

主要用于获取系统的属性数据和其他操作，构造方法私有的

方法名	说明
static void arraycopy(…)	复制数组
static long currentTimeMillis();	获取当前系统时间，返回毫秒值
static void gc();	建议jvm赶快启动垃圾回收期器回收垃圾
static void exit(int status);	退出jvm 如果参数是0表示正常退出jvm 非0表示异常退出,终止java虚拟机

package com.cly.scanner;

public class Demo12 {
    public static void main(String[] args) {
        //arraycopy:数组的复制
        //src：原数组 srcPos：从哪个位置开始复制0 dest：目标数组 destPos：目标数组的位置 length：复制的长度
        int[] arr = {20, 18, 39, 3};//静态初始化数组
        int[] dest = new int [4];//动态初始化数组
        System.arraycopy(arr,0,dest,0,arr.length);
        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);
        }
    }
}

package com.cly.demo;
//1秒=1000毫秒
public class SystemDemo {
    public static void main(String[] args) {
        long now=System.currentTimeMillis();//以毫秒值返回当前系统时间（1970-1-1 0.0.0至今过了多少毫秒）
        System.out.println(now);
    }
}
//1616820109857