java常用类库续3(比较器Comparable、Comparator、观察者设计模式、正则表达式、定时调度)

最新推荐文章于 2020-06-17 13:54:47 发布
最新推荐文章于 2020-06-17 13:54:47 发布
阅读量2.4k 收藏 2
点赞数 1
分类专栏： j2se 文章标签： 正则表达式 设计模式 java string import 任务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cz1029648683/article/details/6666855
版权
 

比较器(Comparable、Comparator)

Comparable接口

可以直接使用java.util.Arrays类进行数组的排序操作，但对象所在的类必须实现Comparable接口，用于指定排序接口。

Comparable接口定义如下：

public interface Comparable<T>{
   public int compareTo(T o);
}

从接口的定义格式上来看，可以发现如果想实现对象属性的排序功能，要实现Comparable接口，并且覆写compareTo(T o)方法。此方法返回的是一个int类型的数据，但是此int类型的数据只能是一下三种：

·1：表示大于

·-1：表示小于

·0：表示等于

看如下的实例：一个学生类，里面有三个属性姓名、年龄、成绩三个属性，要求按成绩由高到底排序，如果成绩相等，则按照年龄由底到高排序。

class Student implements Comparable<Student>	//指定类型为Student
{
	private String name;
	private int age;
	private float score;
	public Student(String name,int age,float score){
		this.name=name;
		this.age=age;
		this.score=score;
	}
	public String toString(){
		return name+"\t\t"+age+"\t\t"+score+"\t\t";
	}
	public int compareTo(Student stu){	//覆写compareTo方法，实现排序规则的应用
		if(this.score<stu.score){
			return -1;
		}
		if(this.score>stu.score){
			return 1;
		}
		else{
			if(this.age<stu.age){
				return -1;
			}
			if(this.age>stu.age){
				return 1;
			}
			else{
				return 0;
			}
		}
	}
}
public class ComparableDemo01
{
	public static void main(String args[]){
		Student stu[]={
			new Student("张三",20,89.1f),
			new Student("李四",26,53.5f),
			new Student("王五",30,79.0f),
			new Student("赵六",20,66.0f),
			new Student("孙七",25,66.0f)
		};
		java.util.Arrays.sort(stu);	//进行排序操作
		for(Student x:stu){	//循环输出
			System.out.println(x);
		}
	}
}

注意：如果在此时Student类没有实现Comparable接口，则在执行的时候会出现一下异常：

Exception in thread "main" java.lang.ClassCastException: Student cannot be cast
to java.lang.Comparable

另一种比较器Comparator

此比较器其实跟Comparable是非常类似的。如果现在已经完成了一个类的开发，但是并没有实现Comparable接口，此时肯定是无法进行对象排序操作的，所以为了解决这种问题，java又定义了另一个比较器的操作接口---Comparator。此接口在java.util包中，接口如下定义：

pubic interface Comparator<T>{
  public int compare(T o1,T o2);
  boolena equals(Object obj);
}

代码如下：

import java.util.*;
class Student 	 {
	private String name;
	private int age;
	private float score;
	public Student(String name,int age,float score){
		this.name=name;
		this.age=age;
		this.score=score;
	}
	public void setName(String name){
		this.name=name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		this.age=age;
	}
	public int getAge(){
		return age;
	}
	public String toString(){
		return name+"\t\t"+age+"\t\t"+score+"\t\t";
	}
}
class StudentComparator implements Comparator<Student>
{
	//因为Object类中已经覆写过equals方法
	public int compare(Student s1,Student s2){
		if(s1.equals(s2)){
			return 0;
		}	
		else if(s1.getAge()<s2.getAge()){	//按照年龄进行比较
			return 1;
		}
		else{
			return -1;
		}
	}
}
public class ComparableDemo02
{
	public static void main(String args[]){
		Student stu[]={
			new Student("张三",20,89.1f),
			new Student("李四",26,53.5f),
			new Student("王五",30,79.0f),
			new Student("赵六",20,66.0f),
			new Student("孙七",25,66.0f)
		};
		java.util.Arrays.sort(stu,new StudentComparator());	//进行排序操作
		for(Student x:stu){	//循环输出
			System.out.println(x);
		}
	}
}

