1. 包装类接上——经典面试题2 464
1.1 判读输出
代码在com.stulzl.wrapper_exercise02.包中
Exercise02
package com.stulzl.wrapper_exercise02;
//包装类 经典面试题02 464
public class Exercise02 {
public static void main(String[] args) {
//示例一
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1 == i2);//F//new得对象
//示例二
Integer i3 = new Integer(128);
Integer i4 = new Integer(128);
System.out.println(i3 == i4);//F//new得对象
//示例三
Integer i5 = 127;//底层 Integer.valueOf(127)
Integer i6 = 127;//-128~127
System.out.println(i5 == i6); //T//在范围内
//示例四
Integer i7 = 128;
Integer i8 = 128;
System.out.println(i7 == i8);//F//不在范围内
//示例五
Integer i9 = 127; //Integer.valueOf(127)//在范围内
Integer i10 = new Integer(127);//new的
System.out.println(i9 == i10);//F
//示例六
Integer i11=127;//在范围内
int i12=127;// 只有 有基本数据类型,==判断的是值是否相同
System.out.println(i11==i12); //T
//示例七
Integer i13=128;//在范围内
int i14=128;//只有 有基本数据类型,==判断的是值是否相同
System.out.println(i13==i14);//T
}
}
2. String 类的理解和创建对象 465
1) String对象用于保存字符串,也就是一 组字符序列
2)字符串常量对象是用双引号括起的字符序列。例如: "你好"、"12.97"、 "boy"等
3)字符串的字符使用Unicode字符编码,一个字符(不区分字母还是汉字)占两个字节。
4) String类较常用构造器(其它看手册):
String s1 = new String(); //
String s2 = new String(String original);
String s3 = new String(char[] a);
String s4 = new String(charD a,int startIndex,int count)
代码在com.stulzl.string_.包中
String01
package com.stulzl.string_;
//String类465
public class String01 {
public static void main(String[] args) {
//1.String 对象用于保存字符串,也就是一组字符序列
//2. "jack" 字符串常量, 双引号括起的字符序列
//3. 字符串的字符使用 Unicode 字符编码,一个字符(不区分字母还是汉字)占两个字节
//4. String 类有很多构造器,构造器的重载
// 常用的有 String s1 = new String(); //
//String s2 = new String(String original);
//String s3 = new String(char[] a);
//String s4 = new String(char[] a,int startIndex,int count)
//String s5 = new String(byte[] b)
//5. String 类实现了接口 Serializable【String 可以串行化:可以在网络传输】
// 接口 Comparable [String 对象可以比较大小]
//6. String 是 final 类,不能被其他的类继承
//7. String 有属性 private final char value[]; 用于存放字符串内容
//8. 一定要注意:value 是一个 final 类型, 不可以修改:即 value 不能指向
// 新的地址,但是单个字符内容值是可以变化的
String name = "jack";
final char[] value = {'a','b','c'};
char[] v2 = {'t','o','m'};
value[0] = 'H';//但是值可以修改
//value = v2; //不可以修改 value 地址,因为是final修饰的
}
}
3. 创建 String 对象的两种方式
3.1 两种创建 String 对象的区别466
方式一:直接赋值Strings= "hsp";
方式二:调用构造器String s2 = new String("hsp");
1.方式一:先从常量池查看是否有"hsp"数据空间,如果有,直接指向;如果没有则重新创建,然后指向。s最终指向的是常量池的空间地址;
2.方式二:先在堆中创建空间,里面维护了value属性,指向常量池的hsp空间。如果常量池没有"hsp",重新创建,如果有,直接通过value指向。最终指向的是堆中的空间地址。
3.画出两种方式的内存分布图
4. String类测试题
4.1 练习1 判断输出 466
代码在com.stulzl.string_exercise01.包中
Exercise01
package com.stulzl.string_exercise01;
//String练习466
public class Exercise01 {
public static void main(String[] args) {
String a = "abc";
String b = "abc";
System.out.println(a.equals(b));//t
System.out.println(a==b);//t//a b指向同一对象
}
}
4.2 练习2 判断输出 467
知识点:
当调用 intern方法时,如果池已经包含 个等于此String对象的字符串(用
equals(Object), 方法确定),则返回池中的字符串。 否则,将此String 对象添加到池中, 并返回此String对象的引用
解读: (1) b.intern()方法最终返回的是常量池的地址(对象)
代码在com.stulzl.string_exercise02.包中
Exercise02
package com.stulzl.string_exercise02;
public class Exercise02 {
public static void main(String[] args) {
String a = "hsp"; //a 指向 常量池的 “hsp”
String b =new String("hsp");//b 指向堆中对象
System.out.println(a.equals(b)); //T//值相等
System.out.println(a==b); //F//对象(也就是地址)不同
//b.intern() 方法返回常量池地址
System.out.println(a==b.intern()); //T //b.intern()返回常量池地址,a也指向常量池地址
System.out.println(b==b.intern()); //F //这个b指向堆中对象
}
}
4.3 练习3 判断输出 467
代码在com.stulzl.string_exercise03包中
Exercise03
package com.stulzl.string_exercise03;
//练习3 判断输出 467
public class Exercise03 {
public static void main(String[] args) {
String s1 = "hspedu"; //指向常量池”hspedu”
String s2 = "java"; //指向常量池”java”
String s4 = "java";//指向常量池”java”
String s3 = new String("java");//指向堆中对象
System.out.println(s2 == s3); // F
System.out.println(s2 == s4); //T
System.out.println(s2.equals(s3));//T
System.out.println(s1 == s2); //F
}
}
4.4 练习4 判断输出 468
代码在com.stulzl.string_exercise04包中
Exercise04
package com.stulzl.string_exercise04;
//练习4 判断输出 468
public class Exercise04 {
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "hspedu";
Person p2 = new Person();
p2.name = "hspedu";
System.out.println(p1.name.equals(p2.name));//比较内容: True
//p1.name 和 p2.name都指向常量池"hspedu"的地址
System.out.println(p1.name == p2.name); //T
//p1.name指向常量池中"hspedu"地址,而"hspedu"就在常量池中为同一对象
System.out.println(p1.name == "hspedu"); //T
String s1 = new String("bcde");
String s2 = new String("bcde");
System.out.println(s1==s2); //False
}
}
class Person {
public String name;
}
5. 字符串的特性 469
1) String是一 个final类, 代表不可变的字符序列
2)字符串是不可变的。一个字符串对象一-旦被分配,其内容是不可变的.
5.1 题1 字符串特性面试题 469
5.2 题2 469
代码在com.stulzl.string_exercise05.包中
Exercise05
package com.stulzl.string_exercise05;
//练习5 判断输出 469
public class Exercise05 {
public static void main(String[] args) {
String a = "hello"; //创建 a对象
String b = "abc";//创建 b对象
//总结,就是将hello和abc合成一个helloabc放在常量池中,然后堆中有
// 一个value指向常量池中的helloabc,最后c在指向堆中的value
String c = a + b;
//解读
//1. 先 创建一个 StringBuilder sb = StringBuilder()
//2. 执行 sb.append("hello");
//3. sb.append("abc");
//4. String c= sb.toString()
//最后其实是 c 指向堆中的对象(String) value[] -> 池中 "helloabc"
String d = "helloabc";
System.out.println(c == d);//真还是假? 是false
String e = "hello" + "abc";//直接看池, e指向常量池
System.out.println(d == e);//真还是假? 是true
}
}
6.练习
6.1 练习6 判断输出
代码在com.stulzl.string_exercise06.包中
Exercise06
package com.stulzl.string_exercise06;
//String练习6 判断输出470
public class Exercise06 {
public static void main(String[] args) {
String s1 = "hspedu"; //s1 指向池中的 “hspedu”
String s2 = "java"; // s2 指向池中的 “java”
String s5 = "hspedujava"; //s5 指向池中的 “hspedujava”
String s6 = (s1 + s2).intern();//s6 指向池中的 “hspedujava”
System.out.println(s5 == s6); //T
System.out.println(s5.equals(s6));//T
}
}
6.2 练习7 判断输出 (有难度)470
代码在com.stulzl.string_exercise07.包中
Exercise07
package com.stulzl.string_exercise07;
//String练习7 判断输出470
public class Exercise07 {
public static void main(String[] args) {
}
}
class Test1 {
String str = new String("hsp");//在常量池中hsp,堆中有value指向常量池hsp
final char[] ch = {'j', 'a', 'v', 'a'};//在堆中//数组默认放在堆中
public void change(String str, char ch[]) {
str = "java";//调用方法产生的新栈,这个str会在常量池中创建一个java
ch[0] = 'h';//修改堆中的数组ch第一个元素为h
}
public static void main(String[] args) {
Test1 ex = new Test1();
ex.change(ex.str, ex.ch);//调用方法就会产生一个新栈
System.out.print(ex.str + " and ");//hsp and //因为方法中新创建的str和他没关系
System.out.println(ex.ch);//hava
}
}
7. String常用方法 471
7.1 说明
String类是保存字符串常量的。每次更新都需要重新开辟空间,效率较低,因此java设计者还提供了StringBuilder和StringBuffer来增强String的功能,并提高效率。[后面我们还会详细介绍StringBuilder和StringBuffer]
7.2 String 类的常见方法一览 01 471
equals //判断内容是否相等(区分大小写)
equalslgnoreCase //忽略大小写的判断内容是否相等
length /获取字符的个数,字符串的长度
indexOf //获取字符在字符串中第1次出现的索引,索引从0开始,如果找不到返回-1
lastlndexOf //获取字符在字符串中最后1次出现的索引,索引从0开始,如找不到,返回-1
substring //截取指定范围的子串
trim //去前后空格
charAt:获取某索引处的字符,注意不能使用Str[index]这种方式
代码在com.stulzl.string_method.包中
StringMethod01
package com.stulzl.string_method;
//String常用的方法01 471
public class StringMethod01 {
public static void main(String[] args) {
//1. equals 前面已经讲过了. 比较内容是否相同,区分大小写
String str1 = "hello";
String str2 = "Hello";
System.out.println(str1.equals(str2));//f
// 2.equalsIgnoreCase 忽略大小写的判断内容是否相等
String username = "johN";
if ("john".equalsIgnoreCase(username)) {
System.out.println("Success!");
} else {
System.out.println("Failure!");
}
// 3.length 获取字符的个数,字符串的长度
System.out.println("韩顺平".length());//3
// 4.indexOf 获取字符在字符串对象中第一次出现的索引,索引从0开始,如果找不到,返回-1
String s1 = "wer@terwe@g";
int index = s1.indexOf('@');
System.out.println(index);// 3
System.out.println("weIndex=" + s1.indexOf("er"));//1//也可以多字符
// 5.lastIndexOf 获取字符在字符串中最后一次出现的索引,索引从0开始,如果找不到,返回-1
s1 = "wer@terwe@g@";
index = s1.lastIndexOf('@');
System.out.println(index);//11
System.out.println("ter的位置=" + s1.lastIndexOf("ter"));//4
// 6.substring 截取指定范围的子串
String name = "hello,张三";
//下面name.substring(6) 从索引6开始截取后面所有的内容
System.out.println(name.substring(6));//截取后面的字符
//name.substring(0,5)表示从索引0开始截取,截取到索引 5-1=4位置
System.out.println(name.substring(2,5));//llo,截取到第5-1=4个
}
}
7.3 String 类的常见方法一览 02 472-473
toUpperCase
toLowerCase
concat
replace替换字符串中的字符
split分割宇符串,对于某些分割字符,我们需要转义比如| \\ 等
案例: String poem = "锄禾日当午汗滴禾下土,谁知盘中餐,粒粒皆辛苦";和文件路径.
compareTo //比较两个字符串的大小
toCharArray //转换成字符数组
format //格式字符串%s字符串%c字符%d整型%.2f浮点型
案例,将一个人的信息格式化输出.
代码在com.stulzl.string_method.包中
StringMethod02
package com.stulzl.string_method;
//String常用的方法02 472-473
public class StringMethod02 {
public static void main(String[] args) {
// 1.toUpperCase转换成大写
String s = "heLLo";
System.out.println(s.toUpperCase());//HELLO
// 2.toLowerCase
System.out.println(s.toLowerCase());//hello
// 3.concat拼接字符串
String s1 = "宝玉";
s1 = s1.concat("林黛玉").concat("薛宝钗").concat("together");
System.out.println(s1);//宝玉林黛玉薛宝钗together
// 4.replace 替换字符串中的字符
s1 = "宝玉 and 林黛玉 林黛玉 林黛玉";
String s5 = s1.replace("林黛玉", "薛宝钗");//在s1中,将 所有的 林黛玉 替换成薛宝钗
System.out.println(s5);//宝玉 and 薛宝钗 薛宝钗 薛宝钗
// 解读: s1.replace() 方法执行后,返回的结果才是替换过的.
// 注意对 s1没有任何影响
String s11 = s1.replace("宝玉", "jack");//在s1中,将 所有的 宝玉 替换成jack
System.out.println(s1);//宝玉 and 林黛玉 林黛玉 林黛玉
System.out.println(s11);//jack and 林黛玉 林黛玉 林黛玉
// 5.split 分割字符串, 对于某些分割字符,我们需要 转义比如 | \\等
String poem = "锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦";
String[] split = poem.split(",");
//解读:
// 1. 以 , 为标准对 poem 进行分割 , 返回一个数组
// 2. 在对字符串进行分割时,如果有特殊字符,需要加入 转义符 \
poem = "E:\\aaa\\bbb";
split = poem.split("\\\\");
System.out.println("==分割后内容===");
for (int i = 0; i < split.length; i++) {
System.out.println(split[i]);
}
// 6.toCharArray 转换成字符数组
String s4 = "happy";
char[] chs = s4.toCharArray();
for (int i = 0; i < chs.length; i++) {
System.out.println(chs[i]);
}
// 7.compareTo 比较两个字符串的大小,如果前者大,
// 则返回正数,后者大,则返回负数,如果相等,返回0
// 解读
//如果长度相同,但是个别内容不同,就直接相减(结果为 正数 或 负数)
//如果长度不同,但是前边内容相同,就是长度相减
//如果长度不同前边内容也不相同,就按照内容相减
String a = "jcck";
String b = "jack";
System.out.println(a.compareTo(b)); // 返回值是 'c' - 'a' = 2的值
// 8.format 格式字符串 473
/* 占位符有:
* %s 字符串 %c 字符 %d 整型 %.2f 浮点型
*
*/
String name = "john";
int age = 10;
double score = 56.857;
char gender = '男';
//将所有的信息都拼接在一个字符串.普通方法
String info =
"我的姓名是" + name + "年龄是" + age + ",成绩是" + score + "性别是" + gender + "。希望大家喜欢我!";
System.out.println(info);
//解读
//1. %s , %d , %.2f %c 称为占位符
//2. 这些占位符由后面变量来替换
//3. %s 表示后面由 字符串来替换
//4. %d 是整数来替换
//5. %.2f 表示使用小数来替换,替换后,因为.2f只会保留小数点两位, 并且进行四舍五入的处理
//6. %c 使用char 类型来替换
String formatStr = "我的姓名是%s 年龄是%d,成绩是%.2f 性别是%c.希望大家喜欢我!";
String info2 = String.format(formatStr, name, age, score, gender);
System.out.println("info2=" + info2);
}
}