JAVA基础再回首（九）——Object类、String类及其获取功能、转换功能、其他功能

时间：2022-06-27 19:25:48

JAVA基础再回首（九）——Object类、String类及其获取功能、转换功能、其他功能

七夕，你们要怎么过，反正我和代码过。（这么晚了，我还想和你们多闲聊两句）
女生最爱问男朋友什么问题？“你喜欢我什么？”这个问题可是难到了多少英雄好汉。你回答的慢了女生嫌弃你犹豫了，回答的快了说你没诚意，不回答了说你根本就不喜欢她。
千那，这都是什么逻辑，没错，这就是女生。因为她知道比她好的人比她优秀的人很多，你为什么选择了她呢？
其实作为男生也没必要去编写一大推好听的获取她的芳心，反而有时候，会使得其反，让她觉得很假，这样肯定就不好了。
最好的爱情，不是我在很多人中做选择，爱这个，或者爱那个，而是我只能选择爱你，或者更爱你。
就像《白马啸西风》中李秀文说的话，那些都是很好很好的，可我偏偏不喜欢。
所谓真爱，就是唯一。
所谓承诺，就是一生只爱一个人。

Object类

Object类的概述

  • 类 Object 是类层次结构的根类。
  • 每个类都使用 Object 作为超类。
  • 所有的类都直接或者间接的继承自Object类。

Object类的方法

  • public int hashCode()
    • 返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。
    • 不同对象的，hashCode()一般来说不会相同。但是，同一个对象的hashCode()值肯定相同。
    • 不是对象的实际地址值，可以理解为逻辑地址值。

  • public final Class getClass()

    • 返回此 Object 的运行时类。
    • 可以通过Class类中的一个方法，获取对象的真实类的全名称。
      • public String getName()：以 String 的形式返回此 Class 对象所表示的实体

  • public String toString()

    • 返回该对象的字符串表示。

               //底层源码。
      public static String valueOf(Object obj) {
      return (obj == null) ? "null" : obj.toString();
                  }

    • 它的值等于：getClass().getName() + ‘@’ + Integer.toHexString(hashCode())

    • 由于默认情况下的数据对我们来说没有意义，一般建议重写该方法。a:手动重写b:自动生成
    • 注意：直接输出一个对象的名称，其实就是调用该对象的toString()方法。
  • public boolean equals(Object obj)
  • 指示其他某个对象是否与此对象“相等”。 (下面有详细讲解)
  • protected void finalize()
    • 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
    • 垃圾回收器不会马上回收垃圾，但是我们可以建议它尽快回收垃圾。(System.gc()方法)
    • 主要针对堆内存。
  • protected Object clone()
    • 创建并返回此对象的一个副本，这种克隆机制十分高效，而且二者之间完全隔离。
    • 自定义类实现克隆步骤：
      • 自定义类实现Cloneable接口，这是一个标记性接口，实现这个接口的类的对象可以实现自我克隆。
      • 自定义类中重写Object类的clone()方法。
      • 重写clone()方法时通过super.clone()调用Object类的clone()方法来得到该对象的副本，并返回该副本。

下面我们来举例说明：

    //首先我们定义一个学生类让它继承Object类，定义name和age属性
public class Student extends Object {
private String name;
private int age;
public Student() {
super();
    }
public Student(String name, int age) {
super();
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 + "]";
    }
    }
