栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

第十一章 Java常用类

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

第十一章 Java常用类

今天我们来学习一下Java常用类。Java API(Java Application Programming Interface,Java应用程序接口),是Java语言提供的组织成包结构的许多类和接口的集合。

Java常用包

java.applet.*             提供了创建applet需要的所有类

java.awt.*                  提供了创建用户界面以及绘制和管理图像、图形的类

java.beans.*             提供了开发JavaBeans需要的所有类

java.io.*                    提供了通过数据流,对象序列以及文件系统实现的系统输入输出

java.lang.*                提供了Java编程语言的基本类库

java.math.*                提供了整数运算以及十进制算数的基本函数

java.net.*                    提供了用于实现网络通讯应用的所有类

java.nio.*                    提供了用于实现nio应用的所有类

java.rmi.*                    提供了与远程方法调用相关的所有类

java.security.*            提供了设计网络安全方案需要的一些类

java.sql.*                     提供了访问和处理来自Java标准数据源数据的类

java.text.*                    提供了处理文本,日期、数字和消息的类和接口

java.time.*                   提供了Java日期时间类

java.util.*                      提供了集合类、时间处理模式、日期时间工具等各类常用工具包

javax.serverlet            提供了支持serverlet编程的类和接口

javax.swing                 提供了扩充和增强基本图形用户界面功能的类和接口

java.lang包是Java语言的核心类库,包含了Java语言必不可少的系统类定义,如Object类、基本数据类型包装类、Math数学类、String类、System类和Runtime类、Class类操作类、Error错误类和Exception异常类、Thread线程类和Runnable接口。为了简化编程,系统默认自动导入(import)了java.lang包,我们可以在代码中直接使用以上列举的类!

Java Object 类

Java Object 类是所有类的父类,子类可以使用 Object 的所有方法。当我们创建一个类时,如果没有明确继承一个父类,那么它就会自动继承 Object,成为 Object 的子类。Java Object 类中的方法如下:

Class getClass()

获取运行时对象的类,可以通过该类中的getName方法,获取对象的类名。

protected Object clone()

创建并返回对象的拷贝,实现对象的复制,但必须实现Cloneable接口。JAVA类对象传参数都是引用传递,如果不希望在方法里将参数改变,就可以使用clone方法复制一份数据。

boolean equals(Object obj)

比较两个对象是否相等,默认比较的是对象的引用(内存地址)是否相同。该方法很容易联想到“==”比较运算符,它既可以比较基本数据类型,也可以比较引用数据类型。如果是基本数据类型比较的是值,引用数据类型比较的是引用(内存地址)。也就是说,equals方法和“==”比较运算符对于引用数据类型来讲,都是比较内存地址。但是,在String类中,它重写了equals()方法,比较的是字符串的值,这一点大家要注意啊!

protected void finalize()

析构方法,当GC (垃圾回收器)确定不存在对该对象的引用时,由JVM自动调用此方法。

int hashCode()

返回对象的hash值,该值根据对象的内存地址来计算,不同对象的hash值是不一样的。

String toString()

返回对象的字符串表示形式:类的全路径名称+它的hash值,在实际的开发中会重写该方法。

void notify(),void notifyAll()     ,void wait(),void wait(long timeout),void wait(long timeout, int nanos) 这五个方法都是和线程相关的,分别用于唤醒线程和阻塞线程,两者相互配合使用。

Java的包装类

java语言是一个面向对象的语言,但是java中的基本数据类型却不是对象,但是我们在实际使用中经常将基本数据类型转换成对象。Java有8种基本数据类型:整型(byte、short、int、long)、浮点型(float、double)、布尔型boolean、字符型char,相对应地,Java提供了8种包装类Byte、Short、Integer、Long、Float、Double、Boolean、Character。对于关系如下:

基本数据类型            包装类

byte                             Byte

boolean                       Boolean

short                            Short

char                             Character

int                                 Integer

long                             Long

float                             Float

double                         Double

