12 Java常用类（二）（String类+时间类+BigDecimal类等等）

最新推荐文章于 2023-10-07 14:15:06 发布

yinying293

最新推荐文章于 2023-10-07 14:15:06 发布

阅读量497

点赞数 2

分类专栏： # Java基础文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/yinying293/article/details/128725142

版权

Java基础专栏收录该内容

33 篇文章 6 订阅

订阅专栏

Java常用类（二）

12.4 String类

12.4.1 概念

String类代表字符串。 Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例。
String字符串被创建就不能修改。

12.4.2 String创建对象

直接赋值
通过构造方法创建对象

//String类的定义
//1、直接赋值
String s = "cxk";
System.out.println(s);
//2、通过构造方法创建String类的对象
String s1 = new String("李四哈哈"); // String s1 = "李四哈哈";
System.out.println(s1);

//通过字节数组变成一个字符串
byte[] b = {97,98,99};
//参数1：字节数组  参数2：起始下标   参数3：长度
String s2 = new String(b, 0, b.length);
System.out.println(s2);

//通过字符数组变成一个字符串
char[] c = {'z','y','x'};
String s3 = new String(c, 0, c.length);
System.out.println(s3);

12.4.3 String类常用方法

//获取的方法----------------------------------------------------------------------------
//String str = "abcn12c3fcds";
//charAt(index) 获取指定下标对应的字符，返回char类型
//System.out.println(str.charAt(3));
//indexOf("字符串")  获取指定字符串在原字符串中的下标,如果不包含该字符串则返回-1
//System.out.println(str.indexOf("cn2"));
//lastIndexOf("字符串") 与indexOf方法一致，区别：从后往前找
//System.out.println(str.lastIndexOf("c"));
//length()  获取字符串的长度
//System.out.println(str.length());

//判断的方法----------------------------------------------------------------------------
//String str = "abcD"; 
//判断两个字符串是否相等
//System.out.println("abcd".equals(str));
//判断两个字符串是否相等,忽略大小写
//System.out.println("abcd".equalsIgnoreCase(str));
//判断字符串是否为空串  ""
//System.out.println(str.isEmpty());
//String str = "123478923";
//判断字符串是否以指定的字符串开头
//System.out.println(str.startsWith("12"));
//判断字符串是否以指定的字符串开头,指定开始位置
//System.out.println(str.startsWith("34", 2));
//判断字符串是否以指定的字符串结尾
//System.out.println(str.endsWith("23"));
//判断字符串中是否包含自定的字符串
//System.out.println(str.contains("SB"));

//其他方法----------------------------------------------------------------------------
//     ！！！ 记得要重新赋值 ！！！
//String str = "hello,SB";
//将字符串与指定的字符串进行拼接
//str = str.concat("world"); //str = str + "world";
//System.out.println(str);
//字符串替换：将字符串中指定的字符串替换成指定的字符串
//str = str.replace("SB", "**");
//System.out.println(str);

//字符串截取，从指定的下标开始和结束      范围是左闭右开
//str = str.substring(0, 5);
//System.out.println(str);

//字符串截取，从指定的下标开始一直到最后
//str = str.substring(6);
//System.out.println(str);

//字符串切割，按照指定的字符串对原字符串进行切割
//String str = "zhangsan lisi wangwu";
//String[] s = str.split(" ");
//System.out.println(Arrays.toString(s));

//去除字符串前后的空格
//String str = "      n你好。。        哈哈      ";
//str = str.trim();
//System.out.println(str);

//String str = "abcd你好";
//将字符串变成字节数组
//byte[] b = str.getBytes();
//System.out.println(Arrays.toString(b));

//将字符串变成字符数组
//char[] c = str.toCharArray();
//System.out.println(Arrays.toString(c));

//String str = "abcADC你好";
//将字符串中的字母变成大写
//System.out.println(str.toUpperCase());
//将字符串中的字母变成小写
//System.out.println(str.toLowerCase());

int i = 10;
//方式1：
String s = i+"";
//方式2：将其他的类型的数据转换成String类型
String s2 = String.valueOf(i);
System.out.println(s);
System.out.println(s2);

12.5 可变字符串

StringBuffer
StringBuilder

12.5.1 StringBuffer、StringBuilder类

常用方法

append(String str);
delete(int start, int end)
insert(int offset, String str)
reverse()
toString()

