Java_常用类

最新推荐文章于 2023-08-30 17:32:54 发布

清纯献给了作业

最新推荐文章于 2023-08-30 17:32:54 发布

阅读量999

点赞数 4

分类专栏： Java 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/qq_45459526/article/details/123687739

版权

Java 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

内部类

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

外部类可以直接访问内部类的私有成员，而不破坏封装；
编译之后可以生成独立的字节码文件（2个.java的文件）；
可为外部类提供必要的内部功能组件；

成员内部类

概念：在类的内部定义，和实例变量和实例方法同级的类；
作为外部类的一部分，在创建内部类的对象时，必须依赖外部类对象；

成员内部类中是不能定义静态成员的，但可以包含静态的常量private static final String name;这样；

//Test类
public class Test {
    private String name = "柴玲玲";
    private int age = 21;
    class Inner {
        private String address = "甘肃";
        private int phone = 120;
        public void show() {
            System.out.println(name);
            System.out.println(age);
            System.out.println(address);
            System.out.println(phone);
        }
    }
}
//Demo 类
public class Demo {
    public static void main(String[] args) {
        //Test test = new Test();
        //Test.Inner inner = test.new Inner();
        Test.Inner inner = new Test().new Inner();
        inner.show();
    }
}
/*
柴玲玲
21
甘肃
120
*/

注意：当内部类和外部类存在重名属性的时候，优先访问内部类的属性，此时若想访问外部类的这个属性，则需要外部类名称.this.属性才可以访问；

//Test类
public class Test {
    private String name = "柴玲玲";
    private int age = 21;
    class Inner {
        private String address = "甘肃";
        private int phone = 120;
        private String name = "李四";
        public void show() {
            System.out.println(name);//访问内部类的name
            System.out.println(Test.this.name);//访问外部类的属性
            System.out.println(age);
            System.out.println(address);
            System.out.println(phone);
        }
    }
}
//Demo类
public class Demo {
    public static void main(String[] args) {
        //Test test = new Test();
        //Test.Inner inner = test.new Inner();
        Test.Inner inner = new Test().new Inner();
        inner.show();
    }
}
/*
李四
柴玲玲
21
甘肃
120
*/

静态内部类

概念：不依赖外部类的对象，可直接创建或通过类名访问，可声明静态成员；（也就是说相当于一个外部类，级别和外部类相同外部类可以包含什么，这个内部类就可以包含什么）

//Test
public class Test {
    private String name = "柴玲玲";
    private int age = 21;
    static class Inner {
        private String address = "甘肃";
        private int phone = 120;
        private String name = "李四";
        private static int count = 1000;//静态成员
        public void show() {
            System.out.println(name);//访问内部类的name
            /*访问外部类的成员*/
            Test test = new Test();
            System.out.println(test.name);
            System.out.println(test.age);
            System.out.println(address);
            System.out.println(phone);
            System.out.println(count);
        }
    }
}
//Demo
public class Demo {
    public static void main(String[] args) {
        Test.Inner inner = new Test.Inner();//注意和成员内部类中的区别
        inner.show();
    }
}
/*
李四
柴玲玲
21
甘肃
120
1000
*/

注意：只有内部类才可以有static修饰，一般的类不能有static修饰；

局部内部类

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

局部内部类不能加任何访问修饰符；
局部内部类访问外部类当前方法中的局部变量的时候，因无法保证变量的生命周期与自身相同，变量必须修饰为 final；

//Demo02
package OOP.Class;

public class Demo02 {
    private String name = "dl";
    private int age = 21;
    public void show() {
        String address = "辽宁";
        //局部内部类
        class Inner {
            private String phone = "122";
            private String email = "22@qq.com";
            public void test() {
                //访问
                System.out.println(Demo02.this.name);
                System.out.println(Demo02.this.age);
                System.out.println(this.phone);
                System.out.println(this.email);
                //局部变量 address 前面省略了 final 他其实是一个常量
                System.out.println(address);

            }
        }
        Inner inner = new Inner();
        inner.test();
    }
}
//Demo02_1
package OOP.Class;

