String
1、String表示字符串类型,属于引用数据类型,不属于基本数据类型。
2、在java中随便使用双引号括起来的都是String对象。例如:“abc”,“def”,“hello world!”,这是3个String对象。
3、java中规定,双引号括起来的字符串,是不可变的,也就是说"abc"自出生到最终死亡,不可变,不能变成"abcd",也不能变成"ab"
4、在JDK当中双引号括起来的字符串,例如:“abc” "def"都是直接存储在“方法区”的“字符串常量池”当中的。
为什么SUN公司把字符串存储在一个“字符串常量池”当中呢。因为字符串在实际的开发中使用太频繁。为了执行效率, 所以把字符串放到了方法区的字符串常量池当中。
public static void main(String[] args) {
String s1 = "hello";
// "hello"是存储在方法区的字符串常量池当中
// 所以这个"hello"不会新建。(因为这个对象已经存在了!)
String s2 = "hello";
// 分析结果是true还是false?
// == 双等号比较的是不是变量中保存的内存地址?是的。
System.out.println(s1 == s2); // true
String x = new String("xyz");
String y = new String("xyz");
// 分析结果是true还是false?
// == 双等号比较的是不是变量中保存的内存地址?是的。
System.out.println(x == y); //false
// 通过这个案例的学习,我们知道了,字符串对象之间的比较不能使用“==”
// "=="不保险。应该调用String类的equals方法。
// String类已经重写了equals方法,以下的equals方法调用的是String重写之后的equals方法。
System.out.println(x.equals(y)); // true
String k = new String("testString");
//String k = null;
// "testString"这个字符串可以后面加"."呢?
// 因为"testString"是一个String字符串对象。只要是对象都能调用方法。
System.out.println("testString".equals(k)); // 建议使用这种方式,因为这个可以避免空指针异常。
System.out.println(k.equals("testString")); // 存在空指针异常的风险。不建议这样写。
}
}
关于String类中的构造方法
- String s = new String("");
//创建一个字符串对象,不常用
String s=new String("abc");
- String s = " ";
//常用方法
String s="abc"
- String s = new String(char数组);
//创建一个char数组
char[] chars = {'张','小','小','是','猪'};
//将char数组装换成字符串
String s4 = new String(chars);//张小小是猪
- String s = new String(char数组,起始下标,长度);
//创建一个char数组
char[] chars = {'张','小','小','是','猪'};
//将char数组装换成字符串
String s4 = new String(chars, 0, 3);//张小小
- String s = new String(byte数组);
//创建一个byte数组
//97是a,98是b,99是c
byte[] bytes = {97, 98, 99};
//调用方法把byte数组装换成字符串
String s2 = new String(bytes);//abc
- String s = new String(byte数组,起始下标,长度)
//创建一个byte数组
//97是a,98是b,99是c
byte[] bytes = {97, 98, 99};
//调用方法把byte数组装换成字符串
String s2 = new String(bytes,1,2);//bc
关于String类中的常用方法
- .charAt(int index)
//"中国人"是一个字符串String对象。只要是对象就能调方法
char c = "中国人".charAt(1);
System.out.println(c); // 国
- .compareTo(String anotherString)
// 字符串之间比较大小不能直接使用 > < ,需要使用compareTo方法。
int result = "abc".compareTo("abc");
System.out.println(result); //0(等于0) 前后一致 10 - 10 = 0
int result2 = "abcd".compareTo("abce");
System.out.println(result2); //-1(小于0) 前小后大 8 - 9 = -1
int result3 = "abce".compareTo("abcd");
System.out.println(result3); // 1(大于0) 前大后小 9 - 8 = 1
// 拿着字符串第一个字母和后面字符串的第一个字母比较。能分胜负就不再比较了。
System.out.println("xyz".compareTo("yxz")); // -1
- .contains(CharSequence s)
// 判断前面的字符串中是否包含后面的子字符串。
System.out.println("HelloWorld.java".contains(".java")); // true
System.out.println("http://www.baidu.com".contains("https://")); // false
- .startsWith(String prefix)
// 判断某个字符串是否以某个子字符串开始。
System.out.println("http://www.baidu.com".startsWith("http")); // true
System.out.println("http://www.baidu.com".startsWith("https")); // false
- .endsWith(String suffix)
// 判断当前字符串是否以某个子字符串结尾。
System.out.println("test.txt".endsWith(".java")); // false
System.out.println("test.txt".endsWith(".txt")); // true
System.out.println("fdsajklfhdkjlsahfjkdsahjklfdss".endsWith("ss")); // true
- .equals(Object obj)
// 比较两个字符串必须使用equals方法,不能使用“==”
System.out.println("abc".equals("abc")); // true
- .equalsIgnoreCase(String anotherString)
// 判断两个字符串是否相等,并且同时忽略大小写。
System.out.println("ABc".equalsIgnoreCase("abC")); // true
- .getBytes()
// 将字符串对象转换成字节数组
byte[] bytes = "abcdef".getBytes();
for(int i = 0; i < bytes.length; i++){
System.out.println(bytes[i]);
}
//97,98,99...
- .indexOf(String str);
// 判断某个子字符串在当前字符串中第一次出现处的索引(下标)。
System.out.println("oraclejavac++.".indexOf("java")); // 6
- .isEmpty();
// 判断某个字符串是否为“空字符串”。底层源代码调用的应该是字符串的length()方法。
//String s = "";
String s = "a";
System.out.println(s.isEmpty());
- .length()
// 判断数组长度和判断字符串长度不一样
// 判断数组长度是length属性,判断字符串长度是length()方法。
System.out.println("abc".length()); // 3
System.out.println("".length()); // 0
- .lastIndexOf(String str)
// 判断某个子字符串在当前字符串中最后一次出现的索引(下标)
System.out.println("oraclejavac++".lastIndexOf("java")); //22
- .replace(CharSequence target, CharSequence replacement);
// 替换。
// String的父接口就是:CharSequence
String str= "http://www.baidu.com".replace("http://", "https://");
System.out.println(str); //https://www.baidu.com
// 把以下字符串中的“=”替换成“:”
String str2 = "name=zhangsan&password=123&age=20".replace("=", ":");
System.out.println(str2); //name:zhangsan&password:123&age:20
- .split(String regex);
// 拆分字符串
String[] str = "1980-10-11".split("-"); //"1980-10-11"以"-"分隔符进行拆分。
for(int i = 0; i < str.length; i++){
System.out.println(str[i]);
}
String param = "name=zhangsan&password=123&age=20";
String[] params = param.split("&");
for(int i = 0; i <params.length; i++){
System.out.println(params[i]);
// 可以继续向下拆分,可以通过“=”拆分。
}
- .toLowerCase();
// 转换为小写。
System.out.println("ABCDefKXyz".toLowerCase());
//abcdefkxyz
- .trim();
// 去除字符串前后空白
System.out.println(" hello world ".trim());
//hello world
- .valueOf();
//静态的,不需要new对象
// 作用:将“非字符串”转换成“字符串”
String s1 = String.valueOf(true);
String s1 = String.valueOf(100);
String s1 = String.valueOf(3);
StringBuffer
思考:我们在实际的开发中,如果需要进行字符串的频繁拼接,会有什么问题?
因为java中的字符串是不可变的,每一次拼接都会产生新字符串。这样会占用大量的方法区内存。造成内存空间的浪费。
String s = “abc”;
s += “hello”;
就以上两行代码,就导致在方法区字符串常量池当中创建了3个对象: “abc”, “hello”, “abchello”
所以如果以后需要进行大量字符串的拼接操作,建议使用JDK中自带的:
java.lang.StringBuffer
public static void main(String[] args) {
// 创建一个初始化容量为16个byte[] 数组。(字符串缓冲区对象)
StringBuffer stringBuffer = new StringBuffer();
// 拼接字符串,以后拼接字符串统一调用 append()方法。
// append是追加的意思。
stringBuffer.append("a");
stringBuffer.append("b");
stringBuffer.append("d");
stringBuffer.append(3.14);
stringBuffer.append(true);
// append方法底层在进行追加的时候,如果byte数组满了,会自动扩容。
stringBuffer.append(100L);
System.out.println(stringBuffer.toString());
// 指定初始化容量的StringBuffer对象(字符串缓冲区对象)
StringBuffer sb = new StringBuffer(100);
sb.append("hello");
sb.append("world");
System.out.println(sb);//helloworld
}
}
扩展
1、面试题:String为什么是不可变的?
我看过源代码,String类中有一个byte[]数组,这个byte[]数组采用了final修饰,因为数组一旦创建长度不可变。并且被final修饰的引用一旦指向某个对象之后,不可再指向其它对象,所以String是不可变的!
“abc” 无法变成 “abcd”
2、StringBuilder/StringBuffer为什么是可变的呢?
我看过源代码,StringBuffer/StringBuilder内部实际上是一个byte[]数组,这个byte[]数组没有被final修饰,StringBuffer/StringBuilder的初始化容量我记得应该是16,当存满之后会进行扩容,底层调用了数组拷贝的方法
System.arraycopy()…是这样扩容的。所以StringBuilder/StringBuffer,适合于使用字符串的频繁拼接操作。
public static void main(String[] args) {
// 字符串不可变是什么意思?
// 是说双引号里面的字符串对象一旦创建不可变。
String s = "abc"; //"abc"放到了字符串常量池当中。"abc"不可变。
// s变量是可以指向其它对象的。
// 字符串不可变不是说以上变量s不可变。说的是"abc"这个对象不可变。
s = "xyz";
//"xyz"放到了字符串常量池当中。"xyz"不可变
Date
1、获取系统当前时间
// 直接调用无参数构造方法就行。
Date d = new Date();
2、日期格式化:Date --> String
//调用方法格式化日期
SimpleDateFormat sdf = new SimpleDate("yyyy-MM-dd HH:mm:ss SSS");
String s = sdf.format(new Date());
3、String --> Date
// 假设现在有一个日期字符串String,怎么转换成Date类型?
String time = "2008-08-08 08:08:08 888"; //SimpleDateFormat sdf2 = new SimpleDateFormat("格式不能随便写,要和日期字符串格式相同");
// 注意:字符串的日期格式和SimpleDateFormat对象指定的日期格式要一致。不然会出现异常:java.text.ParseException
SimpleDateFormat sdf2 = newSimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
Date dateTime = sdf2.parse(time);
System.out.println(dateTime); //Fri Aug 08 08:08:08 CST 2008
4、获取毫秒数
long begin = System.currentTimeMillis();
Date d = new Date(begin - 1000 * 60 * 60 * 24);
Number
1、BigDecimal 属于大数据,精度极高。不属于基本数据类型,属于java对象(引用数据类型)这是SUN提供的一个类。专门用在财务软件当中。
public static void main(String[] args) {
// 这个100不是普通的100,是精度极高的100
BigDecimal v1 = new BigDecimal(100);
// 精度极高的200
BigDecimal v2 = new BigDecimal(200);
// 求和
// v1 + v2; // 这样不行,v1和v2都是引用,不能直接使用+求和。
BigDecimal v3 = v1.add(v2); // 调用方法求和。
System.out.println(v3); //300
BigDecimal v4 = v2.divide(v1);
System.out.println(v4); // 2
}
}
Random
随机数
public static void main(String[] args) {
// 创建随机数对象
Random random = new Random();
// 随机产生一个int类型取值范围内的数字。
int num1 = random.nextInt();
System.out.println(num1);
// 产生[0~100]之间的随机数。不能产生101。
// nextInt翻译为:下一个int类型的数据是101,表示只能取到100.
int num2 = random.nextInt(101); //不包括101
System.out.println(num2);
}
}