熬夜死磕Java类三剑客字符串时间数学计算,耗费大仙1024根头发,还不懂你只能回家养猪了!
Posted Java架构师-大仙
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了熬夜死磕Java类三剑客字符串时间数学计算,耗费大仙1024根头发,还不懂你只能回家养猪了!相关的知识,希望对你有一定的参考价值。
一、String类
java.lang.String
类的使用
(一)概述
String:字符串,使用一对""引起来表示。
1.String声明为final的,不可被继承
2.String 实现了 Serializable 接口:表示字符串是支持序列化的。 实现了 Comparable 接口:表示String可以比较大小
3.String内部定义了 final char[] value 用于存储字符串数据
4.String:代表不可变的字符序列。简称:不可变性。
体现:
4.1.当对字符串重新赋值时,需要重写指定内存区域赋值,不能使用原有的value进行赋值。
4.2.当对现有的字符串进行连接操作时,也需要重新指定内存区域赋值,不能使用原有的value进行赋值。
4.3.当调用String的 replace() 方法修改指定字符或字符串时,也需要重新指定内存区域赋值,不能使用原有的value进行赋值。
5.通过字面量的方式(区别于new给一个字符串赋值,此时的字符串值声明在字符串常量池中)。
6.字符串常量池中是不会存储相同内容(使用String类的equals()比较,返回true)的字符串的)。
(二)String的特性
String类:代表字符串。Java程序中的所有字符串字面值(如"abc")都作为此类的实例实现。 String是一个final类,代表不可变的字符序列。 字符串是常量,用双引号引起来表示。它们的值在创建之后不能更改。 String对象的字符内容是存储在一个字符数组vaue[]中的。
String源码构造器:
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[];
/** Cache the hash code for the string */
private int hash; // Default to 0
1. String的不可变性
1.1 说明:
1.当对字符串重新赋值时,需要重写指定内存区域赋值,不能使用原有的value进行赋值。
2.当对现的字符串进行连接操作时,也需要重新指定内存区域赋值,不能使用原有的value进行赋值。
3.当调用String的 replace() 方法修改指定字符或字符串时,也需要重新指定内存区域赋值,不能使用原有的value进行赋值。
1.2 代码举例:
String s1 = "abc";//通过字面量的定义方式
String s2 = "def";
s1 = "hello";
System.out.println(s1 == s2); //false 比较s1与s2的地址值
System.out.println(s1);//hello
System.out.println(s2);//def
System.out.println("-----------------------");
String s3 = "abc";
s3 += "def";
System.out.println(s3);//abcdef
System.out.println(s2);//def
System.out.println("-----------------------");
String s4 ="test";
String s5 = s4.replace("t","b");
System.out.println(s4);//test
System.out.println(s5);//besb
1.3 图示解析:
2. String实例化方法
2.1 实现方式说明:
- 方式一:通过字面量定义的方式
- 方式二:通过new + 构造器的方式
面试题:
String s = new String("abc");
方式创建对象,在内存中创建了几个对象?
两个:一个是堆空间中new结构,另一个是char[]
对应的常量池中的数据:“abc”
2.2 代码实例:
//通过字面量定义的方式:此时的s1和s2的数据javaEE声明在方法区中的字符串常量池中。
String s1 = "javaEE";
String s2 = "javaEE";
//通过new + 构造器的方式:此时的s3和s4保存的地址值,是数据在堆空间中开辟空间以后对应的地址值。
String s3 = new String("javaEE");
String s4 = new String("javaEE");
System.out.println(s1 == s2);//true
System.out.println(s1 == s3);//false
System.out.println(s1 == s4);//false
System.out.println(s3 == s4);//false
String str1=“abc”;
与 String str2= new String(“abc”);
的区别?
新建String对象的内存解析
3. 字符串拼接方式赋值对比
3.1说明:
1.常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
2.只要其中一个是变量,结果就在堆中。
3.如果拼接的结果调用 intern() 方法
,返回值就在常量池中
3.2 代码示例
String s1 = "javaEE";
String s2 = "hadoop";
String s3 = "javaEEhadoop";
String s4 = "javaEE" + "hadoop";
String s5 = s1 + "hadoop";
String s6 = "javaEE" + s2;
String s7 = s1 + s2;
System.out.println(s3 == s4);//true
System.out.println(s3 == s5);//false
System.out.println(s3 == s6);//false
System.out.println(s3 == s7);//false
System.out.println(s5 == s6);//false
System.out.println(s5 == s7);//false
System.out.println(s6 == s7);//false
String s8 = s6.intern();//返回值得到的s8使用的常量值中已经存在的“javaEEhadoop”
System.out.println(s3 == s8);//true
****************************
String s1 = "javaEEhadoop";
String s2 = "javaEE";
String s3 = s2 + "hadoop";
System.out.println(s1 == s3);//false
final String s4 = "javaEE";//s4:常量
String s5 = s4 + "hadoop";
System.out.println(s1 == s5);//true
4. String使用陷阱
- String s1=“a”;
说明:在字符串常量池中创建了一个字面量为"a"的字符串。
- s1=s1+“b”
说明:实际上原来的“a”字符串对象已经丢弃了,现在在堆空间中产生了一个字符串s1+“b”(也就是"ab")。如果多次执行这些改变串内容的操作,会导致大量副本字符串对象存留在内存中,降低效率。如果这样的操作放到循环中,会极大影响程序的性能。
-
String s2=“ab”; 说明:直接在字符串常量池中创建一个字面量为"ab"的字符串。
-
String s3=“a”+“b”; 说明:s3指向字符串常量池中已经创建的"ab"的字符串。
-
String s4=s1.intern(); 说明:堆空间的S1对象在调用 intern()之后,会将常量池中已经存在的"ab"字符串赋值给s4。
5. String类常用方法
5.1 字符串操作
操作字符:
- int length():返回字符串的长度: return value.length
- char charAt(int index): 返回某索引处的字符 return value[index]
- boolean isEmpty():判断是否是空字符串:return value.length == 0
- String toLowerCase():使用默认语言环境,将 String 中的所字符转换为小写
- String toUpperCase():使用默认语言环境,将 String 中的所字符转换为大写
- String trim():返回字符串的副本,忽略前导空白和尾部空白
- boolean equals(Object obj):比较字符串的内容是否相同
- boolean equalsIgnoreCase(String anotherString):与 equals() 方法类似,忽略大小写
- String concat(String str):将指定字符串连接到此字符串的结尾。 等价于用 +
- int compareTo(String anotherString):比较两个字符串的大小
- String substring(int beginIndex):返回一个新的字符串,它是此字符串的从beginIndex 开始截取到最后的一个子字符串。
- String substring(int beginIndex, int endIndex) :返回一个新字符串,它是此字符串从 beginIndex 开始截取到 endIndex (不包含)的一个子字符串。
代码示例:
@Test
public void test2() {
String s1 = "helloword";
System.out.println(s1.length());//9
System.out.println(s1.charAt(4));//o
System.out.println(s1.isEmpty());//false
String s2 = "HELLOword";
System.out.println(s2.toLowerCase());//hellowod
System.out.println(s2.toUpperCase());//HELLOWORD
String s3 = " hello word ";
System.out.println(s3.trim());//hello word
String s4 = "helloword";
System.out.println(s4.equals(s1));//true
System.out.println(s4.equalsIgnoreCase(s2));//true
String s5 = "hello";
System.out.println(s5.compareTo(s4));//-4 相等时返回0,小的时候返回负数
System.out.println(s4.compareTo(s1));//0
System.out.println(s4.substring(5));//word
System.out.println(s4.substring(5, 9));//word,取值范围左开右闭
}
判断字符:
1.boolean endsWith(String suffix):测试此字符串是否以指定的后缀结束
2.boolean startsWith(String prefix):测试此字符串是否以指定的前缀开始
3.boolean startsWith(String prefix, int toffset):测试此字符串从指定索引开始的子字符串是否以指定前缀开始
@Test
public void test3() {
String s1 = "javaEE";
System.out.println(s1.endsWith("EE"));//true
System.out.println(s1.startsWith("a"));//false
System.out.println(s1.startsWith("EE", 4));//true
}
5.2 查找字符串中的字符
1.boolean contains(CharSequence s):当且仅当此字符串包含指定的 char 值序列时,返回 true
2.int indexOf(String str):返回指定子字符串在此字符串中第一次出现处的索引
3.int indexOf(String str, int fromIndex):返回指定子字符串在此字符串中第一次出现处的索引,从指定的索引开始
4.int lastIndexOf(String str):返回指定子字符串在此字符串中最右边出现处的索引
5.int lastIndexOf(String str, int fromIndex):返回指定子字符串在此字符串中最后一次出现处的索引,从指定的索引开始反向搜索
注:indexOf 和 lastIndexOf 方法如果未找到都是返回-1
代码示例:
@Test
public void test3() {
String s2="hello word";
System.out.println(s2.contains("o"));//true
System.out.println(s2.indexOf("h"));//0
System.out.println(s2.indexOf("o", 5));//7
System.out.println(s2.lastIndexOf("o"));//7
System.out.println(s2.lastIndexOf("l", 2));//2
}
5.3 字符串操作方法
1.替换:
- String replace(char oldChar, char newChar):返回一个新的字符串,它是通过用 newChar 替换此字符串中出现的所 oldChar 得到的。
- String replace(CharSequence target, CharSequence replacement):使用指定的字面值替换序列替换此字符串所匹配字面值目标序列的子字符串。
- String replaceAll(String regex, String replacement):使用给定的 replacement 替换此字符串所匹配给定的正则表达式的子字符串。
- String replaceFirst(String regex, String replacement):使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
2.匹配:
- boolean matches(String regex):告知此字符串是否匹配给定的正则表达式。
3.切片:
-
String[] split(String regex):根据给定正则表达式的匹配拆分此字符串。
-
String[] split(String regex, int limit):根据匹配给定的正则表达式来拆分此字符串,最多不超过limit个,如果超过了,剩下的全部都放到最后一个元素中。
代码示例:
@Test
public void test4() {
String str1 = "北京你好,你好北京";
String str2 = str1.replace('北', '南');
System.out.println(str1);//北京你好,你好北京
System.out.println(str2);//南京你好,你好南京
String str3 = str1.replace("北京", "上海");
System.out.println(str3);//上海你好,你好上海
System.out.println("*************************");
String str = "12hello34world5java7891mysql456";
//把字符串中的数字替换成,,如果结果中开头和结尾有,的话去掉
String string = str.replaceAll("\\\\d+", ",").replaceAll("^,|,$", "");
System.out.println(string);//hello,world,java,mysql
System.out.println("*************************");
str = "12345";
//判断str字符串中是否全部有数字组成,即有1-n个数字组成
boolean matches = str.matches("\\\\d+");
System.out.println(matches);//true
String tel = "0571-4534289";
//判断这是否是一个杭州的固定电话
boolean result = tel.matches("0571-\\\\d{7,8}");
System.out.println(result);//true
System.out.println("*************************");
str = "hello|world|java";
String[] strs = str.split("\\\\|");
for (int i = 0; i < strs.length; i++) {
System.out.println(strs[i]);//依次输出hello word java
}
System.out.println();
str2 = "hello.world.java";
String[] strs2 = str2.split("\\\\.");
for (int i = 0; i < strs2.length; i++) {
System.out.println(strs2[i]);//依次输出hello word java
}
}
6. String与其他结构的转换
6.1 String与基本数据类型、包装类之间的转换
String --> 基本数据类型、包装类:调用包装类的静态方法:parseXxx(str)
基本数据类型、包装类 --> String:调用String重载的 valueOf(xxx)
代码示例:
@Test
public void StringToBasic() {
String str1 = "123";
int i = Integer.parseInt(str1);
System.out.println(i);
System.out.println(i == 123);//true
int j = 456;
String s = String.valueOf(j);
System.out.println(s);
System.out.println(s.equals("456"));//true
}
6.2 与字符数组之间的转换
String --> char[]:调用String的 toCharArray() char[] --> String:调用String的构造器
代码示例:
@Test
public void BasicToString() {
String s1 = "helloword";
char[] chars = s1.toCharArray();
for (int i = 0; i < chars.length; i++) {
System.out.println(chars[i]);
}
char[] charArray = new char[]{'h', 'e', 'l', 'l', 'o'};
String s2 = new String(charArray);
System.out.println(s2);
}
6.3 与字节数组之间的转换
- 编码:String --> byte[]:调用String的 getBytes()
- 解码:byte[] --> String:调用String的构造器
- 编码:字符串 -->字节 (看得懂 —>看不懂的二进制数据)
- 解码:编码的逆过程,字节 --> 字符串 (看不懂的二进制数据 —> 看得懂
- 说明:解码时,要求解码使用的字符集必须与编码时使用的字符集一致,否则会出现乱码。
@Test
public void StringToByteTest() throws UnsupportedEncodingException {
String s1 ="你好java世界";
byte[] bytesArray = s1.getBytes();//使用默认字符集编码
System.out.println(Arrays.toString(bytesArray));//[-28, -67, -96, -27, -91, -67, 106, 97, 118, 97, -28, -72, -106, -25, -107, -116]
byte[] gbks = s1.getBytes("gbk");//使用gbk编码集合
System.out.println(Arrays.toString(gbks));//[-60, -29, -70, -61, 106, 97, 118, 97, -54, -64, -67, -25]
System.out.println("--------------------------------");
String str1=new String(bytesArray);//使用默认字符进行解码
System.out.println(str1);//你好java世界
String str2 = new String(gbks);//使用默认字符对gbk编码进行解码
System.out.println(str2);//���java����解码错误,出现中文乱码,原因:编码和解码不一致
String str3 = new String(gbks,"gbk");//使用gbk格式进行解码
System.out.println(str3);//你好java世界,解码正确,原因:编码和解码一致
}
6.4 与StringBuffer、StringBuilder之间的转换
1.String -->StringBuffer、StringBuilder: 调用StringBuffer、StringBuilder构造器
@Test
public void StringToStringBufferTest(){
String str1 ="helloword";
StringBuffer stringBuffer = new StringBuffer(str1);
System.out.println(stringBuffer);//helloword
StringBuilder stringBuilder = new StringBuilder(str1);
System.out.println(stringBuilder);//helloword
stringBuffer.append("isStringBuffer");
System.out.println(stringBuffer);//hellowordandgood
stringBuilder.append("isStringBuider");
System.out.println(stringBuilder);
}
2.StringBuffer、StringBuilder -->String:
①调用String构造器; ②StringBuffer、StringBuilder的toString()
@Test
public void StringBuiderOrStringBufferToStringTest() {
StringBuffer sb1 = new StringBuffer("hello StringBuffer");
System.out.println(sb1);
StringBuilder sb2 = new StringBuilder("hello StringBuider");
System.out.println(sb2);
System.out.println("----------------------");
String str1 = new String(sb1);
System.out.println(str1);
String str2 = new String(sb2);
System.out.println(str2);
System.out.println("----------------------");
System.out.println(sb1.toString());
System.out.println(以上是关于熬夜死磕Java类三剑客字符串时间数学计算,耗费大仙1024根头发,还不懂你只能回家养猪了!的主要内容,如果未能解决你的问题,请参考以下文章