JAVA part 9：Scanner、Object和String

JAVA part 9：Scanner、Object和String

API

应用程序编程接口

帮助文档

Scanner

用于获取键盘录入数据（基本数据类型和字符串数据类型）的关键字
public String nextLine(): 获取键盘录入字符串数据

//Scanner字符串输入
package Day_9;
import java.util.Scanner;

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

        System.out.println("请输入一个字符串数据");
        String line = sc.nextLine();

        System.out.println("Line"+line);
    }
}

Object

是类层次结构的跟类，所有的类都直接或者间接继承该类

构造方法：Object();

Object类的toString()方法

toString：
返回该对象的字符串表示。通常，toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。

package Day_9;


// 直接输出对象名，输出底层调用的是该对象的toString()
//查看API，我们发现建议所有子类都重写toString();
//重写自动生成就好-->generate-->toString

public class test2 {
    public static void main(String[] args) {
    
        Student s = new Student();
        
        s.setName("林青霞");
        s.setAge(30);
        
        System.out.println(s);
        System.out.println(s.toString());
/*
    public void println(Object x) {       // Object x = s;
        String s = String.valueOf(x);
        synchronized (this) {
            print(s);
            newLine();
        }
    }
    public static String valueOf(Object obj) {    //Object obj = x;
        return (obj == null) ? "null" : obj.toString();
    }
*/
    }
}

package Day_9;
public class Student {

    private String name;
    private int age;

    public Student(){}

    public String getName(String 林青霞) {
        return name;
    }

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

    public int getAge(int i) {
        return age;
    }

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

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

Object类的equals()方法

== ：
1.比较基本数据类型：
比较基本数据类型的时候比较的是基本数据类型的值是否相同
2.比较引用数据类型：
比较引用数据类型的时候比较的是引用数据类型的地址值是否相同

通过比较对象是否相等的方法：
public boolean equals(Object obj);

package Day_9;
//Object类中的equals()方法默认比较的是对象的地址是否相同
//如果想比较对象的内容是否相同就必须重写该方法
//重写方法自动生成即可-->generate-->equals() and hashcode()
public class test3 {
    public static void main(String[] args) {
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("林青霞", 30);

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

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

        /*
        public boolean equals(Object obj) {
            //this -- s1
            //obj -- s2
            return (this == obj);
        }
        */
    }
}

package Day_9;
import java.util.Objects;
public class Student {

    private String name;
    private int age;

    public Student(){}

    public Student(String name,int age){
        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 +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        //比较的是对象是否是同一个类的对象
        if (!(o instanceof Student)) return false;
        Student student = (Student) o;
        return age == student.age &&
                name.equals(student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

String类

代表字符串类；由多个字符组成的一串数据；字符串的本质就是一个字符数组/

构造方法：
1.把字符串数据分装乘字符串对象
String(String original);
2.把字符数组的数据封装成字符串对象
String(char[ ] value);
3.把字符数组的一部分数据封装成字符串对象
String(char[ ] value, int index, int count);

package Day_9;
public class test4 {
    public static void main(String[] args) {

        //String(String original);
        String s1 = new String("hello");
        System.out.println(s1);

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

        //String(char[ ] value);
        char[] value = {'h', 'e', 'l', 'l', 'o'};
        String s2 = new String(value);
        System.out.println(s2);

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

        //String(char[ ] value, int index, int count);
        //String s3 = new String(value, 0, value.length);
        String s3 = new String(value, 0, 3);
        System.out.println(s3);
        
        //最常用
        String s4 = "hello";
        System.out.println(s4);
    }
}

String类创建对象的特点：
1.通过构造方法创建对象
2.通过直接赋值的方式创建对象

这两种方式的创建是有区别：
1.通过构造方法创建的字符串对象在堆内存中
2.通过直接赋值的方式创建的字符串对象是在方法区的常量池

StringBulider和String

如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，即耗时，又浪费空间。而StringBulider就可以解决这个问题
StringBulider是一个可变的字符串类

String和StringBulider的区别：
1.String的内容是固定的
2.StringBulider的内容是可变的

构造方法：
public StringBulider();
public StringBulider(String str);

package Day_9;
public class test5 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        System.out.println("sb:"+sb);
        System.out.println(sb.length());

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

        StringBuilder sb2 = new StringBuilder("helloworld");
        System.out.println("sb2:"+sb2);
        System.out.println(sb2.length());
    }
}

StringBuilder的添加和反转

添加功能：
public StringBuilder append(任意类型);//添加数据并返回对象本身
反转功能：
public StringBuilder reverse();

//添加功能和反转功能
package Day_9;
public class test6 {
    public static void main(String[] args) {

        StringBuilder sb = new StringBuilder();

		//添加功能
        /*
        sb.append("hello");
        sb.append("world");
        sb.append("true");
        sb.append("100");
        */
        
        //链式编程
        sb.append("hello").append("world").append("true").append("100");

        System.out.println("sb:"+sb);// 输出sb:helloworldtrue100


        //反转功能
        sb.reverse();
        System.out.println("sb:"+sb);// 输出sb:001eurtdlrowolleh
    }
}