java_day10_Object、Scanner、String

一、Object类

java中所有的类默认都有一个共同的父类：Object

== 比较：
    1、比较的是两个基本数据类型的话，比较两个数值是否相等
    2、比较的是两个引用数据类型的话，比较的是两个对象的地址值是否相等

成员方法：
    int hashCode() 返回对象的哈希码值。 可以看作地址值的另外一种表现形式
    public final Class getClass() 返回此 Object的运行时类。 获取当前类的class文件对象, 一个类全局只有一个在方法区中
    public String toString()
        打印一个对象名，默认调用的是类中的toString()方法
        若我们自己没有编写该方法的话，默认使用父类Object类中的toString()
        而父类中默认的toString()打印是一个地址值
        我们今后打印一个对象名的时候，输出是地址值意义不大，我们今后更多的是想看一个对象中成员变量值的情况
        要想实现上面的输出成员变量值的话，重写toString()方法，这样调用的就是自己重写后的toString()
        自动生成即可

代码案例

class Student{
    String name;
    int age;

    public Student() {
    }

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

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

public class ObjectDemo1 {
    public static void main(String[] args) {
//        Student s1 = new Student();
//        Student s2 = new Student();
//
//        System.out.println(s1.hashCode());
//        System.out.println(s2.hashCode());
//
//        System.out.println(s1==s2);
//
//        Class c1 = s1.getClass();
//        System.out.println(c1.getName());

        Student s1 = new Student("李刚", 18);
//        System.out.println(s1.hashCode());
//        System.out.println(s1.getClass().getName() );
//        System.out.println(s1.toString()); // com.shujia.day10.Student@4554617c
        //this.getClass().getName() + "@" + Integer.toHexString(this.hashCode());

        System.out.println(s1.toString());
    }
}

public boolean equals(Object obj)
protected void finalize() 垃圾回收用的

equals()用法代码

import java.util.Objects;

class Student2{
    String name;
    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 +
                '}';
    }

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

}

public class ObjectDemo3 {
    public static void main(String[] args) {
        Student2 s1 = new Student2("李刚", 21);
        Student2 s2 = new Student2("李刚", 21);

        //默认情况下，若对象类中没有自己编写equals方法，默认使用的是父类中Object类中的equals方法
        //而父类中Object类中的equals方法底层调用的是==比较，若比较的是引用数据类型，比较的是地址值
        //而我们这里s1和s2接受的是不同两个对象的地址值，所以默认比较的结果是false
//        System.out.println(s1.equals(s2));
        //需求：当对象的姓名和年龄一样的时候，表示是同一个学生
        //比较的对象类中自己重写一个equals方法，自动生成即可
        System.out.println(s1.equals(s2));



    }
}

protected Object clone()

java中并不是所有的类都可以被克隆，只有授权的类的对象才可以使用克隆方法
我们通过阅读帮助文档后发现，若一个对象的类没有实现Cloneable接口的话，是不可以调用clone方法的
然后，我们再去看Cloneable接口的时候，发现该接口中没有任何抽象方法，今后像这样的接口称之为标记接口

克隆在IT行业中，称之为拷贝。
拷贝分为两种：
    1、浅拷贝
    2、深拷贝

面试题：Object类中的clone是浅拷贝还是深拷贝。答：是浅拷贝

代码案例

class Demo1 {
    int a = 10;


}

class Student3 implements Cloneable {
    String name;
    int age;
    Demo1 demo1;

    public Student3() {
    }

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

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

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

public class ObjectDemo4 {
    public static void main(String[] args) throws Exception {
        Demo1 d1 = new Demo1();


        Student3 s1 = new Student3("刘亦菲", 36, d1);
        System.out.println("s1: " + s1);
        System.out.println(s1.hashCode());
//        Student3 s2 = new Student3("章若楠", 21);

        System.out.println("===========================================");
        //首先，如果此对象的类不实现接口Cloneable ，则抛出CloneNotSupportedException 。
//        Object o1 = s1.clone();
        Object o1 = s1.clone();
        System.out.println("o1: " + o1);
        System.out.println(o1.hashCode());


    }
}

二、Scanner类

Scanner: 一个简单的文本扫描器，可以使用正则表达式解析原始类型和字符串。

构造方法：
    Scanner(InputStream source) 构造一个新的 Scanner ，产生从指定输入流扫描的值。

代码案例

import java.util.Scanner;


public class ScannerDemo1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        //获取一个数字：
//        int i = sc.nextInt();
//        System.out.println(i);
//
//        String s1 = sc.next();
//        System.out.println(s1);

