九、实用类

小猪VS恒哥

已于 2022-07-02 15:04:50 修改

阅读量543

点赞数

分类专栏： 1.JavaSE 文章标签： java

于 2022-06-30 23:56:22 首次发布

本文链接：https://blog.csdn.net/qq_42263859/article/details/125550390

版权

1.JavaSE 专栏收录该内容

34 篇文章 2 订阅

订阅专栏

示例3：所有包装类都可将与之对应的基本数据类型作为参数，来构造它们的实例。

07、StringBuffer类和StringBuilder类

1、使用StringBuffer类处理字符串

2、使用StringBuilder类处理字符串

3、String类、StringBuffer类及StringBuilder类对比

（1）String：字符串常量

（2）StringBuffer：字符串变量

（3）StringBuilder：字符串变量

4、常用的StringBuffer类方法使用

示例12：insert()方法

示例13：append()

示例14：toString()方法（暂时无）

示例16：Calendar类常见方法和字符示例

示例17 ：处理日期（计算2015年4月6日是一年中的第几星期）

3、SimpleDateFormat类

（1）通过API查询SimpleDateFormat类：日期和时间模式表

（2）SimpleDateFormat类常用方法

示例18：使用SimpleDateFormat类格式化时间

示例19：处理日期（对示例17进行扩展）

01、Java API介绍

02、认识枚举

1、枚举概述

（1）从Java SE 5.0开始，Java程序设计语言引入了一种新的类型--->枚举

（2）枚举是指由一组固定的常量组成的类型，使用关键字 enum 定义。

（3）定义枚举语法格式：待补充

示例1：定义性别的枚举

需求说明：

定义表示性别的枚举，两个枚举常量分别代表 "男" 和 "女"。

代码：

（1）Genders类

（2）Student类

（3）StudentTest类

enum枚举类：

package cn.bdqn.demo09;
public enum Genders {
	//枚举是由一组固定常量组成的类型
	男,女
}

使用定义的枚举类型"Genders"声明变量"gender"

package cn.bdqn.demo09;
public class Student {	
	public String name; //姓名
	public Genders gender; //性别

}

实现类

package cn.bdqn.demo09;
public class StudentTest {
	public static void main(String[] args) {
		//使用无参构造方法创建对象
		Student stu = new Student();
		//给属性赋值
		stu.name = "张三";
		stu.gender = Genders.男;
		System.out.println(stu.name+"--"+stu.gender);
	}
}

输出结果：

2、使用枚举实现输出每周日程信息

在Java中，通常使用枚举表示一组个数有限的值，用于实现对输入的值进行约束检查。

待补充

03、包装类

1、包装类概述

包装类把基本数据类型转换为对象

包装类并不是用来取代基本数据类型的，只是为了在基本数据类型需要用对象表示时使用。

包装类的作用：

（1）提供了一系列实用的方法

（2）集合不允许存在基本数据类型数据，存放数字时，要用包装类型

下表为：包装类和基本数据类型的对应表

表包装类和基本数据类型的对应表
基本数据类型	包装类
byte	Byte
boolean	Boolean
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double

包装类的用途主要有两个：

（1）包装类作为和基本数据类型对应的类存在，方便对象的操作

（2）包装类包含每种基本数据类型的相关属性，如最大值、最小值，以及相关的操作方法。

示例2：集合中是不允许存放基本数据类型的

package cn.bdqn.demo10;

import java.util.ArrayList;

public class Demo01 {

	public static void main(String[] args) {
		ArrayList al = new ArrayList();
		//集合中是不允许存放基本数据类型的，这里的100和45先是自动转换为对应的包装类型，然后对应的包装类型会转换为Object类型，存储到集合中
		al.add(100);
		al.add(45);
		for (Object object : al) {
			System.out.println(object);
		}
	}

}

2、包装类的构造方法

所有包装类都可将与之对应的基本数据类型作为参数，来构造它们的实例。

示例3：所有包装类都可将与之对应的基本数据类型作为参数，来构造它们的实例。

注意事项：

（1）Character类：除Character类外，其他包装类可将一个字符串作为参数构造它们的实例

例如：Character character2 = new Character("char"); 是错误的

（2）Boolean类构造方法参数为String类型时，若该字符串内容为true(不考虑大小写)，则该Boolean对象表示true，否则表示false

（3）对于Number类型的对象，字符串需要是“数字形式的字符串”,也不能传递一个null值，否则编译不通过，运行时会抛出NumberFormatException异常。

package cn.bdqn.demo10;

