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

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

输出结果：

今晚写完，明天审核通过，应该就是虐狗节了，你们给我省点狗粮。（什么七夕，我不知道，我只知道明天周二，我要好好上班，希望我的领导能看见，哈哈）

/*
 * 字符串的特点：一旦被赋值，就不能改变。
 */
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);
    }
}

输出结果：

• 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
我在群里等你。