        //获取数字的时候，我们是不是只能够输入数字呢？
//        System.out.println("请输入一个数字：");
        //hasNextXxx()判断下一个输入的内容是否是指定类型
//        if(sc.hasNextInt()){
//            int i = sc.nextInt();
//            System.out.println(i);
//        }else {
//            System.out.println("您输入的内容不是一个int类型的值！");
//        }

//        int i = sc.nextInt();
//        System.out.println(i);
        String s1 = sc.next(); //无法接收换行等空白特殊字符
        System.out.println(s1);
        //输入字符串的另外一种方法
//        String s1 = sc.nextLine(); //可以接收换行等空白特殊字符
//        System.out.println(s1);


        System.out.println("hello world");
    }
}

三、String类

字符串：由若干个字符构成的字符序列叫做字符串
    String类代表字符串。
    Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例。
    字符串不变; 它们的值在创建后不能被更改指的是字符串本身不能改
    因为String对象是不可变的，它们可以被共享。
    字符串可以被看作成一个字符数组

String类中的构造方法：

    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 StringDemo2 {
    public static void main(String[] args) {
        //public String() 创建一个空字符串
        String s1 = new String(); // 堆内存
        System.out.println("s1: " + s1);

//        String s2 = ""; // 常量池
//        System.out.println(s1==s2);
        System.out.println("=============================");

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

        System.out.println("=============================");
        //public String(byte[] bytes,int index,int length) 从字节数组的某个位置开始，向后截取变成字符串
        String s3 = new String(bytes, 2, 3);
        System.out.println("s3: "+s3);
        System.out.println("=============================");
        //public String(char[] value)  //将一个字符数组转成一个字符串
        char[] chars = {'我','爱','中','华'};
        String s4 = new String(chars);
        System.out.println("s4: "+s4);
        System.out.println("=============================");
        //public String(char[] value,int index,int length) 将字符数组一部分转成字符串
        String s5 = new String(chars,1,2);
        System.out.println("s5: "+s5);
        System.out.println("=============================");
        //public String(String original) 将字符串封装成一个String对象在堆内存中
        String s6 = new String("你好");
        System.out.println("s6: "+s6);
    }
}

String类中的判断功能

String类中的判断功能：
    boolean equals(Object obj)
    boolean equalsIgnoreCase(String str)
    boolean contains(String str)
    boolean startsWith(String str)
    boolean endsWith(String str)
    boolean isEmpty()

代码案例

public class StringDemo4 {
    public static void main(String[] args) {
        //boolean equals(Object obj) 比较两个字符串的内容值
        String s1 = "hello";
        String s2 = "HellO";
        System.out.println(s1.equals(s2));
        //boolean equalsIgnoreCase(String str) 忽略大小写比较字符串内容值
        System.out.println(s1.equalsIgnoreCase(s2));
        //boolean contains(String str)  判断大字符串中是否包含某一个小字符串
        String s3 = "今天的天气还可以李刚决定去洗个脚";
        System.out.println(s3.contains("李刚决"));
        //boolean startsWith(String str) 判断字符串是否以某个字符串开头
        System.out.println(s3.startsWith("今天的天气数可以"));
        // boolean endsWith(String str) 判断字符串是否以某个字符串结尾
        System.out.println(s3.endsWith("洗个脚"));
        //boolean isEmpty() 判断字符串是否为空字符串，指的是内容是否为空
        String s4 = "";
        System.out.println(s4.isEmpty());
        String s5 = null;
//        System.out.println(s5.isEmpty()); // NullPointerException


    }
}

