JavaSE基础day12 String常用功能、StringBuilder、包装类、Math、日期类型Date、SimpleDateFormat类型

一. String类常用功能

(一)String类的转换功能

1. byte[] getBytes()：将当前字符串，转成字节数组

2. char[] toCharArray()：将当前的字符串，转成字符数组

3. String toUpperCase()：将当前的字符串，转成全大写形式

4. String toLowerCase()：将当前的字符串，转成全小写形式

5. static valueOf家族：可以将任意数据类型的数据，转换成字符串

　　　　　　int a = 11231232;

　　String ss = String.valueOf(a);

案例1 : 键盘录入一个大小写混杂的纯英文字符串将字符串转换成首字母大写，其他字母全部小写例如，字符串”i lOvE jAvA”，转换成 “I love java”

import java.util.Arrays;

public class Demo01_StringChange {
    public static void main(String[] args) {
        String s = "ABCD";
        // 1. byte[] getBytes()：将当前字符串，转成字节数组
        byte[] b = s.getBytes();
        // Arrays.toString(b): 将参数数组b中的元素罗列出来
        System.out.println(Arrays.toString(b));// [65, 66, 67, 68]

        // 2.char[] toCharArray()：将当前的字符串，转成字符数组
        char[] ch = s.toCharArray();
        for(int index = 0; index < ch.length; index++){
            System.out.print(ch[index] + "  ");
        }

        // 3.String toUpperCase()：将当前的字符串，转成全大写形式
        // 4.String toLowerCase()：将当前的字符串，转成全小写形式
        String s1 = "HelloABC123";
        System.out.println(s1.toUpperCase());// HELLOABC123
        System.out.println(s1.toLowerCase());// helloabc123

        // 5.static valueOf家族：可以将任意数据类型的数据，转换成字符串
        String boo = String.valueOf(true);
        System.out.println(boo);

        String str = String.valueOf(new Demo01_StringChange());
        System.out.println(str);// com.ujiuye.stringdemo.Demo01_StringChange@1b6d3586

        // 任意类型 + ""
    }
}

案例1代码：

public class Demo02_StringTest {
    public static void main(String[] args) {
        /*案例1 : 键盘录入一个大小写混杂的纯英文字符串将字符串转换成首字母大写，
        其他字母全部小写例如，字符串”i lOvE jAvA”，转换成 “I love java”*/
        String s = "i lOvE jAvA";
        String first = s.substring(0,1);
        String other = s.substring(1);
        System.out.println(first.toUpperCase() + other.toLowerCase());
    }
}

(二)String类其他功能

1、replace(String oldStr, String newStr)：将调用者中的老串替换成新串,返回值为替换后的新字符串

2、split(String regex): 将字符串按照参数字符串regex规则进行切割, 结果是一个String[]

3、str.concat(str2) ：字符串拼接

4、trim()：去掉字符串左右两边的空格、制表符

import java.util.Arrays;

public class Demo03_StringOther {
    public static void main(String[] args) {
        String s = "helloworld";
        // 1、replace(String oldStr, String newStr)：将调用者中的老串替换成新串,返回值为替换后的新字符串
        String str = s.replace("o","*");
        System.out.println(str);

        // 2.split(String regex): 将字符串按照参数字符串regex规则进行切割, 结果是一个String[]
        // 需求: 定义出一个日期字符串: 2022-03-10, 请将年月日分别获取到
        String date = "2022-03-10";
        String[] sArr = date.split("-");
        System.out.println(Arrays.toString(sArr));

        // 3. trim()：去掉字符串左右两边的空格、制表符
        String name = " 张三  ";
        System.out.println(name.length());// 5
        String newName = name.trim();
        System.out.println(newName + newName.length());// 张三2

        String name1 = "张  三";
        System.out.println(name1.trim());// 张  三 
    }
}

二. StringBuilder

(一) 概述

1、概述: StringBuilder是一个可变的字符序列,常用的方法是append和insert，就是在StringBuilder对象本身上，进行相关操作

2、特点:

(1) StringBuilder底层和String类型一样,也是维护了一个字符数组,外界无法直接访问.

(2) String类型和StringBuilder的关系:都是用于描述字符串.但是前者内容是不可以改

变的,后者内容是可以改变的. 做字符串拼接时, 使用StringBuilder优化内存的使用.

3. 扩展:

StringBuilder 叫做字符串生成器, 或者字符串缓冲区, StringBuilder在字符序列存储超出容量时, 自动扩容