public class Demo02_1 {
    public static void main(String[] args) {
        Demo02 demo02 = new Demo02();
        demo02.show();
    }
}

匿名内部类

概念：没有类名的局部内部类（一切属性均和局部内部类相同）；
接口不能实例化，但是通过匿名内部类可以实现实例化；

//Demo01 接口
package OOP.Class_1;

public interface Demo01 {
    void service();
}
//Dmmo
package OOP.Class_1;

public class Dmmo {
    public static void main(String[] args) {
        Demo01 demo01 = new Demo01() {
            @Override
            public void service() {
                System.out.println("连接成功了！！！");
            }
        };
        demo01.service();
    }
}

必须继承一个父类或者实现一个接口；
定义类，实现类，创建对象的语法合并，只能创建一个该类的对象；

object 类

超类、基类，所有类的直接或者间接父类，位于继承树的最顶层；
任何类，如果没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承；

Object类可以存储任何对象：

作为参数，可以传递任何对象；
作为返回值，可以返回任何的对象；

object 类常用方法

getClass()方法

public final Class<?> getClass() {}

返回引用中存储的实际对象类型；

应用：通常用于判断两个引用中实际存储对象类型是否一致；

//Student
package OOP.Class_2;

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;
    }
}
//People
package OOP.Class_2;

public class People {
    public static void main(String[] args) {
        Student student = new Student("aaa", 11);
        Student student1 = new Student();
        Class s1 = student.getClass();
        Class s2 = student1.getClass();
        if(s1 == s2) {
            System.out.println("是同一种类型");
        }else{
            System.out.println("不是同一种类型");
        }
    }
}

hashCode()方法

public int hashCode() {}

返回该对象的哈希码值；

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

//Student
package OOP.Class_2;

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;
    }
}
//People
package OOP.Class_2;

public class People {
    public static void main(String[] args) {
        Student student = new Student("aaa", 11);
        Student student1 = new Student();
        Student student3 = student;
        System.out.println(student.hashCode());
        System.out.println(student1.hashCode());
        System.out.println(student3.hashCode());
    }
}

toString()方法

public String toString() {}

返回该对象的字符串表示（表现形式）；

//Student
package OOP.Class_2;

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;
    }
}
//People
package OOP.Class_2;

public class People {
    public static void main(String[] args) {
        Student student = new Student("aaa", 11);
        Student student1 = new Student();
        Student student3 = student;
        System.out.println(student.hashCode());
        System.out.println(student1.hashCode());
        System.out.println(student3.hashCode());//十进制显示
        System.out.println("=================");
        System.out.println(student.toString());//十六进制显示
        System.out.println(student1.toString());
    }
}
/*
2129789493
668386784
2129789493
=================
OOP.Class_2.Student@7ef20235
OOP.Class_2.Student@27d6c5e0
*/

可以根据程序的需求覆盖该方法，如：展示对象的各个属性值；

//Student
package OOP.Class_2;

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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
//People
package OOP.Class_2;

public class People {
    public static void main(String[] args) {
        Student student = new Student("aaa", 11);
        Student student1 = new Student();
        Student student3 = student;
        System.out.println(student.hashCode());
        System.out.println(student1.hashCode());
        System.out.println(student3.hashCode());
        System.out.println("=================");
        System.out.println(student.toString());
        System.out.println(student1.toString());
    }
}
/*
2129789493
668386784
2129789493
=================
Student{name='aaa', age=11}
Student{name='null', age=0}
*/

equals()方法

public boolean equals(Object obj) {}

默认实现为（this==obj），比较两个对象地址是否相同；

//Teacher
package OOP.Class_3;

public interface Teacher {
    void show();
}
//TeacherImple
package OOP.Class_3;

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

    public TeacherImple() {
    }

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

    @Override
    public void show() {

    }
}
//People
package OOP.Class_3;

