Java常用类详解笔记

最新推荐文章于 2024-08-16 23:08:28 发布

Sucker_苏

最新推荐文章于 2024-08-16 23:08:28 发布

阅读量110

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/m0_51572714/article/details/117416149

版权

Object类

基本概念

Object类又称超类、基类，所有类的直接或间接父类，位于继承树的最顶层
Object类中所定义的方法，是所有对象都具备的方法
Object类型可以存储任何对象
- 作为参数可以接收任何对象
- 作为返回值可以返回任何对象

getClass()方法

返回引用中存储的实际对象类型
通常用于判断两个引用中实际存储对象类型是否一致
返回的是Class类

 package com.Sucker.Object;
 
 public class TestStudent {
     public static void main(String[] args) {
         Student s1 = new Student("aaa",20);
         Student s2 = new Student("bbb",22);
         //判断s1和s2是不是同一个类型
         Class class1 = s1.getClass();
         Class class2 = s2.getClass();
         if(class1==class2) System.out.println("属于同一个类型");
         else System.out.println("不属于");
         if(s1.getClass()==s2.getClass()) System.out.println(1);
     }
 }

hashCode()方法

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

 package com.Sucker.Object;
 
 public class TestStudent {
     public static void main(String[] args) {
         Student s1 = new Student("aaa",20);
         Student s2 = new Student("bbb",22);
         //hashCode方法
         System.out.println(s1.hashCode());
         System.out.println(s2.hashCode());
         Student s3 = s1;
         System.out.println(s3.hashCode());//与s1相同
     }
 }

toString()方法

返回值是String类型，返回该对象的字符串表示(表现形式)
可以根据程序需求覆盖该方法(重写)，如：展示对象各个属性值

     Student s1 = new Student("aaa",20);
     Student s2 = new Student("bbb",22);
     //toString方法
     System.out.println(s1.toString());
     System.out.println(s2.toString());

equals()方法

返回值是boolean类型，有一个参数Object类型参数，boolean equals(Object obj)
默认实现为(this==obj)，比较两个对象地址是否相同

 public class TestStudent {
     public static void main(String[] args) {
         Student s1 = new Student("aaa",20);
         Student s2 = new Student("bbb",22);
         //equals方法
         System.out.println(s1.equals(s2));//返回false
     }
 }

可以重写，比较两个对象的内容是否相同

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

 @Override
     public boolean equals(Object o) {
         if (this == o) return true;
         //判断类型也可以用instanceof
         if (o == null || getClass() != o.getClass()) return false;
         Student student = (Student) o;
         return age == student.age && Objects.equals(name, student.name);
     }

finalize()方法

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

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

 public class TestStudent2 {
     public static void main(String[] args) {
         Student s1 = new Student("aaa",20);
         Student s2 = new Student("bbb",20);
         Student s3 = new Student("ccc",20);
         Student s4 = new Student("ddd",20);
         Student s5 = new Student("eee",20);
 
         //回收垃圾
         new Student("eee",20);
         new Student("eee",20);
         new Student("eee",20);
         new Student("eee",20);
         System.gc();
         System.out.println("回收垃圾");
     }
 }

包装类

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

类型转换与装箱、拆箱

public class Demo01 {
    public static void main(String[] args) {
        //int num=10;
        //类型转换：装箱：基本类型转换为引用类型
        int num1=18;//栈中
        //使用Integer类创建对象
        Integer integer1 = new Integer(num1);//放到堆中
        Integer integer2 = Integer.valueOf(num1);//第二种方式

        //拆箱：引用类型转成基本类型
        Integer integer3 = new Integer(100);//integer3指向堆中100
        int num2 = integer3.intValue();//栈中num2=100
        //以上为JDK1.5前

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

基本类型与字符串之间的转换

//基本类型和字符串之间转换
        //基本类型在转换成字符串
        int n1=15;
        //1.使用+号
        String s1 = n1+"";
        //2.使用Integer中toString方法
        String s2 = Integer.toString(n1);
        //toString重载方法,这里表示将n1用16进制表示，输出的是f
        String s3 = Integer.toString(n1, 16);

        //字符串转换成基本类型
        String str = "150";
        //使用Integer.parseXXX();
        int i = Integer.parseInt(str);

        //boolean字符串形式转换成基本类型  ”true“-->true  非"true"-->false
        String str2 = "tru";
        boolean b = Boolean.parseBoolean(str2);
        System.out.println(b);//非true输出false

Integer缓冲区

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

自动装箱调用的是Integer.valueof(),此方法中初始化了数组，表示-127-128之间的数会直接是相同的地址，而下面200超过了，则使用new

public class Demo02 {
    public static void main(String[] args) {
        //面试题
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1==integer2);//对比的是地址，false

        Integer integer3 = 100;  //自动装箱是Integer.valueof()
        Integer integer4 = 100;
        System.out.println(integer3==integer4);//这里是true

        Integer integer5 = 200;
        Integer integer6 = 200;
        System.out.println(integer5==integer6);//false
    }
}

String类

概述

字符串是常量，创建后不可改变(指不是修改，而是重新开辟空间)

字符串字面值存储在字符串池中，可以共享

public class Demo03 {
    public static void main(String[] args) {
        String name = "Hello";//字符串常量存储在字符串池中
        name = "zhangsan";//赋值不是修改原来的数据，而是重新开辟空间
        String name2 = "zhangsan";
    }
}

JDK8以前字符串池在方法区，JDK8及以后移到堆中

String s = "hello";产生一个对现象，字符串池中存储。String s = new String("Hello");产生两个对象，堆、池中各存储一个，此时栈中str存储的是堆中地址

//演示字符串另一种创建方式
        String str = new String("Java");
        String str2 = new String("Java");
        System.out.println(str==str2);//false
        System.out.println(str.equals(str2));//这里比较了数据true

常用方法

public int length():返回字符串长度
public char charAt(int index):根据下标获取字符

public boolean contains(String str):判断当前字符串中是否包含str