(二) 构造方法

1、构造方法作用：创建当前对象、将其他类型的数据，转换成当前类型

2、StringBuilder的构造方法：

StringBuilder()：创建一个生成器，初始容量为16个字符

StringBuilder(int capacity)：创建一个生成器，初始容量为capacity大小

StringBuilder(String str)：创建一个生成器，初始值就是str这些字符，初始大小是str+16

3、获取容积的方法：

capacity()：获取当前生成器的容器大小

length()：获取当前生成器中的实际字符个数

public class StringBuilderConstructor {
    public static void main(String[] args) {
        // 1. StringBuilder()：创建一个生成器，初始容量为16个字符
        StringBuilder sb = new StringBuilder();
        System.out.println(sb);

        // 2. StringBuilder(int capacity)：创建一个生成器，初始容量为capacity大小
        StringBuilder sb2 = new StringBuilder(56);

        // 3. StringBuilder(String str)：创建一个生成器，初始值就是str这些字符，初始大小是str+16
        StringBuilder sb3 = new StringBuilder("ab");
        System.out.println(sb3);// ab

        // 4.capacity()：获取当前生成器的容器大小
        //  length()：获取当前生成器中的实际字符个数
        System.out.println(sb.capacity());// 16
        System.out.println(sb.length());// 0
    }
}

(三) StringBuilder常用功能

3.1 添加功能

1、append(任意类型)：可以将任意数据类型，转成字符，添加到生成器中

2、insert(int index, 任意数据类型)：可以将任意数据类型，添加到指定的位置

public class StringBuilderAdd {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("abc");
        // append : 末尾追加数据到生成器中
        sb.append(3.14);
        sb.append(true);
        System.out.println(sb);

        // insert(int index, Object obj): 将数据obj添加到StringBuilder指定的index索引位置处
        // abc3.14true
        sb.insert(5,"hi");// abc3.hi14true
        System.out.println(sb);

        // sb.append(x) 和 sb.insert(sb.length(), x) 具有相同的效果
        System.out.println(sb.length());// 13, 索引位置0-12, 末尾追加, 第13索引位置上添加数据
        sb.insert(sb.length(),"end");
        System.out.println(sb);// abc3.hi14trueend
        // sb.insert(sb.length()+2,"end"); 索引越界异常
    }
}

3.2 删除功能

1、deleteCharAt(int index) ：删除指定索引的字符

2、delete(int startIndex, int endIndex)：删除指定范围的字符，被删除的部分包含头不包含尾

public class StringBuilderDelete {
    public static void main(String[] args) {
        // 1、deleteCharAt(int index) ：删除指定索引的字符
        StringBuilder sb = new StringBuilder("你好hello123");
        sb.deleteCharAt(3);
        System.out.println(sb);// 你好hllo123

        // 2、delete(int startIndex, int endIndex)：删除指定范围的字符，被删除的部分包含头不包含尾
        sb.delete(2,7).append("end");
        System.out.println(sb);// 你好23end
    }
}

3.3 替换和反转功能

1、replace(int startIndex, int endIndex ,String str)：

将字符串缓冲区中的从start开始到end-1这部分内容，替换成str

2、reverse()：将原有字符序列进行反转

public class StringBuilderMethod {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("helloworld");
        // 1.replace(int startIndex, int endIndex ,String str)：
        //  将字符串缓冲区中的从start开始到end-1这部分内容，替换成str
        sb.replace(2,5,"哈哈");
        System.out.println(sb);// he哈哈world

        // 2、reverse()：将原有字符序列进行反转
        sb.reverse();
        System.out.println(sb);
    }
}

三种StringBuilder转成String类型的方法

public static String reverse1(String str){
        StringBuilder sb = new StringBuilder(str);
        // 1)
        //sb.reverse();
        //String s1 = String.valueOf(sb);
        //return s1;
        // 2)
        //return sb.reverse().toString();
        return sb.reverse() + "";
    }

练习1

定义一个方法，接收一个String类型的字符串，返回该字符串的反转形式

举例：接收字符串为abc，返回字符串为cba

要求：使用StringBuilder进行反转，提高开发效率

练习2

定义一个方法，接收一个int[]类型的数组，返回该数组的字符串表示形式

举例：接收数组为int[] arr = {1, 2, 3}，返回的字符串为[1, 2, 3]

要求：使用StringBuilder进行拼接，提高运行效率

