复习：常用类Object类
object类
构造方法：
Object()
子类构造方法中，第一行默认有一个super()调用的就是这里的（指的是类没有继承其他的父类了）
常用方法：
hashCode(): 简单理解为是地址值的另外一种表现
toString(): 将来直接打印引用数据类型变量的时候，底层会默认调用该方法，如果一个类中没有重写该方法，默认调用的是父类
Object类中的toString()方法，获取的是地址值。this.getClass.getName()+"@"+Integer.toHexString(this.hashCode())
将来你打印一个引用数据类型的变量，如果结果不是以上结果，说明该类中重写toString()方法。
将来我们写类的时候，要重写该方法。
equals与的区别：
""
1、"=="是运算符，运用在基本数据类型、引用数据类型中
2、在比较基本数据类型的时候，比较的是数据的值，因为进本数据类型是在常量池中存储的，所以也是一样的额，在常量池中的地址
3、在比较引用数据类型的时候，也是比较两者之间的地址
“equals”
1、只能比较引用数据类型，将来如果一个对象调用该方法，要想比较两个对象的成员变量值是否相同的时候，该类要重写equals()
如果不重写，调用的是Object类中的equals()方法,默认比较的是地址值。
protected void finalize()：
当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象。
一个子类覆盖了处理系统资源或执行其他清理的finalize方法。
你们就简单理解这个方法为用于垃圾回收的，什么时候回收，不确定
GC机制，标记法。
protected Object clone():
不是所有的类都能使用克隆的方法，只有实现了Cloneable类的对象才可以使用该方法,并且该类中重写clone方法，通过super()关键字调用。
class Student extends Object implements Cloneable{
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 == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age && Objects.equals(name, student.name);
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
public class ObjectDemo1 {
public static void main(String[] args) throws CloneNotSupportedException {
Object obj = new Object();
System.out.println(obj.hashCode());
System.out.println(obj.toString());
System.out.println(obj.getClass().getName() + "@" + Integer.toHexString(obj.hashCode()));
System.out.println("****************************************");
Student stu1 = new Student("姚龙", 18);
System.out.println(stu1.hashCode());
//如果Student方法没有重写Object方法中的toString的时候，使用的是父类中的提String方法
// System.out.println(stu1);
System.out.println(stu1.getClass().getName() + "@" + Integer.toHexString(stu1.hashCode()));
//重写过后，可以按照自己的方法去实现想要得到的结果
System.out.println(stu1.toString());
//这里的equals方法默认是父类的方法，等同与两个对象相等
//if(stu1 == stu2)
// public boolean equals(Object obj) {
// return (this == obj);
// }
Student stu2 = new Student("姚龙", 18);
//重写之后发现equals方法不一样
System.out.println(stu1.equals(stu2));
System.out.println("***************************************");
String name1 = "姚龙";
String name2 = "姚龙";
//这里可以看吃，只要不是new出来的字符串，都是常量值，数据再常量池内，所以地址是一样的
System.out.println(name1 == name2);
System.out.println("***************************************");
//隐含了一个多态
Object obj2 = stu1.clone();
System.out.println(obj2.toString());
//克隆后的地址值是一样的
System.out.println(obj2.equals(stu1));
}
}
Scanner类
Scanner:
概述：用于键盘录入数据，在程序中使用
Scanner(InputStream source)
由于该类实在java.util包下，所以将来使用的时候，需要导包。
1、获取键盘上的int类型的数据
nextInt()
2、获取字符串数据
next(): 不会接收到特殊字符
nextLine(): 会接收到特殊字符，如换行符
import java.util.Scanner;
public class ScannerDmmo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
System.out.println(num);
// String str = sc.next();
// System.out.println(str);
//如果在打印了前一个回车的时候，nextLine会自动识别，因为回车也可以当作一个字符
String str = sc.nextLine();
System.out.println(str);
}
}
String类
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 StringDemo1 {
public static void main(String[] args) {
String str = new String();
//输出的是空，所以可以看出String类重写了Object的方法
System.out.println(str);
//如果字符串中为空，则length()输出0
System.out.println(str.length());
System.out.println("=====================================================");
//public String(byte[] bytes) //根据一个字节数组创建出一个字符串对象
byte[] bytes = {97, 98, 99, 100, 101};
String s1 = new String(bytes);
System.out.println(s1);
System.out.println("=====================================================");
//public String(byte[] bytes,int index,int length)
//将字节数组中的一部分转化成字符串
String s2 = new String(bytes, 1, 4);//如果为5的就会越界
System.out.println(s2);
System.out.println("=====================================================");
//public String(char[] value)
//将字符数组转成一个字符串
char[] value = {'a', 'b', 'c', 'd', 'e'};
String s3 = new String(value);
System.out.println(s3);
System.out.println("=====================================================");
//public String(char[] value,int index,int length)
//将字符数组的一部分转成字符串
String s4 = new String(value, 1, 3);
System.out.println(s4);
//public String(String original)
//初始化新创建的String对象，使其表示与参数相同的字符序列; 换句话说，新创建的字符串是参数字符串的副本
System.out.println("=====================================================");
//比较字符串拼接的小细节
String str1 = "hello";
String str2 = "world";
String str3 = "helloworld";
String str4 = "hello" + "world";
//这里是两个常量相加，首先会在常量池中创建上述的地址值，然后常量拼接的时候是要在常量池中寻找
//如果找到的话，就可以相等，两者的地址值相等
System.out.println(str4 == str3);
//这里是两个变量相加，JVM会在常量池中开辟新的空间，然后将两个值加在一起,添加到开辟的新空间中
System.out.println(str3 == (str1 + str2));
}
}
String 的判断功能
String类的判断功能：
boolean equals(Object obj) 判断两个值是否相等
boolean equalsIgnoreCase(String str) 不考虑大小写，判断两个值是否相等
boolean startsWith(String str) 测试此字符串是否以指定的前缀开头。
boolean endsWith(String str) 测试此字符串是否以指定的结束。
boolean isEmpty() 判断是否为空
注意：String s = “”;与String s = null; 引出字符串之间比较的注意事项，避免空指针异常
public class StringDemo2 {
public static void main(String[] args) {
String s1 = "hello";
String s2 = "hello";
System.out.println(s1.equals(s2));
//boolean startsWith(String str)
System.out.println(s1.startsWith("he"));
String s3 = "";
String s4 = null;
System.out.println(s3.isEmpty());//不为空的时候输出true
System.out.println(s4.isEmpty());//如果为空的时候则会空指针错误
}
}
String 的获取功能
String类的获取功能：
int length() 获取字符串的长度
char charAt(int index) //获取指定字符串的位置的值
int indexOf(int ch) //传入一个int的值，在目标字符串中寻找指定的字符的位置，用阿兹科马值的形式展示
int indexOf(String str) //在目标字符串中寻找指定的字符串
int indexOf(int ch,int fromIndex) 从fromIndex的位置开始搜索，返回指定字符的第一次出现的位置
int indexOf(String str,int fromIndex) 从fromIndex的位置开始搜索，返回指定字符串的第一次出现的位置
String substring(int start) 从指定位置到最后以为所有字符
String substring(int start,int end) 输出指定的一部分字符串(口诀：头包尾不包)
public class StringDemo3 {
public static void main(String[] args) {
String str = "abcd";
for(int i=0;i
String 的转换功能
String类的转换功能：
byte[] getBytes() //将字符串转换成byte数组
char[] toCharArray() //将字符串转换成字符数组
static String valueOf(char[] chs) //可以直接使用String.方法名来调用，将字符数组转换成字符串
static String valueOf(int i) //可以直接使用String.方法名来调用，将整型转换成字符串
String toLowerCase() //返回全部变成小写字符串
String toUpperCase() //返回全部变成大写字符串
String concat(String str) 将字符串str拼接到指定的字符串后面
public String[] split(String regex) **********分割字符串以指定的字符串分割，，，，，后面还会用到正则表达式
public class StringDemo4 {
public static void main(String[] args) {
//byte[] getBytes() //将字符串转换成byte数组
String s1 = "abcdef";
byte[] bytes = s1.getBytes();
// System.out.println(bytes);
for (int i = 0; i < bytes.length; i++) {
System.out.print(bytes[i] + " ");
}
System.out.println();
System.out.println("=====================================================");
//char[] toCharArray() //将字符串转换成字符数组
char[] chars = s1.toCharArray();
System.out.println(chars);
System.out.println("=====================================================");
//static String valueOf(char[] chs)
String s2 = String.valueOf(chars);
System.out.println(s2);
System.out.println(s2.getClass().getName());
System.out.println("=====================================================");
//String toLowerCase() //返回全部变成小写字符串
String s3 = "HelLO";
System.out.println(s3.toLowerCase());
System.out.println("=====================================================");
//String toUpperCase() //返回全部变成大写字符串
String s4 = "HelLO";
System.out.println(s3.toUpperCase());
System.out.println("=====================================================");
//String concat(String str) 将字符串str拼接到指定的字符串后面
System.out.println(s4.concat("scala"));
System.out.println("=====================================================");
//public String[] split(String regex) 分割字符串以指定的字符串分割，，，，，后面还会用到正则表达式
String s5 = "hello java scala Web javaee";
String[] str = s5.split(" ");
for (int i = 0; i < str.length; i++) {
System.out.println(str[i]);
}
}
}
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 StringDemo5 {
public static void main(String[] args) {
String s1 = "hellojavascalahellojavascalahellojavascalahellojavascala";
String s2 = s1.replace("ll","@@");//将新字符串的替换指定字符串中的字符串
System.out.println(s2);
System.out.println("=====================================================");
//测试旧字符串和新字符串的个数可以不同不？？？？
String s3 = s1.replace("ll","@@@@@");
System.out.println(s3);
System.out.println("=====================================================");
//去除字符串两边若干个空格
String s4 = " hello java ";
System.out.println(s4.trim());
System.out.println("=====================================================");
//按字典顺序比较两个字符串内容是否一样，这里涉及到源码分析
//int compareTo(String str)
//int compareToIgnoreCase(String str)
String s6 = "hello"; // h的ASCII码值是 104
String s7 = "hello";
String s8 = "abc"; // a的ASCII码值是 97
String s9 = "qwe"; // q的ASCII码值是 113
//从源码中寻找联系
System.out.println(s6.compareTo(s7)); //若两个字符串相同的时候 输出0
//若两个字符串的第一个字符不相等的时候，使用compareTo方法则输出两个字符串的第一个字符的阿兹科马值的差值
System.out.println(s6.compareTo(s8));
System.out.println(s6.compareTo(s9));
String s10 = "hout";
System.out.println(s6.compareTo(s10));
//若第二个字符串是第一个字符串的部分的时候，则输出两个字符串长度的差值 s6的长度-s10的长度
String s11 = "hel";
System.out.println(s6.compareTo(s11)); //2
//int compareToIgnoreCase(String str) 忽略大小写
}
}
总结
常用类：目的是为了让大家熟练地使用API帮助文档
Object:
概述：是java中所有类的父类，所有的类都继承自这个类。
由于Object类是属于java.lang包下的，所以我们使用的时候不需要导包
构造方法：
Object()
子类构造方法中，第一行默认有一个super()调用的就是这里的（指的是类没有继承其他的父类了）
方法：
hashCode(): 简单理解为是地址值的另外一种表现
toString(): 将来直接打印引用数据类型变量的时候，底层会默认调用该方法，如果一个类中没有重写该方法，默认调用的是父类
Object类中的toString()方法，获取的是地址值。this.getClass.getName()+"@"+Integer.toHexString(this.hashCode())
将来你打印一个引用数据类型的变量，如果结果不是以上结果，说明该类中重写toString()方法。
将来我们写类的时候，要重写该方法。
equals(): equals()只能用于引用数据类型之间的比较，将来如果一个对象调用该方法，要想比较两个对象的成员变量值是否相同的时候，该类要重写equals()
如果不重写，调用的是Object类中的equals()方法,默认比较的是地址值。
protected void finalize()：
当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象。
一个子类覆盖了处理系统资源或执行其他清理的finalize方法。
你们就简单理解这个方法为用于垃圾回收的，什么时候回收，不确定
GC机制，标记法。
protected Object clone(): 不是所有的类都可以使用clone()方法，只有实现了Cloneable类的对象才可以使用该方法，并且该类中
重写clone方法，通过super()关键字调用。clone()是浅拷贝，拷贝的时候，对象中的引用数据类型变量的地址值不会变化，会创建一个新的对象赋值。
Scanner:
概述：用于键盘录入数据，在程序中使用
Scanner(InputStream source)
由于该类实在java.util包下，所以将来使用的时候，需要导包。
1、获取键盘上的int类型的数据
nextInt()
2、获取字符串数据
next(): 不会接收到特殊字符
nextLine(): 会接收到特殊字符，如换行符
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)
注意：
1、String s = new String("hello");与String s = "hello";的区别
new的时候会在堆内存中开辟空间。
2、字符串相加的时候需要注意的问题：
a、字符串如果是变量相加，是先在常量池中开辟空间，然后再做拼接。
b、字符串如果是常量相加，是先相加，然后再去常量池中去找，如果找到了，就返回，如果没有找到就开辟新的空间，存储拼接后的值。
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; 引出字符串之间比较的注意事项，避免空指针异常
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)
String类的转换功能：
byte[] getBytes()
char[] toCharArray()
static String valueOf(char[] chs)
static String valueOf(int i)
String toLowerCase()
String toUpperCase()
String concat(String str)
public String[] split(String regex) **********
String类的其他功能：
替换功能
String replace(char old,char new)
String replace(String old,String new)
去除字符串两边若干个空格
String trim()
按字典顺序比较两个字符串内容是否一样，这里涉及到源码分析
int compareTo(String str)
int compareToIgnoreCase(String str)
