Java之String 类的学习
目录
2. boolean equals(Object anObject) 方法：按照字典序比较
3. int compareTo(String s) 方法: 按照字典序进行比较
4. int compareToIgnoreCase(String str) 方法：与compareTo方式相同，但是忽略大小写比较
1. String类的重要性
在C语言中要表示字符串只能使用字符数组或者字符指针但是这种将数据和操作数据方法分离开的方式不符合面相对象的思想，而字 符串应用又非常广泛，因此Java语言专门提供了String
2. 常用方法
2.1 字符串常用3种构造
public static void main(String[] args) {
// 使用常量串构造
String s1 = "hello bit";
System.out.println(s1);
// 直接newString对象
String s2 = new String("hello bit");
System.out.println(s1);
// 使用字符数组进行构造
char[] array = {'h','e','l','l','o','b','i','t'};
String s3 = new String(array);
System.out.println(s1);
}2.2 String对象的4种比较
1. ==比较是否引用同一个对象
public static void main(String[] args) {
2. boolean equals(Object anObject) 方法：按照字典序比较
字典序：字符大小的顺序
String类重写了父类Object中equals方法，Object中equals默认按照==比较，String重写equals方法后，按照
如下规则进行比较，比如： s1.equals(s2)
int a = 10;
int b = 20;
int c = 10;
// 对于基本类型变量，==比较两个变量中存储的值是否相同
System.out.println(a == b); // false
System.out.println(a == c); // true
// 对于引用类型变量，==比较两个引用变量引用的是否为同一个对象
String s1 = new String("hello");
String s2 = new String("hello");
String s3 = new String("world");
String s4 = s1;
System.out.println(s1 == s2); // false
System.out.println(s2 == s3); // false
System.out.println(s1 == s4); // true
}2. boolean equals(Object anObject) 方法：按照字典序比较
public boolean equals(Object anObject) {
// 1. 先检测this 和 anObject 是否为同一个对象比较，如果是返回true
if (this == anObject) {
return true;
}
// 2. 检测anObject是否为String类型的对象，如果是继续比较，否则返回false
if (anObject instanceof String) {
// 将anObject向下转型为String类型对象
String anotherString = (String)anObject;
int n = value.length;
// 3. this和anObject两个字符串的长度是否相同，是继续比较，否则返回false
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
// 4. 按照字典序，从前往后逐个字符进行比较
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
public static void main(String[] args) {
String s1 = new String("hello");
String s2 = new String("hello");
String s3 = new String("Hello");
// s1、s2、s3引用的是三个不同对象，因此==比较结果全部为false
System.out.println(s1 == s2); // false
System.out.println(s1 == s3); // false
// equals比较：String对象中的逐个字符
// 虽然s1与s2引用的不是同一个对象，但是两个对象中放置的内容相同，因此输出true
// s1与s3引用的不是同一个对象，而且两个对象中内容也不同，因此输出false
System.out.println(s1.equals(s2)); // true
System.out.println(s1.equals(s3)); // false
}3. int compareTo(String s) 方法: 按照字典序进行比较
与
equals
不同的是，
equals
返回的是
boolean
类型，而
compareTo
返回的是
int
类型。具体比较方式：
1.
先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值
2.
如果前
k
个字符相等
(k
为两个字符长度最小值
)
，返回值两个字符串长度差值
public static void main(String[] args) {
String s1 = new String("abc");
String s2 = new String("ac");
String s3 = new String("abc");
String s4 = new String("abcdef");
System.out.println(s1.compareTo(s2)); // 不同输出字符差值-1
System.out.println(s1.compareTo(s3)); // 相同输出 0
System.out.println(s1.compareTo(s4)); // 前k个字符完全相同，输出长度差值 -3
}4. int compareToIgnoreCase(String str) 方法：与compareTo方式相同，但是忽略大小写比较
public static void main(String[] args) {
String s1 = new String("abc");
String s2 = new String("ac");
String s3 = new String("ABc");
String s4 = new String("abcdef");
System.out.println(s1.compareToIgnoreCase(s2)); // 不同输出字符差值-1
System.out.println(s1.compareToIgnoreCase(s3)); // 相同输出 0
System.out.println(s1.compareToIgnoreCase(s4)); // 前k个字符完全相同，输出长度差值 -3
}方法整合+分析代码实例
public class MainCompare {
public static void main4(String[] args) {
String jkl1 = "Abcd";
String jkl2 = "abcd";
//忽略大小写比较大小
System.out.println(jkl1.compareToIgnoreCase(jkl2));
}
public static void main3(String[] args) {
//compareTo函数利用ASLLOC的值来比较字符串大小
//ifA>B,那么返回负数,<返回正数,=返回0
String A = "hello";
String B = "world";
String C = "world";
System.out.println(A.compareTo(B));
System.out.println(B.compareTo(A));
System.out.println(B.compareTo(C));
/*
* compareTo函数比较逻辑：
* 1.如果两个字符串的长度是一样的，那么第一个不一样的字符的大小就是整个字符串的大小
* 2.如果两个不一样长，那么优先比较两者的差值，在这个差值范围内，有不一样的字符就能
* 比较出来，但如果都一样，那么谁长谁就大
* */
}
public static void main2(String[] args) {
String jkl1 = "hello";
String jkl2 = "hello";
//没有new来修饰的话,输出true
System.out.println(jkl1 == jkl2);
}
public static void main1(String[] args) {
String str1 = new String("hello");
String str2 = new String("hello");
//new两者开辟空间位置不一样,所以输出false
System.out.println(str1 == str2);
System.out.println("==============");
//两者内容一样,输出true
//因为equal被重写
System.out.println(str1.equals(str2));
}
}
2.3 字符串查找
public class MainSeek {
public static void main(String[] args) {
String jkl1 = "abcd";
//从前往后找输出数组字符串指定位置的字符 c
char ch = jkl1.charAt(2);
System.out.println(ch);
System.out.println("==============");
//indexOf前往后位置查找,找不到返回-1
int index = jkl1.indexOf('c',3);
System.out.println(index);
System.out.println("==============");
//lastIndexOf从后往前找
String jkl2 = "abcdabcd";
//由于lastIndexOf方法寻找的是 最后一次出现 的指定字符
int index2 = jkl2.lastIndexOf('b');
//从6的位置下标往前找
int index3 = jkl2.lastIndexOf('c',5);
System.out.println(index2);
System.out.println(index3);
}
}
2.4 字符串转化
public class MainChange {
//4格式化
public static void main(String[] args) {
String s = String.format("%d-%d-%d", 2019, 9,14);
System.out.println(s);
}
//3字符串转数组
public static void main3(String[] args) {
String s = "hello";
// 字符串转数组
char[] ch = s.toCharArray();
for (int i = 0; i < ch.length; i++) {
System.out.print(ch[i]);
}
System.out.println();
// 数组转字符串
String s2 = new String(ch);
System.out.println(s2);
}
//2大小写之间的转换
public static void main2(String[] args) {
String s1 = "hello";
String s2 = "HELLO";
// 小写转大写,开辟空间产生了新的字符
System.out.println(s1.toUpperCase());
// 大写转小写
System.out.println(s2.toLowerCase());
}
//1数组和字符串的转换
static class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "姓名:" + name + ", 年龄:" + age;
}
}
// 可以使用静态类型static的main能运行
public static void main1(String[] args) {
// 数字转字符串
// valueOf函数会重写
String s1 = String.valueOf(1234);
String s2 = String.valueOf(12.34);
String s3 = String.valueOf(true);
// 构造Student重写toString方法，返回你想要的字符串表示。
String s4 = String.valueOf(new Student("Hanmeimei", 18));
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
System.out.println(s4);
System.out.println("=================================");
// 字符串转数字
// 转化成整形
int data1 = Integer.parseInt("1234");
// 转化成Double类型
double data2 = Double.parseDouble("12.34");
System.out.println(data1);
System.out.println(data2);
}
}
2.5字符串替换
public class MainReplace {
public static void main(String[] args) {
String str = "abcdab";
//1把所有的ab换成jkl
//生成空间创造出了新的字符串
String ret = str.replace("ab","jkl");
System.out.println(ret);
System.out.println("=====================");
//2单字符替换
String ret2 = str.replace('a','z');
System.out.println(ret2);
System.out.println("=====================");
//3遇到符合条件的第一个替换
String ret3 = str.replaceFirst("ab","kk");
System.out.println(ret3);
System.out.println("=====================");
//4所有符合条件的进行替换
String ret4 = str.replaceAll("ab","kk");
System.out.println(ret4);
}
}
2.6字符串拆分
public class MainResolution {
public static void main(String[] args) {
String str = "name=zhangsan&age=10";
//以&作为拆分点，拆分结果放在数组里面
String[] strings = str.split("&");
for (int i = 0; i < strings.length; i++) {
System.out.println(strings[i]);
}
System.out.println("=====================");
String str2 = "hello work hello jkl";
//以空格进行分割，分割为2组
String[] strings2 = str2.split(" ",2);
for (int i = 0; i < strings2.length; i++) {
System.out.println(strings2[i]);
}
System.out.println("=====================");
String str3 = "192.44.56.7.8";
//以.进行分割时要添加字符'\\'转义
String[] strings3 = str3.split("\\.");
for (int i = 0; i < strings3.length; i++) {
System.out.println(strings3[i]);
}
System.out.println("=====================");
String str4 = "192\\44\\56\\7\\8";
//以\进行分割时要添加字符'\\\\'转义
String[] strings4 = str4.split("\\\\");
for (int i = 0; i < strings4.length; i++) {
System.out.println(strings4[i]);
}
System.out.println("=====================");
String str5 = "name=zhangsan&age=10";
//=分割为多组数据时
String[] strings5 = str5.split("&|=");
for (int i = 0; i < strings5.length; i++) {
System.out.println(strings5[i]);
}
}
}
2.7字符串截取
public class MainCutOut {
public static void main(String[] args) {
String s = "abcde";
//截取下标为1，输出后面的数
String ret = s.substring(1);
//0下标返回新的对象
String ret2 = s.substring(0);
//指定返回区间
//Java中都是[1,4)
String ret3 = s.substring(1,4);
System.out.println(ret);
System.out.println(ret2);
System.out.println(ret3);
System.out.println("====================");
//取出左右两边的空格,不能去掉中间的空格
String s1 = " abc de ";
System.out.println(s1);
String ret1 = s1.trim();
System.out.println(ret1);
}
}
以上是学习String的相关内容，希望能对正在学习的读者提供帮助
原文地址：https://blog.csdn.net/2301_80176093/article/details/142470780
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！