public class StringBuilderTest {
    public static void main(String[] args) {
        String s = "abc";
        System.out.println(getStringReverse(s));

        int[] arr = {12,17,888};
        System.out.println(getString(arr));
    }

    /*定义一个方法，接收一个String类型的字符串，返回该字符串的反转形式
    举例：接收字符串为abc，返回字符串为cba
    要求：使用StringBuilder进行反转，提高开发效率*/
    public static String getStringReverse(String str){
         StringBuilder sb = new StringBuilder(str);
        // return sb.reverse().toString();
        // return String.valueOf(sb.reverse());
        return sb.reverse() + "";
    }


    /*定义一个方法，接收一个int[]类型的数组，返回该数组的字符串表示形式
    举例：接收数组为int[] arr = {1, 2, 3}，返回的字符串为[1, 2, 3]
    要求：使用StringBuilder进行拼接，提高运行效率*/

    public static String getString(int[] arr){
        if(arr == null){
            return null;
        }else if(arr.length == 0){
            return "[]";
        }else{
            StringBuilder sb = new StringBuilder("[");
            for(int index = 0; index < arr.length; index++){
                int ele = arr[index];
                if(index == arr.length-1){
                    sb.append(ele).append("]");
                }else{
                    sb.append(ele).append(",");
                }
            }
            return sb.toString();
        }
    }
}

三. 基本类型的包装类

(一) 概述

1、基本数据类型有八种，都是非常简单的数据类型

2、在这些类型中，只能表示简单的数据，不能包含一些操作数据的方法，没有办法存储描述这些数据的内容。需要准备一个引用数据类型，能将基本数据类型进行包装，提供一些操作基本类型的方法，定义一些描述数据的数据。

3、基本类型的包装类：

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

(二) Integer类型

1、各种包装类型的方法、特点基本相同，只要学习一个Integer类型，其他的也触类旁通。

2、Integer类型的对象中，维护了一个私有的成员变量，是一个int类型的字段（成员变量、属性），用于表示这个Integer对象要表示的数字。

3、提供了在int、Integer、String类型之间相互转换的方法

4、提供了一些常量

(三) Integer的构造方法

1、Integer(int i)：将一个基本类型的int数，转换成Integer类型的对象

使用i给Integer对象中的成员变量赋值

2、Integer(String s)：将一个字符串类型的数字，转换成Integer类型的对象

转换的作用

(四) Integer类型的成员方法

1、xxxValue()：可以将Integer类型的对象，转成其他的基本数据类型：

例如：byteValue()、floatValue()

2、静态方法：

parseInt(String str)：将str以十进制的方式解读为一个int数

public class IntegerConstructor {
    public static void main(String[] args) {
        Integer i = new Integer(10);
        System.out.println(i);

        Integer i1 = new Integer("456");
        System.out.println(i1);

       /* Integer i2 = new Integer("小飞机");
        System.out.println(i2);*/

        // 1、xxxValue()：可以将Integer类型的对象，转成其他的基本数据类型：
        double d = i1.doubleValue();
        byte b = i1.byteValue();
        System.out.println(d);// 456.0
        System.out.println(b);// -56

        // 2. parseInt(String str)：将str以十进制的方式解读为一个int数
        int age = Integer.parseInt("15");
        System.out.println(age + 1);// 16
    }
}

(五) 自动装箱和拆箱（jdk1.5特性,掌握）

1、装箱和拆箱

装箱：将基本数据类型，封装成包装类型的对象，就是装箱，使用构造方法即可

拆箱：从包装类型的对象中，将其包装的基本类型数据取出，就是拆箱，使用intValue方法即可

2、自动装箱和拆箱

自动装箱：可以直接使用基本类型数据，给对应的引用数据类型包装类对象变量赋值

自动拆箱：可以直接使用包装类对象，给基本类型变量赋值或与基本类型直接运算

public class 自动拆装箱 {
    public static void main(String[] args) {
        Integer i = new Integer(10);
        // 自动装箱: 使用基本数据类型直接给对应的引用数据类型包装类对象进行赋值
        Integer i1 = 10;
        // 自动拆箱: 使用引用数据类型包装类对象直接给基本数据类型进行赋值; 并且引用类型可以和基本类型进行运行
        int w = i1;

        int q = i1 + 100;
        /*
              1. i1先自动拆箱称为int 10数值
              2. 进行加法运行  10 + 100 = 110 --->int
              3. 将110数值自动装箱, 赋值给q2引用数据类型包装类
         */
        Integer q2 = i1 + 100;
    }
}

