Java基础工具类详解
本文详细介绍了Java中常用的工具类，包括Arrays类的各种数组操作方法、Calendar类的时间日期处理、System类的系统级功能、Date类及其与字符串的转换、Math类的数学运算、Random类的随机数生成以及正则表达式的应用。
Arrays：
对象数组：存储对象的一个数组；
举例：Student[] student = new Student[5] ;
Arrays：针对数组操作的工具类 (提供了一些针对数组排序和二分搜索法)：
public static String toString(int[] a)：可以将int类型的数组转换成字符串 ([元素1,元素2,元素3...])；public static void sort(int[] a)：对指定的 int 型数组按数字升序进行排序；
public static int binarySearch(int[] a,int key)：二分搜索法：在int类型的数组中查找key元素的索引；
举例：
public class ArraysDemo {
public static void main(String[] args) {
//定义一个数组:静态初始化
int[] arr = {24,69,80,57,13} ;
//public static String toString(int[] a):可以将int类型的数组转换成字符串 ([元素1,元素2,元素3...])
//直接用Arrays去调用
String str = Arrays.toString(arr) ;
System.out.println("str:"+str); //[24, 69, 80, 57, 13]
System.out.println("-----------------------");
//public static void sort(int[] a)对指定的 int 型数组按数字升序进行排序
Arrays.sort(arr);
String str2 = Arrays.toString(arr) ;
System.out.println("str2:"+str2); //[13, 24, 57, 69, 80]
System.out.println("-----------------------");
//public static int binarySearch(int[] a,int key):二分搜索法:
//在int类型的数组中查找key元素的索引
//需求:查找57元素对应的索引
Arrays.sort(arr);
int index = Arrays.binarySearch(arr, 57) ;
System.out.println("index:"+index); //2
int index2 = Arrays.binarySearch(arr, 577) ;
System.out.println("index2:"+index2); //-6
}
}Calendar类：日历类；
Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法；
注意：抽象类不能实例化；
解决方法：public static Calendar getInstance()：通过一个静态功能来创建日历的对象；
举例：
public class CalendarDemo {
public static void main(String[] args) {
//创建日历类的对象
//Calendar rightNow = new Calendar() ; 不能实例化,所以这条语句会报错
//Calendar类的实例化
Calendar rightNow = Calendar.getInstance() ;
//System.out.println(rightNow);
//public int get(int field)返回给定日历字段的值
//获取年:public static final int YEAR
int year = rightNow.get(Calendar.YEAR) ;
//获取年中的月份:public static final int MONTH
int month = rightNow.get(Calendar.MONTH) ;
//public static final int DATE :获取月份的那一天
int date = rightNow.get(Calendar.DATE) ;
System.out.println(year+"年"+(month+1)+"月"+date+"日"); //通过日历类获取当前系统时间
}
} public abstract void add(int field,int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量；
public final void set(int year, int month,int date)：设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值；
举例：
public class CalendarDemo2 {
public static void main(String[] args) {
//算出当前时间
Calendar c = Calendar.getInstance() ;
//年
int year = c.get(Calendar.YEAR) ;
//月
int month = c.get(Calendar.MONTH) ;
//日
int date = c.get(Calendar.DATE) ;
System.out.println(year+"年"+(month+1)+"月"+date+"日");
//需求:3年前的今天
c.add(Calendar.YEAR, -3);
//获取年
year = c.get(Calendar.YEAR) ;
System.out.println(year+"年"+(month+1)+"月"+date+"日");
//需求:5年后的10天前
c.add(Calendar.YEAR, 5);
c.add(Calendar.DATE, -10);
//获取年
year = c.get(Calendar.YEAR) ;
date = c.get(Calendar.DATE) ;
System.out.println(year+"年"+(month+1)+"月"+date+"日");
System.out.println("------------------------------");
//public final void set(int year, int month,int date)设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值
c.set(2018, 5,20);
// 获取年
year = c.get(Calendar.YEAR);
// 获取月
month = c.get(Calendar.MONTH);
// 获取日
date = c.get(Calendar.DATE);
System.out.println(year + "年" + (month + 1) + "月" + date + "日");
}
}package org.westos.b_calendar;
import java.util.Calendar;
import java.util.Scanner;
/**
* 需求:获取任意一年的二月有多少天 (改进:键盘录入一个年份)
*
*分析:
* 1)键盘录入任意一个年份
* 2)创建日历类对象
* 3)设置年月日
* set(录入year,2,1) ; //实际是3月1日
* 4)再利用add(int field,int amount) : 在这里只需要将日期往前退一天即可
*/
public class CalendarTest {
public static void main(String[] args) {
//创建键盘入对象
Scanner sc = new Scanner(System.in) ;
//录入数据
System.out.println("请输入一个年份:");
int year = sc.nextInt() ;
//创建日历类对象
Calendar c = Calendar.getInstance() ;
//设置年月日
c.set(year, 2, 1); //实际3月1日
//只需要将日期往前推一天即可
c.add(Calendar.DATE, -1);
System.out.println("二月有:"+c.get(Calendar.DATE)+"天");
}
}System类：包含一些有用的类字段和方法，它不能被实例化；
常用的方法：public static void gc()：运行垃圾回收器；
public static void exit(int status)：终止当前正在运行的 Java 虚拟机，参数用作状态码；
一般情况,需要终止Jvm,那么参数0；
public static long currentTimeMillis()：返回以毫秒为单位的当前时间；
public static void arraycopy(Object src,int srcPos, Object dest,int destPos, int length)：从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束；
src：原数组；
dest：目标数组；
srcPos：从原数组的哪个位置开始；
destPos：到目标数组的哪个位置结束；
length：长度；
举例：
public class SystemDemo2 {
public static void main(String[] args) {
System.out.println("我们喜欢高圆圆....");
//public static void exit(int status)
//System.exit(0); //jvm已经退出了，后边的程序不执行
System.out.println("我们也喜欢杨桃....");
System.out.println("-----------------------");
// public static long currentTimeMillis()返回以毫秒为单位的当前时间
long time = System.currentTimeMillis() ;
System.out.println("tiem:"+time);
System.out.println("-----------------------");
//单独使用,没有意义
//一般情况,来测试一段代码的执行效率 (后面:jdbc: PreparedStatement Statement 也可以用currentTimeMillis来测试速率 )
long start = System.currentTimeMillis() ;
for(int x =0 ; x < 1000; x ++) {
System.out.println("hello"+x);
}
long end = System.currentTimeMillis() ;
System.out.println("共耗时:"+(end-start)+"毫秒");
System.out.println("---------------------------");
int[] arr1 = {11,22,33,44,55,66} ;
int[] arr2 = {5,6,7,8,9,10} ;
System.out.println(Arrays.toString(arr1));
System.out.println(Arrays.toString(arr2));
System.out.println("---------------------------");
System.arraycopy(arr1, 1, arr2, 2, 2); //将arr2中的元素覆盖了，由Str1中的元素代替；
System.out.println(Arrays.toString(arr1));
System.out.println(Arrays.toString(arr2));
}
}Date类：表示特定的瞬间，精确到毫秒；
构造方法：public Date()：表示分配它的时间（精确到毫秒）；
public Date(long date)：创建一个日期对象,指定毫秒值 (需要将long时间毫秒值转换成Date对象)；
public void setTime(long time)：设置毫秒值；
public long getTime()：将Date--->long的毫秒值，通常认为Date.getTime()可以得到得到1970年01月1日0点零分以来的毫秒数；
举例：
public class DateDemo {
public static void main(String[] args) throws ParseException {
//创建日期类对象
Date d = new Date() ;
System.out.println(d); //Date类型的日期格式: Sun Apr 29 11:22:47 CST 2018
//Date的文本格式: String :2018-4-29
Date dd = new Date(1000) ;
System.out.println(dd);
//创建日期类对象
Date ddd = new Date() ;
long time = ddd.getTime() ;
System.out.println("time:"+time);
//System.out.println(System.currentTimeMillis());
}
}Date---->String(格式化)
String-->Date(解析)
中间的转换：使用中一个中间类DateFormat，（DateFormat是一个抽象类，抽象意味着不能实例化）所以应该考虑用它的子类（SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类）；
它允许进行：格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化；
SimpelDateFormat的构造方法：
public SimpleDateFormat(String pattern)：构造一个SimpleDateFormat对象，根据pattern(模式:规则)；
SimpleDateFormat sdf = new SimpleDateFormat("xxx年xx月xx日") ;
日期和时间模式：
年: yyyy
月: MM
日: dd
时: hh
分: mm
秒: ss
举例：
public class DateDemo3 {
public static void main(String[] args) throws ParseException {
//Date---String:(格式化)
//创建一个日期对象
Date d = new Date() ;
//创建SimpleDateFormat类对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
//public final String format(Date date):格式化
String str = sdf.format(d) ; //格式化
System.out.println("str:"+str); //str:2018-04-29 11:12:41
System.out.println("----------------------");
//String:日期文本格式:---->Date:日期格式：(解析)
//public Date parse(String source):解析
String strDate = "2018-6-25 09:01:09" ;
//创建SimpleDateFormat类对象
//SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日") ;
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss") ;
//注意 :simpleDateFormat在解析文本格式的时候,里面 模式(规则)一定要和文本格式的模式一直,否则就出现PareseException
Date dd = sdf2.parse(strDate) ; //解析
System.out.println("dd:"+dd); //dd:Mon Jun 25 00:00:00 CST 2018
}
}package org.westos.d_date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
/**
*键盘录入你的出生年月日,算一下你来到这个世界多少天?
*
*分析:
* 1)创建键盘录入对象,录入一个数据出生年月日
* 2)1990-xx-xx
* 3)将文本格式的数据解析成日期对象
* 4)getTime() ; 获取出生所在日期的时间毫秒值
* 5)获取当前系统时间毫秒值
* (6) 5)-4) = long time
*
* 6)换算
*
*
*/
public class DateTest {
public static void main(String[] args) throws ParseException {
/* //创建键盘录入对象
*
*
try { //捕获异常(IO流异常类说到)
} catch (ParseException e) {
e.printStackTrace(); //将代码出现的原因以及多少行会打印在控制台上
}*/
Scanner sc = new Scanner(System.in) ;
//录入数据
System.out.println("请输入您的出生年月日:");
String str = sc.nextLine() ; //yyyy-MM-dd
//创建SimpleDateFormat对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd") ;
Date date = sdf.parse(str) ;
//获取出生年月所在的系统时间
long oldTime = date.getTime() ;
//在获取当前系统时间的毫秒值
long newTime = System.currentTimeMillis() ;
long time = newTime - oldTime ;
long day = time/1000 /60 /60 /24 ;
System.out.println("您来到世间已经有:"+day+"天");
}
}package org.westos.d_date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* 这是Date和Stirng文本格式进行相互转换的工具类
* @author Administrator
* @version v1.0
*/
class DateUtil {
//无参构造私有化
private DateUtil() {
}
/**
* 这是一个将Date的日期格式转换成日期的文本格式
* @param format 模式
* @param d 需要被格式化的Date格式
* @return 返回的就是日期的文本格式
*/
public static String dateToString(String format,Date d) {
/*SimpleDateFormat sdf = new SimpleDateFormat(format) ;
String s = sdf.format(d) ;
return s ;*/
return new SimpleDateFormat(format).format(d) ;
}
/**
* 这一个将字符串文本日期格式转换Date的日期格式的功能
* @param format 模式
* @param s 需要被解析的日期文本格式
* @return 返回的就Date日期格式
* @throws ParseException 解析如果出问题了,就会有这个异常
*/
public static Date stringToDate(String format,String s) throws ParseException {
return new SimpleDateFormat(format).parse(s) ;
}
}
public class DateUtilTest {
public static void main(String[] args) throws ParseException {
Date d = new Date();
//Date---String
String s1 = DateUtil.dateToString("yyyy-MM-dd", d) ;
System.out.println("s1:"+s1); //s1:2018-05-01
String s2 = DateUtil.dateToString("yyyy年MM月dd日 hh:mm:ss", d) ;
System.out.println(s2); //2018年05月01日 10:02:59
System.out.println("----------------------");
//String---Date
String str = "2018-10-10" ;
Date dd = DateUtil.stringToDate("yyyy-MM-dd", str);
System.out.println(dd); //Wed Oct 10 00:00:00 CST 2018
}
}
Math类：包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数；
常用方法：public static int abs(int a)：绝对值；
public static double ceil(double a)：向上取整；
public static double floor(double a)：uuu向下取整；
public static int max(int a,int b)：求最大值；
public static int min(int a,int b)：求最小值；
public static double pow(double a,double b)：a的b次幂；
public static double random()：返回带正号的 double 值，该值大于等于 0.0 且小于 1.0；
public static int round(float a)：四射五入；
public static double sqrt(double a)：一个数的正平方根；
举例：
public class MathDemo {
public static void main(String[] args) {
//public static int abs(int a):绝对值
System.out.println(Math.abs(-10));
System.out.println(Math.abs(10));
//public static double ceil(double a):向上取整
System.out.println(Math.ceil(12.34));
//public static double floor(double a):向下取整
System.out.println(Math.floor(12.34));
//public static int max(int a,int b):求最大值
System.out.println(Math.max(10, 20));
//方法中嵌套方法
//方法递归(方法本身调用方法的这种现象)
System.out.println(Math.max(Math.max(10, 20), 20));
//public static double pow(double a,double b):a的b次幂
System.out.println(Math.pow(2.0, 3.0));
//public static double random()返回带正号的 double 值，该值大于等于 0.0 且小于 1.0
System.out.println(Math.random());
//public static int round(float a):四射五入
System.out.println(Math.round(12.56));
//public static double sqrt(double a):一个数的正平方根
System.out.println(Math.sqrt(4));
System.out.println("---------------------------------------");
//面试题:有两个变量,让他们的值进行互换 (考官想问的是:你能否指定位^的特点)
int a = 10 ;
int b = 20 ;
//实际开发中:中间变量的方式进行互换
//位^的特点:一个数据被另一个数据位^两次,其值是它本身
/*System.out.println(a^b^b);
System.out.println(a^b^a);*/
System.out.println("a:"+a+",b:"+b);
//=号左边: a,b,a
//=右边: a^b
a = a ^ b ;
b = a ^ b ;//b = a^b ^ b ==> (将上式的a=a^b代到这个式子中)
a = a ^ b ;
System.out.println("a:"+a+",b:"+b);
}
}Random类：是一个可以获取随机数的类；
Random类常用的方法：public Random()：无参构造方法；
public Random(long seed)：指定long类型的数据进行构造随机数类对象 ；
public int nextInt()：获取随机数,它的范围是在int类型范围之内；
public int nextInt(int n)：获取随机数,它的范围是在[0,n)之间；
举例：
package org.westos.f_random;
import java.util.Random;
public class RandomDemo {
public static void main(String[] args) {
//创建Random类对象
Random r = new Random() ;
for(int x = 0 ; x < 10 ; x ++) {
int n = r.nextInt(5) ;
System.out.println(n);
System.out.println((int)(Math.random()*100)+1); //随机的删除1~100之间的任意一个整数;
}
}
}正则表达式：
类别：字符：
x x字符
\\ 反斜线字符
\t 制表符
\n 换行符
\r 回车符
字符类:
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）
预定义字符类:
. 任何字符 如果本身就是. \. qq.com 写正则表达式(\\.)
\d 数字：[0-9] 写正则表达式 :\\d
\w 单词字符：[a-zA-Z_0-9]:字母大小写,数字字符 \\w
边界匹配器:
^ 行的开头
$ 行的结尾
\b 单词边界 尾 (helloword?haha:world)
Greedy 数量词(重点)
X? X字符出现一次或一次也没有
X* X字符出现零次或多次
X+ X字符出现一次或多次
X{n} X字符恰好出现n次
X{n,} X字符至少出现n次
X{n,m} X字符至少出现n次,但不超过m次
//判断给定的字符串是否符合正则表达式的规则：public static boolean matches(String regex)；
//检验我们的字符串数据是否和正则规则匹配,如果匹配成功则返回true；
举例：
public class RegexDemo2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in) ;
//接收数据
System.out.println("请输入一个QQ号码:");
String QQ =sc.nextLine() ;
boolean flag = checkQQ(QQ) ;
System.out.println(flag);
}
public static boolean checkQQ(String qq) {
//使用matches方法判断字符串是否符合正则表达式的规则：public static boolean matches(String regex)
//检验我们的字符串数据是否和正则规则匹配,如果匹配成功则返回true；
//定义正则规则：
/*String regex= "[1-9][0-9] {4,14}" ;
boolean flag = qq.matches(regex) ;
return flag ;*/
//改进
return qq.matches("[1-9]\\d{4,14}") ;
}
}使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串：
public String replaceAll(String regex,String replacement)；
举例：
public class RegexDemo4 {
public static void main(String[] args) {
//定义一个字符串
String s = "hello12345World781323244454JavaEE" ;
//需求:要将数字字符被替换成*
String regex = "\\d+" ;
//定义替换的字符串
String ss = "*" ;
//将字符串s中的数字字符被 * 替换
String result = s.replaceAll(regex, ss) ;
System.out.println("result:"+result); //result:hello*World*JavaEE
}
}public String[] split(String regex)：按照指定的格式进行分割，分割后返回的是一个字符串数组；
举例：
import java.util.Scanner;
public class RegexTest2 {
public static void main(String[] args) {
//给定义一个字符串
String str = "18-24" ;
//利用分割功能
String[] strArray = str.split("-") ;
//要将String[]数组的字符串数据转换成int类型的数据:
int start = Integer.parseInt(strArray[0]) ;
int end = Integer.parseInt(strArray[1]) ;
//键盘录入一个年龄
Scanner sc = new Scanner(System.in) ;
//接收
System.out.println("请输入搜索的年龄:");
int age =sc.nextInt() ;
if(age >=start && age<=end) {
System.out.println("是我们要找的人...");
}else {
System.out.println("不是我们要找的...");
}
}
}public class RegexTest3 {
public static void main(String[] args) {
String s1 = "aa,bb,cc" ;
String[] str = s1.split(",") ; //以 , 分割
for (int x = 0; x < str.length; x++) {
System.out.println(str[x]);
}
System.out.println("----------------------------");
String s2 = "aa.bb.cc" ;
String[] str2 = s2.split("\\.") ; //表示 . 字符
for(int x = 0 ; x <str2.length; x ++) {
System.out.println(str2[x]);
}
System.out.println("----------------------------");
String s3 = "aa bb cc" ;
String[] str3 = s3.split(" +") ; //一个或多个空格
for(int x = 0 ; x <str3.length ; x ++) {
System.out.println(str3[x]);
}
System.out.println("----------------------------");
//硬盘上的路径的形式
String s4 = "E:\\JavaSE\\Code\\day11" ;
String[] str4 = s4.split("\\\\"); //两个\\猜表示\
for(int x = 0 ; x <str4.length ; x ++) {
System.out.println(str4[x]);
}
}
}package org.westos.g_patten;
import java.util.Arrays;
/**
* 需求:我有如下一个字符串:"91 27 46 38 50"
* 请写代码实现最终输出结果是："27 38 46 50 91"
*
* 分析:
* 1)定义这样一个字符串
* 2)将字符串进行分割,返回字符串数组
* 3)将字符串数组变成int类型的数组
* 4)将int类型中的元素拼成字符串类型
* 5)输出即可
*
*/
public class RegexTest4 {
public static void main(String[] args) {
//定义一个字符串:
String s = "91 27 46 38 50" ;
//将字符串进行分割,返回一个字符串数组
String[] strArray = s.split(" ") ;
//将字符串变成int类型数组
int[] arr = new int[strArray.length] ;
//遍历arr数组
for(int x = 0 ; x <arr.length ;x ++) {
arr[x] = Integer.parseInt(strArray[x]) ;
}
//排序:直接用Arrays工具类
Arrays.sort(arr);
//创建一个字符串缓冲区:
//StringBuilder
StringBuilder sb = new StringBuilder() ;
//遍历int类型数组
for(int x = 0 ; x < arr.length ; x ++) {
sb.append(arr[x]).append(" ") ;
}
//还需将StringBulider转换字符串
String result = sb.toString().trim() ;
System.out.println("result:"+result);
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
