Java常用类

已于 2022-12-13 20:21:02 修改
阅读量98 收藏
点赞数 1
文章标签： java jvm 算法
于 2022-12-08 11:47:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58432872/article/details/128220589
版权

1、内部类

  1. 概念：在一个类的内部再定义一个完整的类
  2. 特点：
    • 编译之后可生成独立的字节码文件
    • 内部类可直接访问外部类的私有成员，而不破坏封装
    • 可为外部类提供必要的内部功能组件

1.1、成员内部类

  • 在类的内部定义，与实例变量、实例方法同级别的类
  • 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象
  • 成员内部类不能定义静态成员，但可以定义静态常量
    public static void main(String[] args) {
        Other other = new Other();
        other.new Inner().show();
}
class Other{
    //实例变量
    private String name="张三";
    private int age=20;

    //内部类
    class Inner{
        private String address="北京";
        private String phone="110";
        private static final  int a=10; 

        //方法
        public void show(){
            //访问外部类属性
            System.out.println(name);   //张三
            //访问内部类属性
            System.out.println(address);    //北京
        }
    }
}

1.2、静态内部类

  • 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员
    public static void main(String[] args) {
        Other1.Inner inner = new Other1.Inner();
        inner.show();


    }
class Other1{
    //实例变量
    private String name="张三";
    private int age=20;

    //静态内部类
    static class Inner{
        private String address="北京";
        private String phone="110";
        private static  int a=10;

        //方法
        public void show(){
            //访问外部类属性
            Other1 other1 = new Other1();
            System.out.println(other1.name);   //张三
            //访问内部类属性
            System.out.println(address);    //北京
            //访问静态成员
            System.out.println(a);  //10
        }
    }
}

1.3、局部内部类

  • 定义在外部类方法中，作用范围和创建对象仅限于当前方法
  • 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰final
    public static void main(String[] args) {
        Other2 other2 = new Other2();
        other2.show();
    }
class Other2{
    //实例变量
    private String name="张三";
    private int age=20;

    public void show(){
        final String address="北京";  //jdk1.8之后final可省略

        //局部内部类
        class Inner{
                //private String address="北京";
                private String phone="110";

                public void show2(){
                    System.out.println(name);
                    System.out.println(address);
                }
        }
        Inner inner = new Inner();
        inner.show2();
    }
}

1.4、匿名内部类

  • 没有类名的局部内部类（一切特征与局部内部类相同）
  • 必须继承一个父类或者实现一个接口
  • 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
  • 优点：减少代码量
  • 缺点：可读性较差
    public static void main(String[] args) {
        Usb usb=new Usb() {
            @Override
            public void service() {
                System.out.println("匿名内部类");
            }
        };
        usb.service();
    }

interface Usb{
    public void service();
}

2、Object类

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

2.1、getClass()方法

  • public final Class<?> getClass(){}
  • 返回引用中存储的实际对象类型
  • 应用：通常用于判断两个引用中实际存储对象类型是否一致
    public static void main(String[] args) {
        Student s1=new Student("aaa",20);
        Student s2=new Student("bbb",20);
        //判断是不是同一类型
        Class<? extends Student> s1Class = s1.getClass();
        System.out.println(s1Class);    //class com.qianfeng.Student
        Class<? extends Student> s2Class = s2.getClass();
        if (s1Class==s2Class){
            System.out.println("同一个类型"); //true
        }else {
            System.out.println("不是同一类型");
        }
}
class Student{
    private String name;
    private int age;

2.2、hashCode()方法

  • public int hashCode(){}
  • 返回该对象的哈希码值
  • 一般情况下相同对象返回相同哈希码
    public static void main(String[] args) {
        Student1 s1=new Student1("aaa",20);
        Student1 s2=new Student1("bbb",20);

        //不同对象哈希码值不同
        System.out.println(s1.hashCode());  //460141958
        System.out.println(s2.hashCode());  //1163157884
        Student1 s3=s1;
        System.out.println(s3.hashCode());  //460141958

    }
class Student1{
    private String name;
    private int age;

2.3、toString()方法

