第二十五讲——常用类

1.——内部类

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

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

public class Body{
    class Head{
        
    }
}

内部类也会生成独立class文件有￥符号做分割Outer￥Inter.class
内部类可以直接访问外部类的私有成员，而不破坏封装
可以为外部类提供必要的内部功能组件（身体与头）

成员内部类

在类的内部定义，与实例变量、实例方法同级别的类

public class Body{
    class Head{
    }
}

外部类的一个实例部分，创建成员内部类对象时，必须依赖外部类对象（即先实例化外部类再实例化内部类）

//new Body().new Head().age();(匿名内部类)
Body body = new Body();
Head head = body.new Head();
//Head head = new Body().new Head();缩写

在调用成员内部类时，最好导入内部类

import Base.Body.Head;

当成员内外部类属性相同时优先访问成员内部类(Outer.this.属性)

Test

package Base;
public class Body {
    private int age = 12;
     class Head{
        private int age = 88;
        public void print(){
            System.out.println(age);
            System.out.println(Body.this.age);
        }
    }
}

Applincation

package Base;
        import Base.Body.Head;
public class Application {
    public static void main(String[] args) {
        Body body = new Body();
        Head head = body.new Head();
        head.print();
    }
}

print

88
12

Process finished with exit code 0

成员内部类不能定义静态成员(TypeAndMethod) | 可以定义静态常量

成员内部类

Type

package Base;
public class Body {
    private int age = 12;
    private String name = "拉布拉多";
     class Head{
        private int money = 88;
        public void print(){
            System.out.println(age+"\t"+name+"\t"+money);
        }
    }
}

Appilcation

package Base;
public class Application {
    public static void main(String[] args) {
        //  1 匿名内部类方法
        //new Body().new Head().print();
        
        //  2 一一创建
        /**Body body = new Body();
        Body.Head head = body.new Head();
        head.print();
         */
        
        //  3 一步到位
        Body.Head head = new Body().new Head();
        head.print();
    }
}

print

12	拉布拉多	88

Process finished with exit code 0

静态内部类

与成员内部类+static

public class Body{
    static class Head{
        //静态内部类
    }
}

静态内部类不依赖外部类对象，可直接创建(指的是不用先实例化外部类)或通过类名访问，可声明静态成员

//成员内部类         依赖外部类需要实例化外部类
Body.Head head = new Body().new Head();
//静态内部类         不依赖不需要实例化外部类
Body.Head head = new Body.Head();
//静态内部类         或通过类名访问(添加static为静态方法)
Body.Head.say();

只能直接访问外部类的静态成员，(非静态需要实例化后访问)

Body body = new Body();

Type

package Base;
public  class Person {
    private static int age = 12;
    private String name = "XXX";
    //在成员内部类基础上添加static | 静态内部类
    static class Student{
        private String Home = "北京";
         private static int money = 88;
         public  void print(){
             //访问外部类静态成员 | 通过类名 访问
             System.out.println(Person.age);
             //访问外部类非静态成员 | 实例化外部类对象访问
             Person person = new Person();
             System.out.println(person.name);
             //访问内部类非静态成员 | 直接访问
             System.out.println(this.Home);
             //访问内部类静态成员 | 直接访问
             System.out.println(this.money);

         }
    }
}

Application

package Base;
public class Application {
    public static void main(String[] args) {
        //直接创建静态内部类(不需要实例化外部类) 对象声明包含关系
        Person.Student student = new Person.Student();
        //Person没有()表示包含关系 有代表实例化
        student.print();
        //改非静态方法为静态方法可用
        //Person.Student.print();
    }
}

Print

F:\Application\out\production\Application Base.Application
12
XXX
北京
88

Process finished with exit code 0

局部内部类

定义在外部类方法中，作用范围和创建对象范围仅限于当前方法

public class Body{
    public void print(){
        private static final int age = 8;
        //外部类方法局部变量一旦被局部内部类访问，就会转变成final
        class Head{
            public void println(){
                System.out.println(age);
            }
        }
    }
}

局部内部类访问外部类当前方法的局部变量时，因无法保障变量的生命周期与自身相同所以必须声明为final

Test

package Base;
public class Outer {
    private int age = 32;
    private String name = "刘德华";
    public void print(){
        //局部变量
         int money = 88;
        //局部内部类
         class Inner{
            //局部类写在方法里面 不能使用private等修饰类
             private int phone = 135872545;
             //private static final int years = 8;内部类的属性除常量外不能用static
             public void say(){
                 //访问外部类属性
                 System.out.println(Outer.this.age);
                 System.out.println(Outer.this.name);
                 //访问内部类的属性 访问非静态的属性 需要 this 静态 用类名
                 System.out.println(this.phone);
                 //访问局部变量的属性      !!!!
                 //如果局部变量的名称和内部类的一样 会优先调用内部类 所以最好别重名
                 System.out.println(money);
                 //添加后的局部变量的属性会变成常量 自动添加final

             }
             //不能在类的上面new类，因为还没有类

        }
        Inner inner = new Inner();
        inner.say();
    }
}

Application

package Base;
public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //要在外部类的方法中局部内部类的下面new局部内部类并调用局部内部类的方法
        outer.print();

    }
}

Print

F:\Application\out\production\Application Base.Application
32
刘德华
135872545
88

Process finished with exit code 0

匿名内部类

定义在外部类方法中，作用范围和创建对象范围仅限于当前方法
局部内部类访问外部类当前方法的局部变量时，因无法保障变量的生命周期与自身相同所以必须声明为final
必须继承一个父类或者实现一个接口
定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
优点; 减少代码量
缺点; 可读性较差

接口实现

在接口中定义抽象方法—在实现类中编写具体实现—在应用中具体应用

接口

package Application;
public interface Usb{
    public void service();
}

实现类

package Application;
public class Mouse implements Usb{
    @Override
    public void service(){
        System.out.println("链接成功，鼠标开始工作...");
    }
}
}

Application

package Application;

