JavaAPI，介绍一些常用的类

最新推荐文章于 2023-01-03 21:54:26 发布

啊帅和和。

最新推荐文章于 2023-01-03 21:54:26 发布

阅读量202

点赞数

分类专栏： Java专栏。文章标签： java hibernate spring

本文链接：https://blog.csdn.net/l_dsj/article/details/119461385

版权

Java专栏。专栏收录该内容

37 篇文章 1 订阅

订阅专栏

这一块的内容，主要是有关Java中的API，并且介绍一些简单的类

常用类

Java中有一些常用的类，主要有这些：红色和蓝色字体的多掌握一下，这里主要带着帮助文档列举几个（Object类、String类）
在这里插入图片描述

API：应用程序编程接口

Object类

Object类的成员方法

在这里插入图片描述

Object：是类Object结构的根，每个class都有Object作为超类
所有对象（包括数组）都实现了这个类的方法
每个类都直接或间接的继承自Object类
Object类中的方法：hashCode()
public int hashCode()返回对象的哈希值。支持这种方法是为了散列表，如HashMap提供的那样。
注意：哈希值就是根据哈希算法计算出来的一个值，这个值跟地址有关系，但是不是实际的地址值。你可以简单的理解为就一种地址。
```
  public final 类<?> getClass() 返回此Object的运行时类。 返回的类对象是被表示类的static synchronized方法锁定的对象
  
  Student是一个继承自Object类的子类
```

public class StudentTest {
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(student.hashCode());//685325104
        Student student1 = new Student();
        System.out.println(student1.hashCode());//460141958

        Student student2 = student;
        System.out.println(student2.hashCode());//685325104

        System.out.println("**************************");

        Student student3 = new Student();
        System.out.println(student3.getClass());//class com.bigdata.shujia15.Student

        System.out.println("**************************");

        Class c = student3.getClass();
        System.out.println(c.getName());//com.bigdata.shujia15.Student

        System.out.println("**************************");

        System.out.println(student3.getClass().getName());//com.bigdata.shujia15.Student
        
    }
}

Object类中的方法：toString()，代码中顺道介绍为什么要重写toString方法
public String toString() 返回对象的字符串表达形式，一般来说，toString方法返回一个对象的字符串
Integer类中提供了一个静态的方法：
public static String toHexString(int i)返回整数参数的字符串表示形式，作为16位中的无符号整数

public class StudentTest2 {
    public static void main(String[] args) {
        Student2 student2 = new Student2();
        System.out.println(student2.hashCode());//685325104
        System.out.println(student2.getClass().getName());//com.bigdata.shujia15.Student2
        System.out.println(student2.toString());//com.bigdata.shujia15.Student2@28d93b30

        System.out.println("****************");

        //toString方法的值等价于以下内容，然而这样的输出没有意义，所以JVM中为我们重写了toString方法
        //student2.getClass().getName()+"@"+Integer.toHexString(student2.hashCode())

        System.out.println(student2.getClass().getName()+"@"+Integer.toHexString(student2.hashCode()));

        //重写之后的toString方法
        student2.setName("祥哥");
        student2.setAge(21);
        System.out.println("重写之后的方法："+student2.toString());
    }
}
//685325104
//com.bigdata.shujia15.Student2
//Student2{name='null', age=0}
//****************
//com.bigdata.shujia15.Student2@28d93b30
//重写之后的方法：Student2{name='祥哥', age=21}

Object中的方法：equals（这个方法，要重写）
public boolean equals(Object obj) 指示一些其他的对象是否等于此，这个方法，默认情况下，比较的是地址值，但是呢，比较地址值是没有意义的，更多情况下，我们比较对象中成员变量的值是否一样，所以想到的是重写方法

==：
基本类型：比较的是值是否相同
引用类型：比较的是地址值是否相同
equals：
引用类型：默认情况下，比较的是地址值。不过，根据情况重写，可以自己重写，也可以自动生成

public class StudentTest3 {
    public static void main(String[] args) {
        Student3 s1 = new Student3("张三",21);
        Student3 s2 = new Student3("李四", 22);

        System.out.println(s1==s2);//false
        Student3 s3 = s1;
        System.out.println(s1==s3);//true

        System.out.println("********");

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

        System.out.println("********");

        Student3 s4 = new Student3("王五", 23);
        System.out.println(s1.equals(s4));//false

        System.out.println("********");

        Demo demo = new Demo();
        System.out.println(s1.equals(demo));//false
    }
}

Object中的方法：finalize()、clone()
protected void finalize()
throws Throwable当垃圾回收器确定不再有对该对象的引用时，垃圾回收器在对象上调用该对象。一个子类覆盖了处理系统资源或执行其他清理的finalize方法。简单来说，它就是用于垃圾回收的，但是呢，什么时候回收不确定
protected Object clone()
throws CloneNotSupportedException创建并返回此对象的副本。返回的是这个实例的一个克隆。

public interface Cloneable一个类实现Cloneable接口，以指示Object.clone()方法，该方法对于该类的实例进行现场赋值是合法的，也就是必须要实现Cloneable接口才能使用clone方法