  • public String toString(){}
  • 返回该对象的字符串表示（表现形式）
  • 可以根据程序需求覆盖该方法，如：展示对象各个属性值
        public static void main(String[] args) {
            Student2 s1=new Student2("aaa",20);
            Student2 s2=new Student2("bbb",20);

            System.out.println(s1.toString());  //Student2{name='aaa', age=20}
            System.out.println(s2.toString());  //Student2{name='bbb', age=20}

        }

    }
    class Student2{
        private String name;
        private int age;

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

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

2.4.1、equals()方法

  • public boolean equals(Object obj){}
  • 默认实现为（this==obj），比较两个对象地址是否相同
  • 可进行覆盖，覆盖后比较两个对象的内容是否相同
    public static void main(String[] args) {
        Student3 s1=new Student3("aaa",20);
        Student3 s2=new Student3("aaa",20);

        System.out.println(s1.equals(s2));  //false

    }

}
class Student3{
    private String name;
    private int age;

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

2.4.2、equals()方法覆盖步骤

  • 比较两个引用是否指向同一个对象
  • 判断obj是否为null
  • 判断两个引用指向的实际对象类型是否一致
  • 强制类型转换
  • 依次比较各个属性值是否相同
    public static void main(String[] args) {
        Student4 s1=new Student4("aaa",20);
        Student4 s2=new Student4("aaa",20);

        System.out.println(s1.equals(s2));  //true
    }
}
class Student4{
    private String name;
    private int age;

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student4 student4 = (Student4) o;
        return age == student4.age && Objects.equals(name, student4.name);
    }

2.5、finalize()方法

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

3、包装类

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

3.1、基本数据类型对应的包装类：

在这里插入图片描述

3.2、装箱、拆箱

  • valueOf（）：装箱
  • intValue（）：拆箱
public static void main(String[] args) {
        /*
             JDK1.5之前，手动装箱和拆箱
         */
        
        //类型转换：装箱，基本数据类型转成引用类型
        int num1=19;
        Integer integer1 = new Integer(num1);   //用构造器
        Integer integer2 = Integer.valueOf(num1);   //用方法
        //类型转换：拆箱，引用类型转成基本数据类型
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();

        /*
            JDK1.5之后，提供自动装箱和拆箱
         */
        int age1=30;
        //自动装箱
        Integer integer4=age1;
        //自动拆箱
        int age2=integer4;

    }

3.3、类型转换

  • toString（）：基本类型转成字符串
  • parseXXX（）：字符串转成基本类型
		//1.基本类型转成字符串
        int n1=100;
        Integer.toString(n1);
        System.out.println(n1); //100

        //2.字符串转成基本类型
        String str="150";
        Integer.parseInt(str);  //150

3.4、缓冲区

public static void main(String[] args) {
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1==integer2); //false

        Integer integer3=Integer.valueOf(100);   //自动装箱
        Integer integer4=100;   //自动装箱
        System.out.println(integer3==integer4); //true

        Integer integer5=200;   //自动装箱
        Integer integer6=200;   //自动装箱
        System.out.println(integer5==integer6); //false
    }
  • 自动装箱隐藏的valueOf（）方法中有缓存的对象范围（-128-127）
  • 因此在这个范围内会使用内存缓存的对象，超过之后才会重新创建新的对象!

在这里插入图片描述
2.
在这里插入图片描述
3.
在这里插入图片描述

4、String类

  • 字符串是常量 ，创建之后不可改变（不可变性）
  • 字符串字面值存储在字符串中（方法区中），可以共享
  • 栈（基本数据类型）、堆（对象）、方法区
  • String s =“hello”; //产生一个对象，字符串池中存储
  • String s = new String（“hello”）; //产生两个对象，堆、池各存储一个

4.1、常用方法

  • public int length()：返回字符串的长度
String s="java是世界上最坑的语言";
System.out.println(s.length()); //13
  • public char charAt（int index）:根据下标获取字符