我们都知道在Java语言中,用new关键字创建的对象是存储在堆里的,我们通过栈中的引用(内存地址)来使用这些对象,所以,对象本身来说是比较消耗资源的。而Java基本类型直接存储在栈中,因此它们的存取速度要快于存储在堆中的对应包装类的实例对象。

在应用中我们经常需要进行基本类型数据和包装类对象之间的互转。

// 基本数据类型转为包装类
Integer a = new Integer(1);
System.out.println(a);

// 包装类型转为基本数据类型
int b = a.intValue();
System.out.println(b);

而Java为了方便我们使用,给我们提供了自动装箱、拆箱机制。这种机制简化了基本类型和包装类型的转换。

// 自动装箱
Integer  a1 = 2;
System.out.println(a1);

// 自动拆箱
int b1 = a1;		
System.out.println(b1);

包装类还为基本类型添加了属性和方法,丰富了基本类型的操作。如当我们想知道int取值范围的时候,我们可以直接使用Integer.MIN_VALUE和Integer.MAX_VALUE获取即可。

// Int取值范围
System.out.println(Integer.MIN_VALUE);
System.out.println(Integer.MAX_VALUE);

另外包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型:

public static byte parseByte(String s):将字符串参数转换为对应的byte基本类型。

public static short parseShort(String s):将字符串参数转换为对应的short基本类型。

public static int parseInt(String s):将字符串参数转换为对应的int基本类型。

public static long parseLong(String s):将字符串参数转换为对应的long基本类型。

public static float parseFloat(String s):将字符串参数转换为对应的float基本类型。

public static double parseDouble(String s):将字符串参数转换为对应的double基本类型。

public static boolean parseBoolean(String s):将字符串参数转换为对应的boolean基本类型。

如果是基本类型转换为字符串String的话,可以使用如下方式:

方式一:直接在数字后加一个空字符串

方式二:通过String类静态方法valueOf()

方式三:使用包装类的toString()方法

关于数据类型和字符串的转化,我们之前的Java基础课程中都讲解过,这里不再细述!

System类

System类代表操作系统,我们可以通过它获取很多系统属性。由于该类的构造方法是private的,所以无法实例化该类。其内部的成员方法和成员变量都是static(静态)的,所以可以直接使用。system中包含了in、out和err三个成员变量,分别代表标准输入流(键盘输入)、标准输出流(显示器)和标准错误输出流(显示器)。

public final static InputStream in;               // 标准输入流

public final static PrintStream out;              // 标准输出流

public final static PrintStream err;               // 标准错误流

System.out.print和println()方法输出数字或字符到屏幕上,后者输出后换行而已。System.in.read()用来读取键盘输入数值的ASCII码,我们数字游戏项目中使用过此方法。在输入方面,Java还有一个Scanner类,它提供了更多的方法来对输入数据进行处理,我们可以使用Scanner类对System.in进行包装。如下:Scanner reader = new Scanner(System.in); 然后reader对象调用下列方法读取用户在命令行输入的各种类型的数据:

nextByte(), nextDouble(), nextFloat, nextInt(), nextLine(), nextLong(), nextShot()

但我们日常的Web或GUI开发中,都不会使用上述的输入和输出方式。

接下来我们了解一下System中常用的方法:

System.arraycopy(src, strPos, dest, destPos, length);

其中,str是被复制的数组,strPos是复制的起始位置,dest是复制到的数组,destPos是复制到这个数组的起始位置,length是复制到这个数组的结束位置。

// 数组的复制
int[] src = {1,2,3,4,5,6,7,8,9,0};
int[] dest = new int[5];
// 将数组src中前五个元素复制到dest中
System.arraycopy(src, 0, dest, 0, 5);
for(int i=0; i<5; i++)
System.out.print(dest[i] + " ");

System.currentTimeMillis();

该方法返回自1970年1月1日零点到现在时刻所经历的的毫秒数,称之为时间戳(Long类型)。

// 获取时间戳
long s = System.currentTimeMillis();
System.out.println(s);

System.getProperty获取操作系统属性,例如:Jdk信息,操作系统信息,文件分隔符等等。