public class Demo02 {

	public static void main(String[] args) {
		//所有包装类都可将与之对应的基本数据类型作为参数，来构造它们的实例
		// 除Character类外，其他包装类可将一个字符串作为参数构造它们的实例(对于Number类型的对象，字符串需要是“数字形式的字符串”,也不能传递一个null值)
		
		System.out.println("-------------------(1)Byte----------------------");
		byte byt = 10;
		//byte1是一个对象，这个对象里存储了数据byt
		Byte byte1 = new Byte(byt);
		Byte byte2 = new Byte("123");
		//Byte byte3 = new Byte("abc");//此处输出会报错：NumberFormatException，字符串需要是“数字形式的字符串”,也不能传递一个null值
		System.out.println(byte1);
		System.out.println(byte2);
		System.out.println(Byte.MAX_VALUE); //一个常量，保存 byte 类型可取的最大值，即 27-1。
		System.out.println(Byte.MIN_VALUE); //一个常量，保存 byte 类型可取的最小值，即 -27。
		
		System.out.println("-------------------(2)Short----------------------");
		short sho=100;
		Short short1 = new Short(sho);
		Short short2 = new Short("1234");
		System.out.println(short1);
		System.out.println(short2);
		
		
		System.out.println(Short.MAX_VALUE);
		System.out.println(Short.MIN_VALUE);
		
		System.out.println("-------------------(3)Integer----------------------");
		int num = 1000;
		Integer integer1 = new Integer(num);
		Integer integer2 = new Integer("1122");
		System.out.println(integer1);
		System.out.println(integer2);
		
		System.out.println("-------------------(4)Long----------------------");
		long lon = 10000L;
		Long long1 = new Long(lon);
		Long long2 = new Long("156");
		System.out.println(long1);
		System.out.println(long2);
		
		System.out.println("-------------------(5)Float----------------------");
		float flo = 100.5F;
		Float float1 = new Float(flo);
		Float float2 = new Float("12.5");
		System.out.println(float1);
		System.out.println(float2);
		
		System.out.println("-------------------(6)Double----------------------");
		double dou = 100.5;
		Double double1 = new Double(dou);
		Double double2 = new Double("12.55");
		System.out.println(double1);
		System.out.println(double2);
		
		System.out.println("-------------------(7)Boolean----------------------");
		boolean bool = true;
		Boolean boolean1 = new Boolean(bool);	//true	
		
		//字符串里的内容为true（不区分大小写）的时候，对象里存储的是true，其它所有情况都为false
		Boolean boolean3 = new Boolean("true"); //true
		Boolean boolean4 = new Boolean("false");//false	
		Boolean boolean2 = new Boolean("xiaozhu");//false	  
		Boolean boolean5 = new Boolean(true); //true
		Boolean boolean6 = new Boolean(false); //false
		
		System.out.println("-------------------(8)Charater----------------------");
		char cha = '好';
		Character char1 = new Character(cha); 
		System.out.println(char1); //好

	}
}

输出结果：

3、包装类的常用方法

（1）XXXValue():包装类转换成基本类型

（2）toString():以字符串形式返回包装对象表示的基本类型数据（基本类型->字符串）

（3）parseXXX()：把字符串转换为相应的基本数据类型数据（Character除外,并且字符串里面的内容要能够转换为数字，否则会报异常）（字符串->基本类型）

（5）valueOf():

1）所有包装类都有如下方法（基本类型->包装类）

public static Type valueOf(type value)

2）除Character类外，其他包装类都有如下方法（字符串->包装类）

public static Type valueOf(String s)

示例4：包装类的常用方法

package cn.bdqn.demo10;

public class Demo03 {

	public static void main(String[] args) {
		//包装类常用方法
		System.out.println("------------------(1)XXXValue()-----------------");
		//XXXValue():包装类转换为基本数据类型
		Long lon1 = new Long(125L);
		long num1 = lon1.longValue();  //num1=125
		
		System.out.println("------------------(2)toString()-----------------");
		// toString():以字符串形式返回包装对象表示的基本类型数据（基本类型->字符串）
		String sex = Character.toString('男');  //男
		String str = Boolean.toString(true);	//true
		
		Integer inte = new Integer(100);
		String str1 = Integer.toString(inte);//100
		
		System.out.println("------------------(3)parseXXX()-----------------");
		// parseXXX()：把字符串转换为相应的基本数据类型数据（Character除外,并且字符串里面的内容要能够转换为数字，否则会报异常）（字符串->基本类型）
		byte num2 = Byte.parseByte("123");
		System.out.println(num2);//123
		
		Boolean result = Boolean.parseBoolean("True");
		System.out.println(result);//true
		
		System.out.println("------------------(4)valueOf()-----------------");
		//valueOf():所有包装类都有如下方法（基本类型->包装类） public static Type valueOf(type value)
		byte byte2 = 10;
		Byte byte3 = Byte.valueOf(byte2);
		
		Character cha = Character.valueOf('女');
		
		// 除Character类外，其他包装类都有如下方法（字符串->包装类）public static Type valueOf(String s)
		Byte byte4 = Byte.valueOf("123");
		//Character.valueOf("a");  是错误的
	}

}