public class Application {
    public static void main(String[] args) {
        /**普通实现接口
       接口的引用指向实现类
        Usb usb = new Mouse();
        //多态; 有继承关系,子类重写父类方法,父类引用指向子类对象
        usb.service();
         */
        //利用局部内部类来实现接口
        /**class Fan implements Usb{
            @Override
            public void service() {
                System.out.println("链接成功  风扇开始工作~");
            }
        }
        Usb usb = new Fan();
        usb.service();*/
        //这个类只用一次就不再用了，太浪费，还能不能没有优化？  ——>匿名内部类
       //匿名内部类来实现接口
        Usb usb = new Usb(){
            //父类指向子类也能用匿名内部类
            //new 后面可以是子类，abstract;
            @Override
            public void service() {
                System.out.println("链接成功  鼠标开始工作~");
            }
        };
        usb.service();
    }
}

匿名内部类也是有名字的类，只是系统命名的

其作用就是给在有继承关系或者实现接口中的一次性使用的类做优化

2.——Object类

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

GetClass方法

返回引用中存储的实际对象类型(类路径)
应用；通常用于判断两个引用中实际储存对象类型是否一致

        Student s1 = new Student(25,"李白");
        Student s2 = new Student(52,"刘备");
         引用类型 ——> 实际类型(比较这个)
        //判断是不是同一个类型 —— getClass
        Class class1 = s1.getClass();//class Tets.Student
        Class class2 = s2.getClass();//class Tets.Student
        System.out.println(class1==class2);//true

类

package Tets;

public class Student {
    //属性
    private int age;
    private String name;

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

实例化

package Tets;

public class TestStudent {
    public static void main(String[] args) {
        //getClass方法
        Student s1 = new Student(25,"李白");
        Student s2 = new Student(52,"刘备");
        //判断是不是同一个类型 —— getClass
        Class class1 = s1.getClass();//lass Tets.Student
        Class class2 = s2.getClass();//lass Tets.Student
        System.out.println(class1==class2);//true
    }
}

hashCode()方法

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

类

package Tets;

public class Student {
    //属性
    private int age;
    private String name;

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

实例化

import java.util.Arrays;
public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student(25,"李白");
        Student s2 = new Student(52,"刘备");
        //hashCode 该实际对象的哈希码值
        System.out.println(s1.hashCode());//668386784
        System.out.println(s2.hashCode());//1329552164
        Student s3 = s1;
        //把s1的地址赋值给了s3，在内存里是一样的
        //后来试了一下，s1的任何属性都和s3的一样 任意改s1或s2都会一起改变
        System.out.println(s3.hashCode());//668386784
    }
}

toString方法

返回该对象的字符串表示(表现形式)（即; 返回字符串格式的地址哈希值）
可以根据程序需求覆盖该方法，如；展示对象各个属性值
这里没多少说的，一种是默认使用，一种是重写方法(重写即; 父类的方法不能满足子类的需要，因此子类重写父类的方法，以达成需要)

类

package Tets;

public class Student {
    //属性
     int age;
     String name;
    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }
    //toString 重写方法  这里重写的是Object的方法
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

Application

package Tets;

public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student(25,"李白");
        Teacher s2 = new Student(52,"刘备");
        //初始功能       toString ————返回该对象的字符串形式
        System.out.println(s1.toString());//Tets.Student@27d6c5e0     类路径@哈希值(字符串格式)
        System.out.println(s2.toString());//Tets.Student@4f3f5b24     类路径@哈希值(字符串格式)
        //重写toString   ALT-insect
        /**
         * print
         * Student{age=25, name='李白'}
        Student{age=52, name='刘备'}
         */
    }
}

print

F:\Application\out\production\Application Tets.TestStudent
Student{age=25, name='李白'}
Student{age=52, name='刘备'}

Process finished with exit code 0

equals方法

public boolean equals(Object obj){}
默认实现为(this == obj),比较两个对象地址是否相同
进阶(重写)可进行覆盖，比较两个对象的内容是否相同

/**
- 比较两个引用是否指向同一个对象
- 判断obj是否为null
- 判断两个引用指向的实例对象类型是否一致
- 强制类型转换
- 依次比较个个属性值是否相同
*/

类

package Tets;

public class Student extends Teacher{
    //属性
     int age;
     String name;
    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public boolean equals(Object obj) {
        //1.  比较两个引用是否指向同一个对象(两个值是不是同一个)
        if(this == obj){
            return true;
        }
        //2.  判断obj是否为null
        if(obj == null){
            return false;
        }
        //3.  判断两个引用指向的实例对象类型是否一致(即类型)
        if(obj instanceof Student){//obj instanceof Student ==this.getClass() == obj.getClass()
            //4.  如果是同一个类型则强制类型转换
            Student s = (Student)obj;
            //5.  依次比较个个属性值是否相同
            if (this.name.equals(s.name)&&this.age==s.age){
                return true;
            }
        }
        return false;
    }
}

Application

package Tets;

public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student(25,"李白");
        Student s2 = new Student(52,"刘备");
        //1. 初始功能    equals比较两个对象的地址 返回boolean值  |  s1.equals(s2)
        System.out.println(s1.equals(s2));//false
        //2. 属性一样，不同的new出的不同对象  比较地址
        Student s3 = new Student(14,"不朽");
        Student s4 = new Student(14,"不朽");
        System.out.println(s3.equals(s4));//false  类型一样  属性一样  new出的对象地址不一样 比较对象的地址
        //3. 进阶(重写)可进行覆盖，比较两个对象的内容是否相同 上面是不比较内容的 比较地址
        Student s5 = new Student(14,"无欲");
        System.out.println(s3.equals(s4));
        System.out.println(s3.equals(s5));
    }
}

print

F:\Application\out\production\Application Tets.TestStudent
false
true
true
false

Process finished with exit code 0

gc()方法

一般不会使用该方法

