Java基础(3)常用API
常用API
常用包:lang,util,io
1,Object
toString() //返回运行时类类型。 getClass() equals() hashCode() //返回对象的哈希码值。 clone() //根据原对象复制一个新对象 //分配一个和源对象同样大小的空间,在这个空间中创建一个新的对象 finalize() //释放资源 wait() //线程休眠 notify() //唤醒在该对象上等待的某个线程 notifyAll() //唤醒该对象上的等待的所有线程
clone与copy的区别
Employee tobby = new Employee(“CMTobby”,5000)
Employee cindy = tobby
这是copy,改变cindy的值,tobby的也会改变。
Employee tom= tobby.clone();
这是clone,是一个新对象,改变cindy的值,tobby的不会改变。
浅拷贝与深拷贝
clone方法执行的是浅拷贝
实现深拷贝:在类中重写clone方法。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vwEJOUNz-1594542740254)(Java基础.assets/1592879940804.png)]
equals()和==的区别
==判断的是两个对象的引用地址是否相同,即这两个是不是同一个对象。
object类的equals()方法实际上也是使用==实现的,但是Sting和Integer等一些类重写了equals()方法,条件是根据里面的内容判断是否相等。
2,包装类
基本数据类型 | 对应的包装类 |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
char | Character |
float | Float |
double | Double |
boolean | Boolean |
包装类介绍:
基本类型的数据不具备“对象”的特性——不携带属性、没有方法可调用。 沿用它们只是为了迎合人类根深蒂固的习惯,并的确能简单、有效地进行常规数据处理。不支持面向对象编程。
每个包装类的对象可以封装一个相应的基本类型的数据,并提供了其它一些有用的方法。包装类对象一经创建,其内容(所封装的基本类型数据值)不可改变。
基本类型和对应的包装类可以相互转换
由基本类型向对应的包装类转换称为装箱,例如把 int 包装成 Integer 类的对象;
包装类向对应的基本类型转换称为拆箱,例如把 Integer 类的对象重新简化为 int。
包装类的应用
实现 int 和 Integer 的相互转换、
intValue()
public static void main(String[] args) { int m = 500; Integer obj = new Integer(m); // 手动装箱 int n = obj.intValue(); // 手动拆箱 System.out.println("n = " + n); Integer obj1 = new Integer(500); System.out.println("obj 等价于 obj1?" + obj.equals(obj1)); }
将字符串转换为整数
Integer.parseInt()
public static void main(String[] args) { String[] str = {"123", "123abc", "abc123", "abcxyz"}; for(String str1 : str){ try{ int m = Integer.parseInt(str1, 10); System.out.println(str1 + " 可以转换为整数 " + m); }catch(Exception e){ System.out.println(str1 + " 无法转换为整数"); } } } //结果 123 可以转换为整数 123 123abc 无法转换为整数 abc123 无法转换为整数 abcxyz 无法转换为整数
将整数转换为字符串
Integer.toString()
public static void main(String[] args) { int m = 500; String s = Integer.toString(m); String s2 = m+""; System.out.println("s = " + s); }
自动拆箱和装箱
public static void main(String[] args) { int m = 500; Integer obj = m; // 自动装箱 int n = obj; // 自动拆箱 System.out.println("n = " + n); Integer obj1 = 500; System.out.println("obj 等价于 obj1?" + obj.equals(obj1)); } //结果: // n = 500 // obj 等价于 obj1?true
总结
- 所有的包装类都是Number类的子类。
package java.lang; public abstract class Number implements java.io.Serializable { //以下都是拆箱操作,拆成对应的方法返回类型。 public abstract int intValue(); public abstract long longValue(); public abstract float floatValue(); public abstract double doubleValue(); public byte byteValue() { return (byte)intValue(); } public short shortValue() { return (short)intValue(); } private static final long serialVersionUID = -8742448824652078965L; }
- Integer常用方法
//类方法 //1.两数操作 static int max(int a, int b) //返回两个 int的较大值,就像调用 Math.max一样 。 static int min(int a, int b) //返回两个 int的较小值,就像调用 Math.min一样 。 static int sum(int a, int b) //根据+运算符将两个整数相加。 //2.String转int static int parseInt(String s) //将字符串参数解析为带符号的十进制整数。 static int parseInt(String s, int radix) //将字符串参数解析为第二个参数指定的基数中的有符号整数。 //3.int转String static String toString(int i) //返回一个 String指定整数的 String对象。 static String toString(int i, int radix) //返回由第二个参数指定的基数中的第一个参数的字符串表示形式。 static String toBinaryString(int i) //在基数2中返回整数参数的字符串表示形式为无符号整数。 static String toHexString(int i) //返回整数参数的字符串表示形式,作为16位中的无符号整数。 static String toOctalString(int i) //在基数8中返回整数参数的字符串表示形式为无符号整数。 //4.int转Integer static Integer valueOf(int i) //返回一个 Integer指定的 int值的 Integer实例。 static Integer valueOf(String s) //返回一个 Integer对象,保存指定的值为 String 。 //对象方法 //5.两数比较 int compareTo(Integer anotherInteger) //数字比较两个 Integer对象。 //6.父类Number中的对象方法。 Integer转int int intValue()...
3,Math
//1.类属性 Math.PI 记录的圆周率 Math.E 记录e的常量 static double ceil(double a) //向上取整(4.1 -> 5) static double floor(double a) //向下取整(4.8 -> 4) Math.IEEEremainder //求余 Math.max //求两数中最大 Math.min //求两数中最小 Math.sqrt //求开方 Math.pow //求某数的任意次方, 抛出ArithmeticException处理溢出异常 Math.exp //求e的任意次方 Math.log10 //以10为底的对数 Math.log //自然对数 Math.rint //求距离某数最近的整数(可能比某数大,也可能比它小) Math.round //同上,返回int型或者long型(上一个函数返回double型) Math.random //返回0,1之间的一个随机数 Math.abs //求绝对值 Math.sin //正弦函数 Math.asin 反正弦函数 Math.cos //余弦函数 Math.acos 反余弦函数 Math.tan //正切函数 Math.atan 反正切函数 Math.atan2 商的反正切函数 Math.toDegrees //弧度转化为角度 Math.toRadians 角度转化为弧度
public static void main(String[] args) { /** *Math.sqrt()//计算平方根 *Math.cbrt()//计算立方根 *Math.pow(a, b)//计算a的b次方 *Math.max( , );//计算最大值 *Math.min( , );//计算最小值 */ System.out.println(Math.sqrt(16)); //4.0 System.out.println(Math.cbrt(8)); //2.0 System.out.println(Math.pow(3,2)); //9.0 System.out.println(Math.max(2.3,4.5));//4.5 System.out.println(Math.min(2.3,4.5));//2.3 /** * abs求绝对值 */ System.out.println(Math.abs(-10.4)); //10.4 System.out.println(Math.abs(10.1)); //10.1 /** * ceil天花板的意思,就是返回大的值 */ System.out.println(Math.ceil(-10.1)); //-10.0 System.out.println(Math.ceil(10.7)); //11.0 System.out.println(Math.ceil(-0.7)); //-0.0 System.out.println(Math.ceil(0.0)); //0.0 System.out.println(Math.ceil(-0.0)); //-0.0 System.out.println(Math.ceil(-1.7)); //-1.0 /** * floor地板的意思,就是返回小的值 */ System.out.println(Math.floor(-10.1)); //-11.0 System.out.println(Math.floor(10.7)); //10.0 System.out.println(Math.floor(-0.7)); //-1.0 System.out.println(Math.floor(0.0)); //0.0 System.out.println(Math.floor(-0.0)); //-0.0 /** * random 取得一个大于或者等于0.0小于不等于1.0的随机数 [0,1) */ System.out.println(Math.random()); //小于1大于0的double类型的数 System.out.println(Math.random()+1);//大于1小于2的double类型的数 /** * rint 四舍五入,返回double值 * 注意.5的时候会取偶数 异常的尴尬=。= */ System.out.println(Math.rint(10.1)); //10.0 System.out.println(Math.rint(10.7)); //11.0 System.out.println(Math.rint(11.5)); //12.0 System.out.println(Math.rint(10.5)); //10.0 System.out.println(Math.rint(10.51)); //11.0 System.out.println(Math.rint(-10.5)); //-10.0 }
4,Random
-
java.lang.Math.random()
调用这个Math.Random()函数能够返回带正号的double值,该值大于等于0.0且小于1.0。
即取值范围是 [0.0,1.0) 的左闭右开区间。
public static void main(String[] args) { // 结果是个double类型的值,区间为[0.0,1.0) System.out.println("Math.random()=" + Math.random()); int num = (int) (Math.random() * 3); // 注意不要写成(int)Math.random()*3,这个结果为0或1,因为先执行了强制转换 System.out.println("num=" + num); } //结果 //Math.random()=0.44938147153848396 //num=1
-
java.util.Random
Random r1 = new Random(); //默认当前系统时间的毫秒数作为种子数: Random r1 = new Random(20); //构造Random对象的时候指定种子 //种子数解释: //你在创建一个Random对象的时候可以给定任意一个合法的种子数,种子数只是随机算法的起源数字,和生成的随机数的区间没有任何关系。 //常用方法 nextInt(10) nextBoolean() protected int next(int bits)://生成下一个伪随机数。 boolean nextBoolean()://返回下一个伪随机数,它是取自此随机数生成器序列的均匀分布的boolean值。 void nextBytes(byte[] bytes)://生成随机字节并将其置于用户提供的 byte 数组中。 double nextDouble()://返回下一个伪随机数,它是取自此随机数生成器序列的、在0.0和1.0之间均匀分布的 double值。 float nextFloat()://返回下一个伪随机数,它是取自此随机数生成器序列的、在0.0和1.0之间均匀分布float值。 double nextGaussian()://返回下一个伪随机数,它是取自此随机数生成器序列的、呈高斯(“正态”)分布的double值,其平均值是0.0标准差是1.0。 int nextInt()://返回下一个伪随机数,它是此随机数生成器的序列中均匀分布的 int 值。 int nextInt(int n)://返回一个伪随机数,它是取自此随机数生成器序列的、在(包括和指定值(不包括)之间均匀分布的int值。 long nextLong()://返回下一个伪随机数,它是取自此随机数生成器序列的均匀分布的 long 值。 void setSeed(long seed)://使用单个 long 种子设置此随机数生成器的种子。
//案例1 public static void main(String[] args) { Random ran1 = new Random(10); System.out.println("使用种子为10的Random对象生成[0,10)内随机整数序列: "); for (int i = 0; i < 10; i++) { System.out.print(ran1.nextInt(10) + " "); } System.out.println(); Random ran2 = new Random(10); System.out.println("使用另一个种子为10的Random对象生成[0,10)内随机整数序列: "); for (int i = 0; i < 10; i++) { System.out.print(ran2.nextInt(10) + " "); } System.out.println("Math.random()"); for (int i = 0; i < 10; i++) { System.out.print((int)(Math.random()*10) + " "); } } 使用种子为10的Random对象生成[0,10)内随机整数序列: 3 0 3 0 6 6 7 8 1 4 使用另一个种子为10的Random对象生成[0,10)内随机整数序列: 3 0 3 0 6 6 7 8 1 4 Math.random() 4 9 3 1 3 7 8 9 6 3
//案例2 int n2 = r.nextInt(10); //生成[0,10)区间的整数。 double d1 = r.nextDouble(); //生成[0,1.0)区间的小数。 double d2 = r.nextDouble() * 5; //生成[0,5.0)区间的小数。 double d3 = r.nextDouble() * 1.5 + 1; //生成[1,2.5)区间的小数。
5,Date
//构造方法 Date() //分配一个 Date对象,并初始化它,以便它代表它被分配的时间,测量到最近的毫秒。 Date(long date) //分配一个 Date对象,并将其初始化为表示自称为“时代”的标准基准时间以后的指定毫秒数,即1970年1月1日00:00:00 GMT。 //常用方法 boolean after(Date date) //若当调用此方法的Date对象在指定日期之后返回true,否则返回false。 boolean before(Date date) //若当调用此方法的Date对象在指定日期之前返回true,否则返回false。 int compareTo(Date date) //比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。 int compareTo(Object obj) //若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。 long getTime( ) //返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。 void setTime(long time) //用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。 Object clone( ) //返回此对象的副本。 boolean equals(Object date) //当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。 int hashCode( ) //返回此对象的哈希码值。 String toString( ) //把此 Date 对象转换为以下形式的 String: // dow mon dd hh:mm:ss zzz yyyy --> 星期 月份 几号 时:分:秒 时区 年份 // Sat Apr 27 15:09:43 CST 2019
public static void main(String args[]) { // 初始化 Date 对象 Date date = new Date(); // 使用 toString() 函数显示日期时间 System.out.println(date.toString()); //Sat Apr 27 15:09:43 CST 2019 } public static void main(String[] args){ Date date = new Date(); long time = date.getTime(); long time2 = date.getTime(); System.out.println(time==time2); //true } public static void main(String[] args) { boolean before = new Date(97, 01, 05).before(new Date(99, 11, 16)); System.out.println(before); //true }
SimpleDateFormat
SimpleDateFormat 是一个以语言环境敏感的方式来格式化和分析日期的类。SimpleDateFormat 允许你选择任何用户自定义日期时间格式来运行。
public static void main(String[] args){ SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); Date date = new Date(); String s = format.format(date); System.out.println(s); //2020-06-23 15:19:35 }
// yyyyy完整年份 yy年份后两位 // MM月份 mm分钟 // HH24小时 hh12小时 //SimpleDateFormat函数语法: G 年代标志符 y 年 M 月 d 日 h 时 在上午或下午 (1~12) H 时 在一天中 (0~23) m 分 s 秒 S 毫秒 E 星期 D 一年中的第几天 F 一月中第几个星期几 w 一年中第几个星期 W 一月中第几个星期 a 上午 / 下午 标记符 k 时 在一天中 (1~24) K 时 在上午或下午 (0~11) z 时区
使用printf格式化日期
printf 方法可以很轻松地格式化时间和日期。使用两个字母格式,它以 *%t* 开头并且以下面表格中的一个字母结尾。
public static void main(String[] args){ // 初始化 Date 对象 Date date = new Date(); // %tc -> 星期二 六月 23 15:35:18 CST 2020 System.out.printf("全部日期和时间信息:%tc%n",date); // %tF -> 2020-06-23 System.out.printf("年-月-日格式:%tF%n",date); // %tD -> 06/23/20 System.out.printf("月/日/年格式:%tD%n",date); // %tr -> 03:35:18 下午 System.out.printf("HH:MM:SS PM格式(12时制):%tr%n",date); // %tT -> 15:35:18 System.out.printf("HH:MM:SS格式(24时制):%tT%n",date); // %tR -> 15:35 System.out.printf("HH:MM格式(24时制):%tR",date); }
Calendar
作用:用于操作日历字段,设置和获取日期数据的特定部分:小时,日,或者分钟。
public static void main(String[] args){ Calendar instance = Calendar.getInstance(); System.out.println(instance); } /*java.util.GregorianCalendar[ time=1592898627406,areFieldsSet=true,areAllFieldsSet=true, lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai", offset=28800000,dstSavings=0,useDaylight=false,transitions=29,lastRule=null], firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2020,MONTH=5,WEEK_OF_YEAR=26,WEEK_OF_MONTH=4, DAY_OF_MONTH=23,DAY_OF_YEAR=175,DAY_OF_WEEK=3,DAY_OF_WEEK_IN_MONTH=4,AM_PM=1, HOUR=3,HOUR_OF_DAY=15,MINUTE=50,SECOND=27,MILLISECOND=406,ZONE_OFFSET=28800000,DST_OFFSET=0] */
常用方法
static Calendar getInstance() //使用默认时区和区域设置获取日历。 abstract void add(int field, int amount) //根据日历的规则,将指定的时间量添加或减去给定的日历字段。 void set(int year, int month, int date) //根据特定日期设置Calendar对象 void set(int year, int month, int date, int hourOfDay, int minute) void set(int year, int month, int date, int hourOfDay, int minute, int second) int get(int field) //返回给定日历字段的值。可使用下面的类字段,也可直接输入int
类字段
Calendar.YEAR //年份(1) Calendar.MONTH //月份(2) 1月~12月 -> 0~11 Calendar.DATE //日期(5) Calendar.DAY_OF_MONTH //日期(5),和上面的字段意义完全相同 Calendar.HOUR //12小时制的小时(10) Calendar.HOUR_OF_DAY //24小时制的小时(11) Calendar.MINUTE //分钟(12) Calendar.SECOND //秒(13) Calendar.DAY_OF_WEEK //星期日~星期六(7) -> 1~7
演示案例
Calendar instance = Calendar.getInstance(); instance.set(1994,0,23); //获得指定日期的Calender对象,如果不设置就是当前时间 //1994年1月23日 int month = instance.get(Calendar.MONTH); //输出0,1月 int date = instance.get(Calendar.DATE); //输出23 int date2 = instance.get(Calendar.DAY_OF_MONTH); //输出23 int week = instance.get(7); //等价于DAY_OF_WEEK,输出1,星期日
Calendar c1 = Calendar.getInstance(); c1.set(2009, 6 - 1, 12); //把Calendar对象c1的年月日分别设这为:2009、6、12 c1.set(Calendar.DATE,10); //设置为10号 c1.set(Calendar.YEAR,2008); //设置为2008年 c1.set(2017, 2, 1); //输出2017-2-1 -> 2017年3月1日 c1.set(2017, 2, 0); //输出2017-1-28 -> 2017年2月28日。 //date为0代表上个月最后一天 instance.set(1994,0,0); //输出1993 11 31 ->代表1993年12月31号 c1.add(Calendar.DATE, 10); //把c1对象的日期加上10,也就是c1也就表示为10天后的日期 c1.add(Calendar.DATE, -10); //把c1对象的日期减去10,也就是c1也就表示为10天前的日期
GregorianCalendar
public class GregorianCalendar extends Calendar
GregorianCalendar是Calendar的具体子类 ,并提供了世界上大多数国家使用的标准日历系统。
//该类特定方法 public boolean isLeapYear(int year) //确定给定年份是否是闰年
public static void main(String[] args) { String months[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; int year; // 初始化 Gregorian 日历 // 使用当前时间和日期 // 默认为本地时间和时区 GregorianCalendar gcalendar = new GregorianCalendar(); // 显示当前时间和日期的信息 System.out.print("Date: "); System.out.print(months[gcalendar.get(Calendar.MONTH)]); System.out.print(" " + gcalendar.get(Calendar.DATE) + " "); System.out.println(year = gcalendar.get(Calendar.YEAR)); System.out.print("Time: "); System.out.print(gcalendar.get(Calendar.HOUR) + ":"); System.out.print(gcalendar.get(Calendar.MINUTE) + ":"); System.out.println(gcalendar.get(Calendar.SECOND)); // 测试当前年份是否为闰年 if (gcalendar.isLeapYear(year)) { System.out.println("当前年份是闰年"); } else { System.out.println("当前年份不是闰年"); } } //Date: Jun 23 2020 //Time: 4:26:3 //当前年份是闰年
6,String
String 类代表字符串。Java 程序中的所有字符串字面值(如 “abc” )都作为此类的实例实现。 字符串是常量;它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的,所以可以共享。
查看String源码
public final class String implements java.io.Serializable, Comparable<String>, CharSequence { //String的属性值 private final char value[]; //数组被使用的开始位置 private final int offset; //String中元素的个数 private final int count; //String类型的hash值 private int hash; // Default to 0 private static final long serialVersionUID = -6849794470754667710L; private static final ObjectStreamField[] serialPersistentFields = new ObjectStreamField[0]; }
从源码看出String底层使用一个字符数组来维护的。成员变量可以知道String类的值是final类型的,不能被改变的,所以只要一个值改变就会生成一个新的String类型对象,存储String数据也不一定从数组的第0个元素开始的,而是从offset所指的元素开始。
构造方法
String() //初始化一个新创建的 String 对象,使其表示一个空字符序列。 String(StringBuffer buffer) //分配一个新的字符串,它包含字符串缓冲区参数中当前包含的字符序列。 String(StringBuilder builder) //分配一个新的字符串,它包含字符串生成器参数中当前包含的字符序列。 String(byte[] bytes) //通过使用平台的默认字符集解码指定的 byte 数组,构造一个新的 String。 String(byte[] bytes, Charset charset) String(byte[] bytes, int offset, int length) String(byte[] bytes, int offset, int length, Charset charset) String(byte[] bytes, int offset, int length, String charsetName) String(byte[] bytes, String charsetName) String(char[] value) String(char[] value, int offset, int count) String(int[] codePoints, int offset, int count) String(String original)
创建String对象方法
String str="hello"; //直接赋值的方式,放在方法区的常量池 String str=new String("hello"); //实例化的方式,放在堆内存
案例
public static void main(String[] args) { String str1 = "Lance"; String str2 = new String("Lance"); String str3 = str2; //引用传递,str3直接指向st2的堆内存地址 String str4 = "Lance"; /** * ==: * 基本数据类型:比较的是基本数据类型的值是否相同 * 引用数据类型:比较的是引用数据类型的地址值是否相同 * 所以在这里的话:String类对象==比较,比较的是地址,而不是内容 */ System.out.println(str1==str2);//false System.out.println(str1==str3);//false System.out.println(str3==str2);//true System.out.println(str1==str4);//true }
避免空指向
==在对字符串比较的时候,对比的是内存地址,而equals比较的是字符串内容
String str = null; //此时会出现空指向异常 if(str.equals("hello")){ ... } //此时equals会处理null值,可以避免空指向异常 if("hello".equals(str)){ ... }
常用方法
//1.查询操作 int length() //返回此字符串的长度。 int indexOf(int ch) //返回指定字符第一次出现的字符串内的索引。 int indexOf(int ch, int fromIndex) //以指定的索引开始搜索。 int indexOf(String str) int indexOf(String str, int fromIndex) int lastIndexOf(int ch) //返回指定字符的最后一次出现的字符串中的索引。 int lastIndexOf(int ch, int fromIndex) //从指定的索引开始向后搜索。 int lastIndexOf(String str) int lastIndexOf(String str, int fromIndex) char charAt(int index) //返回 char指定索引处的值。 //2.转换操作 char[] toCharArray() //将此字符串转换为新的字符数组。 static String valueOf(boolean b) //返回 boolean参数的字符串 boolean形式。 // 参数类型:char,char[],double,float,int,long,Object String toLowerCase() //全转为小写。 String toUpperCase() //全转为大写。 //3.替换与去除 String replace(char oldChar, char newChar) //替换全部 String replaceAll(String regex, String replacement) //使用正则表达式替换全部 String replaceFirst(String regex, String replacement) //使用正则替换第一个 String trim() //删除原字符串前后空格 //4.截取与分割 String[] split(String regex) //根据正则表达式分割 String substring(int beginIndex) //截取索引beginIndex后的所有字符。 String substring(int beginIndex, int endIndex) //截取限定范围内的子字符串 //5.判断操作 boolean equals(Object anObject) //判断内容是否相等 boolean equalsIgnoreCase(String anotherString) //忽略大小写 boolean startsWith(String prefix) //判断是否以字符串prefix开头 boolean startsWith(String prefix, int toffset) //判断在索引toffset处是否以字符串prefix开头 boolean endsWith(String suffix) //判断是否以字符串suffix结尾 boolean contains(CharSequence s) //是否包含s子字符串 boolean isEmpty() //length()是否为0 //6.连接操作 String concat(String str) //返回和原字符串拼接后的新字符串
String的不可变性
public static void main(String[] args) { String a = "abc"; String b = "abc"; String c = new String("abc"); System.out.println(a==b); //true System.out.println(a.equals(b)); //true System.out.println(a==c); //false System.out.println(a.equals(c)); //true }
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jNBUa2o4-1594542740256)(Java基础.assets/1592908385872.png)]
不可变性的好处:
-
可以实现多个变量引用堆内存中的同一个字符串实例,避免创建的开销。
-
我们的程序中大量使用了String字符串,有可能是出于安全性考虑。
-
大家都知道HashMap中key为String类型,如果可变将变的多么可怕。
-
当我们在传参的时候,使用不可变类不需要去考虑谁可能会修改其内部的值,如果使用可变类的话,可能需要每次记得重新拷贝出里面的值,性能会有一定的损失。
7,StringBuilder和StringBuffer
StringBuilder和StringBuffer都是可变的字符序列。它们继承于AbstractStringBuilder,实现了CharSequence接口。
区别:StringBuilder非线程安全,StringBuffer线程安全。
常用方法
//1.追加到末尾 StringBuilder append(String str) //追加到原字符串的尾部 StringBuilder appendCodePoint(int codePoint) //将Unicode编码的字符串追加到尾部。 appendCodePoint(0x5b57); // 0x5b57是“字”的unicode编码 //2,在尾部插入 StringBuilder insert(int offset, String str) //往指定offset位置插入字符串 //3.替换 StringBuilder replace(int start, int end, String str) //[start,end)范围内的字符串替换为str //4.删除 StringBuilder delete(int start, int end) //[start,end)范围内的字符串删除 StringBuilder deleteCharAt(int index) //删除指定位置index的字符 //5.查询 char charAt(int index) //查询index位置的字符 int length() //返回字符串长度 int indexOf(String str) //查询str第一次出现的位置。 int indexOf(String str, int fromIndex) //从指定的索引开始。 int lastIndexOf(String str) //查询str最后一次出现的位置。 int lastIndexOf(String str, int fromIndex) //6.其他 StringBuilder reverse() //字符串翻转 void setCharAt(int index, char ch) //修改指定索引的字符为ch void setLength(int newLength) //修改字符串长度,多余的将删除 CharSequence subSequence(int start, int end) //获取[start,end)范围内的子字符串 String substring(int start) // 从start开始到结尾获取子字符串 String substring(int start, int end) ////获取[start,end)范围内的子字符串
8,String、StringBuffer、StringBuilder之间的区别
-
String 字符串常量
-
StringBuffer 字符串变量(线程安全)
-
StringBuilder 字符串变量(非线程安全)
三者速度
在大多数情况下三者在执行速度方面的比较:StringBuilder > StringBuffer > String
解释:
String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象,然后将指针指向新的 String 对象。
所以经常改变内容的字符串最好不要用 String ,因为每次生成对象都会对系统性能产生影响,特别当内存中无引用对象多了以后, JVM 的 GC 就会开始工作,那速度是一定会相当慢的。
而如果是使用 StringBuffer 类则结果就不一样了,每次结果都会对 StringBuffer 对象本身进行操作,而不是生成新的对象,再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ,特别是字符串对象经常改变的情况下。
为什么是大多数情况呢?
在某些特别情况下, String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接,所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢,而特别是以下的字符串对象生成中,String 效率是远要比 StringBuffer 快的:
-
String S1 = “This is only a” + “ simple” + “ test”;
-
StringBuffer Sb = new StringBuilder(“This is only a”).append(“simple”).append(“ test”);
你会很惊讶的发现,生成 String S1 对象的速度简直太快了,而这个时候 StringBuffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏,在 JVM 眼里,这个String S1 = “This is only a” + “ simple” + “test”;其实就是:String S1 = “This is only a simple test”;
所以当然不需要太多的时间了。但大家这里要注意的是,如果你的字符串是来自另外的 String 对象的话,速度就没那么快了,譬如:
-
String S2 = “This is only a”;
-
String S3 = “ simple”;
-
String S4 = “ test”;
大部分情况下StringBuilder的速度要大于StringBuffer:
java.lang.StringBuilder一个可变的字符序列是5.0新增的。(大多数情况下就是我们是在单线程下进行的操作,所以大多数情况下是建议用StringBuilder而不用StringBuffer的)此类提供一个与 StringBuffer兼容的 API,但不保证同步。该类被设计用作 StringBuffer 的一个简易替换,用在字符串缓冲区被单个线程使用的时候(这种情况很普遍)。如果可能,建议优先采用该类,因为在大多数实现中,它比StringBuffer 要快。两者的方法基本相同。
对于三者使用的总结:
1)如果要操作少量的数据用 = String
2)单线程操作字符串缓冲区 下操作大量数据 = StringBuilder
3)多线程操作字符串缓冲区 下操作大量数据 = StringBuffer
面试题:
StringBuilder与StringBuffer的区别,StringBuilder与String的区别?
1)StringBuilder效率高,线程不安全,StringBuffer效率低,线程安全。
2)String是不可变字符串,StringBuilder是可变字符串。
3)如果是简单的声明一个字符串没有后续过多的操作,使用String。
若后续对字符做频繁的添加,删除操作,或者是在循环当中动态的改变字符穿的长度应该用StringBuilder。
若后续对字符做频繁的添加,删除操作,并且要保证线程安全,使用StringBuffer。
9,File
分割符问题(separator): 不同操作系统下文件分隔符:windows中是“\”,linux中是“/”。但事实上,无论是windows中还是linux中,永远写“/”都没有问题。 另在windows下若要用"\",需写作"\\",因为"\"是转义字符,故"\\"代表"\"。
//类属性 static String pathSeparator //与系统相关的路径分隔符字符,为方便起见,表示为字符串。 static char pathSeparatorChar //与系统相关的路径分隔符。 static String separator //当前系统的路径分隔符。 static char separatorChar //当前系统的路径分隔符。 // 1,2行输出\ // 3,4行输出; //构造方法 File(String pathname) //通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。 File(String parent, String child) //从父路径名字符串和子路径名字符串创建新的 File实例。 File(File parent, String child) //从父抽象路径名和子路径名字符串创建新的 File实例。 File(URI uri) //通过将给定的 file: URI转换为抽象路径名来创建新的 File实例。 //常用方法 boolean canRead() //测试应用程序是否可以读取由此抽象路径名表示的文件。 boolean canWrite() //测试应用程序是否可以修改由此抽象路径名表示的文件。 boolean exists() //测试此抽象路径名表示的文件或目录是否存在。 boolean isFile() //测试此抽象路径名表示的文件是否为普通文件。 boolean isDirectory() //测试此抽象路径名表示的文件是否为目录。 boolean isHidden() //测试此抽象路径名命名的文件是否为隐藏文件。 long lastModified() //返回此抽象路径名表示的文件上次修改的时间。 String getName() //返回由此抽象路径名表示的文件或目录的名称。 String getPath() //将此抽象路径名转换为路径名字符串。 File getParentFile() //返回此抽象路径名的父,或抽象路径名 null如果此路径名没有指定父目录。 boolean createNewFile() //当且仅当具有该名称的文件尚不存在时,创建一个由该抽象路径名命名的新的空文件。 boolean delete() //删除由此抽象路径名表示的文件或目录。 boolean mkdir() //创建由此抽象路径名命名的目录。 boolean mkdirs() //创建由此抽象路径名命名的目录,包括任何必需但不存在的父目录。
//案例 import java.io.File; import java.io.IOException; public class TestFile { /** * File文件类 1.代表文件 2.代表目录 */ public static void main(String[] args) { File f = new File("d:/src3/TestObject.java"); File f2 = new File("d:/src3"); File f3 = new File(f2, "TestFile.java"); File f4 = new File(f2, "TestFile666.java"); File f5 = new File("d:/src3/aa/bb/cc/dd"); //f5.mkdirs(); f5.delete(); try { f4.createNewFile(); System.out.println("文件创建成功!"); } catch (IOException e) { e.printStackTrace(); } if (f.isFile()) { System.out.println("是一个文件!"); } if (f2.isDirectory()) { System.out.println("是一个目录!"); } if (f3.isFile()) { System.out.println("是一个文件奥"); } } }
- Java基础知识:常用API
- Java基础-常用API之String类
- 阶段1 语言基础+高级_1-3-Java语言高级_03-常用API第二部分_第3节 Calendar类_2_Calendar类的常用成员方法...
- Java基础--常用API的总结
- java基础十二天 常用api
- 阶段1 语言基础+高级_1-3-Java语言高级_1-常用API_1_第5节 String类_4_字符串的比较相关方法...
- Java基础——常用对象API(4):集合框架5:Map集合
- 黑马程序员-Java基础:常用API
- Java基础中常用API使用
- 大数据之JAVA基础(十一):Java的常用API--2
- Java基础练习 — 常用API(高级)
- 阶段1 语言基础+高级_1-3-Java语言高级_03-常用API第二部分_第3节 Calendar类_1_Calendar类介绍_获取对象的方式...
- Java基础:常用API(3)
- 阶段1 语言基础+高级_1-3-Java语言高级_1-常用API_1_第4节 ArrayList集合_17-ArrayList练习二_存储自定义...
- Java基础-----常用API
- Java常用基础操作API
- [零基础学JAVA]Java SE应用部分-34.Java常用API类库 推荐
- 【HDFS基础】常用JavaAPI
- Java基础【05】常用API——Integer相关API
- Java基础知识14——常用API-day02正则表达式&Date&DateFormat&Calendar