String
String是最常操作的引用类型了，但也是我最怕的地方（因为不熟悉），最怕还是String和Array同时出现，所以现在先写下一篇博客熟悉熟悉字符串
0. 字符串非空
if( str == null || str.length() == 0){
System.out.println("11");
}1.字符串的不可变性
我们常说String是不可变的，但的对应的变量为什么还是能"改"为不同的字符串呢？
来看一下String的部分源码
- 在114行可以看出，String内部使用数组来存储，使用了private与final修饰，且内部没有修改value数组的方法，所以一旦定义就不能修改，即String的不可变性
不可变性的好处
- 不可变才有字符串常量池，优化空间
- 存储hashCode的，因为经常使用
- 线程安全，因为不可变
2. 但为什么我们的变量还是能改为不同的字符串呢？
String a = new String("String不可变性");
a = new String("String确定不可变吗？");
System.out.println(a);
//输出
//String确定不可变吗？- 其实字符串都没有变，变的是a的引用地址，这样看起来貌似字符串改变了罢了
3. String Pool
创建字符串会放到字符串常量池中，下次创建相同的字符串会从常量池中拿取引用，所以相同字符串引用相同
String a = "String不可变性"; //字面量
String b = "String不可变性";
System.out.println(a == b);
//输出
//true
//但new关键字是在堆中复制一个副本，引用地址给了变量，所以指向的对象的地址不同
String a1 = new String("String不可变性"); //对象
String b1 = new String("String不可变性");
System.out.println(a1 == b1);
//输出
//false对JVM不熟悉的同学可以看我另一篇 学不会的JVM
4. 连接符 “+”
//字符串常量，JVM会优化，在字符串常量池直接存放“123”
String a = "1" + "2" + "3";
//字符串变量，会在底层创建StringBuilder,然后append，最后toString返回
String a = new String("1") + new String("2");5. 构造方法及常用方法
构造函数 | 解释 |
|---|---|
String(byte[] bytes, String charsetName) | 构造一个新的String用指定的字节数组和解码 |
String(String original) | 初始化新创建的String对象，新创建的字符串是参数字符串的副本 |
String(StringBuffer buffer) | 其中包含当前包含在字符串缓冲区参数中的字符序列 |
String(StringBuilder builder) | 其中包含当前包含在字符串构建器参数中的字符序列 |
返回值 | 方法名 | 解释 |
|---|---|---|
char | charAt(int index) | 返回指定索引处的字符 |
int | compareTo(String anotherString) | 按字典顺序比较两个字符串 |
int | compareToIgnoreCase(String str) | 按字典顺序比较两个字符串，忽略大小写 |
String | concat(String str) | 将指定的字符串连接到该字符串的末尾 |
boolean | contains(Strin str) | 判断字符串中是否有指定的子字符串 |
boolean | equals(Object anObject) | 判断值是否相同 |
byte[] | getBytes(String charsetName) | 使用命名的字符集将此String编码为字节序列 |
int | length() | 返回此字符串的长度 |
int | indexOf(int ch,int fromIndex) | 返回指定字符第一次出现的字符串内的索引，从指定索引开始 |
int | lastIndexOf(int ch) | 返回指定字符最后一次出现的字符串内的索引 |
String [] | split(String regex) | 将此字符串分割为给定的字符串 |
String | substring(int beginIndex,int endIndex) | 返回一个字符串，该字符串是此字符串的子字符串。 |
char[] | toCharArray() | 将此字符串转换为新的字符数组 |
String | trim() | 返回一个字符串，删除任何前导和尾随空格 |
String | replace(old char/String, new char/String) | 返回一个新字符串 |
boolean | matches(String regex) | 是否匹配正则 |
计算字串出现的次数
public int StrTimes(String a,String b){
int count = 0
int fromIndex = 0;
while( (fromIndex = a.indexOf(b,fromIndex)) != -1 ){
fromIndex += b.length();
count++;
}
return count;
}6. StringBuilder和StringBuffer
- StringBuilder线程不安全，速度稍快
- StringBuffer 线程安全，速度稍慢
他俩的实现方式是创建一个可变的底层数组，且提供各种改变数组序列的方法
这里来看StringBuffer ，StringBuilder类似，就不讲了
- 二者都继承AbstractStringBuilder
- 66行super()默认构造函数使用父类的，默认大小为16，底层也是字符数组
- 会自动扩容，扩为原数组的2倍加2，这时是创建一个新的数组，并将原数组复制到新数组（与集合扩容类似）
- 线程安全来源于synchronized
常见方法
构造函数
构造函数 | 解释 |
|---|---|
StringBuffer() | 构造一个没有字符的字符串缓冲区，初始容量为16个字符 |
StringBuffer(String str) | 构造一个初始化为指定字符串内容的字符串缓冲区，大小为str.length()+16 |
StringBuffer(int capacity) | 构造一个没有字符的字符串缓冲区和指定的初始容量 |
常用方法
返回值 | 方法名 | 解释 |
|---|---|---|
StringBuffer | append(String str) | 将指定的字符串附加到此字符序列 |
int | capacity() | 返回当前容量 |
StringBuffer | delete(int start, int end) | 删除此序列的子字符串中的字符 |
StringBuffer | insert(int offset, String str) | 将字符串插入到此字符序列中 |
int | length() | 返回长度（字符数） |
StringBuffer | replace(int start, int end, String str) | 用指定的String中的字符替换此序列的子字符串 |
StringBuffer | reverse() | 导致该字符序列被序列的相反代替 |
String | toString() | 返回表示此顺序中的数据的字符串 |
| 并且有String的方法 | |
简单操作
可以链式操作，因为返回的是this本对象
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append("123")
.append("abc")
.append("-----")
.delete(0, 3)
.replace(3, 5, "dddd")
.insert(7, "e");
System.out.println(stringBuffer.length());
System.out.println(stringBuffer.capacity());
System.out.println(stringBuffer.toString());
System.out.println(stringBuffer.reverse());11
16
abcdddde---
---eddddcba7. 总结
String适合操作少量数据
StringBuffer适合线程安全操作大量数据
StringBuilder适合单线程操作大量数据
没有地方写，补充一下日期的格式化
Date date = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
System.out.println(sdf.format(date));
//2019-44-29 21:44:288 补充
java是按值传递，不是引用传递，下面举例
public class Pass {
public static void test(int a, String b, User user){
a = 2;
b = "bb";
user.name = "Change";
System.out.println(a);
System.out.println(b);
System.out.println(user.name);
}
public static void main(String[] args) {
int a = 1;
String b = "b";
User user = new User("Howl");
test(a, b, user);
System.out.println("--------------上面是传递改变，下面是未传递前----------------");
System.out.println(a);
System.out.println(b);
System.out.println(user.name);
}
}2
bb
Change
--------------上面是传递改变，下面是未传递前----------------
1
b
Change这里有个冲突分歧怪异点：为什么String和user对象只有user才能被改变？难道只有自定义对象才是按值传递？
非也，基本类型是按值传递这里大家没有意见把，主要在于引用类型是按值传递还是引用传递？其实这里应该在上面的test方法里加多一个语句才好理解
public static void test(int a, String b, User user){
a = 2;
b = "bb";
user = new User("Change"); // 加的语句在这里
// user.name = "Change";
System.out.println(a);
System.out.println(b);
System.out.println(user.name);
}2
bb
Change?
--------------上面是传递改变，下面是未传递前----------------
1
b
Howl改变语句后，引用传递的效果就失去了，下面来分析一下：
public static void test(int a, String b, User user){
a = 2; // 参数a传递过来的是副本，即按值传递
b = "bb"; // 这里String类型有点特殊，b = “bb” 相当于 b = new String(“bb”),新建了一个对象
user = new User("Change"); // 把user的指向改为new User("XXX"),这里就明示出不是引用传递
// user.name = "Change"; // test方法里和main方法里的user都指向堆内存同一个对象，当然可以改变
System.out.println(a);
System.out.println(b);
System.out.println(user.name);
}总结一下：基本类型按值传递，引用类型的传参传的是地址的副本，在给参数中的引用类型赋值时，改变的是参数的地址，即不属于引用传递，下面画图更好理解
没加入语句前
加入语句前