    //字符串方法的使用
    //1.length()
    //2.charAt(int index)
    //3.contains(String str)

    String content = "java is best";//空格和中文都算一个字符
    System.out.println(content.length());
    System.out.println(content.charAt(content.length()-1));
    System.out.println(content.contains("php"));

public char[] toCharAray() : 将字符串转换为数组
public int indexOf(String str) : 查找str首次出现的下标，存在，则返回下标，否则返回-1

public int lastIndexOf(String str) : 查找字符串在当前字符串中最后一次出现的下标索引

    String content = "java is best";//空格和中文都算一个字符
    System.out.println(Arrays.toString(content.toCharArray()));
    System.out.println(content.indexOf("java"));
    System.out.println(content.indexOf("java", 4));//从第4个下标开始找
    System.out.println(content.lastIndexOf("a"));

public String trim() : 去掉字符串前后的空格
public String toUpperCase() : 将小写转换成大写

public String endWith(String str) :判断字符串是否以str结尾，startsWith判断是否以str开头

    String content2 = "    hello world    ";
    System.out.println(content2.trim());
    System.out.println(content2.toUpperCase(Locale.ROOT));
    System.out.println(content2.toLowerCase(Locale.ROOT));
    String filename = "hello.java";
    System.out.println(filename.endsWith(".java"));//true
    System.out.println(filename.startsWith("hello"));//true

public String replace(char oldChar,char newChar) : 将旧的字符或字符串替换成新字符或字符串，里面若填字符串就是替换字符串

public String[] split(String str) : 根据str做拆分

    String conten3 = "java是世界上最好的语言";
    System.out.println(conten3.replace("java","php"));
    String say = "java is the best   language,java xiang";
    String[] s = say.split("[ ,]+");//中括号选择，空格和逗号都可以进行拆分，加号表示可以出现一个或多个
    System.out.println(s.length);
    for (String string : s) {
        System.out.println(string);
    }

补充equals与compareTo(),后者比较大小，字典序

    //补充equals与compareTo
    String s1 = "hello";
    String s2 = "HELLO";
    System.out.println(s1.equals(s2));
    System.out.println(s1.equalsIgnoreCase(s2));//忽略大小写的比较

    String s3 = "abc";//a为97
    String s4 = "xyz";//x为120
    System.out.println(s3.compareTo(s4));//97-120=-23，前面相同就比后面的

    String s5 = "abc";
    String s6 = "abcxyz";
    System.out.println(s5.compareTo(s6));//长度不同比长度，3-6=-3

案例实现：包含其他方法

public class Demo04 {
    public static void main(String[] args) {
        String str = "this is a text";
        //1.将str中单词单独获取出来
        String[] s = str.split(" ");
        for (String st : s) {
            System.out.println(st);
        }
        //2.将str中的text替换成practice
        String str2 = str.replace("text", "practice");
        System.out.println(str2);
        //3.在text前插入一个easy
        String str3 = str.replace("text", "easy text");
        System.out.println(str3);
        //4.将每个单词首字母变为大写
        for (int i = 0; i < s.length; i++) {
            char first = s[i].charAt(0);//此时s是二维数组了
            //把第一个字符转成大写
            char upperfirst = Character.toUpperCase(first);

            String news = upperfirst+s[i].substring(1);//从s数组的1号位切分开来
            System.out.println(news);
        }
    }
}

可变字符串

StringBuffer:可变长字符串，JDK1.0提供，运行效率慢，线程安全
StringBuilder: 可变长字符串，JDK5.0提供，运行效率快，线程不安全
与String的区别
- 效率比String高
- 比String节省内存

两者基本相同，单线程情况下尽量使用StringBuilder

public class Demo05 {
    public static void main(String[] args) {
        //StringBuffer sb = new StringBuffer();
        StringBuilder sb = new StringBuilder();
        //1. append() 追加
        sb.append("java is the best");
        System.out.println(sb.toString());
        sb.append("java smell well");
        System.out.println(sb.toString());
        //2. insert() 添加
        sb.insert(0,"at first");
        System.out.println(sb.toString());
        //3. replace() 替换
        sb.replace(0,4,"hello00");//替换左闭右开，但是要是超过范围也会全部替换进去，但是不会印象到原本的第五个元素
        System.out.println(sb.toString());
        //4. delete() 删除
        sb.delete(0,6);//左闭右开
        System.out.println(sb.toString());
        //清空
        sb.delete(0,sb.length());
        System.out.println(sb.length());
    }
}

案例实现：验证效率比String高

public class Demo06 {
    public static void main(String[] args) {
        //验证StringBuilder效率高于String

        //开始时间
        long strat = System.currentTimeMillis();
//        String string="";
//        for (int i = 0; i < 99999; i++) {
//            string+=i;
//        }
        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-strat));//用时19127，大约19秒
        //换成StringBuilder后只用13，大约0.013秒


    }
}