// 获取系统属性
System.out.println("操作系统名称:" + System.getProperty("os.name"));
System.out.println("操作系统架构:" + System.getProperty("os.arch"));
System.out.println("Java版本:" 	   + System.getProperty("java.version"));
System.out.println("当前程序路径:" + System.getProperty("user.dir"));
System.out.println("Java类路径:"    + System.getProperty("java.class.path"));
System.out.println("Java库路径:"    + System.getProperty("java.library.path"));

System.getenv()获取系统环境信息,例如环境变量,系统用户名称等等。

// 获取系统环境信息
System.out.println("计算机名称:" + System.getenv("COMPUTERNAME"));
System.out.println("Path环境变量:" + System.getenv("Path"));

Runtime类

Runtime类提供了许多的方法来与运行时环境(Java虚拟机)进行交互。

public Process exec()执行本地程序,比如在win平台下运行exe命令。

public void load()可以加载动态链接库,如linux下的so文件,win下的dll文件。

public long freeMemory() 获得JVM已经从系统中获取到的总共的内存数【byte】

public long totalMemory() 获得JVM中剩余的内存数【byte】

public long maxMemory() 获得JVM中可以从系统中获取的最大的内存数【byte】

备注:maxMemory返回的是java虚拟机(这个进程)能够从操作系统那里获取的最大的内存,当Java程序运行的过程中,java虚拟机内存总是慢慢的从操纵系统那里不断获取,这就是我们的totalMemory 的内存,当达到maxMemory数值后就不能继续获取啦。获取过来而又没有用上的内存,就是 freeMemory啦。因此从大小关系来看:

freeMemory <= totalMemory <= maxMemory

// 获取内存使用情况
long mm = Runtime.getRuntime().maxMemory();
System.out.println("JVM最大内存:" + mm + "字节");
long tm = Runtime.getRuntime().totalMemory();
System.out.println("JVM当前内存:" + tm + "字节");
long fm = Runtime.getRuntime().freeMemory();
System.out.println("JVM空闲内存:" + fm + "字节");

Math类

Java 的 Math 类包含了用于执行基本数学运算的属性和方法,例如指数、对数、平方根和三角函数等等。Math 类中包含 E 和 PI 两个静态常量,正如它们名字所暗示的,它们的值分别等于 e(自然对数)和 π(圆周率)。

// E 常量的值:2.718281828459045
System.out.println(Math.E);
// PI 常量的值:3.141592653589793
System.out.println(Math.PI);
// 返回参数的绝对值
System.out.println("-1的绝对值:" + Math.abs(-1));
// 向上取整,例如2.1,就会得到 3.0
System.out.println("2.1向上取整:"+Math.ceil(2.1));		
// 向下取整,例如2.9,就会得到 2.0
System.out.println("2.9向下取整:"+Math. floor(2.9));
// 四舍五入,例如2.1就是2,2.9就是3
System.out.println("2.1四舍五入:" + Math.round(2.1));
System.out.println("2.9四舍五入:" + Math.round(2.9));
// 返回两个参数中的最小值
System.out.println("2和3谁小:"+Math.min(2,3));
// 返回两个参数中的最大值
System.out.println("2和3谁大:"+Math.max(2,3));
// 返回参数的算术平方根
System.out.println("4的算术平方根:"+Math.sqrt(4));
// 返回参数的正弦值,参数是弧度值
double radian = Math.toRadians(30);
System.out.println("sin30度:" + Math.sin(radian));		
// 返回参数的余弦值,参数是弧度值
radian = Math.toRadians(60);
System.out.println("cos60度:" + Math.cos(radian));
// 返回一个0到1之间的随机小数
System.out.println("随机数:" + Math.random());

Random类

