Java笔记-实用类

最新推荐文章于 2023-10-30 20:41:08 发布

天道酬勤Victor

最新推荐文章于 2023-10-30 20:41:08 发布

阅读量701

点赞数 1

分类专栏： JavaSE 文章标签： Java

本文链接：https://blog.csdn.net/u011753266/article/details/80350976

版权

JavaSE 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

本文将介绍 java.lang和 java.util包中常用的几个类，包括枚举，包装类，String 类型常用方法以及 String 类、 StringBuffer 类和 StringBuilder 类三者的对比、日期类型等。

枚举

1.枚举概括

从 JDK1.5 开始，Java语言引入了一种新的类型-------枚举（Enum）。

枚举：由一组固定的常量组成的类型，使用关键字 enum定义，语法如下：

/*
其他成员：包括构造方法，置于枚举常量的后面。
枚举常量列表必须以分号 ; 结尾
*/
访问修饰符 enum 枚举名{
	常量1[,常量2...[;]]
	//[其他成员]
}

例如：

//定义一个性别的枚举，有female和male
//还包括一个sex的枚举的构造方法
//注意：如果枚举常量后边带有构造方法则常量最后需要有分号 ;
//否则分号可以省略，如代码中注释部分
public class EnumDemo {
	public enum sex {
		//female, male
		female, male;
		private sex() {
		}
	}
}

2.枚举的应用

通常使用枚举表示一组有限的值，实现对输入的值进行约束。例如：

/**
 * 定义一个枚举，包括一周中的7天，并实现日程安排
 * @author 天道酬勤
 */
public class EnumDemo {
	// 定义枚举
	public enum Week {
		MON, TUE, WED, THU, FRI, SAT, SUN
	}

	// 定义日程安排
	public void doByDay(Week day) {
		switch (day) {
		case MON:
		case TUE:
		case WED:
		case THU:
		case FRI:
			System.out.println("工作日");
			break;
		case SAT:
		case SUN:
			System.out.println("休息日");
			break;
		default:
			System.out.println("地球上一周只有7天");
		}
	}

	public static void main(String[] args) {
		EnumDemo ed = new EnumDemo();
		ed.doByDay(Week.TUE);
		Week sat = Week.SAT;
		ed.doByDay(sat);
	}
}

运行结果：
这里写图片描述

示例中，switch 结构传入的变量 day 是 Week 类型，即枚举类型，case 后面的常用类型要与之对应，必须是 Week 中定义的枚举常量。

枚举的好处：

枚举可以使代码更易于维护，有助于确保为变量指定合法的、期望的值。
枚举更易于输入，使用枚举类型，只需要输入枚举名，然后输入一个点（.），就能将所有的值显示出来。
枚举使代码更清晰，允许用描述性的名称表示数据，使用时直观方便。

包装类

1.包装类概述

包装类均位于java.lang包中，包装类和基本数据类型的对应关系如下表所示：

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

包装类用途主要有两个：

包装类作为和基本数据类型对应的类类型存在，方便对象的操作。
包装类包含每种基本数据类型的相关属性，如最大值、最小值等，以及相关的操作方法。

2.包装类和基本数据类型的转换

1.基本数据类型转换为包装类
方法一：使用包装类的构造方法
包装类的构造方法有如下两种形式

//Type表示包装类，参数type为基本数据类型
public Type(type value)
public Type(String value)
//例如：
Integer intValue = new Integer(11);
//或者
Integer intValue = new Integer("11");

//注意唯一特殊的为Character包装类，只能使用如下方法
Character charValue = new Character('x');
//下面的方法均错误
Character charValue = new Character(x);
Character charValue = new Character("x");

方法二：使用包装类的valueOf()方法
包装类中一般含有静态的、重载的valueOf()方法。它也可以接收基本数据类型数据和字符串作为参数并返回包装类的对象。以 Integer 包装类为例，valueOf()方法定义如下表所示：

方法	说明
`Integer valueOf(int i)`	返回一个表示指定的 int 值的 Integer 对象
`Integer valueOf(String s)`	返回保存指定 String 值的 Integer 对象
`Integer valueOf(String s, int radix)`	返回一个 Integer 对象，该对象中保存了用第二个参数提供的基数进行解析时从指定的 String 中提取的值

//例如，创建一个 Integer 类型的包装类对象
Integer intValue = Integer.valueOf("11");
//或者
Integer intValue = Integer.valueOf(11);

