String类
概念： 多个字符组成的字符序列，也可以理解为字符数组。
CharSequence
String, StringBuffer, StringBuilder
public void show(CharSequence seqence);
char charAt(int index) ---------------返回指定索引的 char 值。
int length() ------------------返回此字符序列的长度。
CharSequence subSequence(int start, int end) 返回一个新的 CharSequence，它是此序列的子序列。
String toString() 返回一个包含此序列中字符的字符串，该字符串与此序列的顺序相同。
String的特点:
1.String 类代表字符串。Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。
2.字符串是常量；它们的值在创建之后不能更改。
3.所有的常量在内存的方法区的常量池中
4.频繁的字符串拼接操作会导致常量池容器增加,浪费内存资源
5.字符串缓冲区【StringBuffer,StringBuilder】支持可变的字符串
6.Java在编译时期会针对字符串的拼接操作使用StringBuilder改进,提高效率,节约内存资源
s = (new StringBuilder(String.valueOf(s))).append(“efg”).toString();
System.out.println((new StringBuilder(“s:”)).append(s).toString());
7.因为 String 对象是不可变的，所以可以共享
8.字符串本质是字符数组
常量:
字面值常量
"abc"是一个对象
自定义常量
String s = “abc”;
举例代码如下：
public class StringDemo01 {
public static void main(String[] args) {
String s = "abc";
s += "efg";
System.out.println("s:" + s);
String s2 = "abc";
}
}
内存图分析：
String类的构造方法
public String()
public String(String original)
public String(char[] value)
public String(char[] value, int offset, int count)
public String(byte[] bytes)
public String(byte[] bytes, int offset, int length)
观察字符串源码:
class String {
private final char value[];
public String() {
this.value = "".value;
}
public String(String original) {
this.value = original.value;
this.hash = original.hash;
}
}
String s = "abc"和String s = new String(“abc”);的区别
前者在方法区开辟空间
后者即在方法区,也在堆区开辟空间
一般使用前者创建字符串对象
举例代码如下：
public class StringDemo02 {
public static void main(String[] args) {
String s = new String();
System.out.println("s: " + s);
String s2 = new String("abc");
System.out.println("s2: " + s2);
s2.intern();
// public String(char[] value)
String s3 = new String(new char[]{'a', 'b', 'c'});
System.out.println(s3);
// public String(char[] value, int offset, int count)
char[] chs = {'a', 'b', 'c', 'd'};
// String s4 = new String(chs, -1, 2);
// java.lang.StringIndexOutOfBoundsException
// System.out.println(s4);
// public String(byte[] bytes)
String s5 = new String(new byte[] {97,98,99});
System.out.println(s5);
// public String(byte[] bytes, int offset, int length)
String s6 = new String(new byte[] {97,98,99}, 0, 3);
System.out.println(s6);
String ss = "Hello";
String ss2 = "World";
String sss = "HelloWorld";
System.out.println(sss == "Hello" + "World");
// System.out.println(sss == "HelloWorld");
}
}
char charAt(int index) 返回指定索引处的char字符
int indexOf(int ch) 返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
int indexOf(String str) 返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
int indexOf(int ch,int fromIndex)
返回从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
int indexOf(String str,int fromIndex)返回从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
int lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
int lastIndexOf(int ch,int fromIndex) 返回指定字符在此字符串中最后一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
int lastIndexOf(String str,int fromIndex) 返回指定字符在此字符串中最后一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。
String substring(int start)返回以索引处开始的字符
String substring(int start,int end)起始索引（包括）, 索引从 0 开始。结束索引（不包括）。
int length()返回字符串长度
举例代码如下：
public class StringDemo03 {
public static void main(String[] args) {
// 利用多态来创建字符串
CharSequence sequence = "abc";
String s = "HelloWorldHello";
// System.out.println("charAt: " + s.charAt(0));
// System.out.println("charAt: " + s.charAt(1));
// 遍历字符串每一个字符
for (int i = 0; i < s.length(); i++) {
System.out.println("charAt: " + s.charAt(i));
}
// int indexOf(int ch)
// int ch = 'e';
System.out.println("indexOf(int ch): " + s.indexOf('l'));
System.out.println("int indexOf(String str): " + s.indexOf("World"));
System.out.println("int indexOf(int ch,int fromIndex):" + s.indexOf('o', 5));
System.out.println("int indexOf(String str,int fromIndex):" + s.indexOf("Hello", 5));
// int lastIndexOf(int ch)
System.out.println("int lastIndexOf(int ch): " + s.lastIndexOf('l'));
// int lastIndexOf(int ch,int fromIndex)
System.out.println("int lastIndexOf(int ch,int fromIndex): " + s.lastIndexOf('l', 10));
// String substring(int start)
String str = s.substring(10);
System.out.println(str);
String str2 = s.substring(5, 10); // 左闭右开原则
System.out.println(str2);
CharSequence subSequence = s.subSequence(5, 10);
System.out.println(subSequence);
}
}
boolean isEmpty()：判断字符串是否为空。
boolean equals(Object obj)：将此字符串的内容与指定的对象比较,区分大小写。
boolean equalsIgnoreCase(String str)：将此 String 与另一个 String 比较,忽略大小写。
boolean contains(String str)：判断字符串中是否包含方法传入的字符串。
boolean startsWith(String str)：判断字符串是否以某个指定的字符串开头。
boolean endsWith(String str)：判断字符串是否以某个指定的字符串结尾。
public boolean isEmpty() {
return this.value.length == 0;
}
字符串数组如何转换成字符串
char[] chs = {‘a’, ‘b’, ‘c’};
for(int i = 0; i < chs.length; i++){
}
举例代码如下：
public class StringDemo04 {
public static void main(String[] args) {
char[] chs = {'a', 'b', 'c'};
String result = "";
for(int i = 0; i < chs.length; i++){
result += chs[i];
}
String s = "HelloWorld"; //"" + H + "" + e + "" + l + "" + l + ..
// String s = new String("");
// String s2 = null;
// String s3 = "";
//
// System.out.println(s.isEmpty()); // true
System.out.println(s2.isEmpty()); // 报错
// System.out.println(s3.isEmpty()); // true
System.out.println(s.equals("HelloWorld"));
System.out.println(s.equalsIgnoreCase("helloWorld"));
System.out.println(s.contains(""));
String s2 = "http://www.baidu.com";
String s3 = "HelloWorld.java";
System.out.println(s2.startsWith("http"));
System.out.println(s2.startsWith(""));
System.out.println(s3.endsWith(".java"));
System.out.println(s3.endsWith(""));
}
}
byte[] getBytes() ：将字符串转化为字节数组。
char[] toCharArray()： 将字符串转化为字符数组。
static String valueOf(char[] chs)： 返回 char 数组参数的字符串表示形式。
static String valueOf(int i) ：返回 int 参数的字符串表示形式。
String toLowerCase() ：将此 String 中的所有字符都转换为小写。
String toUpperCase() ：将此 String 中的所有字符都转换为大写。
String concat(String str)： 将指定字符串连接到此字符串的结尾。
举例代码如下：
public class StringDemo05 {
public static void main(String[] args) {
String s = "HelloWorld";
byte[] bys = s.getBytes();
System.out.println(Arrays.toString(bys));
for (byte b : bys) {
System.out.println((char)b);
}
System.out.println("------------------");
char[] chs = s.toCharArray();
for (char c : chs) {
System.out.println(c);
}
System.out.println("-------------------");
String ss1 = String.valueOf(false);
System.out.println(ss1);
String ss2 = String.valueOf(2.5);
String ss3 = String.valueOf(10);
System.out.println(ss2 + ss3);
String ss4 = String.valueOf(new Student());
System.out.println(ss4);
System.out.println("-------------------");
String upperCase = "select * from t_student".toUpperCase();
System.out.println(upperCase);
String lowerCase = upperCase.toLowerCase();
System.out.println(lowerCase);
System.out.println("-------------------");
System.out.println("Hello".concat("World"));
}
}
String replace(char old,char new) ：替换功能。
String replace(String old,String new) ：替换功能。
String trim()：去除字符串两空格。
int compareTo(String str) ：按字典顺序比较两个字符串。
int compareToIgnoreCase(String str)：按字典顺序比较两个字符串，忽略大小写。
public String[] split(String regex)：分隔字符串成字符数组。
举例代码如下：
public class StringDemo06 {
public static void main(String[] args) {
String s = "Hello你好World我好Java他也好";
System.out.println(s.replace('l', 'X'));
System.out.println(s.replace("Java", "Android"));
System.out.println(s.replaceAll("[\\u4e00-\\u9fa5]+", "*"));
String s2 = " Hello World ";
System.out.println(s2.trim() + "===========");
String s3 = "abcd";
String s4 = "abcd";
System.out.println(s3.compareTo(s4));
// 中文比较
Collator collator = Collator.getInstance(Locale.CHINA);
int compare = collator.compare("蠢", "贼");
System.out.println(compare);
// 这个是后面使用比较器 Comparator的核心方法
// public String[] split(String regex)：分隔字符串成字符数组。
String s5 = "Hello_World_Java";
String s6 = "Hello32341World32534Java";
String[] strs = s5.split("_");
System.out.println(Arrays.toString(strs));
System.out.println(Arrays.toString(s6.split("\\d")));
// 合并
CharSequence[] chs = {"Hello", "World", "Java"};
String join = String.join("+", chs);
System.out.println(join);
}
}
扫一扫
7124
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