Random类中实现的随机算法是伪随机,也就是有规则的随机。在进行随机时,随机算法的起源数字称为种子数(seed),在种子数的基础上进行一定的变换,从而产生需要的随机数字。相同种子数的Random对象,相同次数生成的随机数字是完全相同的。也就是说,两个种子数相同的Random对象,第一次生成的随机数字完全相同,第二次生成的随机数字也完全相同。需要说明的是,Random类中各方法生成的随机数字都是均匀分布的,也就是说区间内部的数字生成的几率是均等的。例如,我们要随机生成1-100之间的任意一个数字,那么这个数字不管是多少,产生它的概率几乎都是1%,当然我们产生的随机数越多,概率越精准。请注意,该类位于util包内,使用前最好引入:import java.util.Random;

Random类包含两个构造方法,下面依次进行介绍:

public Random()

该构造方法使用一个和当前系统时间对应的相对时间有关的数字作为种子数,然后使用这个种子数构造Random对象。

public Random(long seed)

该构造方法可以通过制定一个种子数进行创建。

Random类常用方法介绍:

void setSeed(long seed):重新设置Random对象中的种子数。

int nextInt():返回Int数据类型范围内的随机int值。包括最小值但不包括最大值

int nextInt(int n):返回[0,n)之间的随机int值,包含0而不包含n

nextLong():返回Long数据类型范围内的随机long值。

float nextFloat():返回介于[0,1.0)之间随机float值

double nextDouble():返回介于[0,1.0)之间随机double值

boolean nextBoolean():返回随机的boolean值,生成true和false的概率都是50%

// 我们通常使用 nextInt(x) 生成随机数
Random rom = new Random();
System.out.println("[0,100)随机数:" + rom.nextInt(100));

关于Math类中的random方法

其实在Math类中也有一个random方法,该random方法的工作是生成一个[0,1.0)区间的随机小数。Math类中的random方法就是直接调用Random类中的nextDouble方法实现的。

Date类

Date类用来获取当前的日期和时间,该类位于util包中!

Date 类提供两个构造函数来实例化 Date 对象。

Date()

第一个构造函数使用当前日期和时间来初始化对象。

Date(long millisec)

第二个构造函数接收一个参数,该参数是从 1970 年 1 月 1 日起的毫秒数(时间戳)。

Date类常用方法

long getTime( ):自1970年1月1日零点到现在时刻所经历的的毫秒数(时间戳)。

void setTime(long time):用自1970年1月1日零点以来的时间戳设置当前时间。

String toString( ):把此Date对象转换为以下形式的字符串:week mon dd hh:mm:ss zzz yyyy

例如字符串:Mon Feb 14 15:21:49 CST 2022代表周一,二月,14号,时间点,CST时间格式,2022年。当然,这种字符串形式明显不符合我们中国人的习惯。

在 Java 中,我们通常使用SimpleDateFormat 类来格式化日期,该类位于text包中。

// 格式化时间类
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 E HH 点 mm 分 ss 秒");
String nowStr = sdf.format(new Date());
System.out.println(nowStr); // 2022年02月14日 星期一 15 点 33 分 29 秒

我们讲解一些SimpleDateFormat类参数,其中 yyyy 是完整的公元年,MM 是月份,dd 是日期,E代表星期几,HH:mm:ss 代表时:分:秒。注意:有的格式大写,有的格式小写,例如 MM 是月份,mm 是分;HH 是 24 小时制,而 hh 是 12 小时制。

由于Date类比较落后了,我们更多的是使用Calendar类,该类也在util包中。Calendar类的功能要比Date类强大很多,可以方便的进行日期的计算,获取日期中的信息。Calendar类使用getInstance方法用来创建对象,默认创建一个代表系统当前日期的Calendar对象。

接下来,我们就来看看它的一些设置时间的方法:

void set(int year, int month, int date)

设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值。

void set(int year, int month, int date, int hourOfDay, int minute)

设置日历字段 YEAR、MONTH、DAY_OF_MONTH、HOUR_OF_DAY 和 MINUTE 的值。

void set(int year, int month, int date, int hourOfDay, int minute, int second)

设置字段 YEAR、MONTH、DAY_OF_MONTH、HOUR、MINUTE 和 SECOND 的值。

void setTimeInMillis(long millis)

用给定的 long 值设置此 Calendar 的当前时间值。