//注意：同样是 Character 包装类只有一个 valueOf()版本
Character charValue = Character.valueOf('c');
//下面两个例子均为错误示范
Character charValue = Character.valueOf(c);
Character charValue = Character.valueOf("c");

2.包装类转换成基本数据类型
基本使用public type typeValue()方法。其中， type 指的是基本数据类型，如 byteValue() ， charValue()等等，相应的返回值则为 byte ，char

具体用法如下所示：

Integer integerId = new Integer(25);
int intId = integerId.intValue();

Boolean bl = Boolean.valueOf(true);
boolean bool = bl.booleanValue();

3.基本数据类型和包装类的自动转换
在 JDK1.5 以后，编译器会自动完成转换，例如：

//基本数据类型转换成包装类
Integer intObject = 5;
//包装类转换成基本数据类型
int intValue = intObject;

使用Math类生成随机数

java.lang.Math类提供了一些基本数学运算和几何运算的方法。此类中的所有方法均为静态的。这个类是 final 类，因此没有子类， Math 类常见方法如下：

方法	说明
`static double abs(double a)`	返回 double 值的绝对值。例如： `Math.abs(-3.5);` 返回`3.5`
`static double max(double a,double b)`	返回两个double 值中较大的一个，例如： `Math.max(2.5, 3.5);` 返回`3.5`
`static double random()`	返回一个double 值，该值大于等于0.0且小于1.0。即：[0.0，1.0)

//生成0——9中任意整数的方法：
int random = (int)Math.random() * 10;
//生成0.0——10.0（包含0 不包含10.0）中任意小数
double random = Math.random() * 10;

使用String类操作字符串

1.String类常用方法

求字符串长度

语法：字符串.length();

例如：

String str = "abcd";
int strLen = str.length();
system.out.println(strLen);
//输出结果为4

字符串比较

区分大小写的比较方法：
语法：字符串1.equals(字符串2);
不区分大小写的比较方法
语法：字符串1.equalsIgnoreCase(字符串2);
例如：

String s1 = "abc";
String s2 = "abc";
String s3 = "Abc";
system.out.println(s1.equals(s2) + "----" + s1.equals(s3));
//输出结果为：true----false
//结论：equals() 方法严格比较两个字符串的内容
//（空格和大小写均在比较的范围内）

//equalsIgnoreCase()方法，不区分大小写，但是区分空格
String str1 = "abc";
String str2 = "ABc";
String str3 = "a b C";
system.out.println(str1.equals(str2) 
	+ "----" + str1.equals(str3));
//输出结果为：true----false

toUpperCase()：转换字符串中的英文字符为大写。
toLowerCase()：转换字符串中的英文字符为小写。

String s = "aBC";
system.out.println(s.toUpperCase(s) + "---" + s.toLowerCase(s));
//输出：ABC---abc

字符串的连接

语法：字符串1.concat(字符串2);
将字符串2连接到字符串1的后面，返回连接后的新字符串。
例如：

String s1 = "hello";
String s2 = "World!"
String newStr = s1.concat(s2);
system.out.println(newStr);
//输出：helloWorld!

字符串提取和查询

String 类的常用提取和查询如下表：

方法	说明
`int indexOf(int ch)`	搜索第一个出现字符 ch 的位置（下标）
`int indexOf(String value)`	搜索第一个出现字符串 value 的位置（下标）
`int lastIndex(int ch)`	搜索最后一个出现的字符 ch 位置（下标）
`int lastIndexOf(String value)`	搜索最后一个出现的字符串 value 位置（下标）
`String substring(int index)`	提取从位置索引 index 开始的字符串部分
`String substring(int beginindex, int endindex)`	提取 beginindex 和 endindex 之间的字符串部分
`String trim()`	返回一个前后不含任何空格的调用字符串副本

注意：字符串可以理解为字符数组，所以字符串的下标也是从 0 开始的

字符串拆分

语法：字符串名.split(separator, limit);
其中：

separator 为必须项，标志拆分字符串时使用的一个或多个字符。如果不选择该项，则返回包含该字符串所有单个字符的元素数组。
limit 为可选项，该值用来限制返回数组中的元素个数。

例如：

import java.util.Arrays;
public class SplitDemo {
	public static void main(String[] args) {
		String s = "a,b,c d";
		String[] newS = s.split(",");
		System.out.println(Arrays.toString(newS));
		System.out.println(newS[2]);
	}
}
//运行结果为：
//[a, b, c d]
//c d

