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类的练习

统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)

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

我在群里等你。