class Student44 implements Cloneable{
    private String name;
    private int age;

    public Student44(){}

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

    public int getAge() {
        return age;
    }

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

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

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }

    public String getName() {
        return name;
    }

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

    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class StudentTest4 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Student44 student44 = new Student44("张三",21);
        System.out.println(student44.toString());

        Object clone = student44.clone();

        //向下转型
        Student44 sclone = (Student44)clone;
        System.out.println(student44.getName()+"---"+student44.getAge());
        System.out.println(sclone.getName()+"---"+sclone.getAge());

        Student44 s = student44;

        System.out.println("***********************");
        s.setName("李四");
        s.setAge(22);

        //可以看出来，使用clone方法克隆，new出来是一个全新的对象
        System.out.println(student44.getName()+"---"+student44.getAge());
        System.out.println(sclone.getName()+"---"+sclone.getAge());
        System.out.println(s.getName()+"---"+s.getAge());
    }
}
//李四---22
//张三---21
//李四---22

String类

String类概述
- 字符串是由多个字符组成的一串数据（字符序列）
- 字符串可以看成是字符数组
通过查看API，发现
- String类代表字符串
- Java程序中所有字符串文字（例如“abc”）都可以实现为此类的实例
- 字符串字面值“abc”也可以看成一个字符串对象
- 字符串是常量，一旦被赋值，就不能被改变

构造方法

- public String()
- public String(byte[] bytes)
- public String(byte[] bytes,int offset,int length)
- public String(char[] value)
- public String(char[] value,int offset,int count)
- public String(String original)


public class StringDemo1 {
    public static void main(String[] args) {
        String s = new String();
        System.out.println("s:"+s);
        System.out.println("s的长度"+s.length());
        System.out.println("******************");

        //public String(byte[] bytes) 将字节数组转化成字符串
        byte[] b = new byte[]{11,22,33,44,55,66,77,88,99};
        String s1 = new String(b);
        System.out.println("s1:"+s1);
        System.out.println(s1.length());
        System.out.println("******************");

        //public String(byte[] bytes,int offset,int length)
        //将字节数组的一部分截取成字符串
        String s2 = new String(b,1,4);
        System.out.println("s2:"+s2);
        System.out.println(s2.length());
        System.out.println("******************");

        //public String(char[] value) 将字符数组转化成字符串
        char[] c = new char[]{'a','b','c','d','e','f','g'};
        String s3 = new String(c);
        System.out.println("s3:"+s3);
        System.out.println(s3.length());
        System.out.println("******************");

        //public String(char[] value,int offset,int count)
        //将字符数组的一部分转化成字符串
        String s4 = new String(c,1,4);
        System.out.println("s4:"+s4);
        System.out.println(s4.length());
        System.out.println("******************");

        //public String(String original)
        //将字符串常量转化成字符串对象
        String abcde = new String("abcde");
        System.out.println(abcde);
        System.out.println(abcde.length());

        String s6 = "asdfghj";
        String s7 = new String(s6);
        System.out.println("s7:"+s7);
        System.out.println(s7.length());
        
    }
}

字符串的特点：一旦被赋值，就不能被改变
面试题：
但我们发现下面这个例子，s从Hello，变为了HelloWorld

public static void main(String[] args) {
        String s = "Hello";

        s += "World";
        System.out.println("s:"+s);//HelloWorld
    }

但实际上，我们可以发现，当我们创建“Hello”的时候，是在方法区里面的字符串常量池创建了一个空间，“World”也开辟了一个空间，“HelloWorld”也是一个新的空间，s是从“Hello”的地址，变成了“HelloWorld”的地址，但本身的字符串是不发生改变的
在这里插入图片描述

String s = new String(“hello”) 和 String s = "hello"的区别
- == 比较的是引用类型的地址值
- equals默认比较的是地址值，但是String重写了equals方法，所以比较的是内容
- 前者会创建两个对象，后者创建一个对象

public static void main(String[] args) {
        String s1 = new String("hello");
        String s = "hello";

        System.out.println(s == s1);//false
        System.out.println(s1.equals(s));//true
    }

图解：
首先是在栈里面创建了一个s1对象，然后在堆里面开辟了一个空间，赋值了hello，存进了方法区的字符串常量池，s1指向的是堆内存里面的位置；接着在栈里面开辟了s2空间，指向的是方法区中字符串常量池的位置。
在这里插入图片描述

看程序写结果

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

        String s3 = new String("hello");
        String s4 = "hello";
        System.out.println(s3==s4); //false
        System.out.println(s3.equals(s4)); //true

        String s5 = "hello";
        String s6 = "hello";
        System.out.println(s5==s6); //true
        System.out.println(s5.equals(s6)); //true
    }

看程序写结果
- 字符串如果是变量相加，是先开辟空间，再拼接
- 字符串如果是常量相加，是先加，再去常量池中查找，如果找到就返回，否则就创建

public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "world";
        String s3 = "helloworld";
        System.out.println(s3==s1+s2);  //false
        System.out.println(s3.equals(s1+s2));  //true

        //经过编译，自动转化成System.out.println(s3 == "helloworld");
        System.out.println(s3 == "hello"+"world"); //true

        System.out.println(s3.equals("hello"+"world")); //true        
    }