//接下来我们定义一个学生的测试类
package com.adu;
public class StudentTest {
public static void main(String[] args) {
        Student s = new Student();
        System.out.println(s.hashCode()); // 366712642

        System.out.println(s.getClass().getName());////com.adu.Student

        System.out.println(s.toString());

        Student s1 = new Student("梅西", 30);
        Student s2 = new Student("梅西", 30);
        System.out.println(s1 == s2); // false
        Student s3 = s1;
        System.out.println(s1 == s3);// true
        System.out.println(s1.equals(s2));// true
        System.out.println(s1.equals(s1)); // true
        System.out.println(s1.equals(s3)); // true
        Student s4 = new Student("Messi",30);
        System.out.println(s1.equals(s4)); //false

//创建学生对象
        Student ss = new Student();
        s.setName("CSDN");
        s.setAge(27);

//克隆学生对象
        Object obj = s.clone();
        Student ss1 = (Student)obj;

        System.out.println(ss.getName()+"---"+ss.getAge());//CSDN---27
        System.out.println(ss1.getName()+"---"+ss1.getAge());//CSDN---27
//输出结果都在输出语句的后面，方便大家对应查看。
    }
}

这里我们再来详细说一下public boolean equals(Object obj)这个方法

  • 这个方法，默认情况下比较的是地址值。比较地址值一般来说意义不大，所以我们要重写该方法。

  • 一般都是用来比较对象的成员变量值是否相同。

    那么 == 和 equals有什么区别呢？

    ==:
    基本类型：比较的就是值是否相同
    引用类型：比较的就是地址值是否相同
    equals:
    引用类型：默认情况下，比较的是地址值。
    不过，我们可以根据情况自己重写该方法。一般重写都是自动生成，比较对象的成员变量值是否相同(可以看上面代码的举例)

String类概述及其构造方法

  • String类概述

    • 字符串是由多个字符组成的一串数据(字符序列)
    • 字符串可以看成是字符数组

  • 通过查看API，我们可以知道

    • 字符串字面值”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 int length()：返回此字符串的长度。
public class StringDemo {
public static void main(String[] args) {
// public String():空构造
        String s1 = new String();
        System.out.println("s1:" + s1);
        System.out.println("s1.length():" + s1.length());
        System.out.println("--------------------------");

// public String(byte[] bytes):把字节数组转成字符串
byte[] bys = { 97, 98, 99, 100, 101 };
        String s2 = new String(bys);
        System.out.println("s2:" + s2);
        System.out.println("s2.length():" + s2.length());
        System.out.println("--------------------------");

// public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
// 我想得到字符串"bcd"
        String s3 = new String(bys, 1, 3);
        System.out.println("s3:" + s3);
        System.out.println("s3.length():" + s3.length());
        System.out.println("--------------------------");

// public String(char[] value):把字符数组转成字符串
char[] chs = { 'a', 'b', 'c', 'd', 'e', '七', '夕', '快','乐' };
        String s4 = new String(chs);
        System.out.println("s4:" + s4);
        System.out.println("s4.length():" + s4.length());
        System.out.println("--------------------------");

// public String(char[] value,int index,int count):把字符数组的一部分转成字符串
        String s5 = new String(chs, 2, 4);
        System.out.println("s5:" + s5);
        System.out.println("s5.length():" + s5.length());
        System.out.println("--------------------------");

//public String(String original):把字符串常量值转成字符串
        String s6 = new String("abcde");
        System.out.println("s6:" + s6);
        System.out.println("s6.length():" + s6.length());
        System.out.println("--------------------------");

//字符串字面值"abc"也可以看成是一个字符串对象。
        String s7 = "abcde";
        System.out.println("s7:"+s7);
        System.out.println("s7.length():"+s7.length());
    }
}

输出结果：
JAVA基础再回首（九）——Object类、String类及其获取功能、转换功能、其他功能
今晚写完，明天审核通过，应该就是虐狗节了，你们给我省点狗粮。（什么七夕，我不知道，我只知道明天周二，我要好好上班，希望我的领导能看见，哈哈）

/*
 * 字符串的特点：一旦被赋值，就不能改变。
 */
public class StringDemo {
public static void main(String[] args) {
        String s = "hello";
        s += "world";
        System.out.println("s:" + s); // 输出结果helloworld
    }
}

String s = new String(“hello”)和String s = “hello”;的区别?(我们在下面举例说明)

//前者会创建2个对象，后者创建1个对象。我们可以用 == 和 equals来比较

