文章目录
1、常用类
1.1、包装类
1.1.1、包装类的分类
- 针对八种基本数据类型相应的引用类型—包装类
- 有了类的特点,就可以调用类中的方法
1.1.2、包装类和基本数据的转换
package Integer01;
public class Integer01 {
public static void main(String[] args) {
// 演示 int <--> Integer 的装箱和拆箱
// jdk5 前是手动装箱和拆箱
// 手动装箱 int->Integer
int n1 = 100;
Integer integer = new Integer(n1);
Integer integer1 = Integer.valueOf(n1);
// 手动拆箱
// Integer -> int
int i = integer.intValue();
// jdk5 后,就可以自动装箱和自动拆箱
int n2 = 200;
// 自动装箱 int->Integer
Integer integer2 = n2; // 底层使用的是 Integer.valueOf(n2)
// 自动拆箱 Integer->int
int n3 = integer2; // 底层仍然使用的是 intValue()方法
}
}
1.1.3、包装类型和 String 类型的相互转换
package Integer01;
public class WrapperVSString {
public static void main(String[] args) {
// 包装类(Integer) -> String
Integer i = 100; // 自动装箱
// 方式一
String str1 = i + "";
// 方式二
String str2 = i.toString();
// 方式三
String str3 = String.valueOf(i);
// String -> 包装类(Integer)
String str4 = "12345";
// 方式一
Integer i2 = Integer.parseInt(str4); // 使用到自动装箱
// 方式二
Integer i3 = new Integer(str4); // 构造器
}
}
1.1.4、Integer 类和 Character 类的常用方法
package Integer01;
public class WrapperMethod {
public static void main(String[] args) {
System.out.println(Integer.MIN_VALUE); // 返回最小值
System.out.println(Integer.MAX_VALUE); // 返回最大值
System.out.println(Character.isDigit('a')); // 判断是不是数字
System.out.println(Character.isLetter('a')); // 判断是不是字母
System.out.println(Character.isUpperCase('a')); // 判断是不是大写
System.out.println(Character.isLowerCase('a')); // 判断是不是小写
System.out.println(Character.isWhitespace('a')); // 判断是不是空格
System.out.println(Character.toUpperCase('a')); // 转成大写
System.out.println(Character.toLowerCase('A')); // 转成小写
}
}
1.1.5、小练习
package Integer01;
public class WrapperExercise02 {
public static void main(String[] args) {
Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i == j); // false
// 这里主要是看范围 -128 ~ 127 就是直接返回
/*
1. 如果 i 在 IntegerCache.low(-128)~IntegerCache.high(127),就直接从数组返回
2. 如果不在 -128~127,就直接 new Integer(i)
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
*/
Integer m = 1; // 底层 Integer.valueOf(1); -> 阅读源码
Integer n = 1; // 底层 Integer.valueOf(1);
System.out.println(m == n);
// 所以这里主要是看范围 -128 ~ 127 就是直接返回
// 否则就 new Integer(xx);
Integer x = 128; // 底层 Integer.valueOf(1);
Integer y = 128; // 底层 Integer.valueOf(1);
System.out.println(x == y); // False
}
}
1.1.6、Integer 类面试题总结
package Integer01;
public class WrapperExercise03 {
public static void main(String[] args) {
// 示例一
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1 == i2); // false
// 示例二
Integer i3 = new Integer(128);
Integer i4 = new Integer(128);
System.out.println(i3 == i4); // false
// 示例三
Integer i5 = 127; // 底层 Integer.valueOf(127)
Integer i6 = 127; // -128~127
System.out.println(i5 == i6); // true
// 示例四
Integer i7 = 128;
Integer i8 = 128;
System.out.println(i7 == i8); // false
// 示例五
Integer i9 = 127; // Integer.valueOf(127)
Integer i10 = new Integer(127);
System.out.println(i9 == i10); // false
// 示例六
Integer i11 = 127;
int i12 = 127;
// 只有有基本数据类型, 判断的是值是否相同
System.out.println(i11 == i12); // true
// 示例七
Integer i13 = 128;
int i14 = 128;
System.out.println(i13 == i14); // true
}
}
1.2、String 类
1.2.1、String 类的理解和创建对象
package Integer01;
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";
name = "tom";
final char[] value = {'a', 'b', 'c'};
char[] v2 = {'t', 'o', 'm'};
value[0] = 'H';
// value = v2; 不可以修改 value 地址
}
}
1.2.2、创建 String 对象的两种方式
- 方式一:直接赋值 String s = “zhangsan”;
- 方式二:调用构造器 String s = new String(“zhangsan”);
1.2.3、两种创建 String 对象的区别
1、方式一:先从常量池查看是否有“zhangsan” 数据空间,如果有,直接指向;如果没有则重新创建,然后指向,s最终指向的是常量池的空间地址
2、方式二:先在堆中创建空间,里面维护了value属性,指向常量池的zhangsan空间,如果常量池没有"zhangsan",重新创建,如果有,直接通过value指向,最终指向的是堆中的空间地址
1.2.4、小练习
package stringdemo;
public class StringDemo {
public static void main(String[] args) {
String a = "abc";
String b = "abc";
System.out.println(a.equals(b)); // true
System.out.println(a == b); // true
}
}
package stringdemo;
public class StringDemo2 {
public static void main(String[] args) {
String a = new String("abc");
String b = new String("abc");
System.out.println(a.equals(b)); // true
System.out.println(a == b); // false
}
}
package stringdemo;
public class StringDemo3 {
public static void main(String[] args) {
String a = "zhangsan"; // a 指向常量池的 zhangsan
String b = new String("zhangsan"); // b 指向堆中的对象
System.out.println(a.equals(b)); // true
System.out.println(a == b); // false
System.out.println(a == b.intern()); // true
System.out.println(b == b.intern()); // false
}
}
当调用 intern 方法时,如果池已经包含一个等于此 String 对象的字符串(用 equals(Object)方法确定),则返回池中的字符串,否则将此 String 对象添加到池中,并返回此 String 对象的引用
b.intern() 方法最终返回的是常量池的地址(对象)
package stringdemo;
public class StringDemo4 {
public static void main(String[] args) {
String s1 = "python"; // 指向常量池 python
String s2 = "java"; // 指向常量池 java
String s3 = "java"; // 指向常量池 java
String s4 = new String("java"); // 指向堆中对象
System.out.println(s2 == s4); // false
System.out.println(s2 == s3); // true
System.out.println(s2.equals(s4)); // true
System.out.println(s1 == s2); // false
}
}
package stringdemo;
public class StringDemo5 {
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "zhangsan";
Person p2 = new Person();
p2.name = "zhangsan";
System.out.println(p1.name.equals(p2.name)); // true
System.out.println(p1.name == p2.name); // true
System.out.println(p1.name == "zhangsan"); // true
String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1 == s2); // false
}
}
class Person {
public String name;
}
1.2.5、字符串的特性
- String 是一个 final类,代表不可变的字符序列
- 字符串是不可变的,一个字符串对象一旦被分配,其内容是不可变的
String s1 = “hello”;
s1 = “haha”;
一共创建了两个对象
1.2.6、面试题
1.2.7、String 类的常见方法
1.2.8、String 类的常见方法一览
package stringdemo;
public class StringMethod01 {
public static void main(String[] args) {
// 1.equals 比较内容是否相同, 区分大小写
String str1 = "hello";
String str2 = "Hello";
System.out.println(str1.equals(str2)); // false
// 2.equalsIgnoreCase 忽略大小写的判断内容是否相等
String name = "jack";
if ("Jack".equalsIgnoreCase(name)) {
System.out.println("Success!");
} else {
System.out.println("Failure!");
}
// 3.length 获取字符的个数, 字符串的长度
String username = "allen";
System.out.println(username.length()); // 5
String hobby = "旅游";
System.out.println(hobby.length()); // 2
// 4.indexOf 获取字符在字符串对象中第一次出现的索引, 索引从 0 开始, 如果找不到, 返回-1
String s1 = "wer@terwe@g";
int index = s1.indexOf('@');
System.out.println(index); // 3
System.out.println("weIndex=" + s1.indexOf("we")); // weIndex=0
// 5.lastIndexOf 获取字符在字符串中最后一次出现的索引, 索引从 0 开始, 如果找不到, 返回-1
s1 = "wer@terwe@g@";
index = s1.lastIndexOf('@');
System.out.println(index); // 11
System.out.println("ter 的位置=" + s1.lastIndexOf("ter")); // ter 的位置=4
// 6.substring 截取指定范围的子串
String name1 = "hello,张三";
// 下面 name1.substring(6) 从索引 6 开始截取后面所有的内容
System.out.println(name1.substring(6)); // 截取后面的字符, 输出 "张三"
System.out.println(name1.substring(0, 5)); // 表示从索引 0 开始截取, 截取到索引 5-1=4的位置, 输出 "hello"
System.out.println(name1.substring(2, 5)); // llo
}
}
package stringdemo;
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 = "hello";
s1 = s1.concat(" world").concat(" together").concat("!");
System.out.println(s1); // hello world together!
// 4.replace 替换字符串中的字符
s1 = "宝玉 and 林黛玉 林黛玉 林黛玉";
// 在 s1 中, 将 所有的 林黛玉 替换成薛宝钗
// s1.replace() 方法执行后, 返回的结果才是替换过的, 注意对 s1 没有任何影响
String s2 = s1.replace("林黛玉", "薛宝钗");
System.out.println(s1); // 宝玉 and 林黛玉 林黛玉 林黛玉
System.out.println(s2); // 宝玉 and 薛宝钗 薛宝钗 薛宝钗
// 5.split 分割字符串, 对于某些分割字符, 我们需要 转义比如 | \\等
String poem = "锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦";
// (1). 以逗号为标准对 poem 进行分割, 返回一个数组
// (2). 在对字符串进行分割时, 如果有特殊字符, 需要加入 转义符 \
String[] split = poem.split(",");
System.out.println("===分割后的数据===");
for (int i = 0; i < split.length; i++) {
System.out.println(split[i]); // 锄禾日当午
// 汗滴禾下土
// 谁知盘中餐
// 粒粒皆辛苦
}
poem = "E:\\aaa\\bbb";
split = poem.split("\\\\");
System.out.println("===分割后的数据===");
for (int i = 0; i < split.length; i++) {
System.out.println(split[i]); // E:
// aaa
// bbb
}
// 6.toCharArray 转换成字符数组
s = "happy";
char[] chs = s.toCharArray();
for (int i = 0; i < chs.length; i++) {
System.out.println(chs[i]);
}
// 7.compareTo 比较两个字符串的大小, 如果前者大, 则返回正数, 后者大, 则返回负数, 如果相等, 返回 0
// (1) 如果长度相同, 并且每个字符也相同, 就返回 0
// (2) 如果长度相同或者不相同, 但是在进行比较时, 可以区分大小
// 就返回 if (c1 != c2) {
// return c1 - c2;
// }
// (3) 如果前面的部分都相同, 就返回 str1.len - str2.len
String a = "jcck";
String b = "jack";
System.out.println(a.compareTo(b)); // 返回值是 'c' - 'a' = 2 的值
// 8.format 格式字符串
/* 占位符有:
%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); // 我的姓名是john, 年龄是10, 成绩是56.857, 性别是男, 希望大家喜欢我!
// (1). %s , %d , %.2f %c 称为占位符
// (2). 这些占位符由后面变量来替换
// (3). %s 表示后面由 字符串来替换
// (4). %d 是整数来替换
// (5). %.2f 表示使用小数来替换, 替换后, 只会保留小数点两位, 并且进行四舍五入的处理
// (6). %c 使用 char
String formatStr = "我的姓名是%s, 年龄是%d, 成绩是%.2f, 性别是%c, 希望大家喜欢我!";
String info2 = String.format(formatStr, "lily", 15, 99.6, '女');
System.out.println(info2); // 我的姓名是lily, 年龄是15, 成绩是99.60, 性别是女, 希望大家喜欢我!
}
}