String的使用
str = str.concat("DEF123");//在末尾追加字符串，并返回新的字符串
str = str.substring(2);//从开始下标处截取到字符串末尾，并返回新的字符串
str = str.substring(1, 7);//从开始下标处(包含)截取到结束下标处(不包含)，并返回新的字符串
str = str.toUpperCase();//转大写，并返回新的字符串
str = str.toLowerCase();//转小写，并返回新的字符串
str = str.trim();//去除首尾空格，并返回新的字符串
str = str.replace('a', 'A');//替换字符，并返回新的字符串
str = str.replaceAll("123", "xxyyzz");//替换字符串，并返回新的字符串
str = str.replaceFirst("y", "888");//替换第一次出现的字符串，并返回新的字符串
str = str.replaceAll(" ", "");//去空格（把空格字符串替换成没有内容的字符串），并返回新的字符串
System.out.println("判断两个字符串内容是否相同(区分大小写)：" + str.equals("xx888yzzAbcDEF123"));//true
System.out.println("判断两个字符串内容是否相同(不区分大小写)：" + str.equalsIgnoreCase("XX888yzzABCDEF123"));//true
System.out.println("判断此字符串是否以某个字符串开头：" + str.startsWith("xx"));//true
System.out.println("判断此字符串是否以某个字符串结尾：" + str.endsWith("123"));//true
System.out.println("获取子字符串在此字符串中第一次的下标：" + str.indexOf("x"));//0
System.out.println("获取子字符串在此字符串中最后一次的下标：" + str.lastIndexOf("x"));//1
System.out.println("获取指定下标上的字符：" + str.charAt(5));//y
//将其他数据类型转换为字符串
System.out.println(String.valueOf(100));
System.out.println(String.valueOf(123.123));
System.out.println(String.valueOf('x'));
System.out.println(String.valueOf(true));
//将其他数据类型转换为字符串 - 最简便的方法
System.out.println(100 + "");
System.out.println(123.123 + "");
System.out.println('x' + "");
System.out.println(true + "");
StringBuffer的使用
StringBuffer代表可变的字符序列。
* StringBuffer称为字符串缓冲区
* 它的工作原理是：预先申请一块内存，存放字符序列，如果字符序列满了，
* 会重新改变缓存区的大小，以容纳更多的字符序列。
* StringBuffer是可变对象，这个是与String最大的不同
*
* class StringBuffer extends AbstractStringBuilder
//创建16个长度的字符数组
//StringBuffer sb = new StringBuffer();
//创建30个长度的字符数组
//StringBuffer sb = new StringBuffer(30);
//创建"123abc".length() + 16个长度的字符数组
StringBuffer sb = new StringBuffer("123abc");
sb.append("DEF123");//在末尾追加内容
sb.insert(6, "xyz");//在指定下标处插入字符串
sb.setCharAt(7, 'Y');//替换指定下标上的字符
sb.replace(6, 9, "$$$$");//从开始下标处(包含)替换到结束下标处(不包含)的字符串
sb.deleteCharAt(4);//删除指定下标上的字符
sb.delete(5, 9);//从开始下标处(包含)删除到结束下标处(不包含)的字符串
sb.reverse();//反转字符串 StringBuilder的使用
StringBuilder代表可变的字符序列
* StringBuilder称为字符串缓冲区
* 它的工作原理是：预先申请一块内存，存放字符序列，如果字符序列满了，
* 会重新改变缓存区的大小，以容纳更多的字符序列。
* StringBuilder是可变对象，这个是与String最大的不同
*
* class StringBuilder extends AbstractStringBuilder
//创建16个长度的字符数组
//StringBuilder sb = new StringBuilder();
//创建30个长度的字符数组
//StringBuilder sb = new StringBuilder(30);
//创建"123abc".length() + 16个长度的字符数组
StringBuilder sb = new StringBuilder("123abc");
sb.append("DEF123");//在末尾追加内容
sb.insert(6, "xyz");//在指定下标处插入字符串
sb.setCharAt(7, 'Y');//替换指定下标上的字符
sb.replace(6, 9, "$$$$");//从开始下标处(包含)替换到结束下标处(不包含)的字符串
sb.deleteCharAt(4);//删除指定下标上的字符
sb.delete(5, 9);//从开始下标处(包含)删除到结束下标处(不包含)的字符串
sb.reverse();//反转字符串
System.out.println(sb);//321FEDca321
/**
* StringBuffer vs StringBuidler
*
* 因为StringBuffer和StringBuidler都是继承的AbstractStringBuilder，
* 所以在使用层面上是一模一样
*
* StringBuffer：线程安全的（上锁），效率低
* StringBuilder：线程不安全（没有上锁），效率高
*/ String的面试题
//请问该代码会创建几个String对象？
//一个
//原因：“abc”存在常量池，常量池规定不允许有重复数据
//String str1 = "abc";
//String str2 = "abc";
//请问该代码会创建几个String对象？
//三个(常量池有一个，new了两个)
String str1 = new String("abc");
String str2 = new String("abc");String创建对象的问题
String str1 = "abc";
String str2 = "abc";
System.out.println(str1 == str2);//true
//因为"ab"和"c"都是常量，在编译时就直接拼接成"abc"
String str3 = "ab" + "c";
System.out.println(str1 == str3);//true
//因为s1和s2都是常量，在编译时就直接拼接成"abc"
final String s1 = "ab";
final String s2 = "c";
String str4 = s1 + s2;
System.out.println(str1 == str4);//true
//有变量的情况，底层会创建StringBuilder对象进行拼接
String s3 = "ab";
String s4 = "c";
String str5 = s3 + s4;//new StringBuilder(s3).append(s4).toString()
System.out.println(str1 == str5);//false频繁拼接字符串
频繁拼接字符串，请使用StringBuilder或StringBuffer
//获取自1970.1.1 0:0:0 到现在的毫秒数（1000毫秒 = 1秒）
// long startTime = System.currentTimeMillis();
//
// String str = "老师";
// for (int i = 0; i < 10000; i++) {
// str += "教育学生";
// //str = str+"教育学生";
// //str = new StringBuilder(str).append("教育学生").toString();
// }
//
// long endTime = System.currentTimeMillis();
// System.out.println("消耗时长：" + (endTime-startTime));//389
//---------------
//获取自1970.1.1 0:0:0 到现在的毫秒数（1000毫秒 = 1秒）
long startTime = System.currentTimeMillis();
StringBuilder sb = new StringBuilder("老师");
for (int i = 0; i < 10000; i++) {
sb.append("教育学生");
}
long endTime = System.currentTimeMillis();
System.out.println("消耗时长：" + (endTime-startTime));//1包装类
含义：8种基本数据类型对应的类
出现原因：8种基本数据类型不能创建对象，破坏了Java为纯面向对象语言的特征，所以Java又为8种基本数据类型分别匹配了类，这种类叫做包装类/封装类
基本数据类型 包装类 继承关系
* byte Byte Object.Number.Byte
* short Short Object.Number.Short
* int Integer Object.Number.Integer
* long Long Object.Number.Long
* float Float Object.Number.Float
* double Double Object.Number.Double
* char Character Object.Character
* boolean Boolean Object.Boolean//手动装箱：基本数据类型 转 包装类
// int i = 100;
// Integer integer = Integer.valueOf(i);
// System.out.println(integer);
//手动拆箱：包装类 转 基本数据类型
// Integer integer = new Integer(100);
// int i = integer.intValue();
// System.out.println(i);
//JDK1.5的新特性：自动装箱、自动拆箱
//自动装箱：基本数据类型 转 包装类
// int i = 100;
// Integer integer = i;//底层：Integer.valueOf(i);
// System.out.println(integer);
//自动拆箱：包装类 转 基本数据类型
// Integer integer = new Integer(100);
// int i = integer;//底层：integer.intValue();
// System.out.println(i);
//将字符串转换为int值
String str = "123";
int i = Integer.parseInt(str);
System.out.println(i);包装类的面试题
Integer integer1 = Integer.valueOf(100);
Integer integer2 = Integer.valueOf(100);
System.out.println(integer1 == integer2);//true
Integer integer3 = Integer.valueOf(200);
Integer integer4 = Integer.valueOf(200);
System.out.println(integer3 == integer4);//true
System.out.println("-----------------");
MyInteger myInteger1 = MyInteger.valueOf(100);
MyInteger myInteger2 = MyInteger.valueOf(100);
System.out.println(myInteger1 == myInteger2);//true
MyInteger myInteger3 = MyInteger.valueOf(200);
MyInteger myInteger4 = MyInteger.valueOf(200);
System.out.println(myInteger3 == myInteger4);//true
964
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