public class People {
    public static void main(String[] args) {
        TeacherImple teacherImple = new TeacherImple("丁", 21);
        TeacherImple teacherImple1 = new TeacherImple("柴", 21);
        TeacherImple teacherImple2 = new TeacherImple("丁", 21);
        TeacherImple teacherImple3 = teacherImple;
        System.out.println(teacherImple.equals(teacherImple1));//false
        System.out.println(teacherImple.equals(teacherImple2));//false
        System.out.println(teacherImple.equals(teacherImple3));//true
    }
}

可进行覆盖，比较两个对象的内容是否相同；

equals()方法覆盖步骤：

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

//Teacher
package OOP.Class_3;

public interface Teacher {
    void show();
}
//TeacherImple
package OOP.Class_3;

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

    public TeacherImple() {
    }

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

    @Override
    public boolean equals(Object obj) {
        if(this == obj) return true;
        if(obj == null) return false;
        if(obj instanceof TeacherImple) {
            TeacherImple teacher = (TeacherImple)obj;
            if(teacher.name.equals(this.name) == true && teacher.age == this.age) {
                return true;
            }
        }
        return false;
    }

    @Override
    public void show() {

    }
}
//People
package OOP.Class_3;

public class People {
    public static void main(String[] args) {
        TeacherImple teacherImple = new TeacherImple("丁龙", 21);
        TeacherImple teacherImple1 = new TeacherImple("柴玲玲", 21);
        TeacherImple teacherImple2 = new TeacherImple("丁龙", 21);
        TeacherImple teacherImple3 = teacherImple;
        System.out.println(teacherImple.equals(teacherImple1));//false
        System.out.println(teacherImple.equals(teacherImple2));//true
        System.out.println(teacherImple.equals(teacherImple3));//true
    }
}

finalize()方法

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

包装类

概念：基本数据类型所对应的引用类型；

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

类型转换与装箱、拆箱

装箱：把基本类型转换成引用类型；
拆箱：把引用类型转换成基本类型；

//Demo
package OOP.Class_4;

public class Demo {
    public static void main(String[] args) {
        //包装
        int num = 1;
            //第一种 构造方法
        Integer  integer = new Integer(num);
            //第二种 valueof
        Integer integer1 = Integer.valueOf(num);
        System.out.println("装箱");
        System.out.println(integer);
        System.out.println(integer1);
        //拆装
        Integer integer2 = new Integer(100);
        int num1 = integer2.intValue();
        System.out.println("拆箱");
        System.out.println(num1);

        //JDK1.6 以后采用自动拆装 其实是系统帮咋们做
        int num2 = 1;
        Integer integer3 = num2;
        System.out.println("自动装箱");
        System.out.println(integer3);
        int num3 = integer3;
        System.out.println("自动拆箱");
        System.out.println(num3);
    }
}
/*
装箱
1
1
拆箱
100
自动装箱
1
自动拆箱
1
*/

注意：自动装箱、拆箱，调用的是Integer.valueof()；

把基本类型转换成字符串

//Demo01
package OOP.Class_4;

public class Demo01 {
    public static void main(String[] args) {
        //把基本类型转换成字符串
        int num = 10;
            //第一种 + ""
        String s1 = num + "";
        System.out.println(s1);
            //第二种 toString
        String s2 = Integer.toString(num);
        System.out.println(s2);
            //按进制转换 十六进制 八进制 二进制
        String s3 = Integer.toBinaryString(num);//十六进制 八进制 Integer.toHexString(); Integer.toOctalString();
        System.out.println("二进制显示：" + s3);
            //带基数的转换
        String s4 = Integer.toString(num, 16);//后面的基数代表的是进制
        System.out.println(s4);
        //把字符类型转换成基本类型
            //Integer.parseXXX()
        String str = "150";
        int num1 = Integer.parseInt(str);
        System.out.println(num1);
        //boolean字符串形式转换成基本类型boolean
            //只有是 true 的时候转换后才是 true 非 true 的时候转换的都是 false
        String str1 = "true";
        String str2 = "cll";
        boolean boolean1 = Boolean.parseBoolean(str1);
        boolean boolean2 = Boolean.parseBoolean(str2);
        System.out.println(boolean1);
        System.out.println(boolean2);
    }
}
/*
10
10
二进制显示：1010
a
150
true
false
*/