获得时间的方法:

int year = car.get(Calendar.YEAR);                           // 获得年份

int month = car.get(Calendar.MONTH) + 1;        // 获得月份(月份从0开始)

int date = car.get(Calendar.DATE);                            // 获得日期

int hour = car.get(Calendar.HOUR_OF_DAY);           // 获得小时

int minute = car.get(Calendar.MINUTE);                   // 获得分钟

int second = car.get(Calendar.SECOND);                   // 获得秒

int day = c1.get(Calendar.DAY_OF_WEEK);             // 获得星期几:1代表星期日、2代表星期1、3代表星期二,以此类推)

long getTimeInMillis() // 返回此 Calendar 的时间值,以毫秒为单位

Date getTime()             // 返回一个表示此 Calendar 时间值对应的 Date 对象

// Calendar 类
Calendar car = Calendar.getInstance();
System.out.println(car.get(Calendar.YEAR) + "年");
System.out.println(car.get(Calendar.MONTH)+1 + "月");
System.out.println(car.get(Calendar.DATE) + "日");
System.out.println(car.get(Calendar.DAY_OF_WEEK)-1 + "星期");
System.out.println(car.get(Calendar.HOUR_OF_DAY) + "时");
System.out.println(car.get(Calendar.MINUTE) + "分");
System.out.println(car.get(Calendar.SECOND) + "秒");

Calendar类还可以对日期进行加减操作,用于计算过去和将来的时间。我们使用Add方法来进行时间的加减法操作,该方法有两个参数,第一个是时间类型,第二个是时间值。

// 10天后的时间
car.add(Calendar.DATE, 10); // -10代表10天前
String dateStr = sdf.format(car.getTime());
System.out.println("10天后:" + dateStr);

StringBuffer类和StringBuilder类

当对字符串进行修改的时候,需要使用 StringBuffer 和 StringBuilder 类。和 String 类不同的是,StringBuffer 和 StringBuilder 类的对象能够被多次的修改,并且不产生新对象。所以如果需要对字符串进行修改推荐使用 StringBuilder。StringBuilder 类和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的,但是StringBuilder 相较于 StringBuffer 有速度优势,所以多数情况下建议使用 StringBuilder 类。如果在应用程序要求线程安全的情况下,则必须使用 StringBuffer 类啦。

接下来我们看看StringBuilder的构造函数:

StringBuilder()                           // 空字符,初始容量为16个字符大小。

StringBuilder(int capacity)    // 空字符,初始容量为capacity个字符大小。

StringBuilder(String str)                            // 根据字符串进行初始化

StringBuilder(CharSequence seq)         // 根据字符序列进行初始化

CharSequence是一个接口, String,StringBuffer和StringBuilder都实现了该接口。另外需要说明的是,String, StringBuilder和StringBuffer本质上都是通过字符数组实现的!

接下来我们介绍StringBuilder中常用的方法,都是对字符串进行增删改查四种操作。

Append方法用来追加各种类型的数据到StringBuilder对象中。

Insert方法用于在指定位置插入各种类型的数据。

indexOf方法和lastIndexOf方法用于查询字符位置

length方法使用字符长度

capacity方法是容量大小

delete方法用于删除指定索引位置的字符

replace方法用于替换

substring方法用于截取字符串

toString方法用于转化为String对象

// StringBuilder 类的使用:拼凑字符串
StringBuilder builder = new StringBuilder();
// 追加String
builder.append("abc");
// 追加int
builder.append(100);
// 追加double
builder.append(20.15);
// 追加boolean
builder.append(true);
// 输出完整的字符串
System.out.println(builder.toString());

// 在位置0处插入int
builder.insert(0, 123);
System.out.println(builder.toString());

// "abc"的位置
int apos = builder.indexOf("abc");
System.out.println("abc位置:"+apos);

// 整个字符串的长度
int len = builder.length();
System.out.println("字符串长度:"+len);

// 字符串容量
int size = builder.capacity();
System.out.println("字符串容量:"+size);