输出结果：

4、装箱和拆箱

（1）装箱：基本数据类型转为包装类的对象

（2）拆箱：包装类对象转换为基本数类型

（3）JDK1.5后，允许基本数据类型和包装类型进行混合数学运算

示例5：装箱和拆箱

package cn.bdqn.demo10;

public class Demo04 {

	public static void main(String[] args) {
		//装箱和拆箱
		
		System.out.println("-------------------(1)装箱---------------");
		//之前通过：基本类型-->包装类
		byte byte1 = 10;
		
		Byte byte2 = new Byte(byte1);  //（基本类型->包装类）
		Byte byte3 = Byte.valueOf(byte1);//valueOf():（基本类型->包装类）	
		//装箱：直接将基本数据类型赋值给了包装类对象
		Byte byte4 = byte1;
		System.out.println(byte4);

		System.out.println("-------------------(2)拆箱---------------");
		//之前通过：包装类-->基本类型
		Integer int1 = new Integer(20);
		
		int int2 = int1.intValue();	
		//拆箱：：将包装类对象直接赋值给基本数据类型的变量
		int int3 = int1;
		System.out.println(int3);
		
		System.out.println("-------------------(3)允许基本数据类型和包装类型进行混合数学运算---------------");
		Integer num1 = new Integer(100);
		int num2 = 1000;
		int sum = num1 + num2;
		System.out.println(sum);
		
		Integer sum2 = num1+num2;
		System.out.println(sum2);
		
	}

}

输出结果：

04、Math类

java.lang.Math类提供了一些基本数字运算和集合运算的方法。此类中的所有方法都是静态的。这个类是final类，因此没有子类。

示例6：Math类常用方法

（1）Math.random():随机获取[0.0,1.0)之间的数