当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列。
垃圾对象；没有有效引用指向此对象时，为垃圾对象
垃圾回收；由GC销毁垃圾对象，释放数据储存空间
自动回收机制； JVM的内存耗尽，一次性回收所有垃圾
手动回收制；使用System.gc()；通知JVM执行垃圾回收(至于JVM会不会执行还要看情况，所以本质还是JVM说了算)

类

package Test;

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

    public Student() {
    }

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

    public Student(int age, int money, String name) {
        this.age = age;
        this.money = money;
        this.name = name;
    }
    //重写 回收  gc 添加回收会报告消息的功能

}

Application

package Test;

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student(12,"刘邦");
        new Student(12,"刘邦1");
        new Student(12,"刘邦2");
        new Student(12,"刘邦3");
        new Student(12,"刘邦4");
        new Student(12,"刘邦5");
        System.gc();// 通知JVM执行垃圾回收 结果不回收！
        System.out.println("======================================");

    }
}

print

F:\Application\out\production\Application Test.Application
======================================

Process finished with exit code 0

3.——包装类

什么是包装类

基本类型所对应的引用类型数据类型(基本类型储存在栈(栈里放对象的地址)，引用类型在堆)

为了基本数据类型提供更强大的功能—推出包装类(就有了属性和方法)
Object可统一所有的数据，包装类的默认值是null

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

类型转换与装箱、拆箱

基本类型的对象存在栈中，而引用类型存在堆中，

基本类型和包装类之间转换的过程

比如一个基本类型的数据在栈中，要拿到堆里去，把基本类型转换成一个对象；这个过程叫装箱

把堆中的数据拿到栈中，这个过程叫拆箱

Application

package Demo;

public class Demo01 {
    public static void main(String[] args) {
        //类型转换; 装箱——从基本类型转换成引用类型的过程
        //基本类型
        int num01 = 18;
        //使用Integer类创建对象
        Integer integer1 = new Integer(num01);//Method one
        Integer integer2 = Integer.valueOf(num01);//Method tow
        System.out.println("手动装箱");
        System.out.println("integer1"+"\t"+integer1);
        System.out.println("integer2"+"\t"+integer2);

        //类型转型; 拆箱; 引用类型转成基本类型
        System.out.println("手动拆箱");
        Integer integer3 = new Integer(num01);
        System.out.println("integer3"+"\t"+integer3);
        int num02 = integer3.intValue();
        System.out.println("num02"+"\t"+num02);

        //JDK1.5之后，提供自动装箱和拆箱
        int age = 18;
        //自动装箱
        System.out.println("自动装箱");
        Integer integer4 = age;
        System.out.println(integer4);
        //自动拆箱
        int age2 =integer4;
        System.out.println("自动拆箱");
        System.out.println(age2);
        /**
         * 虽然JDK1.5后有自动装箱和拆箱的功能但是，实际上还是在编译器中完成了手动装箱和拆箱(Xjad)
         * */
    }
}

print

F:\Application\out\production\Application Demo.Demo01
手动装箱
integer1	18
integer2	18
手动拆箱
integer3	18
num02	18
自动装箱
18
自动拆箱
18

Process finished with exit code 0

自动装箱与手动装箱

java

//JDK1.5之后，提供自动装箱和拆箱
int age = 18;
//自动装箱
System.out.println("自动装箱");
Integer integer4 = age;
System.out.println(integer4);
//自动拆箱
int age2 =integer4;
System.out.println("自动拆箱");
System.out.println(age2);

java文件中的自动装箱

Integer integer4 = age;

IDEA反编译后的文件class

Integer integer4 = Integer.valueOf(age);

不难看出，编译器在后台为我们自动实现了装箱与拆箱

基本类型和字符串转换

8种包装类提供不同类型间的转换方式；
- Number父类中提供6中共性方法
- parseXXX()静态方法 ~~XXX表示一种类型例如；int double,,,~~

可以实现字符串与基本类型之间的转换

Application

package Demo;

public class Demo03 {
    public static void main(String[]args){
        //基本类型与字符串之间的转换
        System.out.println("===============1. 基本类型转换成字符串================");
        //1. 基本类型转换成字符串
        int i1 = 15;
        //1.1 使用+号
        String s1 = i1+"";
        //1.2 使用Integer中的toString()方法
        String s2 = Integer.toString(i1);//转换为字符串
        System.out.println(s1+"\n"+s2);
        //Integer.toString的进阶使用
        String s3 = Integer.toString(i1,16);//toString(int i,int radix)
        /**    API文档介绍  toString(int i, int radix)
         * static String   toString(int i, int radix)
        返回用第二个参数指定基数表示的第一个参数的字符串表示形式。
         视频教程说可以理解为 radix = 想要转换进制
         */
        //toSting中也有很多可以转换进制的方法 这里就不说了 可以查阅api
        System.out.println(s3);
        //字符串转换成基本类型
        System.out.println("===============2. 字符串转换成基本类型================");
        String str = "150";
        int i2 = Integer.parseInt(str);
        System.out.println("转换基本类型 int");
        System.out.println(i2);
        System.out.println("转换基本类型 long");
        double i3 = Double.parseDouble(str);
        System.out.println(i3);
        //boolean字符串转换成基本类型; "true" ----> true   非"true" ----> false
        System.out.println("==============boolean字符串转换成基本类型===============");
        String test = "true";
        String t2 = "10";
        //对相应包装类的操作 要调用相应的包装类
        boolean type00 = Boolean.parseBoolean(test);
        boolean type01 = Boolean.parseBoolean(t2);
        System.out.println(type00);
        System.out.println(type01);//非"true" ----> false


    }
}

print

F:\Application\out\production\Application Demo.Demo03
===============1. 基本类型转换成字符串================
15
15
f
===============2. 字符串转换成基本类型================
转换基本类型 int
150
转换基本类型 long
150.0
==============boolean字符串转换成基本类型===============
true
false

Process finished with exit code 0

Integer缓冲区

Java预先创建了256个常用的整数包装类型对象

256是指-127是127个值 128是128个值还有一个0 127+128+1=256

在实际应用当中，对已创建的对象进行复用（不理解）