StringBuffer类和StringBuilder类

使用StringBuffer类处理字符串

除了使用String 类存储字符串之外，还可以使用StringBuffer 类来存储字符串。 StringBuffer类也是Java 提供的用于处理字符串的一个类。
优点：是比String 类更高效的存储字符串的一种引用数据类型。特别是对字符串进行连接操作时，使用 StringBuffer 类可以大大提高程序的执行效率。

如何使用StringBuffer类

StringBuffer sb2 = new StringBuffer("abc");

常用的StringBuffer类方法

1.toString()方法
转化为String类型的语法如下：字符串1.toString();

//例如,将StringBuffer类型字符串sb2，转换为String类型s1
//sb2见上面如何使用StringBuffer类中声明的对象
String s1 = sb2.toString();

2.append()方法
语法：字符串.append(参数);
例如：

/**
 * StringBuffer的append()方法和String类的concat()方法区别:
 * concat()方法只能将String字符串追加到指定字符串的后面 
 * append()方法可以将任何类型的值追加到字符串后面 
 * 比如int,char,boolean类型等等
 * @author 天道酬勤
 */
public class AppendDemo {
	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer("你好");
		int num = 110;
		// 在字符串后面追加字符串
		StringBuffer sb1 = sb.append("我也好");
		System.out.println(sb1);
		// 在字符串后面追加字符
		StringBuffer sb2 = sb1.append('啊');
		System.out.println(sb2);
		// 在字符串后面追加整形数字
		StringBuffer sb3 = sb2.append(num);
		System.out.println(sb3);
		// 在字符串后面追加布尔类型
		boolean bl = true;
		StringBuffer sb4 = sb3.append(bl);
		System.out.println(sb4);
	}
}
//运行结果：
//你好我也好
//你好我也好啊
//你好我也好啊110
//你好我也好啊110true

3.insert()方法
语法：字符串.insert(位置, 参数);
insert()方法可以实现将参数插入到字符串的指定位置并返回。参数可以是包括String 的任何类型。

例如：

/**
 * 将一串数字从后到前,每三位插入一个逗号
 * @author 天道酬勤
 */
public class InsertDemo {
	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer("12345678");
		for (int i = sb.length() - 3; i > 0; i = i - 3) {
			sb.insert(i, ',');
		}
		System.out.println(sb);
	}
}

使用StringBuilder类处理字符串

JDK1.5 之后新增的类，位于java.lang.StringBuilder，它是一个可变的字符序列。此类提供一个与StringBuffer 兼容的 API，被设计用作 StringBuffer 的一个简易替换，在大多数实现中， StringBuilder 比 StringBuffer 要快。使用 StringBuilder 类处理字符串的方法与StringBuffer 类基本一致，不再举例了。

String 类、StringBuffer类及StringBuilder类对比

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

2.StringBuffer：字符串变量
StringBuffer 是可变的字符串，在每次对 StringBuffer 对象进行改变时，是对 StringBuffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以，在字符串对象经常改变的情况下推荐使用 StringBuffer 类。
字符串连接操作中，StringBuffer 类的效率要比String 类高，例如：

String str = new String("welcom to");
str += " here";

以上这两句代码是使用 String 类型操作字符串，但其处理步骤实际上是通过建立一个 StringBuffer（或 StringBuilder），让他调用 append() 方法，最后再转换成 String 。这样，String 的连接操作比 StringBuffer 多出了一些附加操作，当然效率要低。并且由于 String 对象的不可变性也会影响性能。

3.StringBuilder：字符串变量
JDK1.5 版本开始提供了 StringBuilder类，他和StringBuffer 类等价，区别在于 StringBuffer 类是线程安全的， StringBuilder 类是单线程的，不提供同步，理论上效率更高。

日期时间类

java.util包中提供的和日期、时间相关的类有 Date 类、Calendar 类和SimpleDateFormat 类等。

Date类

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

import java.util.Date;
public class DateDemo {
	public static void main(String[] args) {
		//获取系统当前时间
		Date date = new Date();
		System.out.println(date);
	}
}
//运行结果：
//Thu May 17 18:36:06 CST 2018

Calendar类

Calendar 类也是用来操作日期和时间的类，他可以看作是Date 类的一个增强版。

Calendar 类提供了一组方法，允许把一个以毫秒为单位的时间转换成年、月、日、小时、分钟、秒。可以把 Calendar 类当作万年历，默认显示的是当前的时间，当然也可以查看其他时间。

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