public class StringBufferDemo {
	public static void main(String[] args) {
		//创建StringBuffer对象
		StringBuffer sb = new StringBuffer();
		
		//常用方法：
		//在字符串的后面追加字符串
		sb.append("abcdef");
		System.out.println(sb); //abcdef
		
		//删除字符串，从指定的下标开始和结束
		sb.delete(2, 4);
		System.out.println(sb);//abef
		
		//在指定下标位置添加指定的字符串
		sb.insert(2, "123");
		System.out.println(sb);//ab123ef
		
		//将字符串翻转
		sb.reverse();
		System.out.println(sb);//fe321ba
		
		//将StringBuffer转换成String类型
		String s = sb.toString();
		System.out.println(s);
	}
}

12.5.2 String、StringBuffer、StringBuilder区别(面试题)

String、StringBuffer、StringBuilder区别

这三个类都可以用于表示字符串

1、String类是字符串常量类，一旦定义不能改变

2、StringBuffer、StringBuilder是可变的字符串,自带有缓冲区。默认缓冲区大小16个字符

3、StringBuffer是线程安全的，所以效率低 StringBuilder是线程不安全的，所以效率高

总结：在大量的字符串拼接的时候，使用 StringBuffer、StringBuilder。而不考虑线程安全的时候，选择StringBuilder，否则选择StringBuffer

public class Demo01 {
	public static void main(String[] args) {
		//需求：做100000次字符串拼接
		
		//获取当前系统时间的毫秒数  4918
//		long start = System.currentTimeMillis();
//		String str = "";
//		for (int i = 0; i < 100000; i++) {
//			str = str + "a";
//		}
//		long end = System.currentTimeMillis();
//		System.out.println("耗时"+(end -start));
				
		//239
//		long start = System.currentTimeMillis();
//		StringBuffer sb = new StringBuffer();
//		for (int i = 0; i < 10000000; i++) {
//			sb.append("a");
//		}
//		long end = System.currentTimeMillis();
//		System.out.println("耗时"+(end -start));
		
		//90
		long start = System.currentTimeMillis();
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < 10000000; i++) {
			sb.append("a");
		}
		long end = System.currentTimeMillis();
		System.out.println("耗时"+(end -start));
	}
}

12.6 String类面试题

package com.qf.string;
public class StringDemo {
	public static void main(String[] args) {
		String s1 = "ab";
		String s2 = "c";
		String s3 = new String("abc");
		
		String str1 = "abc";
		String str2 = "abc";
		String str3 = "ab" +"c";
		String str4 = s1 +s2;
		String str5 = new String("abc");
		String str6 = new String("ab")+"c";
		String str7 = s3.intern();
		/**
		 * String str1 = "abc";
		 * String str2 = "abc";
		 * 这个“abc”存放在常量池中，
		 * 常量池的特点：
		 *    首先会去常量池中找是否有“abc”这个常量字符串，如果有直接用str1指向它，
		 *	如果没有将“abc”放到常量池中，用str1指向它
		 *    再使用去常量池中找有没有“abc”,这个时候已经有了，直接使用str2指向它。
		 */
		System.out.println(str1 == str2);//true
		/**
		 * String str3 = "ab" +"c"; 
		 * 因为“ab”是常量与“c”拼接之后也会在常量池中。
		 */
		System.out.println(str1 == str3);//true
		/**
		 * String s1 = "ab";
		 * String s2 = "c";
		 * 当s1和s2拼接的时候，jdk会将s1和s2转换成StringBuilder类型，然后进行拼接操作，
		 * 最终的内容实在堆内存中。
		 */
		System.out.println(str1 == str4);//false
		/**
		 * String str1 = "abc"; 在常量池
		 * String str5 = new String("abc"); 在堆内存
		 */
		System.out.println(str1 == str5);//false
		/**
		 * String str5 = new String("abc");   在堆内存
		 * String str6 = new String("ab")+"c";在堆内存
		 */
		System.out.println(str5 == str6);//false
		/**
		 * String str1 = "abc"; 在常量池
		 * String str6 = new String("ab")+"c"; 在堆内存 
		 */
		System.out.println(str1 == str6);//false
		/**
		 * String str7 = s3.intern();
		 * intern方法的含义：将String类型的对象指向常量池，如果有直接指向，如果没有放一个指向
		 */
		System.out.println(str1 == str7);//true
	}
}

12.7 Date类

表示一个特定时间，精确到毫秒

public class DateDemo {
	public static void main(String[] args) {		
		//创建Date类的对象    默认是系统当前时间
//		Date d1 = new Date();
//		//Fri Mar 12 11:35:00 CST 2021
//		System.out.println(d1);
		
		/**
		 * year：年份，默认从1900开始计算
		 * month：月份，默认是0-11
		 * date：日期
		 */
//		Date d2 = new Date(1998-1900, 2-1, 20);
//		System.out.println(d2);
		
//		Date d3 = new Date();
//		//返回当前date日期对应的时间的毫秒数 		 从1970年开始计算的毫秒数
//		System.out.println(d3.getTime()/1000/60/60/24/365);
		
//		Date d1 = new Date();
//		Date d2 = new Date(1998-1900, 2-1, 20);
//		//判断d1是否在d2之前
//		System.out.println(d1.before(d2));
//		//判断d1是否在d2之后
//		System.out.println(d1.after(d2));
		
		//随堂案例：计算自己活了多长时间
		Date d1 =  new Date(1998-1900, 2-1, 20);
		Date d2 = new Date();
		long time = d2.getTime() - d1.getTime();
		System.out.println(time/1000/60/60/24);
	}
}