听起来很懵逼，没关系，先尝试分析一道面试题

Application

package Demo;

public class Demo04 {
    public static void main(String[] args) {
        //面试题; 他们为什么会产生这样的结果，为什么       true/false?
        System.out.println("==============手动装箱================");
        Integer i1 = new Integer(100);
        Integer i2 = new Integer(100);
        System.out.println(i1==i2);//false;  值虽然一样地址不一样 它是引用类型 对象不一样
        System.out.println("==============自动装箱================");
        Integer i3 = 100;//看class文件后发现   Integer.valueOf(100) 不是调用构造方法
        Integer i4 = 100;
        System.out.println(i3==i4);//true
        Integer i5 = 200;//Integer.valueOf(200)
        Integer i6 = 200;
        System.out.println(i5==i6);//false
    }
}

print

F:\Application\out\production\Application Demo.Demo04
============手动装箱=================
false
============自动装箱=================
true
false

Process finished with exit code 0

问题就出来了为什么 true/false

i3（100）	i4（100）	true
i5（200）	i6（200）	false

首先我们知道自动装箱调用的是 Integer.valueOf 方法

Integer i5 = count;//Integer.valueOf(count)

所以选中 Integer.valueOf 按住 ALT+CTRL+B 查看源码查找原因（在IDEAclass文件中进行操作）

以下为该方法源码

@HotSpotIntrinsicCandidate
public static Integer valueOf(int i) {
    return i >= -128 && i <= Integer.IntegerCache.high ? Integer.IntegerCache.cache[i + 128] : new Integer(i);
}

三元运算符 条件 ? true : false； 差点忘记拉: )
Cache 高速缓冲

i <= Integer.IntegerCache.high   //这一行通过查源码发现; Integer.IntegerCache.high ==  127

Integer.valueOf(count)

现在就能解读 Integer.valueOf( int i ) 的意思了如果 i -128<=i<=127 则在高速缓冲区内寻找该值，然后在栈中赋予地址(即是基本类型地址相同)，否则就New一个Integer，在堆里创建引用类型

至于 Integer.IntegerCache.cache[i + 128] 这一段我也不理解先放着视频中解释是说，在高速缓存中寻找该值

所以得出结论，自动装箱数值在 -128 127 之间，会在高速缓存中找到值，在栈中产生值，否则会New一个Integer（引用类型），引用类型地址是不一样的，所以一定是false

4.——String类

String概述

字符串是常量，创建之后不可改变
字符串字面值存储在字符串池中，可以共享

package Demo;

public class Demo05 {
    public static void main(String[] args) {
        String name00 = "李四";//在常量池/字符串池中创建"李四"
        name00 = "张三";
        /**
         * 此时池中的"李四"并不会被删除——字符串是常量，创建之后不可改变
         */
        String name01 = "张三";
        /**
         * 此时程序会在常量池/字符串池中查询有没有张三
         * 如果  有  就把 name01 指向池中的地址，因此是和 name00 是一样的
         * --字符串字面值存储在字符串池中，可以共享
         * 如果  没有  就在池中新建一个地址 "张三"
         * */
    }
}

String str = “Hello" ; 产生一个对象，字符串池中储存
String str = new String ( ”Hello“ ) ; // 产生两个对象，堆、池中各一个

package Demo;

public class Demo06 {
    public static void main(String[] args) {
        //两种定义字符串的方式
        //- 直接用String 定义
        String str00 = "Hello";//在常量池/字符串池中查，没有就新建，有就共享
        //- 使用 new String();
        String str01 = new String("Hello");
        //这个会直接在常量池/字符串池，与堆中各创建一个"Hello",在池中的创建还是一样，没有就新建，有就共享。
        String str02 = new String("Hello");
        System.out.println(str01==str02);//false
        // 因为通过new 虽然池中堆中都有创建，但是在程序中是指向堆的地址，堆是引用类型，new的引用类型地址是不一样的。所以false
        System.out.println(str01==str00);//false 一个指向堆 一个指向常量池/字符串池 地址不同
        //  - 所以在比较字符串时，使用equals 因为它比的是值，不是地址
        System.out.println(str01.equals(str02));//true
        System.out.println(str01.equals(str00));//true
    }
}

结合上一图理解

String 常用方法(一)

public int length(): //返回字符串的长度
public char charAt(int index) :  //根据下标获取字符
public boolean contains(String str) : //判断当前字符串中是否包含str

Application

package Demo;

public class Demo07 {
    public static void main(String[]args){
        //字符串方法的使用
        /**
         * ——length();             返回字符串的长度
         * ——charAt(int index);    返回对应下标的字符
         * ——contains(String str); 判断是否包含某个字符串
         */
        String content = "跑的快,不如,跑的久 。";// 12字符  空格算一个
        System.out.println(content.length());//12
        System.out.println(content.charAt(2));//下标是从0开始
        System.out.println(content.contains("快"));//true
        System.out.println(content.contains("person"));//false
        /**
         * System.out.println(content.charAt(content.length()));
         * ——显示长度的下标会报错,因为下标是从0开始*/
        System.out.println(content.charAt(content.length()-1));
    }
}

print

F:\Application\out\production\Application Demo.Demo07
12
快
true
false
。

Process finished with exit code 0

String 常用方法(二)

public char[] toCharArray() |  //将字符串转换成数组 | 因为字符串可以理解为字符数组的组合
public int indexOf(String str) | //查找str首次出现的下标，存在，则返回该下标，不存在则返回-1
public int lastIndexOf(string str) | //查找字符串当前字符串中最后一次出现的下标索引

Application

