java基础进阶篇(一)------String
文章目录
- 前言
- 一.构造方法
- 1.参数为空
- 2.参数是普通字符串
- 3.参数为char 类型数组, 此构造方法有两种选择
- 4.参数为int 类型数组
- 5.参数是StringBuffer, StringBuilder的情况.
- 另外String构造方法支持byte类型参数,
- 面试常见问题:
- 二.字符串常规操作: 查找,替换,连接 分割,截取
- 1.查找
- 2.替换
- 3.连接
- 4.分割
- 5.截取
- 三.正则判断方法
- 四.格式转换
- 1 .转大小写 toUpperCase, 无差别,全别转换成大写.
- 2.转字符数组 toCharArray.
- 3.自定义格式转换 format
- 3.浮点数格式化
- 4.时间日期格式化
- 五.字符串转char数组,字符char数组,基本类型转String类型.
- 1.char[] toCharArray(): 字符串转char数组.
- 2.基本类型转String 有三站方法
- 3.valueOf(Object arg)
- 1.调用包装类的parseXXX静态方法.
- 2.调用包装类的valueOf()方法转换为基本类型的包装类,会自动拆解转换.
前言
原生态的String 提供了很多好用的冷门重载方法…
通过不同参数可以节约代码,一行实现我们想要的效果.
ver. JDK1.8
一.构造方法
String本身是final类型,不可继承,不可变更. 创建String 对象有两种:
使用构造方法new String();
直接定义String str = “abc”;
构造方法有重载方法,
1.参数为空
public String()
String str1 = new String();
2.参数是普通字符串
public String(String original);
String str2 = new String("abc");
System.out.println("str2= " + str2);
3.参数为char 类型数组, 此构造方法有两种选择
String(char value[])
String(char value[], int offset, int count)
offset：数组的起始下标索引
count：选择的字符个数
char[] c1 = { 'a', 'b', 'c' };
String str3 = new String(c1);
System.out.println("str3= " + str3);
String str4 = new String(c1, 1, 2);
System.out.println("str4= " + str4);
4.参数为int 类型数组
public String(int[] int, int offset, int count)
int: 数组 offset: 开始处索引 count: 取几个值
int[] i1 = new int[2];
i1[0] = 1;
i1[1] = 2;
String str5 = new String(i1, 0, i1.length);
System.out.println("str5= " + str5);
5.参数是StringBuffer, StringBuilder的情况.
StringBuffer sbuffer = new StringBuffer();
sbuffer.append("string");
sbuffer.append(" ");
sbuffer.append("buffer");
String buffer = new String(sbuffer);
System.out.println("buffer: " + buffer);
StringBuilder sbuilder = new StringBuilder();
sbuilder.append("string");
sbuilder.append(" ");
sbuilder.append("builder");
String builder = new String(sbuilder);
System.out.println("builder: " + builder);
另外String构造方法支持byte类型参数,
面试常见问题:
String a1 = “abc”, 和 String a2 = new String(“abc”);有什么不同???
new 的方式重新开辟了内存,创建是一个全新的值和全新的引用地址.
直接定义String 方式会先在常量池中查找是否已经创建了该相等的值,若查到已有,则不开辟内存,直接创建一个引用地址指向查到的值.比如:
String a1 = "abc";
String a2 = "abc";
String a3 = new String("abc");
// a2创建时,发现值和a1相同,所以仅创建了引用地址指向已有的a1的值.
System.out.println("a1 == a2: " + a1 == a2);// true
System.out.println("a1.equals(a2): " + a1.equals(a2));// true: 值相等
// a3是用new 的方式重新开辟内存并存储与a1相等的一个独立的值.但值的引用地址是各自不同
System.out.println("a1 == a3: " + a1 == a3);// false
System.out.println("a1.equals(a3): " + a1.equals(a3));// true: 值相等));// true: 值相等
二.字符串常规操作: 查找,替换,连接 分割,截取
1.查找
查找类方法简单常用,根据需求使用.
boolean contains(String argues): 判断是包含子字符串.
String str = "Hello World !";
System.out.println(str.contains("S"));// false
System.out.println(str.contains("World"));// true
System.out.println(str.contains("ell"));// true
System.out.println(str.contains("ddd"));// false
int indexOf(String str): 查找指定字符或字符串在字符串中第一次出现地方的索引，未找到的情况返回 -1.
通过判断结果是否为-1,同样可以用作是否包含子字符串的判断.
String str1 = "012345";
String str2 = "23";
String str3 = "24";
System.out.println(str1.indexOf(str2));// 2
System.out.println(str1.indexOf(str3));// -1
重载方法 int indexOf(String str，int index): 从index的索引处开始找，返回str第一次出现的索引下标值.
String indexOfStr1 = "012345012345";
String indexOfStr2 = "23";
System.out.println(indexOfStr1.indexOf(indexOfStr2, 5));// 8
System.out.println(indexOfStr1.indexOf(indexOfStr2, 9));// -1
int lastIndexOf(String str): 查找指定字符或字符串在字符串中最后出现的索引,无则返回-1.
String lastIndexOfStr = "this is index of example";
int index = lastIndexOfStr.lastIndexOf('s');
System.out.println(index);// 6
重载: lastIndexOf(String str, int fromIndex);从指定索引处进行反向搜索.
index = lastIndexOfStr.lastIndexOf('s', 5);
System.out.println(index);// 3
boolean startsWith(String prefix): 如果字符串以指定的前缀开始，则返回 true；否则返回 false.
String withStr = new String("www.runoob.com");
System.out.println(withStr.startsWith("www"));// true
System.out.println(withStr.startsWith("runoob"));// false
重载: boolean startsWith(String prefix, int toffset).
prefix: 前缀. toffset 字符串中开始查找的位置.
System.out.println(withStr.startsWith("runoob", 4));// true
boolean endsWith(String suffix): 如果字符串以指定的后缀结束，则返回 true；否则返回 false.
System.out.println(withStr.endsWith("com"));// true
char charAt(int index): 返回索引处字符.
String codeStr = new String("abcdef");
System.out.println(codeStr.charAt(2));// c
int codePointAt(int index): 返回指定索引处字符的Unicode编码值.
System.out.println(codeStr.codePointAt(0));// 97
System.out.println(codeStr.codePointAt(2));// 99
2.替换
相信很多小伙伴对replace和replaceAll这两个兄弟的印象都是一个是替换一次，一个是替换所有。
实际情况是：replace是做简单的全部字符替换，replaceAll是正则表达式替换!
但是实际的运行结果却完全相反!!!，replace把所有的|全替换掉了，replaceAll反而一个也没有替换掉！
|在正则表达式里面是特殊字符，需要转义一下才能达到与replace一样的效果;,替换后的字符串也要注意转义问题!
String replacesrc = "aa|bb|cc";
String replaceStr1 = replacesrc.replace("|", "");
String replaceStr2 = replacesrc.replaceAll("|", "");
System.out.println(replaceStr1);// aabbcc
System.out.println(replaceStr2);// aa|bb|cc
String replaceStr3 = replacesrc.replaceAll("\\|", "");
System.out.println(replaceStr3);// aabbcc
String replaceFirst(String regex, String replacement):
替换字符串第一个匹配给定的正则表达式的子字符串.
返回值: 成功则返回替换的字符串，失败则返回原始字符串.
String replaceFirstStr = new String("hello runoob，I am from runoob。");
System.out.println(replaceFirstStr.replaceFirst("runoob", "google"));
System.out.println(replaceFirstStr.replaceFirst("(.*)runoob(.*)", "google"));
3.连接
" ",常用的+ 和 concat 方法
concat:返回连接后的字符串.
String ljStr = "hello";
System.out.println(ljStr + " world!");// hello world!
// concat: 返回连接后的字符串.
System.out.println(ljStr.concat(" java"));// hello java
static String join(CharSequence delimiter, CharSequence… elements)
是String 的静态方法,可直接调用.用于字符串数组各元素间插入指定的字符串.
String[] joinStr = new String[] { "Yuan", "Mxy", "Cmy" };
System.out.println(String.join("-", joinStr));// Yuan-Mxy-Cmy
List names = new ArrayList<String>();
names.add("Kite");
names.add("Mike");
names.add("Shon");
System.out.println(String.join("-", names));// Kite-Mike-Shon
4.分割
split: 字符串按照指定表达式分割转成一个数组. 此处有个BUG需要注意
String[] split(String regex);
String splitStr1 = "a,b,c,d,e,f";
String[] splitArray1 = splitStr1.split(",");
System.out.println("splitArray1长度: " + splitArray1.length);// splitArray1长度: 6
for (String item : splitArray1) {
System.out.print(item + " ");// a b c d e f
}
String splitStr2 = "a,b,c,d,e,f,";// 同splitStr1不同, 末尾多了一个逗号.再来看看大小
String[] splitArray2 = splitStr2.split(",");
System.out.println("splitArray2长度: " + splitArray2.length);// splitArray2长度: 6
长度仍然为6,实际应为7,最后为空的元素被默认去除了, split会默认去除末尾为空的元素!!! 算是个坑 有个重载方法,可以填坑.
重载: String[] split(String regex, int limit)
limit: 传入一个非0数字即可避免掉, 在此我们传入-1.
String[] splitArray3 = splitStr2.split(",", -1);
System.out.println("splitArray3长度: " + splitArray3.length);// splitArray3长度: 7
for (String item : splitArray1) {
System.out.print(item);// abcdef, 结尾没有空元素,只是在数组中占了一个索引位置.
}
5.截取
String substring(int beginIndex);
返回一个新的子字符串。该子字符串始于指定索引处的字符(包含!)，一直到此字符串末尾
String substring(int beginIndex, int endIndex);
返回一个新的子字符串。该子字符串从指定的 beginIndex 处开始(包含!)， endIndex:到指定的 endIndex-1处结束(不!包含).
String substringStr1 = "abcdef";
System.out.println(substringStr1.substring(2));// cdef
String substringStr2 = "abcdef";
System.out.println(substringStr2.substring(2, 4));// cd
三.正则判断方法
String类提供支持正则表达式判断的方法,省去了开发人员额外引入正则工具类.
boolean matches(String regex);
方法用于检测字符串是否匹配给定的正则表达式,同Pattern.matches(regex, str);作用完全相同,底层源码如下:
public boolean matches(String regex) {
return Pattern.matches(regex, this);
}
实例:
String Str = new String("www.runoob.com");
System.out.println(Str.matches("(.*)runoob(.*)"));// true
System.out.println(Str.matches("(.*)google(.*)"));// false
System.out.println(Str.matches("www(.*)"));// true
四.格式转换
1 .转大小写 toUpperCase, 无差别,全别转换成大写.
String toUpperStr1 = "abCdEf";
System.out.println(toUpperStr1.toUpperCase());// ABCDEF
// 重载 String toUpperCase(Locale locale). locale:指定本地语言属性,非特定需求无需设定
System.out.println(toUpperStr1.toLowerCase());// abcdef
2.转字符数组 toCharArray.
String s1 = new String("abcdef");
char[] c = s1.toCharArray();
System.out.println("数组c的长度为：" + c.length);// 数组c的长度为：6
System.out.println(c);// abcdef
System.out.println(new String(c));// abcdef
String s2 = new String(c, 1, 2);
System.out.println(s2);// bc
3.自定义格式转换 format
String类的format()方法用于创建格式化的字符串以及连接多个字符串对象,类似c++ 中的pringf.
可以对整数, 浮点数和日期进行格式化.
整数–|示例——将-1000显示为(1,000):
int num = -1000;
String str = String.format("%(,d", num);
System.out.println(str);// (1,000)
3.浮点数格式化
浮点数–|对浮点数进行格式化:
double num1 = 123.456789;
System.out.println(String.format("浮点类型：%.2f %n", num1));// 浮点类型：123.46
System.out.println(String.format("十六进制浮点类型：%a %n", num1));// 十六进制浮点类型：0x1.edd3c07ee0b0bp6
System.out.println(String.format("通用浮点类型：%g ", num1));// 通用浮点类型：123.457
4.时间日期格式化
日期–|对日期时间进行格式化:
Date date = new Date();
System.out.printf(String.format("全部日期和时间信息：%tc%n", date));
//输出: 全部日期和时间信息：星期三 二月 19 17:53:58 CST 2020
System.out.printf(String.format("年-月-日格式：%tF%n", date));
//输出: 年-月-日格式：2020-02-19
System.out.printf(String.format("月/日/年格式：%tD%n", date));
//输出: 月/日/年格式：02/19/20
System.out.printf(String.format("HH:MM:SS PM格式（12时制）：%tr%n", date));
//输出: HH:MM:SS PM格式（12时制）：05:53:58 下午
System.out.printf(String.format("HH:MM:SS格式（24时制）：%tT%n", date));
//输出: HH:MM:SS格式（24时制）：17:53:58
System.out.printf(String.format("HH:MM格式（24时制）：%tR", date));
//输出: HH:MM格式（24时制）：17:53
Ps:使用sysout 打印语句时可以省去String.format.
五.字符串转char数组,字符char数组,基本类型转String类型.
1.char[] toCharArray(): 字符串转char数组.
String charStr1 = new String("abcdef");
char[] charArry1 = charStr1.toCharArray();
System.out.println(charArry1.length);// 6
for (char c : charArry1) {
System.out.print(c + " ");// a b c d e f
}
2.基本类型转String 有三站方法
1.使用包装类的toString() 方法.
2.使用String 类的静态方法String.valueOf(char数组|基本类型).
3.+上一个空字符串,得到的就是基本类型对应的字符串.
int val1 = 10;
String val1Str1 = Integer.toString(val1);
String val1Str2 = String.valueOf(val1);
String val1Str3 = val1 + "";
System.out.println(val1Str1);// 结果: 10 (字符串类型)
System.out.println(val1Str2);// 结果: 10 (字符串类型)
System.out.println(val1Str3);// 结果: 10 (字符串类型)
3.valueOf(Object arg)
字符数组转String时有重载方法,可截取任意长度转换成String.
1.static String valueOf(char data[]): char数组转string.
char[] charArray2 = { 'a', 'b', 'c', 'e', 'd', 'e' };
String valueOfStr1 = String.valueOf(charArray2);
System.out.println(valueOfStr1);// abcede
重载: static String valueOf(char data[], int offset, int count):
从指定索引处截取指定长度的char数组转String.
offset: 索引开始处; count: 指定长度.
String valueOfStr2 = String.valueOf(charArray2, 2, 4);
System.out.println(valueOfStr2);// cede
补充: 将字符串转回基本类型的方法
1.调用包装类的parseXXX静态方法.
2.调用包装类的valueOf()方法转换为基本类型的包装类,会自动拆解转换.
String strInt1 = "8";
int si1 = Integer.parseInt(strInt1);
int si2 = Integer.valueOf(strInt1);
扫码关注微信公众号-java源码栈, 及时充电!