Calendar 类提供一些方法和静态字段来操作日历，例如：
int get(int field)：返回给定日历字段的值。

YEAR：指示年
MONTH：指示月
DAY_OF_MONTH：指示一个月中的某天
DAY_OF_WEEK：指示一个星期中的某天

import java.util.Calendar;

public class CalendarDemo {
	public static void main(String[] args) {
		// 获取Calendar对象
		Calendar c = Calendar.getInstance();
		// 输出当前年月日和星期几
		System.out.println("今天是" + c.get(Calendar.YEAR) + "年" 
			+ (c.get(Calendar.MONTH) + 1) + "月"
				+ c.get(Calendar.DAY_OF_MONTH) + "日");
		System.out.println("今天是星期" 
			+ (c.get(Calendar.DAY_OF_WEEK) - 1));
	}
}
//运行结果
//今天是2018年5月17日
//今天是星期4

DateFormat类

他在java.text包内，是一个抽象类，提供了多种格式化和解析时间的方法。格式化是指日期转换成文本格式，解析是指文本转换成日期格式，使用较多的是他们的子类 SimpleDateFormat。 SimpleDateFormat 类是一个以与语言环境有关的方式来格式化和解析日期的具体类，如yyyy-MM-dd HH:mm:ss就是指定的一种日期和时间模式。

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

public class DateFormatDemo {
	public static void main(String[] args) {
		//获取当前时间
		Date date = new Date();
		//格式化对象，带参构造声明格式
		SimpleDateFormat formater = new SimpleDateFormat
			("yyyy-MM-dd HH:mm:ss");
		//输出格式化后的当前时间
		System.out.println("当前时间为:" + formater.format(date));
	}
}
//运行结果：
//当前时间为:2018-05-17 19:03:15

从 JDK1.1 开始，使用 Calendar 类实现日期和时间字段之间的转换，使用 DateFormat 类来格式化和解析日期字符串。

Random类

Random（java.util.Random）类用于生成随机数

Random类中实现的随机算法是伪随机，也就是有规则的随机。在进行随机时，随机算法的起源数字称为种子数(seed)，在种子数的基础上进行一定的变换，从而产生需要的随机数字。

相同种子数的Random对象，相同次数生成的随机数字是完全相同的。也就是说，两个种子数相同的Random对象，第一次生成的随机数字完全相同，第二次生成的随机数字也完全相同。这点在生成多个随机数字时需要特别注意。

Random对象的生成

Random 类的构造方法有两种重载方法，如下表所示：

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

Random类的常用方法

Random类中的方法比较简单，每个方法的功能也很容易理解。需要说明的是，Random类中各方法生成的随机数字都是均匀分布的，也就是说区间内部的数字生成的几率是均等的。

//该方法的作用是生成一个随机的int值，该值介于int的区间。
public boolean nextInt()

public static void main(String[] args) {
	// 创建Random对象
	Random random = new Random();
	// 随机生成10个随机整数，并显示
	// 取值范围为0到10（不包括10）
	for (int i = 0; i < 10; i++) {
		int num = random.nextInt(10);
		System.out.println("第" + (i + 1) + "个随机数为:" + num);
	}
}

运行结果如下：
这里写图片描述

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

public static void main(String[] args) {
	// 创建Random对象
	Random random = new Random();
	Random random1 = new Random(1);
	Random random2 = new Random(1);
	int[] array = new int[10];
	int[] array1 = new int[10];
	int[] array2 = new int[10];

	// 随机生成10个随机整数，并显示
	// 取值范围为0到5（不包括5）
	for (int i = 0; i < 10; i++) {
		array[i] = random.nextInt(5);
		array1[i] = random1.nextInt(5);
		array2[i] = random2.nextInt(5);
	}
	System.out.println(Arrays.toString(array));
	System.out.println(Arrays.toString(array1));
	System.out.println(Arrays.toString(array2));
}

运行结果如下：
这里写图片描述

天道酬勤Victor

关注

1
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
Java笔记-实用类

本文将介绍java.lang和java.util包中常用的几个类，包括枚举，包装类，String 类型常用方法以及 String 类、 StringBuffer 类和 StringBuilder 类三者的对比、日期类型等。一、枚举1.枚举概括从 JDK1.5 开始，Java语言引入了一种新的类型——-枚举（Enum）。枚举：由一组固定的常量组成的类型，使用关键字 enum定义，语法...
复制链接

扫一扫