注意：要保证类型的兼容，否则会产生异常抛出的NumberFormatException；

整数缓冲区（面试题）

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

//Demo03
package OOP.Class_4;

public class Demo03 {
    public static void main(String[] args) {
        Integer integer = new Integer(100);
        Integer integer1 = new Integer(100);
        System.out.println(integer == integer1);//false
        Integer integer2 = 101;
        Integer integer3 = 101;
        System.out.println(integer2 == integer3);//true
        Integer integer4 = 200;
        Integer integer5 = 200;
        System.out.println(integer4 == integer5);//false
    }
}
/*
false
true
false
*/

注意：这里的Integer integer3 = 101是自动重装功能，也就是系统帮我们创建好了Integer integer3 = Integer.valueof(101)，并没有使用构造函数所 new，但是当数值为200的时候就不可以了，因为这个时候就是使用了 new，虽然也是自动重装，主要是因为Java预先创建了256个常用的整数包装类型对象它的数值是 -128~127，当超过这个数值区间的时候，就会使用 new自己创建了，源码在下；

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

看源码就会明白上面所述的问题了；

String 类

简单创建

字符串是常量，创建之后不可改变；
字符串的字面值存储在字符串池中，可以共享；
String 创建的字符串存储在公共池中（在方法区），而 new 创建的字符串对象在堆上：

String s = "Hello"；产生一个对象，字符串池中保存；当后面的赋值相同的时候，会指向同一个字符串池中的对象；这样创建的时候，会事先在字符串池中扫码是否有同一个，没有则创建，有的话直接用（地址也是相同的）；

//Demo01
package OOP.Class_5;

public class Demo {
    public static void main(String[] args) {
        String name = "dl";
        String name1 = "dl";
        String name2 = "cll";
        System.out.println(name + " " + name1 + " " + name2);
    }
}

构造函数创建

String s = new String(“Hello”)；产生两个对象，堆、池各存储一个；当后面的赋值相同的时候，实际上是再次创建了一个对象，堆里面的不相同，字符串池中的相同；

//Demo01
package OOP.Class_5;

public class Demo {
    public static void main(String[] args) {
        String name = new String("dl");
        String name1 = new String("dl");
        String name2 = new String("cll");
        System.out.println(name + " " + name1 + " " + name2);
    }
}

区别

String s1 = "Runoob";               // String 直接创建
String s2 = "Runoob";               // String 直接创建
String s3 = s1;                     // 相同引用
String s4 = new String("Runoob");   // String 对象创建
String s5 = new String("Runoob");   // String 对象创建

注意：字符串的比较；

//Demo
package OOP.Class_5;

import java.nio.charset.StandardCharsets;

public class Demo {
    public static void main(String[] args) {
        String name = new String("dl");
        String name1 = new String("dl");
        System.out.println(name == name1);//false
        System.out.println(name.equals(name1));//true

        String name2 = "dl";
        String name3 = "dl";
        /*注意下面的一句*/
        System.out.println(name2 == name3);//true
        
        System.out.println(name2.equals(name3));//true
    }
}
/*
false
true
true
true
*/

String 类常用方法

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

//Demo02
package OOP.Class_5;

public class Demo02 {
    public static void main(String[] args) {
        String name = "我最爱 cll 要永远和她在一起";
        System.out.println(name.length());
        System.out.println(name.charAt(0));
        System.out.println(name.contains("cll"));
    }
}
/*
16
我
true
*/

public char[] toCharArray()；将字符串转换成数组
public int indexOf(String str)；查找str首次在字符串中出现的下标，若存在，则输出下标，若不存在则返回-1
public int lastIndexOf(Steing str)；查找str在字符串中出现的最后一次下标索引

//Demo02
package OOP.Class_5;

import java.util.Arrays;

