目录
Object类
概述：是java中所有类的父类，所有的类都继承自这个类，由于Object类是属于java.lang包下的，所以我们使用的时候不需要导包
构造方法：Object()；
我们之前说过，在子类的构造方法中，第一行会有一个默认的super();方法，在这里，如果一个类没有继承其他父类，那么它的默认super();方法调用的就是Object();构造方法
class Student{
//这里隐藏着的super()方法会自动调用Object的无参构造方法
public Student(){}
}一些Object类中常用方法
hashCode(): 返回输入对象的哈希值，简单理解为是地址值的另外一种表现，我们用一个Student类来实现这个方法看一下，
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;
}
}
public class StudentDemo{
public static void main(String[] args) {
Student s1 = new Student();//要调用方法，必须创建对象
System.out.println(s1.hashCode());//返回s1的哈希值
}}toString(): 将来直接打印引用数据类型变量的时候，底层会默认调用该方法，如果一个类中没有重写该方法，默认调用的是父类，Object类中的toString()方法，获取的是地址值。this.getClass.getName()+"@"+Integer.toHexString(this.hashCode())， 将来你打印一个引用数据类型的变量，如果结果不是以上结果，说明该类中重写toString()方法。将来我们写类的时候，要重写该方法。我们继续用上的Student类案例来看，我们不修改Student类，只修改测试类
public class StudentDemo{
public static void main(String[] args) {
//这里是上面的Student类，没有重写toString()方法
Student s = new Student();
System.out.println(s.toString());
}如果这里我们修改了Student类，在Student类里重写了这个toString()方法，那么我们在测试类中调用的就是重写后的方法，不再是原来父类中的toStudent()方法，所以结果就是子类中重写toString()方法的结果
equals(): equals()只能用于引用数据类型之间的比较，将来如果一个对象调用该方法，要想比较两个对象的成员变量值是否相同的时候，该类要重写equals()， 如果不重写，调用的是Object类中的equals()方法,默认比较的是地址值。
public class StudentDemo {
public static void main(String[] args) {
Student s1 = new Student("小明", 18);
Student s2 = new Student("小明", 18);
System.out.println(s1.equals(s2));
//这里我们创建了两个对象，两个对象的值相同，但是地址不同
//而我们没有在子类中重写equals方法，比较的是地址值
}}protected void finalize()：
当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象。 一个子类覆盖了处理系统资源或执行其他清理的finalize方法。这个方法为用于垃圾回收的，什么时候回收，不确定GC机制，标记法。
protected Object clone(): 不是所有的类都可以使用clone()方法，只有实现了Cloneable类的对象才可以使用该方法，并且该类中重写clone方法，通过super()关键字调用。clone()是浅拷贝，拷贝的时候，对象中的引用数据类型变量的地址值不会变化，会创建一个新的对象赋值。
public class Student implements Cloneable{
//Student执行Cloneeable接口，表示这个类可以被克隆
//并且要在该类中重写clone()方法
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}我们通过观察API发现，Cloneable接口中没有常量，也没有抽象方法，它只是为了起一个标记作用，告诉我们实现这个接口的类可以用于克隆，今后我们看到类似Cloneable一样，里面什么也没有的接口，我们称之为标记接口
克隆前后的对象，对象里的引用数据类型地址前后一样，整个对象的地址值前后不一样，属于浅拷贝。这里需要提到拷贝的两种方式
拷贝的两种方式
浅拷贝：浅拷贝是指我们拷贝出来的对象的内部引用类型变量和原来变量的内部引用类型变量的地址值相同，但是整个拷贝出来的对象和新对象不是同一个地址值
深拷贝：全部拷贝对象的内容，包括内存的引用类型也进行拷贝，拷贝的时候，重新创建一个对象，成员变量不变，但是后续再对拷贝后的引用数据类型变量做修改，不会影响到原来被拷贝的
Scannner
概述：用于键盘录入数据，在程序中使用
Scanner(InputStream source)
由于该类实在java.util包下，所以将来使用的时候，需要导包。
1、获取键盘上的int类型的数据：nextInt()
2、获取字符串数据
next(): 不会接收到特殊字符
nextLine(): 会接收到特殊字符，如换行符
Scanner sc = new Scanner(System.in);
String s1 = sc.nextline();
String s2 = sc.next(); 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)
我们在同一个StudentDemo案例中查看
public class StringDemo {
public static void main(String[] args) {
//public String()
String s = new String();
System.out.println(s);//String类中重写了toString方法，打印的是里面的值
//public int length()
System.out.println("字符串s的长度为："+s.length());
//如果一个字符串中没有字符，返回0
//public String(byte[] byte),传一个byte型字节数组创建出一个字符串对象
byte[] bytes = {97,98,99,100,101};
String s2 = new String(bytes);
System.out.println("s2:" + s2);
System.out.println("字符串s2的长度为：" + s2.length());
//public String(byte[] bytes,int offset,int length)
//public String(byte[] bytes,int index,int length)理解成index索引
String s3 = new String(bytes, 2, 3);
System.out.println("s3:"+s3);
System.out.println("s3的长度为：" + s3.length());
//public String(char[] value)传一个字符数组，将字符数组转成一个字符串
char[] chars ={'a','b','c','d'};
String s1 = new String(chars);
System.out.println("s1:"+s1);
System.out.println("s1的长度是："+s1.length());
// public String(char[] value,int offset,int count),offset理解成index
String s4 = new String(chars, 1, 3);
System.out.println("s4:"+s4);
System.out.println("字符串s4的长度是："+s4.length());
// public String(String original)
// 今后最常用的创建字符串的方式，把String转变成一个String
String s5 ="你好，我爱你";
String s6 = new String(s5);
System.out.println("s5：" + s5);
System.out.println("字符串s5的长度是：" + s5);
}
} 注意：
1、String s = new String("hello");与String s = "hello";的区别
new的时候会在堆内存中开辟空间。
2、字符串相加的时候需要注意的问题：
a、字符串如果是变量相加，是先在常量池中开辟空间，然后再做拼接。
b、字符串如果是常量相加，是先相加，然后再去常量池中去找，如果找到了，就返回，如果没有找到就开辟新的空间，存储拼接后的值。
public class StringDemo2 {
public static void main(String[] args) {
String s2 = "我爱你";
String s3 = "中国";
String s4 = "我爱你中国";
String s5 = "我爱你"+"中国";
System.out.println(s5 == s4);//常量相加比较
String s6 = s2+s3;
System.out.println(s6==s5);//变量相加比较
System.out.println(s4.euqals(s2+s3));//比较成员变量值
}}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 StringDemo2 {
public static void main(String[] args) {
/*boolean equals(Object obj)\比较字符串中内容是否相同，区分大小写
* 用 == 比较引用数据类型的时候，比较的是地址值*/
String s1 = new String("我爱你");
String s2 = "我爱你";
System.out.println(s1 == s2);//比较地址值
System.out.println(s1.equals(s2));//比较成员变量值因为String类中重写了equals方法 System.out.println("============================================================");
//字符串相加，变量相加先开辟地址，常量相加先找常量池中有没有相加过后的值，如果没有则开辟地址
String s3 = "中国";
String s4 = "我爱你中国";
String s5 = "我爱你"+"中国";
System.out.println(s5 == s4);
String s6 = s2+s3;
System.out.println(s6==s5);
System.out.println("===================================================");
// boolean equalsIgnoreCase(String str)比较字符串中内容是否相同，不区分大小写
String d1 = "helloworld";
String d2 = "HelloWorld";
System.out.println(d1.equalsIgnoreCase(d2));
System.out.println("=======================================================");
// boolean contains(String str)
// 判断大的字符串中是否包含小的字符串，如果包含，返回true，反之返回false
//区分大小写
System.out.println(s4.contains(s3));
System.out.println(s4.contains(d1));
System.out.println(d1.contains("hello"));
System.out.println("=====================================================");
// boolean startsWith(String str)
//测试次字符串是否以此字符开头
//区分大小写
System.out.println(d1.startsWith("hel"));
System.out.println(d1.startsWith("Hel"));
System.out.println("===================================================");
// boolean endsWith(String str)
//测试此字符串是否以指定字符结尾
//区分大小写
System.out.println(d1.endsWith("world"));
System.out.println(d1.endsWith("World"));
System.out.println("===========================================================");
// boolean isEmpty()
//判断字符串是否是空字符串
System.out.println(d1.isEmpty());
String e1 = "";
String e2 = null;
System.out.println(e1==e2);
System.out.println(e2==e1);
System.out.println(e1.equals(e2));
// System.out.println(e2.equals(e1));
// System.out.println(e2.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 StringDemo3 {
public static void main(String[] args) {
// int length()获取字符串长度
String s1 = "helloworld";
System.out.println(s1.length());
System.out.println("=======================");
// char charAt(int index)返回指定索引处的字符
System.out.println(s1.charAt(2));
System.out.println("========================");
// int indexOf(int ch)
//返回指定字符第一次出现在字符串内的索引
System.out.println(s1.indexOf('o'));
//如果字符串中没有此字符则返回-1
System.out.println(s1.indexOf('1'));
System.out.println("======================");
// int indexOf(String str)
//返回指定字符串第一次出现在大串里的位置，返回的是小串第一个字符的索引位置
//不存在则返回-1
System.out.println(s1.indexOf("wor"));
// int indexOf(int ch,int fromIndex)
//返回指定字符第一次出现在字符串中的索引，已指定的索引开始搜索
//找不到则返回-1
System.out.println(s1.indexOf('d', 5));
System.out.println("=============================");
// int indexOf(String str,int fromIndex)
//返回指定字符串第一次出现在大串中的索引，以指定的索引开始搜索
//找不到返回-1
System.out.println(s1.indexOf("llo", 1));
System.out.println(s1.indexOf("zzz",1));
System.out.println("=========================");
// String substring(int start)
//截取字符串，包括开始截取的位置，一直到末尾
//如果给的索引值不存在，则报错
System.out.println(s1.substring(1));
System.out.println("=========================");
//String substring(int start,int end)
//截取字符串，包括开始截取的位置，不包括结束的位置
//不存在索引值，则报错
System.out.println(s1.substring(1, 6));
/* System.out.println(s1.substring(11, 21));
StringIndexOutOfBoundsException*/
}
}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) **********
public class StringDemo4 {
public static void main(String[] args) {
// byte[] getBytes()
// 将字符串转换成字节型数组
String s1 = "HelloWorld";
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();
for(int i=0;i< chars.length;i++){
System.out.print(chars[i]+",");
}
System.out.println();
System.out.println("======================");
// static String valueOf(char[] chs)
// 将字符数组转化成字符串
System.out.println(String.valueOf(chars));
System.out.println("=======================");
// static String valueOf(int i)
//将int类型转换成字符串
String s2 = String.valueOf(100);
System.out.println(s2);//100转换成字符型 "100"
System.out.println("=======================");
// String toLowerCase()
//将字符串中的内容全部转小写
System.out.println(s1.toLowerCase());
System.out.println("========================");
// String toUpperCase()
//将字符串的内容全部转大写
System.out.println(s1.toUpperCase());
System.out.println("=========================");
// String concat(String str)
//字符串的拼接
System.out.println(s1.concat("woaini"));
System.out.println("=========================");
// public String[] split(String regex)
// 将字符串分割，以regex关键词为标记
String s3 = "wo ai ni zhong guo";
String[] split = s3.split(" ");
for(int i=0;i< split.length;i++){
System.out.print(split[i]+",");
}
}
}
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 replace(char old,char new)
//用新字符代替原来的字符
String s1 = "我爱你中国";
System.out.println(s1.replace("中", "祖"));
// String replace(String old,String new)
//用新的字符小串代替旧的字符小串
//不存在则返回原字符串
System.out.println(s1.replace("中国", "中国人民"));
// String trim()，去除字符串两边空格
String s2 = " helloworld ";
System.out.println(s2.trim());
// int compareTo(String str),
// 比较字符串是否相同，相同返回0,不同则是第一个不一样的字母的ASCII值相减
String s3 = "abc";
String s4 = "abc";
String s5= "fc";
System.out.println(s3.compareTo(s4));
System.out.println(s3.compareTo(s5));
//如果一个小串前面字符和大串全部相同，就是字符长度相减
String s6 = "ab";
System.out.println(s3.compareTo(s6));
// int compareToIgnoreCase(String str)
//忽略大小写
String d1 ="Hello";
String d2 ="hello";
System.out.println(d1.compareToIgnoreCase(d2));
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