总结：在开发中尽量还是使用Comparable在需要排序的类上实现好此接口，而Comparator需要单独建立一个排序的类，这样如果有很多的话，则排序的规则类也就会很多，操作起来比较麻烦些。注意：在java中只要是对象排序，永远都是以Comparable接口为准的。

观察者设计模式

具体内容

所谓观察者设计模式，就是某一样东西被多个观察者观察，当这样东西发生变化，则会及时反馈到每个观察者的身上。如果要想实现观察者设计模式，则必须依靠java.util包中的Observable类和Observer接口。

例子：现在很多的购房者都在关注着房子的变化，每当房子价格变化的时候，所有的观察者都能够立即观察到

import java.util.* ;
class House extends Observable{	// 表示房子可以被观察
	private float price ;// 价钱
	public House(float price){
		this.price = price ;
	}
	public float getPrice(){
		return this.price ;
	}
	public void setPrice(float price){
		// 每一次修改的时候都应该引起观察者的注意
		super.setChanged() ;	// 设置变化点
		super.notifyObservers(price) ;// 价格被改变
		this.price = price ;
	}
	public String toString(){
		return "房子价格为：" + this.price ;
	}
}; 
class HousePriceObserver implements Observer{
	private String name ;
	public HousePriceObserver(String name){	// 设置每一个购房者的名字
		this.name = name ;
	}
	public void update(Observable o,Object arg){
		if(arg instanceof Float){
			System.out.print(this.name + "观察到价格更改为：") ;
			System.out.println(((Float)arg).floatValue()) ;
		}
	}
};
public class ObserDemo01{
	public static void main(String args[]){
		House h = new House(1000000) ;
		HousePriceObserver hpo1 = new HousePriceObserver("购房者A") ;
		HousePriceObserver hpo2 = new HousePriceObserver("购房者B") ;
		HousePriceObserver hpo3 = new HousePriceObserver("购房者C") ;
		h.addObserver(hpo1) ;
		h.addObserver(hpo2) ;
		h.addObserver(hpo3) ;
		System.out.println(h) ;	// 输出房子价格
		h.setPrice(666666) ;	// 修改房子价格
		System.out.println(h) ;	// 输出房子价格
	}
};

正则表达式

正则表达式可以方便的对数据进行匹配，可以执行更加复杂的字符串验证、拆分、替换等功能。

例如：现在要求判断一个字符串是否由数字组成，有以下两种方式：

·不使用正则完成

·使用正则完成

第一种方式代码：

public class RegexDemo01{
	public static void main(String args[]){
		String str = "1234567890" ;		// 此字符串由数字组成
		boolean flag = true ;			// 定义一个标记变量
		// 要先将字符串拆分成字符数组，之后依次判断
		char c[] = str.toCharArray() ;	// 将字符串变为字符数组
		for(int i=0;i<c.length;i++){	// 循环依次判断
			if(c[i]<'0'||c[i]>'9'){		// 如果满足条件，则表示不是数字
				flag = false ;			// 做个标记
				break ;					// 程序不再向下继续执行
			}
		}
		if(flag){
			System.out.println("是由数字组成！") ;
		}else{
			System.out.println("不是由数字组成！") ;
		}
	}
};

第二中方式代码：

import java.util.regex.Pattern ;
public class RegexDemo02{
	public static void main(String args[]){
		String str = "1234567890" ;		// 此字符串由数字组成
		if(Pattern.compile("[0-9]+").matcher(str).matches()){	// 使用正则
			System.out.println("是由数字组成！") ;
		}else{
			System.out.println("不是由数字组成！") ;
		}
	}
};

Pattern、Matcher类