public class Demo02 {
    public static void main(String[] args) {
        String name = "我最爱 cll and cll 要永远和她在一起 cll";
        System.out.println(Arrays.toString(name.toCharArray()));
        System.out.println(name.indexOf("cll"));//找第一个 cll
        System.out.println(name.lastIndexOf("cll"));//找最后一个 cll
        System.out.println(name.indexOf("cll", 7));//找第二个 cll
    }
}
/*
[我, 最, 爱,  , c, l, l,  , a, n, d,  , c, l, l,  , 要, 永, 远, 和, 她, 在, 一, 起,  , c, l, l]
4
25
12
*/

public String trim()；去掉字符串前后的空格
public String toUpperCase()；将小写转换为大写
public String toLowerCase()；将大写转换为小写
public boolean endsWith(String str)；判断字符串是否以str结尾
public boolean startsWith(String str)；判断字符串是否以str开头

//Demo03
package OOP.Class_5;

public class Demo03 {
    public static void main(String[] args) {
        String name = "  我最爱 cll and cll 要永远和她在一起 CLL";
        System.out.println(name.trim());
        System.out.println(name.toUpperCase());
        System.out.println(name.toLowerCase());
        System.out.println(name.endsWith("CLL"));
        System.out.println(name.startsWith("cll"));
    }
}
/*
我最爱 cll and cll 要永远和她在一起 CLL
  我最爱 CLL AND CLL 要永远和她在一起 CLL
  我最爱 cll and cll 要永远和她在一起 cll
true
false
*/

public String replace(char oldChar, char newChar)；将旧字符转换成新字符
public String[] split(String str)；根据str做拆分

package OOP.Class_5;

import java.util.Arrays;

public class Demo04 {
    public static void main(String[] args) {
        String name = "  我最爱 cll and cll 要永远和她在一起 C,LL";
        System.out.println(name.replace("LL", "DL"));
        String[] cll = name.split(" ");
        for(String k : cll) {
            System.out.println(k);
        }
    }
}
/*
  我最爱 cll and cll 要永远和她在一起 C,DL


我最爱
cll
and
cll
要永远和她在一起
C,LL
*/

要是拆分的时候是多选，比如是按照空格或者，都可以进行拆分，则需要split([ ,])；

package OOP.Class_5;

import java.util.Arrays;

public class Demo04 {
    public static void main(String[] args) {
        String name = "  我最爱 cll and cll 要永远和她在一起 C,LL";
        System.out.println(name.replace("LL", "DL"));
        String[] cll = name.split("[ ,]");
        for(String k : cll) {
            System.out.println(k);
        }
    }
}
/*
  我最爱 cll and cll 要永远和她在一起 C,DL


我最爱
cll
and
cll
要永远和她在一起
C
LL
*/

当其中有多个空格的时候，想要拆分输出的时候不会出现上述的空格占一行的情况的话，可以使用split([ ,]+)；

package OOP.Class_5;

import java.util.Arrays;

public class Demo04 {
    public static void main(String[] args) {
        String name = "  我最爱 cll and cll    要永远和她在一起 C,LL";
        System.out.println(name.replace("LL", "DL"));
        String[] cll = name.split("[ ,]+");
        for(String k : cll) {
            System.out.println(k);
        }
    }
}
/*
  我最爱 cll and cll    要永远和她在一起 C,DL

我最爱
cll
and
cll
要永远和她在一起
C
LL
*/

equals 和 compareTo

equalsIgnoreCase是忽略大小写的比较是否相同；

//Demo05
package OOP.Class_5;

public class Demo05 {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "HELLO";
        System.out.println(s1.equals(s2));//false
        System.out.println(s1.equalsIgnoreCase(s2));//true

        String s3 = "abc";
        String s4 = "def";
        System.out.println(s3.compareTo(s4));//-3
        String s5 = "abcaaa";
        System.out.println(s3.compareTo(s5));//-3
        String s6 = " abc";
        System.out.println(s3.compareTo(s6));//65
    }
}

//Demo06
package OOP.Class_5;

public class Demo06 {
    public static void main(String[] args) {
        String str = "this is a text";
        String[] arr = str.split(" ");
        for(String k : arr) {
            System.out.println(k);
        }
        System.out.println(str.replace("text", "practice"));
        System.out.println(str.replace("text", "easy text"));
        for(int i = 0; i < arr.length; i ++) {
            char a = arr[i].charAt(0);
            char A = Character.toUpperCase(a);
            arr[i] = A + arr[i].substring(1);
            System.out.print(arr[i] + " ");
        }
    }
}
/*
this
is
a
text
this is a practice
this is a easy text
This Is A Text 
*/