四. Math

Math类的构造方法是私有的, 不允许外类创建Math类型对象,因此所有成员变量和方法一律都是static静态的,可以通过类名直接调用

1、两个常量

E：自然对数的底数，2.718

PI：圆周率

2、常用方法

abs(数字类型)，返回该参数的绝对值

ceil(double d)，返回d的向上取整

floor(double d)，返回d的向下取整

max(int a, int b)，返回a、b的较大值

min(int a, int b)，返回a、b的较小值

pow(int a, int b)，返回a的b次幂

random()，返回0.000~0.999的随机数

round(double d)，返回d四舍五入的结果

public class MathDemo {
    public static void main(String[] args) {
        System.out.println(Math.E);// 2.718281828459045
        System.out.println(Math.PI);// 3.141592653589793

        int i = Math.abs(-17);
        System.out.println(i);// 17

        System.out.println(Math.ceil(3.0));// 3.0
        System.out.println(Math.ceil(3.01));// 4.0

        System.out.println(Math.floor(7.8));// 7.0
        System.out.println(Math.floor(7.0));// 7.0
        System.out.println(Math.max(3.14,5.56));// 5.56
        System.out.println(Math.min(3.14,5.56));// 3.14

        System.out.println(Math.pow(2,3));// 8

        System.out.println(Math.random());// 0.000--0.999 [0.000--1.000)

        // round 方法根据参数第一位小数决定向上或者向下取整, 如果小数第一位 >= 5, 向上取整
        System.out.println(Math.round(4.4)); // 4
        System.out.println(Math.round(4.6)); // 5
        System.out.println(Math.round(4.49999)); // 4
    }
}

五. System类及其常用方法

1、用于描述系统资源的类型，System是一个和系统相关的类，里面提供了一些系统常用的方法，例如调用垃圾回收机制，给出系统时间，关闭虚拟机等。该类不用创建对象，因为构造方法私有, 直接使用静态变量和静态方法即可

2、常用字段(静态常量)：

System.in：标准输入流，默认关联到键盘上

举例 : Scanner sc = new Scanner(System.in);

System.out：标准输出流，默认关联到控制台上

举例 : System.out.println(数据);

System.err：标准错误输出流，默认关联到控制台上，用于打印错误信息，使用该流打印的内容是红色

举例 : 如果代码中发生异常, JVM即使用System.err将异常信息进行输出

3、常用方法全部都是static修饰：

(1) currentTimeMillis()：

返回当前时间的毫秒值，表示的是从1970年1月1日0时0分0秒开始到现在经历的毫秒值，1s = 1000ms。

应用：1、可以通过某些手段，将数字转换成时间对象、指定格式的字符串；2、可以通过计算两次的差值，来获取某段代码运行的时间

(2) static void exit(int status): 退出JVM虚拟机,参数0表示正常终止

import java.util.Scanner;
public class SystemDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println(123);

        System.err.println("错误");

        // exit表示结束虚拟机,参数设计为0,表示正常终止代码
        System.exit(0);

        int[] arr = null;
        System.out.println(arr.length);

// currentTimeMillis() : 获取当前系统时间对应的毫秒值, 1000ms = 1s
        long b = System.currentTimeMillis();
        int w = 0;
        // System.out.println(l);// 1646900277115
        for(int i = 1; i <= 1000000; i++){
             w += i;
        }
        long e =  System.currentTimeMillis();
        System.out.println(e - b);// 8
        System.out.println(w);// 1784293664
    }
}

六. 时间类

(一) 日期Date类型及其常用方法

1. 概述: Date表示特定的瞬间,精确到毫秒.是java中提供的表示时间日期数据的对象,但是这个类,其中大部分的方法已经过时,由Calendar和DateFormat类代替.

2. Date类构造方法:

1) public Date(): 分配 Date 对象并初始化此对象,以表示分配它的时间(精确到毫秒) //Thu Mar 10 22:14:39 CST 2022

2) public Date(long date): 分配 Date 对象并初始化此对象,以表示自从标准基准时间(称为"历元(epoch)",即 1970 年 1 月 1 日 00:00:00 GMT)以来的指定毫秒数

3. Date类常用方法

1) long getTime():

返回自1970 年1月1日 00:00:00 GMT 以来此 Date 对象表示的毫秒数

2) void setTime(long time)

设置此Date对象,以表示 1970 年1月1日 00:00:00 GMT 以后 time 毫秒的对应时间点