System.out.println(s.charAt(3));    //a
  • public boolean contains（String str）：判断当前字符串中是否包含str
System.out.println(s.contains("java")); //true
  • public char[] toCharArray()：将字符串转换成数组
System.out.println(Arrays.toString(s.toCharArray()));   //[j, a, v, a, 是, 世, 界, 上, 最, 坑,
  • public int indexOf（String str）：查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
String s2="java是世界上最坑的语言java";
System.out.println(s2.indexOf("a")); //1
System.out.println(s2.indexOf("牛")); //-1
System.out.println(s2.indexOf("a",4));   //14
  • public int lastIndexOf（String str）：查找字符串在当前字符串中最后一次出现的下标索引
System.out.println(s2.lastIndexOf("a")); //16
System.out.println(s2.lastIndexOf("牛")); //-1
  • public String trim（）：去掉字符串前后的空格
String s3="     hello world  ";
System.out.println(s3.trim());  //hello world
  • public String toUpperCase（）：将小写转成大写
System.out.println(s3.toUpperCase());   //     HELLO WORLD
System.out.println(s3.toLowerCase());   //     hello world
  • public boolean endWith（String str）：判断字符串是否以str结尾
String s4="hello.java";
System.out.println(s4.endsWith(".java"));   //true
System.out.println(s4.startsWith("hello")); //true
  • public String replace（char oldChar,char newChar）：将旧字符串替换成新字符串
String s5="java是世界上最坑的语言java";
System.out.println(s5.replace("java","go"));    //go是世界上最坑的语言go
  • public String[] split（String str）：根据str做拆分
String s6="java is the beat programing  beat language ";
String[] arr=s6.split("beat");
System.out.println(arr.length); //3
for (String string :arr) {
    System.out.print(string+" ");   //java is the   programing    language  
}
  • equals：比较值是否相等 （equalsIgnoreCase()：忽略大小写比较）
String ss1="hello";
String ss2="HELLO";
System.out.println(ss1.equalsIgnoreCase(ss2));  //true
  • compareTo（）：比较大小（在编码表中的顺序大小依次比较，都一样就比较字符串长度）
String ss3="abc";//97
String ss4="xyz";//120
System.out.println(ss3.compareTo(ss4)); //-23
  • substring()：截取字符串

4.2、案例演示

需求：

  • 已知String str=“this is a text”;
    1. 将str中的单词单独获取出来
    1. 将str中的text替换为practice
    1. 在text前面插入一个easy
    1. 将每个单词的首字母改成大写
		String str="this is a text";
        String[] arr = str.split(" ");
        for (String s :arr) {
            System.out.print(s+" ");    //this is a text
        }
        System.out.println("/n");

        System.out.println(str.replace("text", "practice"));    //this is a practice

        System.out.println(str.replace("text", "easy text"));   //this is a easy text

        for (int i = 0; i < arr.length; i++) {
            char first = arr[i].charAt(0);
            char upperfirst = Character.toUpperCase(first);
            String news = upperfirst + arr[i].substring(1);
            System.out.print(news+" "); //This Is A Text
        }

5、 可变长字符串

  • StringBuffer：可变长字符串，JDK1.0提供，运行效率慢，线程安全
  • StringBuilder：可变长字符串，JDK5.0提供，运行效率快，线程不安全
		//StringBuffer stringBuffer = new StringBuffer();
        StringBuilder stringBuffer = new StringBuilder();
        //1.append()：追加
        stringBuffer.append("java");
        System.out.println(stringBuffer);    //java
        //2.insert():添加
        stringBuffer.insert(0,"我在最前面");
        System.out.println(stringBuffer);    //我在最前面java
        //3.replace()：指定位置替换    [ )
        stringBuffer.replace(0,3,"hello");
        System.out.println(stringBuffer);   //hello前面java
        //4.delete：删除   [ )
        stringBuffer.delete(0,5);
        System.out.println(stringBuffer);   //前面java