可变字符串

和String的区别：

运行效率比String要高
比String要节省内存

StringBuffer：可变长字符串，JDK1.0提供，运行效率慢，线程安全；
StringBuilder：可变长字符串，JDK5.0提供，运行效率快，线程不安全；

方法演示：

//Demo01
package OOP.Class_6;

public class Demo01 {
    public static void main(String[] args) {
        //StringBuffer str = new StringBuffer();
        StringBuilder str = new StringBuilder();
        //追加append()
        str.append("我爱 cll");
        System.out.println(str.toString());
        str.append("I Love cll");
        System.out.println(str.toString());
        //添加insert()
        str.insert(6, " DL ");
        System.out.println(str.toString());
        //替换replace
        str.replace(3, 6, "CLL");
        System.out.println(str.toString());
        //删除delete
        str.delete(9, 12);
        System.out.println(str.toString());
        //反转reverse()
        str.reverse();
        System.out.println(str.toString());
        //清空
        str.delete(0, str.length());
        System.out.println(str.length());
    }
}
/*
我爱 cll
我爱 cllI Love cll
我爱 cll DL I Love cll
我爱 CLL DL I Love cll
我爱 CLL DLLove cll
llc evoLLD LLC 爱我
0
*/

运行效率比较：

//String
package OOP.Class_6;

public class Demo02 {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        String str = "";
        for(int i = 0; i < 99999; i ++) {
            str += i;
        }
        System.out.println(str);
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}
/*
4689
*/
//StringBuilder
package OOP.Class_6;

public class Demo02 {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        StringBuilder str = new StringBuilder();
        for(int i = 0; i < 99999; i ++) {
            str.append(i);
        }
        System.out.println(str.toString());
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}
/*
35
*/

BigDecimal 类

作用：精确计算浮点数
import java.math.BigDecimal;
BigDecimal add(BigDecimal db);//加
BigDecimal subtract(BigDecimal db);//减
BigDecimal multiply(BigDecimal db);//乘
BigDecimal divide(BigDecimal db);//除

package OOP.Class_6;

public class Demo03 {
    public static void main(String[] args) {
        double num1 = 0.9;
        double num2 = 0.8;
        System.out.println(num1 - num2);//0.09999999999999998

        double result = (1.4 - 0.5) / 0.9;
        System.out.println(result);//0.9999999999999999
    }
}
/*
0.09999999999999998
0.9999999999999999
*/

double是近似值存储；可以使用BigDecimal来解决这个问题；

package OOP.Class_6;

import java.math.BigDecimal;
import java.math.RoundingMode;

public class Demo03 {
    public static void main(String[] args) {
        BigDecimal num1 = new BigDecimal("1.0");
        BigDecimal num2 = new BigDecimal("0.9");
        BigDecimal result = num1.subtract(num2);
        System.out.println(result);//0.1

        BigDecimal divide = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"));
        System.out.println(divide);//1

        BigDecimal divide1 = new BigDecimal("20").divide(new BigDecimal("3"), 2, RoundingMode.HALF_UP);
        System.out.println(divide1);//6.67
    }
}
/*
0.1
1
6.67
*/

Date 类

表示精确的瞬间，精确到毫秒

package OOP.Class_6;

import java.util.Date;

public class Demo04 {
    public static void main(String[] args) {
        Date date1 = new Date();
        System.out.println(date1.toString());
        System.out.println(date1.toLocaleString());
        Date date2 = new Date(date1.getTime() - 60 * 60 * 12 * 1000);
        System.out.println(date2.toLocaleString());
        System.out.println(date1.after(date2));
        System.out.println(date1.before(date2));
        System.out.println(date1.compareTo(date2));
        System.out.println(date1.equals(date2));
    }
}
/*
Sun Apr 03 10:15:12 CST 2022
2022年4月3日 上午10:15:12
2022年4月2日 下午10:15:12
true
false
1
false
*/

