12 Java常用类(二)(String类+时间类+BigDecimal类等等)

简介: 12 Java常用类(二)(String类+时间类+BigDecimal类等等)

12.4 String类

12.4.1 概念
  • String类代表字符串。 Java程序中的所有字符串文字(例如"abc" )都被实现为此类的实例。
  • String字符串被创建就不能修改。
12.4.2 String创建对象
  1. 直接赋值
  2. 通过构造方法创建对象
//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、St

常用方法

  • 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));
  }
}


相关文章
Java并发包下Atomic相关类的使用
本文介绍了 `java.util.concurrent.atomic` 包下的各类原子类及其使用场景,包括基本类型原子类(如 `AtomicInteger`、`AtomicLong`)、数组类型原子类(如 `AtomicIntegerArray`)、引用类型原子类(如 `AtomicReference`)、对象属性修改原子类(如 `AtomicIntegerFieldUpdater`)以及原子操作增强类(如 `LongAdder` 和 `LongAccumulator`)。同时,详细对比了不同原子类在高并发场景下的性能表现,展示了 `LongAdder` 的高效性。
92 31
关于string的‘\0‘与string,vector构造特点,反迭代器与迭代器类等的讨论
你真的了解string的'\0'么?你知道创建一个string a("abcddddddddddddddddddddddddd", 16);这样的string对象要创建多少个对象么?你知道string与vector进行扩容时进行了怎么的操作么?你知道怎么求Vector 最大 最小值 索引 位置么?
34 0
|
2月前
|
【高薪程序员必看】万字长文拆解Java并发编程!(7):不可变类设计指南
🌟 ​大家好,我是摘星!​ 🌟今天为大家带来的是并发编程中Java不可变类设计指南,废话不多说让我们直接开始。
46 0
Java 类和对象
本文介绍了Java编程中类和对象的基础知识,作为面向对象编程(OOP)的核心概念。类是对象的蓝图,定义实体类型;对象是具体实例,包含状态和行为。通过示例展示了如何创建表示汽车的类及其实例,并说明了构造函数、字段和方法的作用。同时,文章还探讨了访问修饰符的使用,强调封装的重要性,如通过getter和setter控制字段访问。最后总结了类与对象的关系及其在Java中的应用,并建议进一步学习继承等概念。
重学Java基础篇—类的生命周期深度解析
本文全面解析了Java类的生命周期,涵盖加载、验证、准备、解析、初始化、使用及卸载七个关键阶段。通过分阶段执行机制详解(如加载阶段的触发条件与技术实现),结合方法调用机制、内存回收保护等使用阶段特性,以及卸载条件和特殊场景处理,帮助开发者深入理解JVM运作原理。同时,文章探讨了性能优化建议、典型异常处理及新一代JVM特性(如元空间与模块化系统)。总结中强调安全优先、延迟加载与动态扩展的设计思想,并提供开发建议与进阶方向,助力解决性能调优、内存泄漏排查及框架设计等问题。
158 5
|
3月前
|
java中一个接口A,以及一个实现它的类B,一个A类型的引用对象作为一个方法的参数,这个参数的类型可以是B的类型吗?
本文探讨了面向对象编程中接口与实现类的关系,以及里氏替换原则(LSP)的应用。通过示例代码展示了如何利用多态性将实现类的对象传递给接口类型的参数,满足LSP的要求。LSP确保子类能无缝替换父类或接口,不改变程序行为。接口定义了行为规范,实现类遵循此规范,从而保证了多态性和代码的可维护性。总结来说,接口与实现类的关系天然符合LSP,体现了多态性的核心思想。
86 0
Java 的 BigDecimal 是什么?
`BigDecimal` 是 Java 中用于高精度浮点数运算的类,位于 `java.math` 包。它支持精确的数学运算(加、减、乘、除等),并可设置精度和舍入模式,适用于财务和科学计算场景。其主要特点是高精度、不可变性和灵活的运算控制。相比 `float` 和 `double`,`BigDecimal` 能避免二进制表示带来的精度丢失问题。推荐通过字符串或 `BigDecimal.valueOf` 方法创建对象以确保精度。
102 0
java常见的集合类有哪些
Map接口和Collection接口是所有集合框架的父接口: 1. Collection接口的子接口包括:Set接口和List接口 2. Map接口的实现类主要有:HashMap、TreeMap、Hashtable、ConcurrentHashMap以及 Properties等 3. Set接口的实现类主要有:HashSet、TreeSet、LinkedHashSet等 4. List接口的实现类主要有:ArrayList、LinkedList、Stack以及Vector等
|
4月前
|
《从头开始学java,一天一个知识点》之:字符串处理:String类的核心API
🌱 **《字符串处理:String类的核心API》一分钟速通!** 本文快速介绍Java中String类的3个高频API:`substring`、`indexOf`和`split`,并通过代码示例展示其用法。重点提示:`substring`的结束索引不包含该位置,`split`支持正则表达式。进一步探讨了String不可变性的高效设计原理及企业级编码规范,如避免使用`new String()`、拼接时使用`StringBuilder`等。最后通过互动解密游戏帮助读者巩固知识。 (上一篇:《多维数组与常见操作》 | 下一篇预告:《输入与输出:Scanner与System类》)
115 11
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等

登录插画

登录以查看您的控制台资源

管理云资源
状态一览
快捷访问