这两个类为正则的核心操作类，都是定义在java.util.regex包中。Pattern类主要是进行正则规范(如之前的操作“[0-9]“就属于正则规范)的编写，而Matcher类主要是执行规范，验证一个字符串是否符合规范。

常用正则规则：


·\d：表示数字， [0-9]

·\D：表示非数字，[^0-9]

·\w：表示字母、数字、下划线，[a-zA-Z0-9]

·\W：[^a-zA-Z0-9]

常用正则规范2：


以上的正则，如果要想驱动起来，则必须依靠Pattern和Matcher类。

Pattern主要是表示一个规则的意思，即：正则表达式的规则需要在Pattern类中使用。

Matcher类主要表示使用Pattern指定好的规则验证。

Pattern类的常用方法：

方法

描述

public static Pattern compile(String regex)

指定正则表达式规则

public Matcher matcher(CharSequence input)

返回Mather类的实例

public String[] split(CharSequence input)

字符串拆分

在Patter类中如果要想取得Pattern类的实例，则必须调用compile()方法。

本类中没有明确的构造方法可以使用，那么此类的构造方法肯定被私有化了，如果是这样的类，都可以通过本类中的一个静态方法获得该类的实例。

Matcher类中的常用方法：

方法

描述

Public Boolean matches()

执行验证

Public String replaceAll(String replacement)

字符串替换

实例操作：(验证日期是否合法)

import java.util.regex.Pattern ;
import java.util.regex.Matcher ;
public class RegexDemo03{
	public static void main(String args[]){
		String str = "1983-07-27" ;		// 指定好一个日期格式的字符串
		String pat = "\\d{4}-\\d{2}-\\d{2}" ;	// 指定好正则表达式
		Pattern p = Pattern.compile(pat) ;	// 实例化Pattern类
		Matcher m = p.matcher(str) ;	// 实例化Matcher类
		if(m.matches()){		// 进行验证的匹配，使用正则
			System.out.println("日期格式合法！") ;
		}else{
			System.out.println("日期格式不合法！") ;
		}
	}
};

在Pattern类中也可以使用正则进行字符的拆分功能：

import java.util.regex.Pattern ;
import java.util.regex.Matcher ;
public class RegexDemo04{
	public static void main(String args[]){
		// 要求将里面的字符取出，也就是说按照数字拆分
		String str = "A1B22C333D4444E55555F" ;	// 指定好一个字符串
		String pat = "\\d+" ;	// 指定好正则表达式
		Pattern p = Pattern.compile(pat) ;	// 实例化Pattern类
		String s[] = p.split(str) ;	// 执行拆分操作
		for(int x=0;x<s.length;x++){
			System.out.print(s[x] + "\t") ;
		}
	}
};

还可以使用Matcher类中的字符串替换功能：

import java.util.regex.Pattern ;
import java.util.regex.Matcher ;
public class RegexDemo05{
	public static void main(String args[]){
		// 要求将里面的字符取出，也就是说按照数字拆分
		String str = "A1B22C333D4444E55555F" ;	// 指定好一个字符串
		String pat = "\\d+" ;	// 指定好正则表达式
		Pattern p = Pattern.compile(pat) ;	// 实例化Pattern类
		Matcher m = p.matcher(str) ;	// 实例化Matcher类的对象
		String newString = m.replaceAll("_") ;
		System.out.println(newString) ;
	}
};

String类对正则的支持

在String类中有以下三个方法是支持正则操作的：

方法

描述

public boolean matches(String regex)

字符串匹配

public String replaceAll(String regex,String replacement)

字符串替换

public String[] split(String regex)

字符串拆分

代码如下：

import java.util.regex.Pattern ;
import java.util.regex.Matcher ;
public class RegexDemo06{
	public static void main(String args[]){
		String str1 = "A1B22C333D4444E55555F".replaceAll("\\d+","_") ;
		boolean temp = "1983-07-27".matches("\\d{4}-\\d{2}-\\d{2}") ;
		String s[] = "A1B22C333D4444E55555F".split("\\d+") ;
		System.out.println("字符串替换操作：" + str1) ;
		System.out.println("字符串验证：" + temp) ;
		System.out.print("字符串的拆分：") ;
		for(int x=0;x<s.length;x++){
			System.out.print(s[x] + "\t") ;
		}
	}
};