Calendar 类

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

方法名	说明
static Calendar()	设置默认时区和区域获取日历
void set(int year, int mouth, 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 getTimeInMillies()	毫秒为单位返回该日历的时间值

//Demo06
package OOP.Class_6;

import java.util.Calendar;

public class Demo05 {
    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 开始的 比正常小 1
        int mouth = calendar.get(Calendar.MONTH);
            //获取日
        int day = calendar.get(Calendar.DAY_OF_MONTH);
            //获取时
        int hour = calendar.get(Calendar.HOUR);//12小时制
        int hour1 = calendar.get(Calendar.HOUR_OF_DAY);//24小时制
            //获取分
        int minute = calendar.get(Calendar.MINUTE);
            //获取秒
        int second = calendar.get(Calendar.SECOND);
        System.out.println(year + "," + (mouth + 1) + "," + day);
        System.out.println(hour1 + ":" + minute + ":" + second);
        //3.修改时间
        Calendar calendar1 = Calendar.getInstance();
            //修改日
        calendar1.set(Calendar.DAY_OF_MONTH, 5);
        System.out.println(calendar1.getTime().toLocaleString());
        //4.add方法修改时间
        calendar1.add(Calendar.HOUR_OF_DAY, 1);
        System.out.println(calendar1.getTime().toLocaleString());
        //补充方法
        int max = calendar1.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min = calendar1.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max + " : " + min);
    }
}
/*
2022年4月3日 下午3:10:15
1648969815414
2022,4,3
15:10:15
2022年4月5日 下午3:10:15
2022年4月5日 下午4:10:15
30 : 1
*/

SimpleDateFormat

是一个以与语言环境有关的方式来格式化和解析日期的具体类；
进行格式化（日期到文本）、解析（文本到日期）

常用的时间模式字母：

把日期转换成时间字符串；

//格式化
package OOP.Class_6;

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

public class Demo06 {
    public static void main(String[] args) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        Date date = new Date();
        String str = simpleDateFormat.format(date);
        System.out.println(str);
    }
}
/*
2022/04/03 15:24:24
*/

把字符转换成日期；

//解析
package OOP.Class_6;

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

public class Demo06 {
    public static void main(String[] args) throws Exception{
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        Date date = simpleDateFormat.parse("2019/6/6 12:12:12");
        System.out.println(date.toLocaleString());
    }
}
/*
2019年6月6日 下午12:12:12
*/

System 类

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

注意：Arrays.copyOf()和System.arraycopy的区别就是，System.arraycopy内部也是Arrays.copyOf()实现的；

package OOP.Class_6;

import java.util.Arrays;

public class Demo07 {
    public static void main(String[] args) {
        int[] arr = {10, 11, 33, 44, 55, 11, 77, 100};
        int[] dest = new int[8];
        //arraycopy 数组的复制
            //src 原数组 srcPos 从哪个位置开始复制 dest 目标数组 destPos 目标数组的位置 length 复制的长度
        System.arraycopy(arr, 4, dest, 4, 4);
        System.out.println(Arrays.toString(dest));
        //System.currentTimeMillis()
        System.out.println(System.currentTimeMillis());
        //System.exit()
        System.exit(0);
        System.out.println("程序退出！");
    }
}
/*
[0, 0, 0, 0, 55, 11, 77, 100]
1648973982247
*/

清纯献给了作业

关注

4
点赞
踩
8

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java_常用类

内部类概念：在一个类的内部再定义一个完整的类；特点：外部类可以直接访问内部类的私有成员，而不破坏封装；编译之后可以生成独立的字节码文件（2个.java的文件）；可为外部类提供必要的内部功能组件；成员内部类概念：在类的内部定义，和实例变量和实例方法同级的类；作为外部类的一部分，在创建内部类的对象时，必须依赖外部类对象；成员内部类中是不能定义静态成员的，但可以包含静态的常量private static final String name;这样；//Test类public class T
复制链接

扫一扫