6、BigDecimal

		double d1=1.0;
        double d2=0.9;
        System.out.println(d1-d2);  //0.09999999999999998

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

很多实际应用中需要精确运算，而double是近似值存储，不符合 要求，需要借助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);
        System.out.println(r1);     //0.1
        //加法
        BigDecimal r2 = bd1.add(bd2);
        System.out.println(r2);     //1.9
        //乘法
        BigDecimal r3 = bd1.multiply(bd2);
        System.out.println(r3);     //0.90
        //除法
        BigDecimal r4 = new BigDecimal("1.4")
                .subtract(new BigDecimal("0.5"))
                .divide(new BigDecimal("0.9"));
        System.out.println(r4);     //1

7、SimpleDateFormat

  • SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类
  • 进行格式化（日期->文本）、解析（文本->日期）
  • 常用的时间模式字母:
    在这里插入图片描述
		SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日HH：mm：ss");
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/dd/ HH-mm-ss");
        Date date = new Date();
        String format = sdf1.format(date);
        System.out.println(format); //2022年12月08日11：12：43

        String format1 = sdf2.format(date);
        System.out.println(format1);    //2022/12/08/ 11-14-50

        //解析
        SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy/MM/dd");
        Date date1 = sdf3.parse("1990/05/01");
        System.out.println(date1);  //Tue May 01 00:00:00 CDT 1990

8、System类

  • System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的
    System类常用方法