随机获取一个[num1,num2）之间的整数

（2）PI：圆周率

（3）abs():求绝对值

（4）ceil(double a):返回一个比a大的离a最近的整数（向上取整）

floor(double a)：返回一个比a小的离a最近的整数（向下取整）

（5）round()：根据四色五入的原则返回数据

（6）max()/min():最大值/最小值

（7）pow(double a,double b):返回a的b次方结果

package cn.bdqn.demo01;

public class MathDemo {

	public static void main(String[] args) {
		System.out.println("------------（1）--------------");
		//Math.random():随机获取[0.0,1.0)之间的数
		double num = Math.random();
		System.out.println(num);

		//随机获取一个[num1,num2）之间的整数
		//int num = (int)(Math.random()*(num2-num1)+num1);
		
		System.out.println("---------------(2)PI---------------");
		double pi = Math.PI;
		System.out.println(pi); //3.141592653589793
		
		System.out.println("---------------(3)abs():求绝对值---------------");
		//abs():求绝对值
		System.out.println(Math.abs(-35));//35
		
		System.out.println("---------------(4)-1 ceil(double a):向上取整---------------");
		//ceil(double a):返回一个比a大的离a最近的整数
		System.out.println(Math.ceil(3.8));  //4.0
		System.out.println(Math.ceil(-3.5)); //-3.0
		
		System.out.println("---------------(4)-2 floor(double a)：向下取整---------------");
		//floor(double a)：返回一个比a小的离a最近的整数
		System.out.println(Math.floor(3.8));//3.0
		System.out.println(Math.floor(-3.5));//-4.0
		
		System.out.println("---------------(5)round()：根据四舍五入的原则返回数据---------------");
		//round()：根据四色五入的原则返回数据
		System.out.println(Math.round(3.5)); //4
		
		
		System.out.println("---------------(6)max()/min():最大值/最小值---------------");
		System.out.println(Math.max(3, 5));//5
		System.out.println(Math.min(7, 9));//9
		
		System.out.println("---------------(7)pow(double a,double b):返回a的b次方结果---------------");
		//pow(double a,double b):返回a的b次方结果
		System.out.println(Math.pow(3, 4)); //81.0		
	}

}

输出结果：

05、Random类

Random类用于生成随机数。

Random类的构造方法有两种重载方式，如下图：

表 Random类的构造方法
构造方法	说明
Random()	创建一个新的随机生成器
Random(long seed)	使用单个long种子创建一个新的随机生成器

注意：如果用同样一个种子值来初始化两个Random对象，然后用每个对象调用相同的方法，那么得到的随机数也是相同的

示例7：Random类常用的部分方法

(1) nextBoolean():随机生成布尔值

(2) nextInt()：随机生成整数

(3) nextInt(int n)：随机生成[0,n)之间的整数

package cn.bdqn.demo02;

import java.util.Random;

public class RandomDemo {

	public static void main(String[] args) {
		System.out.println("------------构造方法：Random()-创建一个新的随机生成器-------------");
		//Random():创建一个新的随机生成器
		//创建Random类对象
		Random random1 = new Random();
		System.out.println(random1);//生成一个地址值
	
		
		System.out.println("------------(1) nextBoolean():随机生成布尔值------------");
		//nextBoolean():返回下一个伪随机数，返回值类型是布尔值
		boolean result1 = random1.nextBoolean();
		System.out.println(result1);//随机生成布尔值，true或false
	
		
		System.out.println("------------(2) nextInt()：随机生成整数------------");
		//nextint():返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
		int result2 = random1.nextInt();
		System.out.println(result2);
	
		
		System.out.println("------------(3) nextInt(int n)：随机生成[0,n)之间的整数------------");
		//nextInt(int n):返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值n（不包括）之间均匀分布的 int 值。
		int result3 = random1.nextInt(8);
		System.out.println(result3);
	
		
		System.out.println("------------构造方法：Random(long seed)-使用单个long种子创建一个新的随机生成器-----------");
		//Random(long seed):使用单个long种子创建一个新的随机生成器
		//如果用同样一个种子值来初始化两个Random对象，然后用每个对象调用相同的方法，那么得到的随机数也是相同的
		Random random2 = new Random(100L);
		System.out.println(random2.nextInt());
		Random random3 = new Random(100L);
		System.out.println(random3.nextInt());
	}
}

输出结果：

06、String类

1、String类概述

在Java中，字符串被称为String类型的对象来处理。String类位于java.lang包中，默认情况下，该包被自动导入所有的程序。

创建String对象的方法如下所示：

（1）String s = "HelloWorld";

（2）String s = new String();

（3）String s = new String("HelloWorld");

2、String类常用的方法

（1）length():获取字符串长度

（2）equals():比较两个字符串的内容是否相同（英文字母区分大小写）

（3）equalsIgnoreCase():比较两个字符串的内容是否相同（英文字母不区分大小写）

（4）toLowerCase()方法:将大写英文字母转换为小写

（5）toUpperCase()方法:将小写英文字母转换为大写

（6）字符串连接：使用 + 和 concat

示例8：String类常用的方法

package cn.bdqn.demo03;

public class StringDemo {

	public static void main(String[] args) {
		System.out.println("--------(1)length():获取字符串长度-----------");
		String str = "abcdefgh";
		//length():获取字符串长度
		System.out.println(str.length()); //8
		
		String str1 = "qwertyuiop";
		if(str1.length()<6||str1.length()>18){
			System.out.println("密码长度应该在6~18之间，请重新输入");
		}
		
		System.out.println("--------(2)equals():比较两个字符串的内容是否相同（英文字母区分大小写）-----------");
		//equals():比较两个字符串的内容是否相同（英文字母区分大小写）
		String str2 = "abcdefg";
		String str3 = "abcdefG";
		System.out.println(str2.equals(str3));  //false
		
		System.out.println("--------(3)equalsIgnoreCase():比较两个字符串的内容是否相同（英文字母不区分大小写）-----------");
		System.out.println(str2.equalsIgnoreCase(str3)); //true
			
		System.out.println("--------(4)toLowerCase()方法:将大写英文字母转换为小写-----------");
		System.out.println("--------(5)toUpperCase()方法:将小写英文字母转换为大写-----------");
		String str4 = "ABCDqwert";
		System.out.println(str4.toLowerCase());  //abcdqwert
		System.out.println(str4.toUpperCase());  //ABCDQWERT

		System.out.println("--------(6)字符串连接：使用 + 和 concat-----------");
		String str5 = "海底月是天上月";
		String str6 = "眼前人是心上人";
		System.out.println(str5+","+str6);  //海底月是天上月,眼前人是心上人

		System.out.println(str5.concat(","+str6));  //海底月是天上月,眼前人是心上人
		
		
	}

}

输出结果：

示例9：会员注册（练习01）

需求说明：

实现会员注册，要求

（1）用户名长度不小于3

（2）密码长度不小于6

（3）注册时两次输入密码必须相同

代码：

package cn.bdqn.demo03;
import java.util.Scanner;
public class Demo02 {
	public static void main(String[] args) {
		/*
		 * 实现会员注册，
		 * 需求说明: 
		 * （1）用户名长度不小于3 
		 * （2）密码长度不小于6 
		 * （3）注册时两次输入密码必须相同
		 */
		Scanner input = new Scanner(System.in);
		System.out.println("************欢迎进入注册系统************");
		
		String userName; //用户名
		String pwd; //密码
		String repPwd;  //再次输入放入密码
		
		while (true) {
			System.out.print("请输入用户名：");
			userName = input.next();
			System.out.print("请输入密码：");
			pwd = input.next();
			System.out.print("请再次输入密码：");
			repPwd = input.next();
			if (userName.length() < 3 || pwd.length() < 6) {
				System.out.println("用户名长度不能小于3，密码长度不能小于6!");
				continue;
			} else {
				if (!pwd.equals(repPwd)) {
					System.out.println("两次输入的密码不相同");
					continue;
				} else {
					System.out.println("注册成功，请牢记用户名和密码。");
					break;
				}
			}
		}
	}
}

3、字符串常用提取方法

表常用的提取和搜索字符串的方法
方法	说明
public int indexOf(int ch)	搜索第一个出现的字符ch（或字符串value），如果没有找到，返回-1
public int indexOf(String value)	搜索第一个出现的字符ch（或字符串value），如果没有找到，返回-1
public int lastIndexOf(int ch)	搜索最后一个出现的字符ch（或字符串value），如果没有找到，返回-1
public int lastIndexOf(String value)	搜索最后一个出现的字符ch（或字符串value），如果没有找到，返回-1
public String substring(int index)	提取从位置索引开始的字符串部分
public String substring(int beginindex, int endindex)	提取beginindex和endindex之间的字符串部分,包括开始索引的字符，不包括结束索引的字符
public String trim()	返回一个前后不含任何空格的调用字符串的副本

示例10：字符串常用提取方法

package cn.bdqn.demo03;

public class StringDemo02 {

	public static void main(String[] args) {
		System.out.println("--------------(1)-1 indexOf() ----------------");
		// public int indexOf(int ch):搜索第一个出现的字符ch（或字符串value），如果没有找到，返回-1
		// public int indexOf(String value)搜索第一个出现的字符ch（或字符串value），如果没有找到，返回-1
		
		//常用的ASCII码的值：A:65  a:97  0:48
		String str = "abcdefghijk01Amnabc";
		int num = str.indexOf(98);//搜索第一个出现ASCII码值为98的字符（或字符串），ASCII码值98的为b
		System.out.println(num);  // 1
		
		int num1 = str.indexOf("c");//搜索第一个出现的字符串为c，并返回下标值。
		System.out.println(num1);  // 2
		
		int num2 = str.indexOf("de");//搜索第一个出现的字符串为de，并返回下标值。
		System.out.println(num2);  // 3
		
		
		System.out.println("--------------(1)-2 lastIndexOf()----------------");
		// public int lastIndexOf(int ch):搜索最后一个出现的字符ch（或字符串value），如果没有找到，返回-1
		// public int lastIndexOf(String value):搜索最后一个出现的字符ch（或字符串value），如果没有找到，返回-1
		
		//搜索最后一个出现ASCII码值为98的字符（或字符串），ASCII码值98的为b
		System.out.println(str.lastIndexOf(98));   //17
		//搜索最后一个出现的字符串为m，并返回下标值。
		System.out.println(str.lastIndexOf("m")); //14
		
		System.out.println("--------------(2)-1 substring(int index)----------------");
		//public String substring(int index):提取从位置索引开始的字符串部分
		
		String str1 = "abcdef1Amnabc";
		String newStr = str1.substring(3);
		System.out.println(newStr);   //def1Amnabc
		
		System.out.println("--------------(2)-2 substring(int beginindex, int endindex)----------------");
		/* public String substring(int beginindex, int endindex):
		 * 提取beginindex和endindex之间的字符串部分,包括开始索引的字符，不包括结束索引的字符
		 */		
		String str2 = "abcdef1Amnabc";
		String newStr1 = str2.substring(3, 6);
		System.out.println(newStr1); //def
		
		System.out.println("--------------(3) trim() ----------------");
		 //public String trim():返回一个前后不含任何空格的调用字符串的副本
		String str3 = "  abc    qwert   ";
		String newStr2 = str3.trim();
		System.out.println(str3);  //  abc    qwert   
		System.out.println(newStr2);  //abc    qwert

	}
}

输出结果：

4、字符串拆分（方法）

示例11：字符串拆分（使用）

package cn.bdqn.demo03;

public class StringDemo03 {

	public static void main(String[] args) {
		
		System.out.println("----------(1) String[] split(String regex)--------------");
		// String[] split(String regex) :根据拆分规则对字符串进行拆分
		String song = "长亭外,古道边,芳草碧连天,晚风拂,柳笛声残,夕阳山外山";
		String[] str1 = song.split(","); //按照逗号“，”拆分
		for (String string : str1) {
			System.out.println(string);
		}
		
		System.out.println("----------------------");
		String love = "我爱你你不爱我但是我很爱你可我就是不爱你";
		String[] loves = love.split("爱");//按照"爱"拆分
		for (String string : loves) {
			System.out.println(string);
		}
		
		System.out.println("----------(2) charAt(int index):返回指定索引处的 char值--------------");
		//charAt(int index):返回指定索引处的 char值
		String str2 = "海上月是天上月，眼前人是心上人";
		char ch = str2.charAt(3);
		System.out.println(ch);  //是
		
		System.out.println("----------(3) endsWith(String suffix):测试此字符串是否以指定的后缀结束--------------");
		//boolean endsWith(String suffix):测试此字符串是否以指定的后缀结束。返回值为布尔值
		boolean result = str2.endsWith("上人");
		System.out.println(result);//true
		
		System.out.println("----------(4) getBytes():使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。 --------------");
		//getBytes():使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
	
		String str3 = "abcdefg10086";
		byte[] byte1 = str3.getBytes();
		System.out.println(byte1[1]); //98:返回的str这个数组下标为1的元素的ASCII码值
		
		char result1 = (char)byte1[1];
		System.out.println(result1); //将上述所得到的的ASCII码值98转换为b
	}
}

输出结果：

练习02：查找特定字符出现的次数

需求说明：

输入一个字符串，再输入要查找的字符，判断该字符在该字符串中出现的次数

07、StringBuffer类和StringBuilder类

1、使用StringBuffer类处理字符串

对字符串频繁修改（如字符串连接）时，使用StringBuffer类可以大大提高程序执行效率。

（1）如何使用StringBuffer类：StringBuffer类位于java.util包中，是String类的增强类。StringBuffer类提供了很多方法可供使用。

（2）常用的StringBuffer类方法：insert()方法、append()方法、toString()方法等。

2、使用StringBuilder类处理字符串

java.lang.StringBuilder是JDK 5.0版本新增的类，它是一个可变的类。此类提供一个与StringBuffer兼容的类，被设计用作StringBuffer的一个简易替代，在大多数实现中，它比StringBuffer执行要快。使用StringBuilder类处理字符串的方法与StringBuffer类基本一样。

3、String类、StringBuffer类及StringBuilder类对比

（1）String：字符串常量

String是不可变对象，在每次对String类型进行改变时其实都等同于生成了一个新的String对象，然后指向新的String对象，所以经常改变内容的字符串最好不要用String类型，因为每次生成对象都会对系统性能产生影响。

（2）StringBuffer：字符串变量

StringBuffer是可变的字符串，在每次对StringBuffer对象进行改变时，会对StringBuffer对象本身进行操作，而不是生成新的对象，再改变对象引用。所以，在字符串对象经常改变的情况下推荐使用StringBuffer类。

例如：字符串连接操作中，StringBuffer类的执行效率要比String类高。

（3）StringBuilder：字符串变量

JDK 5.0版本以后提供了StringBuilder类，它和StringBuffer类等价，区别在于StringBuffer类是线程安全的，StringBuilder类是单线程的，不提供同步，理论上效率更高。

4、常用的StringBuffer类方法使用

（1）insert()：将参数插入到字符串指定位置后并返回。参数可以是包括String的任何类型（例如boolean、char、double、float、int、long等）

（2）append()：将参数连接到字符串后并返回。

（3）toString()：将StringBuffer类型的字符串1转换为String类型的对象并返回

（字符串1.toString）

示例12：insert()方法

需求说明：

将一个数字字符串转换成逗号分隔的数字串，即从右边开始每三个数字用逗号分隔

package cn.bdqn.demo01;

import java.util.Scanner;

public class StringBufferDemo01 {
	public static void main(String[] args) {
		/*
		 * 将一个数字字符串转换成逗号分隔的数字串，
		 * 即从右边开始每三个数字用逗号分隔 
		 * */
		
		//第一步：要获取键盘输入的数字
		Scanner input = new Scanner(System.in);
		System.out.print("请输入一串数字：");
		String num = input.next();
		
		//第二步：一会使用StringBuffer类里的insert()方法，所以先要将num转换成StringBuffer
		StringBuffer sb = new StringBuffer(num);
		for (int i = sb.length()-3;i>0;i-=3) {
			sb.insert(i, ",");
		}
		System.out.println(sb);
		

		
	}
}

输出结果：

示例13：append()

使用append()：将参数连接到字符串后并返回。

package cn.bdqn.demo01;

public class Demo01 {

	public static void main(String[] args) {
		
		String num = "123";
		//使用StringBuffer类里的append()方法，将num转换成StringBuffer
		StringBuffer sb = new StringBuffer(num);
		//使用append()：将参数连接到字符串后并返回。
		sb.append("恒哥520");
		System.out.println(sb);
	}
}

输出结果：

示例14：toString()方法（暂时无）

toString()：将StringBuffer类型的字符串1转换为String类型的对象并返回

08、日期操作类

1、Date类

java.util.Date类：Date类对象用来表示日期和时间，该类提供了一系列操作日期和时间各组成部分的方法。Date类中使用最多的是获取时间的类，如Date date = new Date();这句代码是使用系统当前时间创建日期对象。

示例15：获取当前时间

package cn.bdqn.demo02;

import java.util.Date;

public class DateDemo01 {
	public static void main(String[] args) {
		
		//创建Date类对象
		Date date = new Date();
		System.out.println(date);//显示当前时间的年月日、时分秒：Sat Jul 02 09:14:59 CST 2022
		
		//获取当前年数
		int year = date.getYear()+1900;//斜扛表示此方法已经过时
		System.out.println(year);//2022
		
		//获取当前星期数
		int day = date.getDay();
		switch(day){
		case 0:
			System.out.println("星期天"); //星期天为0，星期一为1，....，星期六为6
		case 6:
			System.out.println("星期六");
		}
				
	}
}

输出结果：

2、Calendar类

java.util.Calendar类：Calendar类对象也是用来表示日期和时间的类，它可以看做是Date类的一个增强版。Calendar类提供了一组方法，允许把一个以毫秒为单位的时间转换为年、月、日、小时、分、秒。可以把Calendar类当作是万年历，默认显示的是当前的时间，当然也可以查看其他时间。

（1）Calendar类是抽象类，可以通过静态方法getInstance()方法获得Calendar类的对象，其实这个获得的对象是它的子类的对象。

（2）用于设置和获取日期/时间数据的特定部分。

（3）Calendar类提供一些方法和静态字段来操作日历，如下表所示：

表 Calendar类常见方法或者字段
方法获属性	说明
int get(int field)	返回给定日历学段的值
YEAR	指示年
MONTH	指示月
DAY_OF_MONTH	指示一个月中的某天
HOUR	指示时
MINUTE	指示一小时中的分钟
SECOND	指示一分钟中的秒
DAY_OF_YEAR	今天是这一年的第几天
DAY_OF_MONTH	今天是这个月的第几天
DAY_OF_WEEK	今天是这个星期中的哪一天
WEEK_OF_YEAR	这个星期是这一年的第几个星期
WEEK_OF_MONTH	这个星期是这个月的第几个星期

示例16：Calendar类常见方法和字符示例

package cn.bdqn.demo04;

import java.util.Calendar;

public class CalendarDemo01 {

	public static void main(String[] args) {
		// 通过查询API知道Calendar类是一个抽象类，不能直接实例化，
		// 可以调用Calendar类中的getInstance()方法获得getInstance()方法获得Calendar类的引用
		// getInstance():使用默认时区和语言环境获得一个日历。
		Calendar cal = Calendar.getInstance();
		System.out.println(cal);// 输出的cal的可以得到很多的数据，比如年月日时分秒星期数等，但是形式不是我们想要的，所以我们要进行转换
		
		//int get(int field):返回给定日历字段的值,查询API查找Calendar类的字段
		//获取年：字段(YEAR)
		int year = cal.get(Calendar.YEAR);		
		System.out.println("年："+year);
		
		//获取月:字段(MONTH)
		int month = cal.get(Calendar.MONTH);
		System.out.println("月："+(month+1));// 在日历cal中第一个月用0表示，第二个月用1表示，以此类推
		
		//获取日:字段(DAY_OF_MONTH)
		int  day = cal.get(Calendar.DAY_OF_MONTH);
		System.out.println("日："+day);
		
		//获取时/分/秒:字段(HOUR/MINUTE/SECOND)
		int hour = cal.get(Calendar.HOUR);
		int minute = cal.get(Calendar.MINUTE);
		int second = cal.get(Calendar.SECOND);
		System.out.println("现在时间："+hour+":"+minute+":"+second);
		
		//获取今天是这一年的第多少天:字段(DAY_OF_YEAR)
		int dayYear = cal.get(Calendar.DAY_OF_YEAR);
		System.out.println("今天是这一年的第"+dayYear+"天");
		
		//获取星期:字段()
		int dayWeek = cal.get(Calendar.DAY_OF_WEEK);
		System.out.println("今天是星期"+(dayWeek-1));
		
	}

}

输出结果：

示例17 ：处理日期（计算2015年4月6日是一年中的第几星期）

package cn.bdqn.demo04;

import java.util.Calendar;

public class CalendarDemo02 {

	public static void main(String[] args) {
		Calendar cal = Calendar.getInstance();
		cal.set(2015, 3, 6);// 注意月份是从0开始，4月份用3表示
		System.out.println(cal);
		int woy = cal.get(Calendar.WEEK_OF_YEAR);
		System.out.println(woy);
	}

}

输出结果：

3、SimpleDateFormat类

java.text.SimpleDateFormat类:SimpleDateFormat类是DateFormat类的子类，SimpleDateFormat类是DateFormat类中使用比较多的子类，是一个以与语言环境有关的方式来格式化和解析日期的具体类，如"yyyy-MM-dd HH:mm:ss"就是指定的一种日期和时间格式。

（1）通过API查询SimpleDateFormat类：日期和时间模式表

（2）SimpleDateFormat类常用方法

（1）format():将给定的 Date 格式化为日期/时间字符串，并将结果添加到给定的 StringBuffer。

示例18：使用SimpleDateFormat类格式化时间

package cn.bdqn.demo03;

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

public class SimpleDateFormaDemo {

	public static void main(String[] args) {
		/*java.text.SimpleDateFormat类:
		 * SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类。
		 * 它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。
		 * */
		
		//创建Date类对象
		Date date = new Date();
		System.out.println(date);//输出上面的cal的可以得到很多的数据，比如年月日时分秒星期数等，但是形式不是我们想要的，所以我们要进行转换
		
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss E D w");//查询API可知：y:年---M:年中的月份---d:月份中的天数 ---H:一天中的小时数（0-23）---m:小时中的分钟数---s:毫秒数
		String str = sdf.format(date);//format():将给定的 Date 格式化为日期/时间字符串，并将结果添加到给定的 StringBuffer。
		System.out.println(str);	
	}
}

输出结果：

示例19：处理日期（对示例17进行扩展）

需求说明

（1）获取当前时间使用SimpleDateFormat以“年-月-日”方式显示

（2）计算2015年4月6日是一年中的第几星期

package cn.bdqn.demo04;

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

public class CalendarDemo00 {

	public static void main(String[] args) {
		/*
		 * 需求说明：
		 * （1）获取当前时间，使用SimpleDateFormat以“年-月-日”方式显示
		 * （2）计算2015年4月6日是一年中的第几星期
		 * */
		//（1）获取当前时间，使用SimpleDateFormat以“年-月-日”方式显示
		//创建Date类对象
		Date date = new Date();
		SimpleDateFormat cal = new SimpleDateFormat("yyyy-MM-dd");
		//format():将给定的 Date 格式化为日期/时间字符串，并将结果添加到给定的 StringBuffer。
		String str = cal.format(date);
		System.out.println("当前时间为："+str);
		
		//（2）计算2015年4月6日是一年中的第几星期
		Calendar cal1 = Calendar.getInstance();
		cal1.set(2015, 3, 6);
		int weekYear = cal1.get(Calendar.WEEK_OF_YEAR);
		System.out.println("2015年4月6日是一年中的第"+weekYear+"个星期");	
	}
}

输出结果：