package Demo;
import java.util.Arrays;
public class Demo08 {
    public static void main(String[] args) {
        String content = "当归—北窗-北窗";
        //字符串Method的使用
        //4. toCharArray();返回字符串中对应的数组
        //5. indexOf();返回字符串中首次出现的位置
        //6. lastIndexOf();返回字符串最后一次出现的位置
        System.out.println(content.toCharArray());// 当归—北窗  这个也是数组形式的字符串
        System.out.println(Arrays.toString(content.toCharArray()));//[当, 归, —, 北, 窗]
        System.out.println("=================================");
        System.out.println(content.indexOf("北"));
        System.out.println(content.indexOf("北",4));//后面的 int 是指从那个下标开始查起
        System.out.println("=================================");
        System.out.println(content.lastIndexOf("北窗"));
        System.out.println(content.lastIndexOf("北"));
    }
}

print

F:\Application\out\production\Application Demo.Demo08
当归—北窗-北窗
[当, 归, —, 北, 窗, -, 北, 窗]
=================================
3
6
=================================
6
6

Process finished with exit code 0

String 常用方法(三)

public String trim(); //去掉字符串前后的空格
public String toUpperCase(); //将小写转成大写 toLowerCase() 大->小
public boolean endsWith(String str); //判断字符串是否以str结尾 startsWith() 开头是否包含

Application

package Demo;

public class Demo09 {
    public static void main(String[]args){
        //7. trim(); 去掉String前后的空格
        //8. toUpperCase(); 把小写转成大写 toLowerCase() 大写->小写
        //9. endsWith(str); 判断是否以str结尾, startsWith(str); 判断是否以str开头 //star 明星

       String content = "     I Love Java!!        ";
        //=====================   trim()   ===============
        System.out.println(content.trim());

        //=====================   toUpperCase()   toLowerCase()     ===============
        System.out.println(content.trim().toUpperCase());// 实验成功 说明这些方法是可以叠加使用的
        System.out.println(content.toUpperCase());// 这里空格还在 因为前面提到 字符串是常量
        System.out.println(content.toLowerCase());

        //=====================   endsWith()   starWith()     ===============
        System.out.println(content.endsWith("!!"));//false 由此可见 endsWith()方法  包含空格
        System.out.println(content.trim().endsWith("!!"));//true  这配合就很棒！
        System.out.println(content.trim().startsWith("I"));//true
    }
}

print

F:\Application\out\production\Application Demo.Demo09
I Love Java!!
I LOVE JAVA!!
     I LOVE JAVA!!        
     i love java!!        
false
true
true

Process finished with exit code 0

String 常用方法(四)

public String replace (char old, char new ); //将旧的字符串或字符，替换成新的
public String[] split(String str); //根据str做拆分

Application

package Demo;

public class Demo10 {
    public static void main(String[]args){
        String content = "I Love Java";
        //  replace
        System.out.println(content.replace("Java", "C++"));// 替换
        System.out.println("===============================");
        //  split
        String content00 = "java C++ Php, C#, C";
        String[] str = content00.split("[ ,]+");
        /**
         * [] 解决需要多个拆分元素的问题，以及拆分元素集中的问题
         * */
        System.out.println(str.length);
        for(String string : str){
            System.out.println(string);
        }
        System.out.println("===============补充=============");
        //equals、 compare();比较大小 比较字典表里的(数值)顺序
        String s1 = "JAVA";
        String s2 = "java";
        System.out.println(s1.equals(s2));//  区分大小写
        System.out.println(s1.equalsIgnoreCase(s2));//  不区分大小写
        String s3 = "abc";// a=97
        String s4 = "xyz";// x=120
        String s5 = "abcdef";
        String s6 = "abc";
        System.out.println(s3.compareTo(s4));//120-97 只比出一个不同的值相减
        System.out.println(s3.compareTo(s5));//如果长度不一样比长度 -3 前面减后面
        System.out.println(s3.compareTo(s6));//相等 0


    }
}

print

F:\Application\out\production\Application Demo.Demo10
I Love C++
===============================
5
java
C++
Php
C#
C
===============补充=============
false
true
-23
-3
0

Process finished with exit code 0

小试牛刀

Application

package Work;

public class Work03 {
    public static void main(String[] args) {
        String str = "this is a text";
        //第一题————将str中的单词单独获取出来
        String[] result = str.split(" ");
        for (String s : result){
            System.out.println(s);
        }
        System.out.println("======================");
        //第二题————将str中的text替换为practice
        String s1 = str.replace("text","practice");
        System.out.println(s1);
        System.out.println("======================");
        //第三题————在text前面插入一个easy
        String s2 = str.replace("text","easy text");
        System.out.println(s2);
        System.out.println("======================");
        //第四题————将每个单词的首字母改为大写
        for (int i = 0;i<result.length;i++){
            //提取首字
            char first = result[i].charAt(0);
            //把小写首字转换大写
            char upperFirst = Character.toUpperCase(first);//Character 字符串包装类
            String news = upperFirst+result[i].substring(1);// substring()  截取 *********
            System.out.println(news);
        }
    }
}

print

F:\Application\out\production\Application Work.Work03
this
is
a
text
======================
this is a practice
======================
this is a easy text
======================
This
Is
A
Text

Process finished with exit code 0

拓展

        char c1 = 'A';
        String name = "白雪美吗";
        String newName = c1+name.substring(0,3);
        System.out.println(newName);//A白雪美

字符串与字符链接 +
字符串截取 substring() 方法

可变字符串(五)

StringBuffer ：可变长字符串，效率慢，线程安全
StringBuilder ：可变长字符串，效率快(比String快)，线程不安全
两者完全一样

由于String 的不可变性，可能会在运行过程产生很多没有用的垃圾(没用的字符串)

它每次操作的时候都会产生一个新的字符串，从效率来讲也是比较低的

因此推出一个类 substring 它是在空间上开辟了一个缓冲区，直接在缓冲区上操作，从内存上也比String要好

Application

package Demo;
/**
 * StringBuffer和StringBuilder
 * 和String区别  1.效率比String高  2.比String省内存
 * StringBuffer   StringBuilder方法是一模一样的
 * 单线程用StringBuilder
 *
 * @author 夏天的风
 * */