import java.util.Date;
public class DateDemo {
    public static void main(String[] args) {
        // 1. Date(): 定义出当前系统时间的日期对象
        Date d = new Date(); // //Thu Mar 10 22:14:39 CST 2022
        System.out.println(d);

        // 2. Date(long time): 将time对应的毫秒值时间转换成一个Date日期类型对象
        Date d1 = new Date(1000);  //Thu Jan 01 08:00:01 CST 1970 即过了1000毫秒 
        System.out.println(d1);

        // 3. getTime() : 将date日期对象对应的毫秒值计算出来, 结果long
        long time = d.getTime();
        System.out.println(time);// 1646902464353   （Thu Mar 10 22:14:39 CST 2022 --> 1646902464353   ）

 　　　　System.out.println(d1.getTime());// 1000 
　　　　 // 4. void setTime(long time) 
　　　　 // 设置此Date对象,以表示 1970 年1月1日 00:00:00 GMT 以后 time 毫秒的对应时间点 
　　　 　// setTime修改date日期表示的时间 
　　　　 d1.setTime(5000); 
　　　　 System.out.println(d1); //Thu Jan 01 08:00:05 CST 1970
　　}
}

(二) SimpleDateFormat类及其常用方法

1. 概述：简单的日期格式化类，提供了日期的格式化的方法

2. SimpleDateFormat类常用构造方法

1) SimpleDateFormat(): 用默认的模式和默认语言环境的日期格式创建对象

2) SimpleDateFormat(String pattern)

用给定的模式和默认语言环境的日期格式创建对象，

一般pattern传递的是 "yyyy-MM-dd HH:mm:ss"

例如：2021-03-02 16:48:22

3. SimpleDateFormat类常用方法

1) final String format(Date date): 将一个 Date 格式化为日期/时间字符串

2) Date parse(String source) throws ParseException:

SimpleDateFormat sdf1 = new SimpleDateFormat();  // 默认格式 
String d10 = sdf1.format(d); //22-3-10 下午10:38    （Thu Mar 10 17:27:43 CST 2022 -->22-3-10 下午10:38）

System.out.println(d10); 

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  // 指定格式
String d1 = sdf.format(d); //2022-03-10 17:27:43    （Thu Mar 10 17:27:43 CST 2022 -->2022-03-10 17:27:43 ）

System.out.println(d1);

从给定字符串解析文本,以生成一个日期

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
        Date d = new Date();
        System.out.println(d);
        // 1. SimpleDateFormat(): 空参数构造方法, 有默认的对日期类型的格式化标准
        SimpleDateFormat sdf = new SimpleDateFormat();
        //2. final String format(Date date): 将一个 Date 格式化为日期/时间字符串
        String str = sdf.format(d);
        System.out.println(str);// 22-3-10 下午5:11

        // 3.SimpleDateFormat(String pattern): 构造参数给出需要转换的目标时间表示结果
        // 2022-03-10 14:57:17
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String time = sdf2.format(d);
        System.out.println(time);

        // 4. Date parse(String source) throws ParseException:
        // 从给定字符串解析文本,以生成一个日期
        Date da = sdf2.parse("2022-03-10 10:16:20"); //Thu Mar 10 10:16:20 CST 2022

System.out.println(da); } }

案例1: 计算一下你自己出现在地球多少天了(题目本质: 就是计算出两个日期之间所距离的天数)

package com.ujiuye.作业;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class BirthDays {
    public static void main(String[] args) throws ParseException {
        //案例1: 计算一下你自己出现在地球多少天了(题目本质: 就是计算出两个日期之间所距离的天数)
        Date d = new Date(); // Thu Mar 10 18:40:45 CST 2022
        long l1 = d.getTime(); // 1646909535594

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d2 = sdf.parse("1996-11-12 23:46:58"); // Tue Nov 12 23:46:58 CST 1996
        long l2 = d2.getTime(); // 847813618000

        long ms = l1 -l2;
        System.out.println(ms/1000/60/60/24+"天");  //9248天
    }
}

相关阅读:
Flask 入门
 Android studio 混淆打包
 Android----获取包名和sh1
windows下安装 rabbitMQ 及操作常用命令
 Nginx
Linux安装mongoDB步骤和方法
 史上最简单的 SpringCloud 教程 | 终章
 idea 项目热部署设置
 JDK源码阅读顺序
 Linux常用命令
原文地址：https://www.cnblogs.com/lw1095950124/p/15991292.html