String字符串
*
* 1.String代表不可变的字符序列，不可变性
* 体现：①当对字符串重新赋值时，需要重写指定内存区域的值，不能使用原有的value进行赋值。
* ②当对现有的字符串进行连接字符串操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
* ③当调用String的replace()方法修改指定字符或者字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
* 1.String str1="abc";//字面量的定义方式
* * 通过字面量的方式（区别于new String()），给一个字符串赋值，此时的字符串声明在字符串常量池中
* * 字符串常量池中是不会存储相同内容的字符串的
*
*
* 2.String是一个final类,不可被继承
* 3.String是支持序列化的
* 4.String可以比较大小
public class StringTest {
/**
* String实例化的方式
* 1.通过字面量定义的方式
* 2.通过new+构造器的方式
*
*
* 面试题：String s=new String("abc");方式创建对象，在内存中创建了几个对象？
* 两个：一个是堆空间中的new结构，另一个是char[]对应的常量池中的数据“abc”
*
*
*/
@Test
public void test1()
{
//通过字面量定义的方式，此时s1、s2的数据javaEE声明在方法区中的字符串常量池中
String s1="javaEE";
String s2="javaEE";
//通过new+构造器的方式，此时s3、s4保存的地址值，是数据在堆空间中开辟空间之后对应的地址值
String s3=new String("javaEE");
String s4=new String("javaEE");
//true
System.out.println(s1==s2);
//false
System.out.println(s1==s3);
//false
System.out.println(s1==s4);
//false
System.out.println(s3==s4);
}
@Test
public void test2() {
/**
*
* 1.String str1="abc";//字面量的定义方式
* 通过字面量的方式（区别于new String()），给一个字符串赋值，此时的字符串声明在字符串常量池中
* 字符串常量池中是不会存储相同内容的字符串的
*/
String str1="abc";
String str2="abc";
//true
System.out.println(str1==str2);
str1="hello";
System.out.println(str1);
System.out.println(str2);
String s3="abc";
s3=s3+"def";
System.out.println(s3);
String s4="abc";
String s5 = s4.replace('a', 'm');
System.out.println(s4);
System.out.println(s5);
}
/**
* 字符串拼接
* 1.常量与常量的拼接结果在常量池。
* 2.只要有一个是变量，结果就在堆空间中。
* 3.如果拼接的结果调用intern()方法，放回值就在常量池中
*/
@Test
public void test3()
{
String s1="javaEE";
String s2="hadoop";
String s3="javaEEhadoop";
String s4="javaEE"+"hadoop";
String s5=s1+"hadoop";
String s6="javaEE"+s2;
//true
System.out.println(s3==s4);
//false
System.out.println(s3==s5);
//false
System.out.println(s3==s6);
//false
System.out.println(s5==s6);
//返回值得到的s8使用的常量值中已经存在的“javaEEhadoop”；
//true
String s8=s5.intern();
System.out.println(s3==s8);
}
/**
* 一道面试题
*/
@Test
public void test4()
{
String s1=new String("cat");
change(s1);
//cat
System.out.println(s1);
}
public void change(String str)
{
str="tom";
}
/**
* String常用方法
* int length()：返回字符串的长度
* char charAt(int index):返回某索引处的字符
* boolean isEmpty():判断是否是空字符串
* String toLowerCase():将String中所有字符转为小写
* String toUpperCase():将String中所有字符转为大写
* String trim():返回字符串的副本，忽略前导空白和尾部空白
* boolean equals(Object anObject):比较字符内容是否相同
* boolean equalsIgnoreCase(String anotherString)：忽略大小写，比较字符内容是否相同
* String substring(int beginIndex):返回一个新的字符串，它是从beginIndex开始截取到最后一个
* substring(int beginIndex, int endIndex) :返回一个新的字符串，它是从beginIndex开始截取到endIndex（不包含）
* int compareTo(String anotherString):比较两个字符串大小
*/
@Test
public void test5()
{
String s1="hello";
String s2="HELLO";
System.out.println(s1.length());
System.out.println(s1.charAt(0));
System.out.println(s1.isEmpty());
System.out.println(s2.toLowerCase());
System.out.println(s1.toUpperCase());
String s3=" he ll o ";
String s4=s3.trim();
System.out.println("------------"+s3+"------------");
System.out.println("------------"+s4+"------------");
String s5="helloworld";
String s6="helloworld";
String s7="Helloworld";
System.out.println(s5.equals(s6));
System.out.println(s5.equals(s7));
System.out.println(s5.equalsIgnoreCase(s7));
System.out.println(s5.substring(5));
System.out.println(s5.substring(0, 5));
String s8="abc";
String s9="abe";
System.out.println(s8.compareTo(s9));
}
/**
* 常用方法之二
*
* boolean endsWith(String suffix) :测试此字符串是否以指定的后缀结束
* boolean startsWith(String prefix):测试此字符串是否以指定的前缀开始
* boolean startsWith(String prefix, int toffset):测试此字符串从指定索引开始的子字符串是否以指定的前缀开始
* boolean contains(CharSequence s):当且仅当此字符串包含指定char值序列时，返回true（判断是否包含子字符串）
* int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引
* int indexOf(String str, int fromIndex):返回指定字符串在此字符串中第一次出现处的索引，从fromIndex处开始
* int lastIndexOf(String str):返回指定字符串在此字符串中最后一次出现处的索引
* int lastIndexOf(String str, int fromIndex)：返回指定字符串在此字符串中最后一次出现处的索引，fromIndex处开始
* 注：indexOf和lastIndexOf方法如果没有找到都是返回-1
*
*
*/
@Test
public void test6()
{
String s1="hellotxt";
System.out.println(s1.endsWith("txt"));
System.out.println(s1.startsWith("hello"));
System.out.println(s1.startsWith("ll", 2));
System.out.println(s1.contains("hello"));
System.out.println(s1.indexOf("llo"));
System.out.println(s1.indexOf("ll", 1));
String s2="hello123hello";
System.out.println(s2.lastIndexOf("hello"));
System.out.println(s2.lastIndexOf("hello",5));
}
/**
* 常用方法之三
* String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过newChar替换oldChar得来
* String replace(CharSequence target, CharSequence replacement):返回一个新的字符串，它是通过newString替换oldString得来
*
*
*/
@Test
public void test7()
{
String s1="我爱天安门";
System.out.println(s1.replace('天', '南'));
System.out.println(s1.replace("我爱", "他爱"));
}
}
public class StringTest2 {
/**
* String与基本数据类型、包装类之间的转换
* String --> 基本数据类型、包装类 ：调用包装类的parseXXX(str)
* 基本数据类型、包装类 --->String :调用String重载的valueOf(xxx)
*/
@Test
public void test1()
{
String str1="123";
int i = Integer.parseInt(str1);
System.out.println(i);
int j=100;
String str2=String.valueOf(j);
System.out.println(str2);
}
/**
* String 与char[]之间的转换。
* String --> char[]:String.toCharArray()
* char[] --> String:调用String构造器
*/
@Test
public void test2()
{
String str1="abc123";
char [] charArrays=str1.toCharArray();
for(char a:charArrays)
{
System.out.println(a);
}
char [] chars=new char[]{'a','b','c','d','e','f'};
String s1=new String(chars);
System.out.println(s1);
}
/**
* String与字节数组byte[]转换
* （编码）String -->byte[]:调用String的getBytes()方法 或 byte[] getBytes(String charsetName)
* （解码）byte[] -->String：调用String构造器 String(byte[] bytes) 、String(byte bytes[], String charsetName)
* 说明：解码时，要求解码使用的字符集必须与编码时使用的字符集一致，否则会出现乱码。
*/
@Test
public void test3()
{
String s1="hello中国";
//使用默认的字符集进行转换
byte [] bytes=s1.getBytes();
System.out.println(Arrays.toString(bytes));
//使用特定的字符集进行转换
try {
byte[] bytes2=s1.getBytes("gbk");
System.out.println(Arrays.toString(bytes2));
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
byte [] bytes1=new byte[]{110,111,101};
String s2=new String(bytes1);
//
byte [] bytes2=new byte[]{104, 101, 108, 108, 111, -42, -48, -71, -6};
String s3 = null;
try {
s3 = new String(bytes2,"gbk");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
System.out.println(s3);
}
}