public class Demo11 {
    public static void main(String[] args) {
        //StringBuilder sb = new StringBuilder;
        StringBuffer sb = new StringBuffer();
        System.out.println("==========  1. append() 追加 ============");
        //追加append()   在已有的基础上，添加字符串
        sb.append("JAVA——世界第一");
        System.out.println(sb.toString());
        sb.append("I love JAVA");
        System.out.println(sb.toString());
        sb.append("我为JAVA狂");
        System.out.println(sb.toString());
        System.out.println("==========  2. insert()  插入============");
        //insert() 插入  它重写了很多的基本类型都能插入
        sb.insert(4,"必须是");
        System.out.println(sb.toString());
        System.out.println("==========  3. replace()  替换============");
        sb.replace(4,7,"！！！");// 含头不含尾原则 start 开始的index  end 结束的index+1
        System.out.println(sb.toString());
        System.out.println("==========  4. delete()  删除============");
        sb.delete(4,7);//含头不含尾巴
        System.out.println(sb);
        System.out.println("==========  5. reverse()  反转============");
        sb.reverse();
        System.out.println(sb);
        System.out.println("==========  6. delete(0,str.length())  清空============");
        sb.delete(0,sb.length());
        System.out.println(sb);
        System.out.println("==========  7. replace()  替换============");
        System.out.println(sb.length());
    }
}

print

F:\Application\out\production\Application Demo.Demo11
==========  1. append() 追加 ============
JAVA——世界第一
JAVA——世界第一I love JAVA
JAVA——世界第一I love JAVA我为JAVA狂
==========  2. insert()  插入============
JAVA必须是——世界第一I love JAVA我为JAVA狂
==========  3. replace()  替换============
JAVA！！！——世界第一I love JAVA我为JAVA狂
==========  4. delete()  删除============
JAVA——世界第一I love JAVA我为JAVA狂
==========  5. reverse()  反转============
狂AVAJ为我AVAJ evol I一第界世——AVAJ
==========  6. delete(0,str.length())  清空============

==========  7. replace()  替换============
0

Process finished with exit code 0

说Stringbuilder的运行效率比StringBuffer高高在哪里？

Application

package Demo;

import java.sql.SQLOutput;

/**
 * 验证 StringBuilder 的效率比 String  高
 *
 * @author 夏天的风
 * */
public class Demo12 {
    public static void main(String[] args) {
        //String   所用的时间
        long start = System.currentTimeMillis();// start   开始的时间
        String str = "";
        for (int i = 0;i<99999;i++){
            str+=i;
        }
        System.out.println(str);
        long end = System.currentTimeMillis();// end    结束的时间
        System.out.println("String用时"+(end-start));//  5305 毫秒

        System.out.println("============================");
        //StringBuilder  所用的时间
        long last = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i<99999;i++){
            sb.append(i);
        }
        System.out.println(sb.toString());
        long end2 = System.currentTimeMillis();
        System.out.println("StringBuilder 用时;"+(end2-last));//  19ms  毫秒

    }
}

print

F:\Application\out\production\Application Demo.Demo12
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950(略)...
String  用时;5305
================
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950(略)...
StringBuilder 用时;19

Process finished with exit code 0

5——BigDecimal类

import java.math.BigDecimal;

很多的实际应用中需要精确的运算，而 Double 和 Float 是近似值储存，不符合要求，所以需要————BigDecimal 类

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

Application

package Demo;
import java.math.BigDecimal;
public class Demo13 {
    public static void main(String[]args){

        double sum01 = 1.0;
        double sum02 = 0.9;
        System.out.println(sum01-sum02); // 0.09999999999999998

        //面试题
        double result = (1.4-0.5)/0.9;
        System.out.println(result); // 0.9999999999999999
        /**
         * 问题出在于 double 和 float 的储存方式  输给它的是真值 但是在内存中它就变成了一个近似的值
         * 是无限接近真值的  是一种不精确的计算    因此 推出精度要求很高的   BigDecimal类
         * */

        //BigDecimal, 大的浮点数精确计算
        //先导入包;  import java.math.BigDecimal;
        BigDecimal bd0 = new BigDecimal("1.0");
        //输入的字符串会在类中  运算  字符串是最精确的 如果给数字可能还是近似运算
        BigDecimal bd1 = new BigDecimal("0.9");
        //BigDecimal  运算不能直接用运算符
        //===============减法()subtract=======
        BigDecimal r1 = bd0.subtract(bd1);// 0.1
        System.out.println(r1);
        //===============加法(add)============
        BigDecimal r2 = bd0.add(bd1);
        System.out.println(r2);
        //===============乘法(multiply)=======
        BigDecimal r3 = bd0.multiply(bd1);
        System.out.println(r3);
        //===============除法(divide)=========
        /**面试题
            double result = (1.4-0.5)/0.9;
         */
        BigDecimal r4 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"));
        System.out.println(r4);
        // ——当除不尽的时候  10/3   会报错
        //BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3")); // 报错
        //因此 需要添加——精确到几位小数 | 什么舍入方法
        BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);
        // BigDecimal.ROUND_HALF_UP  如果不加四舍五入  计算值为  4
        System.out.println(r5);

    }
}

print

F:\Application\out\production\Application Demo.Demo13
0.09999999999999998
0.9999999999999999
0.1
1.9
0.90
1
3.33

Process finished with exit code 0

进行除法运算时，如果不能准确的计算出结果时(除不尽)，需要指定保留的位数和取舍方式就需要用 divide 重载方法
divide(BigDecimal bd,int scal,RoundingMode mode);
参数scal ；指定精确到小数点后几位
参数mode ；
- 指定小数部分的取舍模式，通常采用四舍五入的模式
- 取值为BigDecimal.ROUND_HALF_UP

BigDecimal r1 = new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);

6——Date类

import java.util.date;
Date 表示特定的瞬间，精确到毫秒。Date类中的大部分方法已经被 Calendar类中的方法所取代
时间单位
- 1秒 = 1000毫秒
- 1毫秒 = 1000微秒
- 1微秒 = 1000纳秒 //毫微秒

Application

package Demo;

import java.util.Date;

