15_常用API_第15天（Object、String、StringBuffer、用户登陆注册）_讲义
程序员文章站
2024-01-16 12:28:28
1、Object 2、String 3、StringBuilder ......
今日内容介绍
1、object
2、string
3、stringbuilder
01api概念
- a:api(application programming interface)
- 应用程序编程接口
- b:java api
- 就是java提供给我们使用的类，这些类将底层的实现封装了起来，
- 我们不需要关心这些类是如何实现的，只需要学习这些类如何使用。
- c: 演示查看object类中的相关方法
02object类概述
- a:object类概述
- 类层次结构的根类
- 所有类都直接或者间接的继承自该类
- object中描述的所有方法子类都可以使用
- 所有类在创建对象的时候，最终找的父类就是object。
- b:构造方法
- public object()
- 回想面向对象中为什么说：
- 子类的构造方法默认访问的是父类的无参构造方法
03equals方法比较内存地址
- a:equals方法比较内存地址
- a: object类中的equals方法
- 用于比较两个对象是否相同，object类中就是使用两个对象的内存地址在比较。
- object类中的equals方法内部使用的就是==比较运算符。
-
b: 案例代码
public class person extends object{ private string name; private int age; public person(){} public person(string name, int age) { this.name = name; this.age = age; } /* * 将父类的equals方法写过来,重写父类的方法 * 但是,不改变父类方法的源代码, 方法equals 比较两个对象的内存地址 * */ public boolean equals(object obj){ return this == obj; } 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 testequals { public static void main(string[] args) { //person类继承object类,继承下来了父类的方法equals person p1 = new person("李四",20); person p2 = new person("张三",20); //person对象p1,调用父类的方法equals,进行对象的比较 boolean b = p1.equals(p1); system.out.println(b); } }
- a: object类中的equals方法
04重写equals方法
- a: 重写equals方法
- a: 开发中要比较两个对象是否相同，经常会根据对象中的属性值进行比较
- b: 在开发经常需要子类重写equals方法根据对象的属性值进行比较。
- c: ==号和equals方法的区别
- ==是一个比较运算符号,既可以比较基本数据类型,也可以比较引用数据类型,基本数据类型比较的是值,引用数据类型比较的是地址值
- equals方法是一个方法,只能比较引用数据类型,所有的对象都会继承object类中的方法,如果没有重写object类中的equals方法,
equals方法和==号比较引用数据类型无区别,重写后的equals方法比较的是对象中的属性
- d: 案例代码
public class person extends object{ private string name; private int age; public person(){} public person(string name, int age) { this.name = name; this.age = age; } /* * 重写父类的方法tostring() * 没有必要让调用者看到内存地址 * 要求: 方法中,返回类中所有成员变量的值 */ public string tostring(){ return name + age; } /* * 将父类的equals方法写过来,重写父类的方法 * 但是,不改变父类方法的源代码, 方法equals 比较两个对象的内存地址 * * 两个对象,比较地址,没有意义 * 比较两个对象的成员变量,age * 两个对象变量age相同,返回true,不同返回false * * 重写父类的equals,自己定义自己对象的比较方式 */ public boolean equals(object obj){ if( this == obj){ return true; } //对参数obj,非null判断 if( obj == null){ return false; } if( obj instanceof person){ // 参数obj接受到是person对象,才能转型 // 对obj参数进行类型的向下转型,obj转成person类型 person p = (person)obj; return this.age == p.age; } return false; } 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 testequals { public static void main(string[] args) { //person类继承object类,继承下来了父类的方法equals person p1 = new person("李四",20); person p2 = new person("张三",20); //person对象p1,调用父类的方法equals,进行对象的比较 boolean b = p1.equals(p1); system.out.println(b); } }
- a: 开发中要比较两个对象是否相同，经常会根据对象中的属性值进行比较
05重写tostring方法
- a: 重写tostring方法
- a: 为什么要重写tostring方法
- tostring方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。
- 由于tostring方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。
- object类中的tostring的核心代码
getclass().getname() + "@" + integer.tohexstring(hashcode()) - 由于默认情况下的数据对我们来说没有意义，一般建议重写该方法。
- b: 案例核心代码(重写person类中的tostring方法)
/* * 重写父类的方法tostring() * 没有必要让调用者看到内存地址 * 要求: 方法中,返回类中所有成员变量的值 */ public string tostring(){ return name + age; } //eclipse中自动生成的tostring @override public string tostring() { return "person [name=" + name + ", age=" + age + "]"; } //测试代码 public class testtostring { public static void main(string[] args) { //调用person类的方法tostring() //输出语句中,写的是一个对象,默认调用对象的tostring方法 person p = new person("张三",20); string s = p.tostring(); system.out.println(p); system.out.println(s); /* * system.out.println(p); * system.out.println(p.tostring()); */ /*random r = new random(); system.out.println(r.tostring()); scanner sc = new scanner(system.in); system.out.println(sc.tostring());*/ } }
- a: 为什么要重写tostring方法
06string类的概念和不变性
- a: string类的概念和不变性
- a:string类
- api中的string类的描述，发现string 类代表字符串
- java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。
- 字符串是常量,在创建之后不能更改
- 其实就是说一旦这个字符串确定了，那么就会在内存区域中就生成了这个字符串。字符串本身不能改变，但str变量中记录的地址值是可以改变的。
- 源码分析,string类底层采用的是字符数组:
private final char value[]
private 修饰说明value只能在string类内部使用,而且又没有提供get方法,所以外部无法获取value数组,就无法改变数组中元素的值
final修饰说明value是常量,一旦创建,就不能被改变,value一旦被初始化成某个数组,将永远指向这个数组,不可能再指向其它的数组了
- b: 案例代码
/* * string类特点: * 一切都是对象,字符串事物 "" 也是对象 * 类是描述事物,string类,描述字符串对象的类 * 所有的 "" 都是string类的对象 * * 字符串是一个常量,一旦创建,不能改变 */ public class stringdemo { public static void main(string[] args) { //引用变量str执行内存变化 //定义好的字符串对象,不变 string str = "itcast"; system.out.println(str); str = "itheima"; system.out.println(str); } }
- a:string类
07string类创建方式和比较
- a: string类创建方式和比较
- a: 创建对象的数量比较
- string s3 = "abc";
- 在内存中只有一个对象。这个对象在字符串常量池中
- string s4 = new string("abc");
- 在内存中有两个对象。一个new的对象在堆中，一个字符串本身对象，在字符串常量池中
- string s3 = "abc";
- b: 案例代码
public class stringdemo2 { public static void main(string[] args) { //字符串定义方式2个, 直接= 使用string类的构造方法 string str1 = new string("abc"); string str2 = "abc"; system.out.println(str1); system.out.println(str2); system.out.println(str1==str2);//引用数据类型,比较对象的地址 false system.out.println(str1.equals(str2));//true } }
- a: 创建对象的数量比较
08string类构造方法
- a: string类构造方法
- a: 常见构造方法
* public string():空构造 * public string(byte[] bytes):把字节数组转成字符串 * public string(byte[] bytes,int index,int length):把字节数组的一部分转成字符串 * public string(string original):把字符串常量值转成字符串
- b: 案例代码
public class stringdemo3 { public static void main(string[] args) { function_1(); } /* * 定义方法,string类的构造方法 * string(byte[] bytes) 传递字节数组 * 字节数组转成字符串 * 通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 string。 * 平台 : 机器操作系统 * 默认字符集: 操作系统中的默认编码表, 默认编码表gbk * 将字节数组中的每个字节,查询了编码表,得到的结果 * 字节是负数,汉字的字节编码就是负数, 默认编码表 ,一个汉字采用2个字节表示 * * string(byte[] bytes, int offset, int length) 传递字节数组 * 字节数组的一部分转成字符串 * offset 数组的起始的索引 * length 个数,转几个 , 不是结束的索引 */ public static void function(){ byte[] bytes = {97,98,99,100}; //调用string类的构造方法,传递字节数组 string s = new string(bytes); system.out.println(s); byte[] bytes1 ={65,66,67,68,69}; //调用string构造方法,传递数组,传递2个int值 string s1 = new string(bytes1,1,3); system.out.println(s1); } }
09string类构造方法_2
- a: string类构造方法
-
a: 常见构造方法
- public string(char[] value):把字符数组转成字符串
- public string(char[] value,int index,int count):把字符数组的一部分转成字符串
-
- b: 案例代码
/* * string类构造方法 * string类的构造方法,重载形式 * */ public class stringdemo3 { public static void main(string[] args) { function_1(); } /* * string(char[] value) 传递字符数组 * 将字符数组,转成字符串, 字符数组的参数,不查询编码表 * * string(char[] value, int offset, int count) 传递字符数组 * 将字符数组的一部分转成字符串 * offset 数组开始索引 * count 个数 */ public static void function_1(){ char[] ch = {'a','b','c','d','e','f'}; //调用string构造方法,传递字符数组 string s = new string(ch); system.out.println(s); string s1 = new string(ch,1,4); system.out.println(s1); } }
10string类的其他方法
* a：string类的其他方法
* a: 方法介绍
* int length(): 返回字符串的长度
* string substring(int beginindex,int endindex): 获取字符串的一部分
* string substring(int beginindex): 获取字符串的一部分
* boolean startswith(string prefix): 判断一个字符串是不是另一个字符串的前缀,开头
* boolean endswith(string prefix): 判断一个字符串是不是另一个字符串的后缀,结尾
* boolean contains (string s): 判断一个字符串中,是否包含另一个字符串
* int indexof(char ch): 查找一个字符,在字符串中第一次出现的索引,被查找的字符不存在,返回-1
* byte[] getbytes(): 将字符串转成字节数组,此功能和string构造方法相反,byte数组相关的功能,查询编码表
* char[] tochararray(): 将字符串转成字符数组,功能和构造方法相反
* boolean equals(object obj): 方法传递字符串,判断字符串中的字符是否完全相同,如果完全相同返回true
* boolean equalsignorecase(string s): 传递字符串,判断字符串中的字符是否相同,忽略大小写
* b: 案例代码
public class stringdemo4 {
public static void main(string[] args) {
function_9();
}
/*
* boolean equals(object obj)
* 方法传递字符串,判断字符串中的字符是否完全相同,如果完全相同返回true
*
* boolean equalsignorecase(string s)
* 传递字符串,判断字符串中的字符是否相同,忽略大小写
*/
public static void function_9(){
string str1 = "abc";
string str2 = "abc";
//分别调用equals和equalsignorecase
boolean b1 = str1.equals(str2);
boolean b2 = str1.equalsignorecase(str2);
system.out.println(b1);
system.out.println(b2);
}
/*
* char[] tochararray() 将字符串转成字符数组
* 功能和构造方法相反
*/
public static void function_8(){
string str = "itcast";
//调用string类的方法tochararray()
char[] ch = str.tochararray();
for(int i = 0 ; i < ch.length ; i++){
system.out.println(ch[i]);
}
}
/*
* byte[] getbytes() 将字符串转成字节数组
* 此功能和string构造方法相反
* byte数组相关的功能,查询编码表
*/
public static void function_7(){
string str = "abc";
//调用string类方法getbytes字符串转成字节数组
byte[] bytes = str.getbytes();
for(int i = 0 ; i < bytes.length ; i++){
system.out.println(bytes[i]);
}
}
/*
* int indexof(char ch)
* 查找一个字符,在字符串中第一次出现的索引
* 被查找的字符不存在,返回-1
*/
public static void function_6(){
string str = "itcast.cn";
//调用string类的方法indexof
int index = str.indexof('x');
system.out.println(index);
}
/*
* boolean contains (string s)
* 判断一个字符串中,是否包含另一个字符串
*/
public static void function_5(){
string str = "itcast.cn";
//调用string类的方法contains
boolean b =str.contains("ac");
system.out.println(b);
}
/*
* boolean endswith(string prefix)
* 判断一个字符串是不是另一个字符串的后缀,结尾
* demo.java
* .java
*/
public static void function_4(){
string str = "demo.java";
//调用string类方法endswith
boolean b = str.endswith(".java");
system.out.println(b);
}
/*
* boolean startswith(string prefix)
* 判断一个字符串是不是另一个字符串的前缀,开头
* howareyou
* how
*/
public static void function_3(){
string str = "howareyou";
//调用string类的方法startswith
boolean b = str.startswith("how");
system.out.println(b);
}
/*
* string substring(int beginindex,int endindex) 获取字符串的一部分
* 返回新的字符串
* 包含头,不包含尾巴
*
* string substring(int beginindex)获取字符串的一部分
* 包含头,后面的字符全要
*/
public static void function_2(){
string str = "howareyou";
//调用string类方法substring获取字符串一部分
str= str.substring(1, 5);
system.out.println(str);
string str2 = "helloworld";
str2 = str2.substring(1);
system.out.println(str2);
}
/*
* int length() 返回字符串的长度
* 包含多少个字符
*/
public static void function(){
string str = "cfxdf#$refewfrt54gt";
//调用string类方法length,获取字符串长度
int length = str.length();
system.out.println(length);
}
}
11string类练习
- a: 获取指定字符串中，大写字母、小写字母、数字的个数
- a: 题目分析
- 为了统计大写字母、小写字母、数字的个数。创建3个计数的变量。
- 为了获取到字符串中的每个字符，进行字符串的遍历，得到每个字符。
- 对得到的字符进行判断，如果该字符为大写字母，则大写字母个数+1；如果该字符为小写字母，则小写字母个数+1；如果该字符为数字，则数字个数+1。
- 显示大写字母、小写字母、数字的个数
- b: 解题步骤
- 略
-
案例代码
public class stringtest { public static void main(string[] args) { getcount("a%a3ebr1ffy"); } /* * 获取指定字符串中，大写字母、小写字母、数字的个数。 * 思想: * 1. 计数器,就是int变量,满足一个条件 ++ * 2. 遍历字符串, 长度方法length() + charat() 遍历 * 3. 字符判断是大写,是小写,还是数字 */ public static void getcount(string str){ //定义三个变量,计数 int upper = 0; int lower = 0; int digit = 0; //对字符串遍历 for(int i = 0 ; i < str.length() ; i++){ //string方法charat,索引,获取字符 char c = str.charat(i); //利用编码表 65-90 97-122 48-57 if(c >='a' && c <=90){ upper++; }else if( c >= 97 && c <= 122){ lower++; }else if( c >= 48 && c <='9'){ digit++; } } system.out.println(upper); system.out.println(lower); system.out.println(digit); } }
- a: 题目分析
12string类练习_2
- a: 将字符串中，第一个字母转换成大写，其他字母转换成小写，并打印改变后的字符串。
- a: 题目分析
- 把字符串分为两个部分，第一部分为字符串中第一个字母，第二部分为剩下的字符串。
- 把第一部分字符串转换成大写字母，把第二部分字符串转换成小写字母
- 把两部分字符串连接在一起，得到一个完整的字符串
- b: 解题步骤
- 略
-
c: 案例代码
public class stringtest { public static void main(string[] args) { system.out.println(toconvert("abc5%4def")); } /* * 将字符串的首字母转成大写,其他内容转成小写 * 思想: * 获取首字母, charat(0) substring(0,1) * 转成大写 touppercase() * * 获取剩余字符串, substring(1) tolowercase() */ public static string toconvert(string str){ //定义变量,保存首字母,和剩余字符 string first = str.substring(0,1); string after = str.substring(1); //调用string类方法,大写,小写转换 first = first.touppercase(); after = after.tolowercase(); return first+after; } }
- a: 题目分析
13string类练习_3
- a: 查询大字符串中，出现指定小字符串的次数
- a: 题目分析
- 在大串中，查找小串出现的位置，出现了就次数+1
- 在上次小串出现位置的后面继续查找，需要更改大串的内容为上次未查询到的字符串。
- 回到第一步，继续查找小串出现的位置，直到大串中查询不到小串为止
- b: 解题步骤
- 略
- c: 案例代码
package cn.itcast.demo02; public class stringtest { public static void main(string[] args) { system.out.println(getstringcount("hellojava,nijavahaojava,javazhenbang", "java")); } /* * 获取一个字符串中,另一个字符串出现的次数 * 思想: * 1. indexof到字符串中到第一次出现的索引 * 2. 找到的索引+被找字符串长度,截取字符串 * 3. 计数器++ */ public static int getstringcount(string str, string key){ //定义计数器 int count = 0; //定义变量,保存indexof查找后的索引的结果 int index = 0; //开始循环找,条件,indexof==-1 字符串没有了 while(( index = str.indexof(key) )!= -1){ count++; //获取到的索引,和字符串长度求和,截取字符串 str = str.substring(index+key.length()); } return count; } }
- a: 题目分析
14stringbuffer特点可变字符数组
- a:stringbuffer类概述
- 通过jdk提供的api，查看stringbuffer类的说明
- 线程安全的可变字符序列
- 底层采用字符数组实现,初始容量为16
- b:stringbuffer和string的区别
- string是一个不可变的字符序列
- stringbuffer是一个可变的字符序列
15stringbuffer类的方法
- a: stringbuffer类的方法
- a: 方法介绍
- stringbuffer append(), 将任意类型的数据,添加缓冲区
- append 返回值,写return this
- 调用者是谁,返回值就是谁
- delete(int start,int end): 删除缓冲区中字符
- 开始索引包含,结尾索引不包含
- insert(int index, 任意类型): 将任意类型数据,插入到缓冲区的指定索引上
- replace(int start,int end, string str): 将指定的索引范围内的所有字符,替换成新的字符串
- reverse(): 将缓冲区中的字符反转
- string tostring(): 继承object,重写tostring()
- 将缓冲区中的所有字符,变成字符串
- stringbuffer append(), 将任意类型的数据,添加缓冲区
- b: 案例代码
public class stringbufferdemo { public static void main(string[] args) { function_5(); } /* * stringbuffer类的方法 * string tostring() 继承object,重写tostring() * 将缓冲区中的所有字符,变成字符串 */ public static void function_5(){ stringbuffer buffer = new stringbuffer(); buffer.append("abcdef"); buffer.append(12345); //将可变的字符串缓冲区对象,变成了不可变string对象 string s = buffer.tostring(); system.out.println(s); } /* * stringbuffer类的方法 * reverse() 将缓冲区中的字符反转 */ public static void function_4(){ stringbuffer buffer = new stringbuffer(); buffer.append("abcdef"); buffer.reverse(); system.out.println(buffer); } /* * stringbuffer类方法 * replace(int start,int end, string str) * 将指定的索引范围内的所有字符,替换成新的字符串 */ public static void function_3(){ stringbuffer buffer = new stringbuffer(); buffer.append("abcdef"); buffer.replace(1, 4, "q"); system.out.println(buffer); } /* * stringbuffer类方法 insert * insert(int index, 任意类型) * 将任意类型数据,插入到缓冲区的指定索引上 */ public static void function_2(){ stringbuffer buffer = new stringbuffer(); buffer.append("abcdef"); buffer.insert(3, 9.5); system.out.println(buffer); } /* * stringbuffer类方法 * delete(int start,int end) 删除缓冲区中字符 * 开始索引包含,结尾索引不包含 */ public static void function_1(){ stringbuffer buffer = new stringbuffer(); buffer.append("abcdef"); buffer.delete(1,5); system.out.println(buffer); } /* * stringbuffer类方法 * stringbuffer append, 将任意类型的数据,添加缓冲区 * append 返回值,写return this * 调用者是谁,返回值就是谁 */ public static void function(){ stringbuffer buffer = new stringbuffer(); //调用stringbuffer方法append向缓冲区追加内容 buffer.append(6).append(false).append('a').append(1.5); system.out.println(buffer); } }
- a: 方法介绍
16stringbuilder类
- a:stringbuilder的概述
- 通过查看api了解一下stringbuilder类
- b:面试题
- string,stringbuffer,stringbuilder的区别
- stringbuffer和stringbuilder的区别
- stringbuffer是jdk1.0版本的,是线程安全的,效率低
- stringbuilder是jdk1.5版本的,是线程不安全的,效率高
- string和stringbuffer,stringbuilder的区别
- string是一个不可变的字符序列
- stringbuffer,stringbuilder是可变的字符序列
- stringbuffer和stringbuilder的区别
- string,stringbuffer,stringbuilder的区别
17stringbuffer类案例拼接数组
- a: stringbuffer类案例拼接数组
- a: 题目分析
- 定义stringbuffer对象
- 遍历数组,按照格式要求拼接处新的字符串,追加到stringbuffer容器中
- 将stringbuffer中的内容以string的形式返回
- b: 解题步骤
- 略
- c: 案例代码
public class stringbuffertest { public static void main(string[] args) { int[] arr = {4,1,4,56,7,8,76}; system.out.println(tostring(arr)); } /* * int[] arr = {34,12,89,68};将一个int[]中元素转成字符串 * 格式 [34,12,89,68] * string s = "[" * 数组遍历 * s+= arr[i]; * s+"]" * stringbuffer实现,节约内存空间, string + 在缓冲区中,append方法 */ public static string tostring(int[] arr){ //创建字符串缓冲区 stringbuffer buffer = new stringbuffer(); buffer.append("["); //数组遍历 for(int i = 0 ; i < arr.length;i++){ //判断是不是数组的最后一个元素 if(i == arr.length-1){ buffer.append(arr[i]).append("]"); }else{ buffer.append(arr[i]).append(","); } } return buffer.tostring(); } }
- a: 题目分析
作业测试
1.用代码演示string类中的以下方法的用法
(1)boolean isempty(): 判断字符串是不是空串,如果是空的就返回true (2)char charat(int index): 返回索引上的字符 (3)string tolowercase(): 字符串转成小写 (4)string touppercase(): 字符串转成大写 (5)string repalce(char oldchar, char newchar): 将字符串中的老字符,替换为新字符 (6)string repalce(string old, string newstr): 将字符串中的老字符串,替换为新字符串 (7)string trim(): 去掉字符串两端空格
2.分析以下需求，并用代码实现：
(1)定义如下方法public static string getpropertygetmethodname(string property); (2)该方法的参数为string类型，表示用户给定的成员变量的名字，返回值类型为string类型，返回值为成员变量对应的get方法的名字 (3)如：用户调用此方法时给定的参数为"name",该方法的返回值为"getname"
3.分析以下需求，并用代码实现：
(1)定义数字字符串数组{"010","3223","666","7890987","123123"}
(2)判断该数字字符串数组中的数字字符串是否是对称(第一个数字和最后一个数字相等，第二个数字和倒数第二个数字是相等的，依次类推)的，并逐个输出
(3)如：010 是对称的，3223 是对称的，123123 不是对称的
(4)最终打印该数组中对称字符串的个数
提示：循环获取字符串的每一个字符，依次比较第一个和最后一个，第二个和倒数第二个。。。
4.分析以下需求，并用代码实现：
(1)从键盘循环录入录入一个字符串,输入"end"表示结束
(2)将字符串中大写字母变成小写字母，小写字母变成大写字母，其它字符用"*"代替,并统计字母的个数
举例:
键盘录入：hello12345world
输出结果：hello*****world
总共10个字母
5.分析以下需求，并用代码实现：
(1)从键盘循环录入录入一个字符串,输入"end"表示结束
(2)定义一个方法
public object[] deletesubstring(string str1,string str2) {
}
(3)方法功能描述:从str1中删除所有的str2,并返回删除后的结果,返回结果为object[]数组
* 该数组的第一个元素为删除所有的str2后的最终的字符串
* 该数组的第二个元素为删除的str2的个数
6.关于string类的练习题，分析运行结果？
public class test01 {
public static void main(string[] args) {
//demo1();
//demo2();
//demo3();
//demo4();
demo5();
}
private static void demo5() {
string s1 = "ab";
string s2 = "abc";
string s3 = s1 + "c";
system.out.println(s3 == s2);
system.out.println(s3.equals(s2)); //true
}
private static void demo4() {
//byte b = 3 + 4; //在编译时就变成7,把7赋值给b,常量优化机制
string s1 = "a" + "b" + "c";
//java中有常量优化机制,在编译时期就能确定s2的值为"abc",所以编译时期,在常量池中创建"abc"
string s2 = "abc";//执行到这里时常量池中已经有了"abc",所以就不再创建,
//所以s1和s2指向的是常量池中同一个字符串常量"abc"
system.out.println(s1 == s2); //true,java中有常量优化机制
system.out.println(s1.equals(s2)); //true
}
private static void demo3() {//==比较的是地址值
string s1 = new string("abc"); //录的是堆内存对象的地址值
string s2 = "abc"; //记录的是常量池中的地址值
system.out.println(s1 == s2); //false
system.out.println(s1.equals(s2)); //true
}
private static void demo2() {
//创建几个对象
//创建两个对象,一个在常量池中,一个在堆内存中
string s1 = new string("abc");
system.out.println(s1);
}
private static void demo1() { //常量池中没有这个字符串对象,就创建一个,如果有直接用即可
string s1 = "abc";
string s2 = "abc";
system.out.println(s1 == s2); //==号比较的是地址值,true
system.out.println(s1.equals(s2)); //比较的是字符串的内容:true
}
}