//==:比较引用类型比较的是地址值是否相同
//equals:比较引用类型默认也是比较地址值是否相同，而String类重写了equals()方法，比较的是内容是否相同。

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

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

//今天看到的面试题是这样的，和上面的真的很像
    String str = "hello";
    String str2 = "he"+new String("llo");
    System.out.println(str == str2);
//你知道答案了吗？ 我们要了解 == 和 equals的区别 还有他们比较的是什么就会很容易的答上来。

    }
}

今天我在一个群里看到一份android的面试题，第一题是java基础和上面的那道题很相似，我就直接写在上面的那个例子中。


  • String类的判断功能
    • 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 class StringDemo {
    public static void main(String[] args) {
    // 创建字符串对象
            String s1 = "helloworld";
            String s2 = "helloworld";
            String s3 = "HelloWorld";

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


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


    // boolean contains(String str):判断大字符串中是否包含小字符串
            System.out.println("contains:" + s1.contains("hello")); //true
            System.out.println("contains:" + s1.contains("hw"));    //false


    // boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
            System.out.println("startsWith:" + s1.startsWith("h"));     //true
            System.out.println("startsWith:" + s1.startsWith("hello")); //true
            System.out.println("startsWith:" + s1.startsWith("world")); //false


    // 练习：boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
            System.out.println("endsWith:" + s1.endsWith("o"));     //false
            System.out.println("endsWith:" + s1.endsWith("d"));     //true

    // boolean isEmpty():判断字符串是否为空。
            System.out.println("isEmpty:" + s1.isEmpty());  //false

            String s4 = "";
            String s5 = null;
            System.out.println("isEmpty:" + s4.isEmpty());//true
    // NullPointerException
    // s5对象都不存在，所以不能调用方法，空指针异常
            System.out.println("isEmpty:" + s5.isEmpty());
        }
    }
    • String类的获取功能
      • 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 class StringDemo {
    public static void main(String[] args) {
    // 定义一个字符串对象
            String s = "helloworld";

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

    // char charAt(int index):获取指定索引位置的字符
            System.out.println("charAt:" + s.charAt(7));//r

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

    // int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
            System.out.println("indexOf:" + s.indexOf("owo"));  //4

    // int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
            System.out.println("indexOf:" + s.indexOf('l', 4));         // 8
            System.out.println("indexOf:" + s.indexOf('k', 4)); // -1
            System.out.println("indexOf:" + s.indexOf('l', 40)); // -1

    // int indexOf(String str,intfromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
            System.out.println("indexOf:" + s.indexOf('o', 1)); //4

    // String substring(int start):从指定位置开始截取字符串,默认到末尾。包含start这个索引
            System.out.println("substring:" + s.substring(5));//world
            System.out.println("substring:" + s.substring(0));//helloworld

    // String substring(int start,int
    // end):从指定位置开始到指定位置结束截取字符串。包括start索引但是不包end索引
            System.out.println("substring:" + s.substring(3, 8)); //loworl
            System.out.println("substring:" + s.substring(0, s.length()));//helloworld
        }
    }
    • String的转换功能
      • byte[] getBytes():把字符串转换为字节数组
      • char[] toCharArray():把字符串转换为字符数组
      • static String valueOf(char[] chs):把字符数组转成字符串
      • static String valueOf(int i):把int类型的数据转成字符串
        • String类的valueOf方法可以把任意类型的数据转成字符串
      • String toLowerCase():把字符串转成小写
      • String toUpperCase():把字符串转成大写
      • String concat(String str):把字符串拼接
    public class StringDemo {
    public static void main(String[] args) {
    // 定义一个字符串对象
            String s = "JavaSE";

    // byte[] getBytes():把字符串转换为字节数组。
    byte[] bys = s.getBytes();
    for (int x = 0; x < bys.length; x++) {
                System.out.println(bys[x]);
            }
            System.out.println("----------------");

    // char[] toCharArray():把字符串转换为字符数组。
    char[] chs = s.toCharArray();
    for (int x = 0; x < chs.length; x++) {
                System.out.println(chs[x]);
            }
            System.out.println("----------------");

    // static String valueOf(char[] chs):把字符数组转成字符串。
            String ss = String.valueOf(chs);
            System.out.println(ss);
            System.out.println("----------------");

    // static String valueOf(int i):把int类型的数据转成字符串。
    int i = 100;
            String sss = String.valueOf(i);
            System.out.println(sss);
            System.out.println("----------------");

    // String toLowerCase():把字符串转成小写。
            System.out.println("toLowerCase:" + s.toLowerCase());
            System.out.println("s:" + s);
    // System.out.println("----------------");
    // String toUpperCase():把字符串转成大写。
            System.out.println("toUpperCase:" + s.toUpperCase());
            System.out.println("----------------");

    // String concat(String str):把字符串拼接。
            String s1 = "hello";
            String s2 = "world";
            String s3 = s1 + s2;
            String s4 = s1.concat(s2);
            System.out.println("s3:"+s3);
            System.out.println("s4:"+s4);
        }
    }

    输出结果：
    JAVA基础再回首（九）——Object类、String类及其获取功能、转换功能、其他功能

    • String类的其他功能
      • 替换功能：
        • String replace(char old,char new)
        • String replace(String old,String new)
      • 去除字符串两空格
        • String trim()
      • 按字典顺序比较两个字符串
        • int compareTo(String str)
        • int compareToIgnoreCase(String str)
    public class StringDemo {
    public static void main(String[] args) {
    // 替换功能
            String s1 = "helloworld";
            String s2 = s1.replace('l', 'k');
            String s3 = s1.replace("owo", "ak47");
            System.out.println("s1:" + s1);//s1:helloworld
            System.out.println("s2:" + s2);//s2:hekkoworkd
            System.out.println("s3:" + s3);//s3:hellak47rld

    // 去除字符串两空格
            String s4 = " hello world ";
            String s5 = s4.trim();
            System.out.println("s4:" + s4 + "---");//s4: hello world ---
            System.out.println("s5:" + s5 + "---");//s5:hello world---

    // 按字典顺序比较两个字符串
            String s6 = "hello";
            String s7 = "hello";
            String s8 = "abc";
            String s9 = "xyz";
            System.out.println(s6.compareTo(s7));// 0
            System.out.println(s6.compareTo(s8));// 7
            System.out.println(s6.compareTo(s9));// -16
        }
    }

    String类的练习

    1. 统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
    public class StringTest {
    public static void main(String[] args) {
    //定义一个字符串
            String s = "Hello123World";

    //定义三个统计变量
    int bigCount = 0;//大写字母
    int smallCount = 0;//小写字母
    int numberCount = 0;//数字

    //遍历字符串，得到每一个字符。
    for(int x=0; x<s.length(); x++){
    char ch = s.charAt(x);

    //判断该字符到底是属于那种类型的
    if(ch>='a' && ch<='z'){
                    smallCount++;
                }else if(ch>='A' && ch<='Z'){
                    bigCount++;
                }else if(ch>='0' && ch<='9'){
                    numberCount++;
                }
            }

    //输出结果。
            System.out.println("大写字母"+bigCount+"个");
            System.out.println("小写字母"+smallCount+"个");
            System.out.println("数字"+numberCount+"个");
        }
    }

    输出结果：
    大写字母2个
    小写字母8个
    数字3个

    关于String类的练习题还有很多需要我们去掌握，所以再学完这一章一定要多练习。
    好了，我们今天就学到这里。今天是七夕，祝天下有情人终成眷属。（啊，西湖的水，我的泪！）

    欢迎有兴趣的同学加我朋友的QQ群：555974449
    我在群里等你。
    标签：

    相关文章