public class Demo14 {
    public static void main(String[] args) {
        //1. 创建Date对象
        //今天的此时此刻
        Date date1 = new Date();
        long l = date1.getTime();
        System.out.println(date1.toString());
        System.out.println(date1.toLocaleString());// 过时了有删除线
        System.out.println(l);
        long l1 = System.currentTimeMillis();//系统当前的毫秒值
        System.out.println(l==l1);// true 说明l是当前的毫秒值
        System.out.println("===========================");
        //昨天的此时此刻
        System.out.println(date1.getTime());
        //getTime()        自 1970 年 1 月 1 日 00:00:00 GMT 以来的毫秒数
        Date date2 = new Date(date1.getTime()-(60*60*24*1000));
        System.out.println(date2.toLocaleString());
        System.out.println("===========================");
        //2. 方法   after  before
        //after 测试此日期是否在指定日期之后。
        boolean b1 = date1.after(date2);
        System.out.println(b1);// true
        boolean b2 = date1.before(date2);
        System.out.println(b2);// false
        System.out.println("===========================");
        //3. compareTo()   比较两个日期的顺序  相等则为 0
        int i = date1.compareTo(date2);// 前面减去后面
        System.out.println(i);// 1
        int i1 = date2.compareTo(date1);
        System.out.println(i1);// -1
        System.out.println("===========================");
        //4. equals  比较两个时间是否相等
        boolean b = date1.equals(date2);
        System.out.println(b);
        System.out.println("===========================");
        //5. setTime  设置此 Date 对象，以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。
        Date t = new Date();//  都有些忘记了 明明知道输入的是long参数 忘记了L | 0L  时间原点
        t.setTime(0L);
        System.out.println(t);// 设置此 Date 对象，以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。
    }

}

print

F:\Application\out\production\Application Demo.Demo14
Thu Mar 18 18:05:53 CST 2021
2021年3月18日 下午6:05:53
1616061953441
false
===========================
1616061953441
2021年3月17日 下午6:05:53
===========================
true
false
===========================
1
-1
===========================
false
===========================
Thu Jan 01 08:00:00 CST 1970

Process finished with exit code 0

7——Calendar类

Calendar 提供了获取设置各种日历字段的方法
构造方法
- protected Calendar(); 由于修饰符是protected，所以无法直接创建该对象
其他方法

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

Application

package Demo;
//先导入类
import java.util.Date;
import java.util.Calendar;
public class Demo15 {
    public static void main(String[] args) {

        //创建Calendar类
        Calendar calendar = Calendar.getInstance();
        //protected Calendar();
        // 由于修饰符是protected，所以无法直接创建该对象  所以要用get方法
        // 1. 打印当前时间
        System.out.println(calendar.getTime().toLocaleString());//还是用过时的方法来打印 比较舒服
        System.out.println(calendar.getTimeInMillis());//当前时间的毫秒值  从1970年起
        // 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+"月"+day+"日"+hour+"时"+minute+"分"+second+"秒");
        // 3. 修改时间
        Calendar c2 = Calendar.getInstance();
        c2.set(Calendar.MONTH,1);//月是从0开始  修改到的月份-1
        System.out.println(c2.getTime().toLocaleString());
        // 4. add方法 修改时间
        calendar.add(calendar.HOUR_OF_DAY,1);
        System.out.println(calendar.getTime().toLocaleString());
        // 5. 补充方法
        int MAX = calendar.getActualMaximum(calendar.MONTH);
        int MIN = calendar.getActualMinimum(Calendar.MONTH);
        System.out.println(MAX);//月份 0-11
        System.out.println(MIN);

    }
}

print

F:\Application\out\production\Application Demo.Demo15
2021年3月19日 下午9:42:25
1616161345998
2021年2月19日21时42分25秒
2021年2月19日 下午9:42:26
2021年3月19日 下午10:42:25
11
0

Process finished with exit code 0

8——SimpleDateFormat类

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

字母	日期或时间	实例
y	年	2019
M	年中月份	08
d	月中天数	10
H	1天中小时数(0-23)	22
m	分钟	16
s	秒	60
S	毫秒	1000

Applicatin

package Demo;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo16 {
    public static void main(String[]args) throws Exception{
        //导入类
     // 1. 创建SimpleDateFormat对象
     SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:s:S");// 括号里写时间模式/格式
        //这里可以是无参构造，也可以有参构造 但是最好用有参 如果无参后面还要设置
        //创建Date
        Date date = new Date();
        // 2. 格式化Date  (日期——>字符串)
        String str = sdf.format(date);// 格式化日期 返回String 自己设置的格式
        //format(Date date, StringBuffer toAppendTo, FieldPosition pos)
        //          将给定的 Date 格式化为日期/时间字符串，并将结果添加到给定的 StringBuffer。
        System.out.println(str);
        // 3. 解析  (字符串——>日期)
        Date d = sdf.parse("1999年03月20日10:10:32:450");//要按照自己设置的格式输入字符串
        //如果没有按照设置的格式输入的话会有异常  在main 方法抛出异常 不知道为啥 按照格式了也异常
        System.out.println(d.toLocaleString());

    }
}

print

F:\Application\out\production\Application Demo.Demo16
2021年03月20日10:22:37:419
1999年3月20日 上午10:10:32

Process finished with exit code 0

9——System类

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

方法名	说明
static void arraycopy();	复制数组
static long currentTimeMillis();	获取当前系统的时间，返回毫秒值
static void gc();	建议系统启动回收器，回收垃圾
static void exit(int status);	退出Jvm，可以输入参数，如果参数是0正常退出jvm，非0表示异常退出

因为System类是私有的静态方法所以不需要创建对象

package Demo;