但是，使用正则需要注意一点，看如下的代码：

import java.util.regex.Pattern ;
import java.util.regex.Matcher ;
public class RegexDemo07{
	public static void main(String args[]){
		String info = "LXH:98|MLDN:90|LI:100" ;			// 定义一个字符串
		// 拆分的形式：
		/*
			LXH	-->	98
			MLDN	-->	90
			LI	-->	100
		*/
		String s[] = info.split("\\|") ;
		System.out.println("字符串的拆分：") ;
		for(int x=0;x<s.length;x++){
			String s2[] = s[x].split(":") ;
			System.out.println(s2[0] + "\t" + s2[1]) ;
		}
	}
};

如果有时候发现一个字符串无法按照指定的字符拆分的话，则需要使用“\”转义，转义的时候连个“\”表示一个“\”。

总结：

1、  使用正则可以方便完成字符串的验证、拆分、替换等功能。

2、  在开发中一般会使用String类提供好的正则支持，很少使用Pattern或者是Matcher类。

3、  在使用一些正则的时候，对于一些敏感的字符要进行转义。

定时调度

定时调度：每隔一段时间，程序会自动执行，成为定时调度。

如果要使用定时调度，则必须保证程序运行这才可以，也就说是相当于定时调度在程序之外又启动了一个新的线程。使用Timer和TimerTask两个类完成定时调度。

Timer类

Timer类是一种线程设施，可以用来实现在某一个时间或某一段时间后，安排某一个任务执行一次，或定期重复执行。该功能要与TimerTask类配合使用。TimerTask类用来实现由Timer安排的一次或重复执行的某一个任务。

Timer类的常用方法：

方法

类型

描述

public Timer()

构造

用来创建一个计时器并启动

 

public void cancel()

普通

 

用来终止该计时器，并放弃所有已安排的任务，对当前正在执行的任务没有影响。

public int purge()

普通

将所有已经取消的任务移除，一般用来释放内存空间

public void schedule(TimerTask task,Date time)

普通

 

安排一个任务在指定的时间执行，如果已经超过该时间，则立即执行。

public void scheduleAtFixedRate(TimerTask task,Date firstTime,long period)

普通

安排一个任务在指定的时间执行，之后以近似固定的频率(单位：毫秒)重复执行

Schedule()与scheduleAtFixedRate()方法的区别：

两者的区别在于重复执行任务时，对于时间间隔出现延迟的情况处理：

·Schedule()方法的执行时间间隔永远是固定的，如果之前出现了延迟的情况，之后也会按照设定好的间隔时间执行。

·scheduleAtFixedRate()方法可以根据出现的延迟时间自动调整下一次间隔的执行时间。

TimerTask类

要想执行具体的任务，则必须使用TimerTask类。TimerTask是一个抽象类，如果要使用该类，需要建立一个子类继承该类，并实现其中的抽象方法。

方法

描述

 

public void cancle()

 

用来终止此任务，如果该任务只执行一次并且还没有执行，则永远不会再执行，如果为重复执行任务，则之后不会再执行(如果该任务正在执行，则执行完后不会再执行)

public void run()

该任务所要执行的具体操作，该方法为引入接口Runable中的方法，子类需要覆写。

 

public long scheduledExecutionTime()

 

返回最近一次执行任务的时间(如果正在运行，则返回该任务的执行安排时间)，一般在run()方法中调用，用来判断当前是否有足够的时间来执行完该任务。

代码示例：定时调度的程序，每隔2秒打印一次。 

//完成具体的任务操作
import java.util.*;
import java.text.SimpleDateFormat;
class MyTask extends TimerTask	//任务调度类都要继承TimerTask
{
	public void run(){
		SimpleDateFormat sd=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
		System.out.println("当前系统时间为："+sd.format(new Date()));
	}
}