12.8 SimpleDateFormat类

日期格式化类

package com.qf.date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDateFormatDemo {
	public static void main(String[] args) {
//		//创建一个Date对象
//		Date date = new Date();
//		//创建日期格式化对象    2021年03月12日   14:15:30
//		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
//		//调用日期格式化对象的format方法
//		String time = sdf.format(date);
//		System.out.println(time);
		
        
//		//将字符串格式的时间转换成Date类型
//		String time = "2021-03-12 14:21:30";
//		//创建日期格式化对象
//		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//		//调用日期格式化对象的parse方法
//		try {
//			Date date = sdf.parse(time);
//			System.out.println(date);
//		} catch (ParseException e) {
//			e.printStackTrace();
//		}
	}
}

12.9 System类

系统类

常用方法：

System.currentTimeMillis()
返回当前系统时间的毫秒数从1970年开始计算

System.exit(0)
终止Java虚拟机的运行参数表示终止的状态 0表示正常退出

package com.qf.system;
import java.text.SimpleDateFormat;
public class SystemDemo {
	public static void main(String[] args) {
		//System 系统类
		//获取系统当前时间，返回自1970年开始以来时间的毫秒数
		System.out.println(System.currentTimeMillis());
		
        //格式化时间
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		String time = sdf.format(System.currentTimeMillis());
		System.out.println(time);
		
		//结束当前虚拟机运行   0表示正常退出
		System.exit(0);
		
		System.out.println("执行吗？");
	}
}

12.10 Math类

数学计算的工具类

package com.qf.math;
public class MathDemo {
	public static void main(String[] args) {
		//求a的b次方法  参数1：底数   参数2：幂数
		System.out.println(Math.pow(2, 10));
		//求a平方根       参数1：要开方的数
		System.out.println(Math.sqrt(100));
		//求a立方根       参数1：要开立方的数
		System.out.println(Math.cbrt(27));
		
		//向上取整
		System.out.println(Math.ceil(10.2));
		//向下取整
		System.out.println(Math.floor(10.9));
		//四舍五入
		System.out.println(Math.round(10.5));
		
		//随机数 默认的范围[0,1)
		System.out.println(Math.random());
		//需求：随机一个两位数  [0,1)*90   [0,90) + 10     
		System.out.println((int)(Math.random()*90)+10);
	}
}

12.11 BigDecimal类

12.11.1 为什么使用BigDecimal?

以下的代码的错误原因是0.9在计算中中的二进制是一个无限循环的

double保存时近似值，所以计算的结果不精确

double d1 = 1.0;

double d2 = 0.9;

System.out.println(d1-d2);//0.0999999998

12.11.2 BigDeicmal基本用法

位置：java.math包中。
作用：精确计算浮点数。
创建方式：BigDecimal bd=new BigDecimal(“1.0”)。

常用方法：

方法名	描述
BigDecimal add(BigDecimal bd)	加
BigDecimal subtract(BigDecimal bd)	减
BigDecimal multiply(BigDecimal bd)	乘
BigDecimal divide(BigDecimal bd)	除

package com.qf.math;
import java.math.BigDecimal;
import java.math.MathContext;
public class BigDecimalDemo {
	public static void main(String[] args) {
		double d1 = 1.0;
		double d2 = 0.9;
		//0.09999999999999998
		System.out.println(d1-d2);		
		//使用BigDecimal类解决
		//创建BigDecimal对象
		BigDecimal bd1 = new BigDecimal("1.0");
		BigDecimal bd2 = new BigDecimal("0.22");
		System.out.println(bd1.add(bd2));
		System.out.println(bd1.subtract(bd2));
		System.out.println(bd1.multiply(bd2));
		//ArithmeticException 算术异常
		/**
		 * 参数说明：
		 * 	参数1：被除数
		 * 	参数2：保留小数位数
		 *  参数3：舍入模式
		 *  		ROUND_CEILING 向上取整
		 *  		ROUND_FLOOR   向下取整
		 *  		ROUND_HALF_UP 四舍五入
		 */	
		System.out.println(bd1.divide(bd2,2,BigDecimal.ROUND_HALF_UP));
	}
}