public class Demo177 {
    public static void main(String[] args) {
        // 1. System.arrayCopy  复制数组
        /**
        -src; 源数组
        -srcPos; 从那个位置开始复制 下标为0
        -dest; 目标数组
        -destPos; 目标数组的位置
        -length; 复制的长度*/
        int[] arr = {1,2,3,6,7,8,9,0};
        int[] arr0 = new int[arr.length];
        //System.arrayCopy(src,srcPos,dest,desPos,length);
        System.arraycopy(arr,4,arr0,4,4);
        for (int i = 0;i<arr.length;i++){
            System.out.print(arr0[i]+"\t");
        }
        // 2. System.currentTimeMillis(); 返回当前系统时间的毫秒值 可以计算 一个算法的运行时间
        System.out.println(System.currentTimeMillis());
        long start = System.currentTimeMillis();
        for (long i =0; i<999999L;i++){
            for (long j =0;j<9999L;j++){
                long result =i+j;
            }
        }
         long end = System.currentTimeMillis();
        System.out.println("用时"+(end-start)+"毫秒");
        // 3. System.gc()  ; 建议垃圾回收器，回收垃圾

        // 4. 退出JVM
        System.exit(1);// 0 是正常退出 非0 异常退出
    }
}

System.gc() 建议垃圾回收器启动

Application

package Demo;

public class Teacher {
    public static void main(String[] args) {
        /**
        Student s1 = new Student("刘邦",32);
        Student s2 = new Student("项羽",28);
        Student s3 = new Student("张良",25);
         不回收
        */
        //视频中给的解释说，三个对象都是有引用的所以不回收
        /**
          new Student("刘邦",32);
          new Student("项羽",28);
          new Student("张良",25);
         不回收
         */
        //这三个是没有引用的  还是不回收 可是视频里回收了！
        new Student("aa",32);
        new Student("bb",28);
        new Student("cc",25);
        System.gc();
    }
}

Student类

package Demo;

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

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

    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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    protected void finalize() throws Throwable {
        //重写该方法 就能看出已经执行了 垃圾回收
        System.out.println("回收了"+name+"\t"+age);
    }

}

print

F:\Application\out\production\Application Demo.Teacher

Process finished with exit code 0

新增单词

0	body	身体	博迪	把外部类比喻身体内部类比喻成必要组件头
1	head	头	哈德
2	phone	手机	疯~	iphone 爱疯~ 苹果手机 \| phone 疯~ 手机
3	email	电子邮件	e 麦偶~
4	equals	等于	1 古偶斯~	String.equals(str) \| 值是否相等区分大小写
5	equalsIgnoreCase	等于	1 个诺r~	String.equalsIgnoreCase(str) \| 值是否相等不区分大小写
6	finalize	垃圾回收的方法	fai no 莱z~	@Override protected void finalize() throws Throwable
7	Integer	int的包装类型	in踢g~
8	Character	char的包装类型	克拉克特~
9	valueOf	返回一个表示指定的 `int`/String 值的 `Integer` 实例	vlu of
10	radix	基数	雷迪克斯
11	parse	解析	泊尔斯~	String str = "150"; int i2 = Integer.parseInt(str);把字符串转换成数值
12	Cache	高速缓存	卡嘘~
13	high	高	海伊
15	charAt	在指定的索引表中返回,相对于下标的一个字符	查尔At	Strring.charAt(int i)
16	contains	是否包含某字符串 \| boolean	肯泰恩次~	String.contains(”String str“）)
17	content	内容	空藤T~
18	last	最后的	拉斯特
19	trim	修剪String前后空格	踹姆~
20	toUpperCase	小写转换成大写	to凹pe_K斯	String.toUpperCase() \| Upper 较高的
21	toLowerCase	大写转换成小写	洛厄	String.toLowerCase() \| 较小的
22	endsWith	判断是否以str结尾	恩德s,维特	String.endWith() \| 以....结束
23	startsWith	判断是否以str开头	star Ts维特~	String.startWith() \| 以...开始
24	replace	替换	瑞普类斯~	String.replace(old,new)
25	old	老的
26	split	拆分	斯部勒特~
27	first	第一	菲尔斯特~
28	substring	截取字符串中的子串	沙吧String
29	StringBuffer	字符串缓冲区	String爸夫~
30	StringBuilder	动态字符串	bui德尔~
31	append	追加	额盘的~
32	current	现在的	柯伦特
33	Millis	毫秒	米利斯
34	BigDecimal	精确的算法类	Big 打斯某~
35	add	加
36	subtract	减	s不tr科特~
37	multiply	乘	摸的噗掳爱~
38	divide	除	低歪的~
39	after	测试此日期是否在指定日期之后	afT~
40	before	测试此日期是否在指定日期之前	笔for~
41	compareTo	比较两个日期的顺序	com佩尔to~
42	Calendar	日期类	卡伦打~
43	getInstance	使用默认时区和区域获取日历		结合instanceOf来背
44	getTimeInMillis	获取当前时间的毫秒值	getTimeIn米利斯
45	month	月	mon夫~
46	hour	时	傲r
47	minute	分	迷你次~
48	second	秒	赛肯的~
49	getActualMaximum	获取最大值	get艾克突LMaxi妈me~	int MAX = calendar.getActualMaximum(calendar.MONTH);//0-11 \| 11
50	getActualMinimum	获取最小值	get艾克突L迷你次_妈me
51	SimpleDateFormat	日期格式	桑普DateFor满次	SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:s:S");
52	format	格式	For满次
53	arrayCopy	复制数组

posted @ 2021-05-23 12:26 项晓忠阅读(65) 评论(0) 编辑收藏举报

Deep

朝闻道，夕死可矣

第二十五讲——常用类

第二十五讲——常用类

1.——内部类

成员内部类

静态内部类

局部内部类

匿名内部类

接口实现

2.——Object类

GetClass方法

hashCode()方法

toString方法

equals方法

gc()方法

3.——包装类

什么是包装类

类型转换与装箱、拆箱

基本类型和字符串转换

Integer缓冲区

4.——String类

String概述

String 常用方法(一)

String 常用方法(二)

String 常用方法(三)

String 常用方法(四)

小试牛刀

可变字符串(五)

5——BigDecimal类

6——Date类

7——Calendar类

8——SimpleDateFormat类

9——System类

新增单词

公告