完成的是一个具体的任务操作类，以后定时调度就是调度此类的操作，方法的主体就是run()方法。注意要继承TimerTask类，下面建立测试类，并执行任务调度：

import java.util.*;
public class TestTask
{
	public static void main(String args[]){
		Timer t=new Timer();
		MyTask mytask=new MyTask();
		t.schedule(mytask,1000,2000);
	}
}

总结：一般在web开发中此内容比较有用，因为要维护一个容器不关闭才可以一直定时调度下去。

cz1029648683
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
两种比较器（Comparator与Comparable）案例实现
weixin_46474145的博客
12-19 635
Comparator 和 Comparable 比较： 1.Comparable是排序接口；若一个类实现了Comparable接口，就意味着“该类支持排序”。 （作用在实体类上） 2.而Comparator是比较器；我们若需要控制某个类的次序，可以建立一个“该类的比较器”来进行排序。 （作用在排序类上） 总结：Comparable相当于“内部比较器”，而Comparator相当于“外部比较器”。 创建一个实体类House,属性（面积，总价），创建一个房屋数组，里面有5套房子，分别使用两个不同的比较器，和数组
【Java设计模式】之以Comparator比较器为例学习策略模式
是田同学啊的博客
12-16 503
对整型数组排序 假设现在我们要写一个类，其 sort() 方法可以接收一个整型数组，然后对该整型数组进行排序。那么排序部分的代码就差不多应该这样写： public class Sort { public static void sort(int[] arr) { int i, j = 0; int temp; for (i = 0; i < arr.length; i++) { for (j = 1; j < arr
软件构造系列（六）比较器与正则表达式的使用
weixin_44135985的博客
06-17 362
我们平时给数组排序都用的sort方法，那么怎么给我们自己创建的类排序呢，这时我们就要给我们类一个可以比较大小的方法，也就是这里的比较器，这里有两种写法。 Comparable为内部比较器，一般你钦定一定会按某种方法排序，就用这个。 Comparator为外部比较器，因为在外面，你可以写很多个外部比较器，按实际情况选择对应的比较器，比较灵活。 有了比较器，我们还需要排序工具，这里我一般使用Collections里的sort方法来进行排序，简单好用。 下面我还是用举例子的方式来说明，我们现在要根据年龄升序给
设计模式-设计模式之间的对比
H_L_S的专栏
03-03 325
1.装饰器和适配器，外观模式， 都是在包装对象，但是它们的意图不一样 (1) 适配在于转换接口，以达到客户所希望的那样接口 (2)装饰器，在于增加现有接口中的新职责和能力，不改变接口 (3)外观模式在于简化接口。它将一个或数个类的复杂的一切都隐藏。只暴露一个美好的外观但没有隔离子系统，如果需要更高级的操作，可以之间操作原来的子系统。外观不只是简化了接口，也将客户从组件的子系...
关于lab3 的迭代器和比较器模式
reensan的博客
06-13 177
1迭代器
比较不错的C#中的常用的正则表达式
10-30
比较不错的C#中的常用的正则表达式
Java使用正则表达式对注册页面进行验证功能实现
10-21
本文给大家分享一段有关java使用正则表达式对注册页面进行验证的代码，代码比较简单，非常不错，感兴趣的朋友一起学习吧
C#词法分析器之正则表达式的使用
01-21
虽然正则表达式并不能表达出所有可能的模式（例如“由等数量的 a 和 b 组成的字符串”），但是它可以非常高效的描述处理词法单元时要用到的模式类型。 一、正则表达式的定义正则表达式可以由较小的正则表达式按照...
比较常用的几个正则表达式匹配数字(收藏)
12-13
正则表达式用于字符串处理、表单验证等场合，实用高效。现将一些常用的表达式收集于此，以备不时之需。 匹配中文字符的正则表达式： [\u4e00-\u9fa5] 评注：匹配中文还真是个头疼的事，有了这个表达式就好办了 匹配...
JAVA 正则表达式陈广佳版本(超详细)
11-21
在Sun的Java JDK 1.40版本中，Java自带了支持正则表达式的包，本文就抛砖引玉地介绍了如何使用java.util.regex包。 　可粗略估计一下，除了偶尔用Linux的外，其他Linu x用户都会遇到正则表达式。正则表达式是个极端...
浅谈Java中几种常见的比较器的实现方法
08-29
下面小编就为大家带来一篇浅谈Java中几种常见的比较器的实现方法。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
设计模式及相似模式对比
github_38220216的博客
07-17 826
设计模式阶段总结（一）写在前面六大原则策略模式观察者模式装饰模式工厂模式单例模式命令模式适配器模式外观模式适配器模式、外观模式、装饰模式对比 写在前面 很久没有这么大块的时间去重温设计模式了，这正好整理一下； 本篇博文包含基础设计模式的概念，以及相似设计模式之间的区别，以便于理解。 后续会持续更新 六大原则 （理解是啥就行） 单一职责原则：一个类应该只有一个引起变化的原因、 里氏替换原则：任何使用...
设计模式大全
热门推荐
马如林的IT博客
12-22 8万+
  Longronglin之设计模式:Christopher Alexander 说过：“每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的解决方案的核心。这样，你就能一次又一次地使用该方案而不必做重复劳动”。模式描述为：在一定环境中解决某一问题的方案，包括三个基本元素--问题，解决方案和环境。阅读类图和对象图请先学习UML创建模式 结构模式 行为模式创建模式：对类
Java设计模式——Comparable接口&&Comparator（CC系）策略模式的应用
世事洞明皆学问
03-04 1967
Comparable接口&&Comparator接口：突然想起了民国时期的CC系，哈哈^_^ 转自：http://www.cnblogs.com/baizhanshi/p/6201875.html Comparable Comparable可以认为是一个内比较器，实现了Comparable接口的类有一个特点，就是这些类是可以和自己比较的，至于具体和另一个实现了Comparab
Java设计模式——Comparable接口&&Comparator（CC系）策略模式的应用[续]
世事洞明皆学问
03-04 905
转自：http://blog.csdn.net/acmman/article/details/46634565 接着上一篇总结继续探讨。 之前我们的DataSorter的Sort方法虽然可以对任何实现了Comparable接口的对象进行排序，不过，麻烦事在于，这些对象实现的comparaTo方法只有一种实现，只能写一种，不能写太多，而且将来我想任意的扩展怎么计算两个对象谁大谁小的规范，这个
Salesforce中Comparable比较Object的列表数据自定义排序
PJ老文的博客
03-14 299
项目中通常有些需求为需要将某个sObject的数据列表按照某种规则排序显示到前台页面上，但是list上面的sort远远满足不了复杂的功能，此种情况需要自定义比较两个object大小的方法，所以需要创建Compare相关的类实现Comparable接口。 需求：实现Goods__c列表排序，GoodsBrand__c为华为的按照价格升序排序，GoodsBrand__c为联想的按照价格降序排列。 ...
设计模式之策略模式(Strategy)&&Comparable、Comparator接口
Eternity0V0的博客
03-13 489
策略模式Strategy，Comparable接口，Comparator接口
java 设计模式 策略模式，comparable 接口,compareTo 方法
yuyi_000的博客
07-20 1179
重点在于判断 对象   谁大谁小 尤其是比较类对象的 “谁大谁小” 打印类对象 print（a） 必须在类里要重写 toString() 方法 @Override public String toString(){ return this.food+"";//后面那个双引号是为了把整个转成字符串。不能直接int打印出 } 对多种类型（当然都是同种类型）来比较 比
Java正则表达式应用总结
10-23
　总结　本文对 Java 正则表达式的应用进行了总结，包括正则表达式的概述、常用的正则表达式语法、常用的 Matcher 方法，以及正则表达式的优化和注意事项等内容。希望本文对 Java 程序员学习和使用正则表达式有所...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值