// 删除位置3(包括)到位置6(不包括)之间的字符"abc"
builder.delete(3, 6);
System.out.println("删除后:"+builder.toString());

// 替换"20.15"为aabb,6和10代表"20.15"的首尾位置
builder.replace(6, 10, "aabb");
System.out.println("替换后:"+builder.toString());

// 截取一段字符串
String str = builder.substring(6, 10);
System.out.println("截取6-10之间字符串:"+str);

StringBuffer的使用方式和StringBuilder是非常相似的,我们这里不再详细介绍了。

Java正则表达式

正则表达式用来描述或者匹配符合“某个规则”的字符串,这个规则就是正则表达式。

正则表达式并不仅限于某一种语言,但是在每种语言中有细微的差别。

比如说,我们如何校验一个字符串是否是邮箱?我们需要做一个“邮箱规则”的正则表达式,然后使用String的matches方法就能进行匹配检测是否正确。

// 正则表达式判断邮箱
String content = "abc@def.com";
String pattern = "\w+@\w+\.\w+";
boolean isMatch = content.matches(pattern);
System.out.println("是否邮箱:" + isMatch);

正则表达式的常用规则如下:

 将下一字符标记为特殊字符。例如,n 匹配换行符,而不是两个字符

^  匹配输入字符串开始的位置。

$  匹配输入字符串结尾的位置。

.  英文句点符号,匹配单个任意字符。

*  零次或多次匹配前面的字符。

+  一次或多次匹配前面的字符。

?  零次或一次匹配前面的字符。

{n}    n 是非负整数,正好匹配 n 次。

{n,}    n 是非负整数,至少匹配 n 次。

{n,m}  m 和 n 是非负整数,其中 n <= m。匹配至少 n 次,至多 m 次。

x|y     匹配 x 或 y。

[xyz]  匹配包含的任一字符。

[a-z]  字符范围。类似的还有[0-9]和[A-Z]

d      数字字符匹配。等效于 [0-9]。

w      匹配任何字类字符,包括下划线。与"[A-Za-z0-9_]"等效。

在java中还有两个专门的正则表达式的类是Matcher和Pattern,他们都在java.util.regex包中。Pattern类的作用在于编译正则表达式后创建一个匹配模式,Matcher类使用Pattern实例提供的模式信息对正则表达式进行匹配。

// 要匹配的字符
String targetStr = "150";
// 正则表达式
String regex = "\d+";
// 构建 Pattern 类
Pattern p = Pattern.compile(regex);
// 创建 Matcher 类
Matcher m = p.matcher(targetStr);
// 进行匹配
boolean flag = m.matches();
// 输出匹配结果
System.out.println("匹配结果:" + flag);

以下是常见的匹配规则下的正则表达式的书写:

验证用户名:^[a-zA-Z]\w{5,20}$

验证密码: ^[a-zA-Z0-9]{6,20}$

验证手机号: ^((17[0-9])|(14[0-9])|(13[0-9])|(15[^4,\D])|(18[0,5-9]))错误!超链接引用无效。

邮箱地址:^[w-]+(.[w-]+)*@[w-]+(.[w-]+)+$

验证邮箱:^([a-z0-9A-Z]+[-|\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\.)+[a-zA-Z]{2,}$

验证汉字:^[u4e00-u9fa5],{0,}$

验证身份证:^\d{18}$)|(^\d{15}$

验证网址:http(s)?://([\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?

验证IP地址:25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d";

今天的内容就讲的这里,我们来总结一下。今天我们主要讲了Java一些常用类。首先我们要先知道Java所有类的父类Object类和它的一些方法,然后要知道基本数据类型对应的包装类,使用包装类做数据类型转化,非常的方便。在我们日常开发中,我们经常使用的是数学Math类,随机Random类,和时间相关的Date类,SimpleDateFormat类和Calendar类。最后就是有关字符串操作的StringBuilder类,以及正则表达式的使用。好的,谢谢大家的收看,欢迎大家在下方留言,我也会及时回复大家的留言的。

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/973924.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号