橙子很诚
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
常用类和内部类(笔记)
cyyttaaioo的博客
03-26 69
常用类和内部类 内部类 分类 成员内部类 静态内部类 局部内部类 匿名内部类 概念：在一个类的内部再定义一个完整的类 特点： 编译之后可生成独立的字节码文件 内部类可直接访问外部类的私有成员，不破坏封装 可为外部类提供必要的内部功能组件 成员内部类 在类的内部定义，与实例变量、实例方法同级别的类 外部类的一个实例部分，创建内部类对象时，必须依赖外部类 Outer out = new Outer(); Inner in = out.new Inner(); 当外部
Java中的常用类的学习
qq_64004917的博客
02-26 290
字符串相关的类 String类 特性： 代表字符串。Java程序中的所有字符串字面值（如“abc”）都作为此类的实例实现 String是一个final类，代表不可变的字符序列。不可被继承 体现： 当对字符串重新赋值时，需要重写指定内存区域复制，不能使用原有的value进行赋值。 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。 当调用String的replace（）
这些Java常用类，你必须要学会，还不快快收藏？（近两万字详细介绍）
Faith_xzc
01-06 4416
本文介绍了Java常用类，包括包装类、Math、String类、可变字符序列和时间日期，并举例说明。欢迎大家交流讨论
类/对象/内部类
weixin_45435381的博客
12-19 279
一 注意事项总结 1.1 构造方法 构造方法是没有返回值的；构造方法的名称要与本类的名称相同。 如果再类中定义的构造方法都不是无参的构造方法，则编译器不会为类设置一个默认的午餐构造方法，当试图调用无参构造方法实例化一个对象时，编译器会报错，所以只用在类中没有定义任何构造方法时，编译器才会在该类中自动创建一个不带参数的构造方法。 public class AnyThting { public AnyThting() { this("this调用有参构造方法"); } public AnyThti
类与类之间的关系+内部类
weixin_40645193的博客
06-29 855
类与类的关系主要有以下三种：
JAVA常用类总结
12-22
JAVA常用类,java封装类,String类和StringBuffer类......
实验5 JAVA常用类.doc
05-02
实验5的Java常用类主要涵盖了Java编程中的一些核心概念和常用工具类的使用。以下是这些知识点的详细说明： 1. **String、StringBuffer(StringBuilder)**： - **String** 类在Java中是不可变的，这意味着一旦创建了...
java常用类总结.docx
06-08
Java中的常用类是编程基础，尤其对于初学者来说，理解并掌握这些类的使用至关重要。...总的来说，理解和熟练使用这些Java常用类，对于编写高效、可靠的代码至关重要，是每个Java开发者的基础技能。
静态内部类 和 内部类
whp404的博客
04-05 2753
今天稍微复习一下 静态内部类和 内部类的相关知识，平常很少用 静态内部类 静态内部类，不能访问外部类的非静态成员 静态内部类 不需要创建外部类的对象就可访问（外部类名.内部类 比如new MyMain.Person().display();就创建了静态内部类对象） 静态内部类可以有public、protected、默认的、private等多种类型 （这个功能我倒是从来没听说,通过实验的确ok...
类和类的成员——内部类
m0_64231944的博客
07-13 269
自学java之类和类的成员——内部类知识点总结
内部类与常用类
WDreamIn的博客
03-25 197
常用类 内部类
外部类与内部类
Moum_j的博客
03-28 4934
什么是外部类、内部类 public class Outer { class Inner{ } } 如上述代码，Outer是一个外部类，Inner是一个内部类，内部类也可以用public、static等修饰，但要注意： 1.静态内部类中可以有非静态的方法； 2.当内部类中有静态方法或者静态成员变量时，一定是静态内部类。 外部类与内部类的区别与联系： 内部类可以访问外部类所有的方法和属性，如果内部类和外部类有相同的成员方法和成员属性，内部类的成员方法调用要优先于外部类即内部
java(4)-深入理解java嵌套类、内部类以及内部类builder构建构造函数
黄规速博客:学如逆水行舟，不进则退
06-08 3万+
一、什么是嵌套类及内部类 　　可以在一个类的内部定义另一个类，这种类称为嵌套类（nested classes），它有两种类型：静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类（inner）。嵌套类从JDK1.1开始引入。其中inner类又可分为三种： 　　其一、在一个类（外部类）中直接定义的内部类； 　　其二、在一个方法（外部类的方法）中
内部类(成员内部类、静态内部类、方法内部类)
热门推荐
liu771626413的博客
06-05 4万+
一：成员内部类：最常见的内部类就是成员内部类，也称作普通内部类；1、Inner类定义在Outer类的内部，相当于Outer类的成员变量的位置，Inner类可以使用任意访问修饰符，如：public、private、protected等。2、Inner类中定义的test()方法可以访问Outer类中的数据，不受访问控制符的影响。3、定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去......
什么是内部类？内部类的作用
LianXu3344的博客
03-07 8349
在java语言中，可以吧一个类定义到另外一个类的内部，在类里面的这个类就叫内部类，外面的类就叫外部类。在这情况下，这个内部类可以看做外部类的一个成员。还有一种类被称为顶层类，指的是类定义代码不嵌套在其他类定义中的类。 需要注意的是嵌套类与内部类类似，只是嵌套类是C++的说法。 内部类可以分为多种、；主要一下4中:静态内部类，成员内部类，局部内部类，匿名内部类 代码 class outerCl...
toString方法：
08-19 259
toString public String toString()返回该对象的字符串表示。通常，toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。 Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@ ”和此对象哈希码的无符号十六进
Java中String、StringBuffer 等常用类
张昂之.
04-27 435
String 1、String表示字符串类型，属于引用数据类型，不属于基本数据类型。 2、在java中随便使用双引号括起来的都是String对象。例如：“abc”，“def”，“hello world!”，这是3个String对象。 3、java中规定，双引号括起来的字符串，是不可变的，也就是说"abc"自出生到最终死亡，不可变，不能变成"abcd"，也不能变成"ab" 4、在JDK当中双引号括起...
java嵌套类和内部类区别_深入理解java嵌套类和内部类
weixin_30707165的博客
02-28 1301
一、什么是嵌套类及内部类可以在一个类的内部定义另一个类，这种类称为嵌套类(nested classes)，它有两种类型：静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类(inner)。嵌套类从JDK1.1开始引入。其中inner类又可分为三种：其一、在一个类(外部类)中直接定义的内部类；其二、在一个方法(外部类的方法)中定义的内部类；其三、匿名内部类。下面...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值