判断功能

一些方法

	boolean equals(Object obj)
    boolean equalsIgnoreCase(String str)
    boolean contains(String str)
    boolean startsWith(String str)
    boolean endsWith(String str)
    boolean isEmpty()
注意事项：
    String s = "";
    String s = null;

    public static void main(String[] args) {

        //创建字符串对象
        String s1 = "helloworld";
        String s2 = "Helloworld";
        String s3 = "HelloWorld";

        //boolean equals(Object obj) 比较字符串的内容是否相同，区分大小写
        System.out.println(s1.equals(s2)); //false
        System.out.println(s1.equals(s3)); //false
        System.out.println("**********************");

        //boolean equalsIgnoreCase(String str)
        // 比较字符串的内容是否相同,忽略大小写
        System.out.println(s1.equalsIgnoreCase(s2)); //true
        System.out.println(s1.equalsIgnoreCase(s3)); //true
        System.out.println("**********************");

        //boolean contains(String str)
        //判断大的字符串中是否包含小的字符串
        System.out.println(s1.contains("Hello"));
        System.out.println(s1.contains("lowo"));
        System.out.println("**********************");

        //boolean startsWith(String str) 测试此字符串是否以指定的前缀开头。
        System.out.println(s1.startsWith("h")); //true
        System.out.println(s1.startsWith("he")); //true
        System.out.println(s1.startsWith("world")); //false
        System.out.println("**********************");

        //boolean endsWith(String str)测试此字符串是否以指定的后缀结尾。
        System.out.println(s1.endsWith("world")); //true
        System.out.println(s1.endsWith("hello")); //false
        System.out.println("**********************");

        //boolean isEmpty() 判断字符串是不是空
        System.out.println(s1.isEmpty());

        System.out.println("**********************");

        String s4 = "";
        String s5 = null;
        System.out.println(s4.isEmpty()); //true
        //因为s5的对象都没有，所以不能够调用方法，空指针异常
//        System.out.println(s5.isEmpty()); //NullPointerException


        System.out.println("asd".equals(s1));

//        System.out.println(s5.equals("asd"));

        //比较字符串的内容，推荐这种
        System.out.println("asd".equals(s5));
    }
}

获取功能

int length():获取字符串的长度

        char charAt(int index)
        int indexOf(int ch)
        int indexOf(String str)
        int indexOf(int ch,int fromIndex)
        int indexOf(String str,int fromIndex)
        String substring(int start)
        String substring(int start,int end)

public static void main(String[] args) {

        String s = "helloworld";

        // int length():获取字符串的长度
        System.out.println(s.length());
        System.out.println("*******************");

        //char charAt(int index)
        //返回char指定索引处的值。 指数范围为0至length() - 1
        System.out.println(s.charAt(7));
        System.out.println("*******************");

        //int indexOf(int ch)
        //返回指定字符第一次出现的字符串内的索引。
        System.out.println(s.indexOf('l')); //2
        System.out.println("*******************");

        //int indexOf(String str)
        //返回指定子字符串第一次出现的字符串内的索引。
        System.out.println(s.indexOf("ello")); //1
        System.out.println("*******************");


        //int indexOf(int ch,int fromIndex)
        //返回指定字符第一次出现的字符串内的索引，以指定的索引开始搜索。
        System.out.println(s.indexOf('l',4)); //8
        System.out.println(s.indexOf('p',4)); //-1
        System.out.println(s.indexOf('l',40)); //-1

        //int indexOf(String str,int fromIndex)
        //返回指定子串的第一次出现的字符串中的索引，从指定的索引开始

        System.out.println("*******************");

        //String substring(int start)
        //返回一个字符串，该字符串是此字符串的子字符串。
        // 子字符串以指定索引处的字符开头，并扩展到该字符串的末尾
        //截串
        //最大可以传的数值到length的值
        System.out.println(s.substring(3)); //loworld
        //System.out.println(s.substring(11));//StringIndexOutOfBoundsException
        System.out.println("*******************");

        //String substring(int start,int end)
        //返回一个字符串，该字符串是此字符串的子字符串。
        // 子串开始于指定beginIndex并延伸到字符索引endIndex - 1 。
        // 因此，子串的长度为endIndex-beginIndex 。
        //左闭右开
        System.out.println(s.substring(1,3)); //el
        System.out.println(s.substring(4,8)); //owor
    }

感谢阅读，我是啊帅和和，一位大数据专业即将大四学生，祝你快乐。

啊帅和和。

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
JavaAPI，介绍一些常用的类

这一块的内容，主要是有关Java中的API，并且介绍一些简单的类常用类Java中有一些常用的类，主要有这些：红色和蓝色字体的多掌握一下，这里主要带着帮助文档列举几个（Object类、String类）API：应用程序编程接口Object类Object类的成员方法Object：是类Object结构的根，每个class都有Object作为超类所有对象（包括数组）都实现了这个类的方法每个类都直接或间接的继承自Object类Object类中的方法：hashCode()publ
复制链接

扫一扫