String类中的获取功能

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 StringDemo5 {
    public static void main(String[] args) {
        String s = "李刚在数加学院中学习非常快乐！";
        //int length() 获取字符串中的字符个数，字符串长度
        System.out.println(s.length());

        //char charAt(int index) 根据索引获取字符串中某一个字符
        //字符串可以被看作成一个字符数组
//        System.out.println(s.charAt(15)); // StringIndexOutOfBoundsException

        //int indexOf(int ch) 根据ascii码值获取对应字符所在的索引位置,左边起第一个
        String s2 = "qweasdsafqe";
        System.out.println(s2.indexOf(104)); // -1
        //int indexOf(int ch,int fromIndex) 从某个索引开始向后寻找某个字符，返回找到字符在整个大字符串中的索引位置
        System.out.println(s2.indexOf(97,5)); // 7

        //int indexOf(String str) 获取大字符串中小字符串的位置，返回小字符串第一个字符的索引
        System.out.println(s2.indexOf("sdsa")); // 4
        //int indexOf(String str,int fromIndex) 从某个索引开始向后寻找某个字符，返回找到字符串第一个字符在整个大字符串中的索引位置
        System.out.println(s2.indexOf("saf",3)); // 6

        //String substring(int start) // 从指定位置向后截取，返回新的字符串
        String s3 = "李刚是真的帅！江川很不服，钱志强觉得自己是最帅的！";
        String res1 = s3.substring(3);
        System.out.println(res1);

        //String substring(int start,int end) 截取字符串中的一部分 [start, end)
        String res2 = s3.substring(7, 12);
        System.out.println(res2);


    }
}

String转换功能

String转换功能：
    byte[] getBytes()
    char[] toCharArray()
    static String valueOf(char[] chs)
    static String valueOf(int i)
    String toLowerCase()
    String toUpperCase()
    String concat(String str)

代码案例

public class StringDemo6 {
    public static void main(String[] args) {
        String s1 = "abcdefg";
        //byte[] getBytes() 将字符串转字节数组
        byte[] bytes = s1.getBytes();
        for(int i=0;i<bytes.length;i++){
            System.out.println(bytes[i]);
        }
        System.out.println("----------------");
        
//        for(byte b : bytes){
//            System.out.println(b);
//        }
//        System.out.println("----------------");
//        System.out.println(Arrays.toString(bytes));
//        System.out.println("----------------");
        //char[] toCharArray()  将字符串转字符数组
        char[] chars = s1.toCharArray();
        for(int i=0;i<chars.length;i++){
            System.out.println(chars[i]);
        }
        System.out.println("----------------");
        String s3 = new String(chars);
        System.out.println(s3);

        //static String valueOf(char[] chs) 将字符数组转字符串
        String s2 = String.valueOf(chars);
        System.out.println(s2);


        //static String valueOf(int i)
        System.out.println(String.valueOf(100)); // 100 -> "100"

        //String toLowerCase() 转小写
        String s4 = "HellOWOrlD";
        String res1 = s4.toLowerCase();
        System.out.println(res1);

        //String toUpperCase()
        String res2 = s4.toUpperCase();
        System.out.println(res2);

        //String concat(String str) 字符串拼接操作
        String res3 = "李刚".concat("真帅！");
        System.out.println(res3);


    }
}

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 StringDemo7 {
    public static void main(String[] args) {
        String s1 = "dasqwajavadwqrajjavaiojadjavafq-aedjavaqajiqa";
        //String replace(char old,char new) 由新字符替换字符串中所有旧字符
        String res1 = s1.replace('a', '$');
        System.out.println(s1);
        System.out.println(res1);
        //String replace(String old,String new) 由新的字符串替换旧的字符串
        String res2 = s1.replace("java", "李刚");
        System.out.println(res2);
        //String trim() 去除字符串两边的空格
        String s2 = "    hello  world    ";
        System.out.println("s2: "+s2);
        String res3 = s2.trim();
        System.out.println("res3: "+res3);
        //int compareTo(String str) 按字典顺序比较两个字符串是否相同 当结果是0的时候表示两个字符串内容相同
        String s3 = "hello";
        String s4 = "world";
        String s5 = "hel";
        String s6 = "hello";
        System.out.println(s3.compareTo(s4)); // -15
        System.out.println(s3.compareTo(s5)); // 2
        System.out.println(s3.compareTo(s6)); // 0


    }
}

compareTo源码解释

class String{
    //s3.compareTo(s4)
    //s3 - "hello"
    //s4 - "hel"
    public int compareTo(String anotherString) {
        // this - "hello"
        // anotherString - "hel"
        int len1 = this.value.length; // 5
        int len2 = anotherString.value.length; // 3
        int lim = Math.min(len1, len2); // 3
        char[] v1 = value; // ['h','e','l','l','o']
        char[] v2 = anotherString.value; // ['h','e','l']
        int k = 0;

        while (k < lim) {
            char c1 = v1[k]; // 'h'  'e'  'l'
            char c2 = v2[k]; // 'h'  'e'  'l'
            if (c1 != c2) {
                return c1 - c2; // 104 - 119 = -15
            }
            k++;
        }
        return len1 - len2; // 5-3=2
    }
}