目录
一、常用方法
1、字符串构造
2、String对象的比较
(1)、equals方法
(2)、compareTo方法
(3)、compareToIgnoreCase方法(忽略大小写进行比较)
3、字符串查找
4、转化
(1)数值和字符串转化
编辑
(2)大小写转换
(3)字符串转数组
(4)格式化
5、字符串替换
6、字符串拆分
7、字符串截取
8、其他操作方法
二、String的不可变性
三、StringBuffer和StingBuilder
1、方法:
2、String、StringBuffer、StringBuilder的区别
三种构造方法
(1)、直接赋值
String s1 = "hello world";
System.out.println(s1);
(2)、创建出新的对象
String s2 = new String("hello");
System.out.println(s2);
(3)、使用字符数组进行构造
char[] ch = {'h','e','l','l','o'};
String s3 = new String(ch);
System.out.println(s3);
三个输出效果如下:
对于基本变量,可以直接用 “==, <, >, <=, >= ”来进行比较,但对于引用类型变量,不可以直接使用上面的表达式来比较,如图:
代码:
String s1 = new String("hello"); String s2 = new String("hello"); System.out.println(s1 == s2);
s1和s2的内容都是一样的,为啥下面输出false呢?
原因是s1和s2是引用类型,使用上述表达式进行比较,比较的是两个对象的地址,两个对象是不同的,地址自然也是不同的。
那么怎么可以比较引用对象的内容呢?有以下方法:
按照字典序比较,字典序:字符大小。
Object的equals默认是按 “==” 进行比较的,如图:
所以类都默认继承Object类,String继承Object类,重写了equals方法,如图:
方法的使用:
代码:
String s1 = new String("hello"); String s2 = new String("hello"); System.out.println(s1.equals(s2)); String s3 = new String("Hello"); System.out.println(s1.equals(s3));
执行效果:
按照字典序比较,和equals方法不同的是:equals返回的是boolean类型,而compareTo返回的是int类型,具体比较方式:
1、先按照字典序大小比较,如果出现不相等的字符,直接返回这两个字符的大小差值。
2、如果前k个字符相同,返回两个字符串长度差值。
方法内部:
public int compareTo(String anotherString) { int len1 = value.length; int len2 = anotherString.value.length; int lim = Math.min(len1, len2); char v1[] = value; char v2[] = anotherString.value; int k = 0; while (k < lim) { char c1 = v1[k]; char c2 = v2[k]; if (c1 != c2) { return c1 - c2; } k++; } return len1 - len2; }
方法使用:
代码:
String s1 = new String("ab"); String s2 = new String("ac"); String s3 = new String("ab"); 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
执行效果:
与compareTo方法一样,不过忽略大小写
方法内部:
public static final Comparator
CASE_INSENSITIVE_ORDER = new CaseInsensitiveComparator(); private static class CaseInsensitiveComparator implements Comparator , java.io.Serializable { // use serialVersionUID from JDK 1.2.2 for interoperability private static final long serialVersionUID = 8575799808933029326L; public int compare(String s1, String s2) { int n1 = s1.length(); int n2 = s2.length(); int min = Math.min(n1, n2); for (int i = 0; i < min; i++) { char c1 = s1.charAt(i); char c2 = s2.charAt(i); if (c1 != c2) { c1 = Character.toUpperCase(c1); c2 = Character.toUpperCase(c2); if (c1 != c2) { c1 = Character.toLowerCase(c1); c2 = Character.toLowerCase(c2); if (c1 != c2) { // No overflow because of numeric promotion return c1 - c2; } } } } return n1 - n2; } 方法的使用:
代码:
String s1 = new String("hello"); String s2 = new String("Hello"); System.out.println(s1.compareToIgnoreCase(s2));
执行效果:
方法 功能 char charAt(int index) 返回index位置上字符,如果index为负数或者越界,抛出
IndexOutOfBoundsException异常int indexOf(int ch) 返回ch第一次出现的位置,没有返回-1 int indexOf(int ch, int
fromIndex)从fromIndex位置开始找ch第一次出现的位置,没有返回-1 int indexOf(String str) 返回str第一次出现的位置,没有返回-1 int indexOf(String str, int
fromIndex)从fromIndex位置开始找str第一次出现的位置,没有返回-1 int lastIndexOf(int ch) 从后往前找,返回ch第一次出现的位置,没有返回-1 int lastIndexOf(int ch, int
fromIndex)从fromIndex位置开始找,从后往前找ch第一次出现的位置,没有返
回-1int lastIndexOf(String str) 从后往前找,返回str第一次出现的位置,没有返回-1 int lastIndexOf(String str, int
fromIndex)从fromIndex位置开始找,从后往前找str第一次出现的位置,没有返
回-1
数值转字符串:
String s1 = String.valueOf(1234); String s2 = String.valueOf(12.34); System.out.println(s1); System.out.println(s2); System.out.println("=============="); String s3 = String.valueOf(true); String s4 = String.valueOf(new Student("Hanmeimei", 18)); System.out.println(s3); System.out.println(s4);
整型转换为字符串型的内部代码:
public static String valueOf(int i) { return Integer.toString(i); }
double类型转换为字符串型代码:
public static String valueOf(double d) { return Double.toString(d); }
boolean转换为字符串的内部代码:
public static String valueOf(boolean b) { return b ? "true" : "false"; }
引用类型转换为字符串型的内部代码:
public static String valueOf(Object obj) { return (obj == null) ? "null" : obj.toString(); }
字符串转换为整型 / double类型:
代码:
int data1 = Integer.parseInt("1234"); Double data2 = Double.parseDouble("12.34");
如图,执行效果:
代码:
String s1 = "hello"; String s2 = "HELLO"; //小写转大写 System.out.println(s1.toUpperCase()); //大写转小写 System.out.println(s2.toLowerCase());
执行效果:
代码:
//字符串转数组 char[] ch = s1.toCharArray(); //数组转字符串 String s2 = new String(ch);
执行效果
代码:
String s = String.format("%d-%d-%d", 2023, 11, 21);
执行效果:
使用一个新的字符串替换旧的字符串,方法如下:
方法 | 功能 |
String replaceAll(String regex, String replacement) | 替换所有的指定内容 |
String replaceFirst(String regex, String replacement) | 替换首个内容 |
代码:
String str = "hello world"; System.out.println(str.replaceAll("l", "-")); System.out.println(str.replaceFirst("l", "-"));
执行效果:
可以将一个完整的字符串按照指定的分隔符划分成若干个字符子串
方法 | 功能 |
String[] split(String regex) | 将字符串全部拆分 |
String[] split(String regex, int limit) | 将字符串以指定的格式,拆分为limit组 |
代码:
String s1 = "hello world hello bit"; String[] result = s1.split(" "); for(String x : result) { System.out.println(x); }
字符串的部分拆分代码:
String s1 = "hello world hello bit"; String[] result = s1.split(" ", 2); for(String x : result) { System.out.println(x); }
拆分IP地址:
String s1 = "192.168.1.1"; String[] result = s1.split("\\."); for(String x : result) { System.out.println(x); }
执行效果:
注意:要写划分ip地址,在字符串里写进转义字符,在字符串里,两个 “ \\ ” 代表一个 “ \ ”
1. 字符"|","*","+"都得加上转义字符,前面加上 "\\" .
2. 而如果是 "\" ,那么就得写成 "\\\\" .
3. 如果一个字符串中有多个分隔符,可以用"|"作为连字符.如下:
String s1 = "192.16-8.1.1"; String[] result = s1.split("\\.|-"); for(String x : result) { System.out.println(x); }
代码示例: 多次拆分
String str = "name=zhangsan&age=18" ; String[] result = str.split("&") ; for (int i = 0; i < result.length; i++) { String[] temp = result[i].split("=") ; System.out.println(temp[0]+" = "+temp[1]); }
从一个完整的字符串截取出部分内容,方法如下:
方法 | 功能 |
String substring(int beginIndex) | 从指定索引截取到结尾 |
String substring(int beginIndex, int endIndex) | 截取部分内容 |
代码:
String s = "helloworld"; System.out.println(s.substring(5)); System.out.println(s.substring(0, 5));
执行效果:
注意:区间是是前闭后开的规则,上面的第二个substring语句,是 [0,5)。所以不包含5下标。
方法 | 功能 |
String trim() | 去掉字符串中的左右空格,保留中间空格 |
String toUpperCase() | 字符串转大写 |
String toLowerCase() | 字符串转小写 |
trim 会去掉字符串开头和结尾的空白字符(空格, 换行, 制表符等).
后面两个函数只转换字母
String是一种不可变对象. 字符串中的内容是不可改变。字符串不可被修改,是因为:
1. String类在设计时就是不可改变的,String类实现描述中已经说明了
String类中的字符实际保存在内部维护的value字符数组中,该图还可以看出:
1. String类被final修饰,表明该类不能被继承。
2. value被修饰被final修饰,表明value自身的值不能改变,即不能引用其它字符数组,但是其引用空间中的内容可以修改。
2. 所有涉及到可能修改字符串内容的操作都是创建一个新对象,改变的是新对象
比如 replace 方法:
原因不是final,
final修饰类表明该类不想被继承,final修饰引用类型表明该引用变量不能引用其他对象,但是其引用对象中的内容是可以修改的
代码验证如下:final int array[] = {1,2,3,4,5}; array[0] = 100; System.out.println(Arrays.toString(array)); //array = new int[]{4,5,6}; //java: 无法为最终变量array分配值
执行效果:
注意:尽量避免直接对String类型对象进行修改,因为String类是不能修改的,所有的修改都会创建新对象,效率非常低下,尽量避免对String的直接修改,如果要修改建议尽量使用StringBuffer或者StringBuilder。
方法 | 说明 |
StringBuff append(String str) |
在尾部追加,相当于String的+=,可以追加:boolean、char、char[]、 double、float、int、long、Object、String、StringBuff的变量 |
char charAt(int index) | 获取index位置的字符 |
int length() | 获取字符串的长度 |
int capacity() | 获取底层保存字符串空间总的大小 |
void ensureCapacity(int mininmumCapacity) |
扩容 |
void setCharAt(int index, char ch) |
将index位置的字符设置为ch |
int indexOf(String str) | 返回str第一次出现的位置 |
int indexOf(String str, int fromIndex) |
从fromIndex位置开始查找str第一次出现的位置 |
int lastIndexOf(String str) | 返回最后一次出现str的位置 |
int lastIndexOf(String str, int fromIndex) |
从fromIndex位置开始找str最后一次出现的位置 |
StringBuff insert(int offset, String str) |
在offset位置插入:八种基类类型 & String类型 & Object类型数据 |
StringBuffer deleteCharAt(int index) |
删除index位置字符 |
StringBuffer delete(int start, int end) |
删除[start, end)区间内的字符 |
StringBuffer replace(int start, int end, String str) |
将[start, end)位置的字符替换为str |
String substring(int start) | 从start开始一直到末尾的字符以String的方式返回 |
String substring(int start,int end) |
将[start, end)范围内的字符以String的方式返回 |
StringBuffer reverse() | 反转字符串 |
String toString() | 将所有字符按照String的方式返回 |
String和StringBuilder最大的区别在于String的内容无法修改,而StringBuilder的内容可以修改。
和StringBuffer的区别也是。频繁修改字符串的情况考虑使用StringBuilder / StringBuffer。
(1)String的内容不可修改,StringBuffer和StringBuilder的内容可修改。
(2)StringBuffer和StringBuilder的大部分功能一样。
(3)StringBuffer采用同步处理,属于线程安全操作,StringBuilder未采用同步处理,不属于线程安全操作。