本文介绍了Java中字符串常量池的概念，强调了String对象的不可变性，并详细讲解了String类的一些常用方法，如length(),indexOf(),substring(),trim()等，还通过代码示例展示了预计算特性和对象创建规则。同时，文章提供了几个实战案例，包括检索字符串、检测回文等，帮助读者更好地理解和运用String类。
JavaEE API的学习之day01 字符串常量池以及String常用方法的使用
文章目录
- 一、文档注释
- 二、正文介绍
- 1.字符串常量池：是java对String的一个优化措施
- String的常用的方法：
- 1. int length()返回当前字符串的长度(字符个数)
- 2. int indexOf(String str)/int indexOf(String str,int index)/int lastIndexOf(String str):检索对应字符串的下标
- 3. String substring(int start,int end)/ String substring(int start)截取当前字符串中指定范围的字符串(含头不含尾)
- 4. String trim() 去除两侧的空白,单词中间的空白不会去除！
- 5. char charAt(int a):返回对应下标的字符,要注意下标
- 6. startsWith()/endsWith()：判断当前字符串是否是以给定的定符串开始/结束的
- 7. toUpperCase()/toLowerCase()：将当前字符串中的英文部分给转换为全大写/全小写
- 8. 静态方法valueOf()：将其它数据类型转换为String
- 几个小案例
- 总结
一、文档注释
1.经常用在类方、法、变量，是功能级注释。
2. 文档注释可以使用javadoc命令生成文档手册
3. 在类上使用时用于说明当前类的整体功能和设计
以下是代码介绍
package akidoc;
public class ApiDocDemo {
public static void main(String[] args) {
System.out.println(ApiDocDemo.demo("小白"));
}
public static final String INFO = "hellow";
/**
*.....方法功能说明
*
* @author xiaobai
* @version 1.0
* @param args
* @see java.lang.String
* @since JDK 1.8
* @return
* @throws
*/
public static String demo(String args) {
return INFO + args;
}
}
输出：hellow小白
二、正文介绍
1.字符串常量池：是java对String的一个优化措施
-
1.引用对象存的是地址，如果引用的字符串相同，会复用前面的直接量对象，指向常量池（堆）中同一个地址。而new对象是强制创建对象，不会将对象引入常量池。
-
2.计算机的预计算特性介绍
理解：所有人都知道天安门，看到的内容都相同，那么对象所指的地址相同， -
3.String是不变对象，内容不可变，改变会创建新对象。
理解：所有人都知道天安门，但是有个人想要在自己家里造一个一模一样的天安门，虽然最后看到的房子都一样，
以下是代码介绍：
package String;
/**
* 字符串常量池
*/
public class StringDemo {
public static void main(String[] args) {
//引用类型存的是地址。使用直接量创建对象会缓存到常量池中，后面创建的直接量的内容若相同会复用前面的直接量对象
String s1 = "123abc";
String s2 = "123abc";
//这个是比较的地址，true,s1和s2地址相同，说明引用的是同一个对象。
System.out.println(s1 == s2);
String s3 = "123abc";
System.out.println(s1 == s3);
//============================
//new是强制创建新对象，该对象不会引入常量池
String s4 = new String("123abc");
//false
System.out.println(s1 == s4);
//===========================修改内容一定会重新创建对象
//触发了编译器的预编译，计算结果并替换计算表达式
String s5 = "123" + "abc";
//true
System.out.println(s1 == s5);
/*
总结：
这里触发了编译器的预计算特性
编译器在编译源代码时，发现一个计算表达式计算符两侧都是字面量时，就会进行
计算，并将结果替换该计算表达式，这样一来每次执行程序是就无需再计算了。
下面的代码会被编译器改为：
String s5 = "123abc";
因此s5会重用对象的
*/
//===========================
//String是不变对象，内容不可变，
s1 = s1 + "!";
s2 = "123abc!";
//false
System.out.println(s1 == s2);
/**
* 练习：
* 1.触发计算机的预计算特性
* 2.String是不可变的，若改变内容一定会重新创建新的对象
*/
//1.理解：所有人都知道天安门，看到的内容都相同，那么对象所指的地址相同，
String a = "12ac";
String b = "12" + "ac";
//true,预编译，做了预计算
System.out.println(a == b);
//2.理解：所有人都知道天安门，但是有个人想要在自己家里造一个一模一样的天安门，
//虽然最后看到的房子都一样，但是地址不同。所以为flase
String c = "12ac!";
String d = "12ac";
//e没有重用，做了拼接，不会做预计算
String e = d + "!";
//false,改变对象会创建新的对象
System.out.println(c == d);
}
}
输出：true true false true false true false
String的常用的方法：
1. int length()返回当前字符串的长度(字符个数)
//String是不变对象
String str = "我爱我的祖国";
int len = str.length();
//6
System.out.println(len);
2. int indexOf(String str)/int indexOf(String str,int index)/int lastIndexOf(String str):检索对应字符串的下标
package String;
/**
* int indexOf(String str)
* 检索当前字符串中给定内容第一次出现的位置，如果当前字符串不包含指定值则返回值为-1
* <p>
* int indexOf(String str,int index)
* 从指定位置开始检索指定的字符串，若没有返回-1
* int lastIndexOf(String str)
* 检索最后一次出现指定内容的地方，返回下标，若没有返回-1
*/
public class IndexOfDemo {
public static void main(String[] args) {
String aA = "thinking in java";
int index = aA.indexOf("IN");
//out:-1
System.out.println(index);
index = aA.indexOf("in");
//out:2
System.out.println(index);
//从下标为4地方开始往后找
index = aA.indexOf("in", 4);
//out:5
System.out.println(index);
//检索最后一次出现“in”的位置
index = aA.lastIndexOf("in");
//out:9
System.out.println(index);
/**
* 应用场景：检索指定内容
* xxx@tedu@.cn
* 使用 indexOf("@")和lastIndexOf("@")作比较，如果返回的下标值相同则找到了指定的@
*/
}
}
3. String substring(int start,int end)/ String substring(int start)截取当前字符串中指定范围的字符串(含头不含尾)
package String;
/**
*String substring(int start,int end)
* 截取当前字符串中指定范围的字符串(含头不含尾)
*
* String substring(int start)
* 截取当前字符串中指定下标后的字符串
*/
public class SubStringDemo {
public static void main(String[] args) {
String str = "www.baidu.com";
//baidu
String aA = str.substring(4, 9);
System.out.println(aA);
String aB = str.substring(4);
//baidu.com
System.out.println(aB);
}
}
4. String trim() 去除两侧的空白,单词中间的空白不会去除！
String line = " a a ";
//a a
System.out.println(line.trim());
5. char charAt(int a):返回对应下标的字符,要注意下标
String line = "www.tedu.com";
//e
System.out.println(line.charAt(5));
6. startsWith()/endsWith()：判断当前字符串是否是以给定的定符串开始/结束的
String line = "thinking in java";
//true
System.out.println(line.startsWith("th"));
//false
System.out.println(line.endsWith("va"));
7. toUpperCase()/toLowerCase()：将当前字符串中的英文部分给转换为全大写/全小写
//字符串是不变对象
String line = "学习新思想，争做新青年,Hellow";
System.out.println(line.toUpperCase(Locale.ROOT));
System.out.println(line.toLowerCase(Locale.ROOT));
8. 静态方法valueOf()：将其它数据类型转换为String
int a = 123;
//强制转换是基本类型之间的转换
//引用关系中是多态在造型
String b = String.valueOf(a);
System.out.println(b);
几个小案例
1.检索指定字符
/**
* 应用场景：检索指定内容
* xxx@tedu@.cn
* 使用 indexOf("@")和lastIndexOf("@")作比较，如果返回的下标值相同则找到了指定的@
*/
2.检索域名
运行代码
package String;
/**
* 练习：检索一个网址中的域名！
*/
public class Test1 {
public static void main(String[] args) {
String s1 = "http://www.baidu.com";
String s2 = "www.baidu.con";
System.out.println("第一个域名是："+getHostName(s1));
System.out.println("第二个域名是："+getHostName(s2));
}
public static String getHostName(String url){
//第一个·的位置
int index = url.indexOf(".");
//第二个.的位置
int index2 = url.indexOf(".",index+1);
return url.substring(index+1,index2);
//核心就是[x,y)含头不含尾
}
}
3.检测回文
运行代码
/**
* 案例：回文检测
* 思路：检测下标对称的两个字符是否相同
* 变量为i 和 length()-1
* 变数：若对应的字符不同则不是回文。
*/
public static String huiWen(String str){
boolean flag = true;
for (int i = 0; i < str.length()/2; i++) {
char c1 = str.charAt(i);
char c2 = str.charAt(str.length()-1-i);
if (c1 != c2){
flag = false;
}
}
return flag?"是回文":"不是回文";
}
在主方法中运行：
public static void main(String[] args) {
String str = "上海自来水来自海上";
System.out.println(CharAtDemo.huiWen(str));
}
//运行结果为：是回文
扫一扫
1033
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
