Java常用类库

1.StringBuffer

StringBuffer支持的方法大部分与String类似。

因为StringBuffer在开发中可以提升代码的性能，所以使用较多。

String类：特性是String的内容一旦声明则不可改变，如果要改变则改变的是String的引用地址。

StringBuffer类：内容是可以改变的。

StringBuffer类中的常用方法：

直接查看JDK

常见操作

字符串连接
在任意位置处为StringBuffer添加内容
字符串反转操作
替换指定范围的内容
字符串截取
删除指定范围的字符串
查找指定的内容是否存在

2.Runtime

在Java中Runtime类表示运行时操作类，是一个封装了JVM进程的类，每一个JVM都对应着一个Runtime类的实例，此实例由JVM运行时为其实例化。所以在JDK文档中没有关于Runtime类中构造方法的定义，是因为Runtime类本身的构造方法是私有化的（单例设计）。

取得Runtime类的方式：
Runtime run = Runtime.getRuntime();

在Runtime类中提供了静态方法：getRuntime()。该方法可以取得Runtime类的实例。

Runtime表示每个JVM实例，所以可以通过Runtime取得一些系统信息：

序号	方法定义	类型	描述
1	public static Runtime getRuntime()	普通	取得Runtime类的实例
2	public long freeMemory()	普通	返回java虚拟机中的空闲内存量
3	public long maxMemory()	普通	返回JVM最大内存量以字节计量
4	public void gc()	普通	运行垃圾收集器，释放空间
5	public Process exec(String[] cmdarray) throws IOException	普通	执行本机命令

观察JVM的内存空间

 public class Demo01 {
    public static void main(String[] args) {
        Runtime runtime = Runtime.getRuntime();
 
        System.out.println("JVM最大内存量：" + runtime.maxMemory());
        System.out.println("JVM空闲内存量：" + runtime.freeMemory());
        String str = "Hello" + "World" + "!!!" + "\t" + "Welcome" + "To" + "MLDN" + "~";
        for (int i = 0; i < 100; i++) {   //循环修改String产生多个垃圾，会占用内存
            str += i;
        }
        System.out.println("操作String后，JVM空闲内存量：" + runtime.freeMemory());
        runtime.gc(); //垃圾回收
        System.out.println("垃圾回收之后，JVM剩余内存量：" + runtime.freeMemory());
    }
}

3.Runtime类与Process类

可以使用Runtime类运行本机的可执行程序：

案例： 调用本机记事本程序，记事本程序执行命令： notepad.exe

 public class Demo01 {
    public static void main(String[] args) {
        Runtime runtime = Runtime.getRuntime();
 
        try{
            runtime.exec("notepad.exe");
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

此方法的返回值是Process，表示一个操作系统的进程类。

可以直接通过Process类进行系统进程的控制：

例如可以使用Process类中的 public void destroy()方法让进程消失。

案例：让记事本进程运行5秒后消失。

 public class Demo01 {
    public static void main(String[] args) {
        Runtime runtime = Runtime.getRuntime();
        Process process = null;
 
        try{
            process = runtime.exec("notepad.exe");
        }catch(Exception e){
            e.printStackTrace();
        }
        try{
            Thread.sleep(5000);
        }catch (Exception e){
            e.printStackTrace();
        }
        process.destroy();
    }
}

4.System

System类是一些与系统相关的属性和方法的集合，System类中所有的属性都是静态的，要想引用这些属性和方法直接使用System类调用即可。

System类中的常用方法：

序号	方法定义	类型	描述
1	public static void exit(int status)	普通	系统退出，如果status为非0就表示退出
2	public static void gc()	普通	运行垃圾收集机制，调用的是Runtime类中的gc方法
3	public static long currentTimeMillis()	普通	返回以毫秒为单位的当前时间
4	public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)	普通	数组复制操作
5	public static Properties getProperties()	普通	取得当前系统的全部属性
6	public static String getProperty(String key,String def)	普通	根据键值取得属性的具体内容

开发中的垃圾收集基本上都是由系统自动完成的。
问题：如果在一个对象被回收之前要进行某些操作怎么办？

回答：在Object类中有个finalize()方法。一个子类只需要覆写此方法即可在释放对象前进行某些操作。

fianlize()方法定义： protected void finalize() throws Throwable

 class Person{
    private String name;
    private int age;
 
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    public String toString(){
        return "姓名：" + this.name + "年龄：" + this.age;
    }
 
    public void finalize() throws Throwable{  //对象释放空间时，默认调用此方法
        System.out.println("对象释放-->" + this);
    }
}
 
public class Demo01 {
    public static void main(String[] args) {
        Person person = new Person("张三", 18);
        person = null;  //断开引用，释放空间
        System.gc();  //强制性释放空间
    }
}

5.日期操作类

1.Date

2.Calendar

3.DateFormat

4.SimpleDateFormat

6.Math

Math类是数学操作类，提供了一系列的数学操作方法，包括求绝对值、三角函数等。在Math类中提供的一切方法都是静态方法，可以直接使用类名调用。

7.Random

Random类是随机数产生类，可以指定一个随机数的范围，然后任意产生在此范围中的数字。

8.NumberFormat

NumberFormat表示数字的格式化类。

1.NumberFormat

2.DecimalFormat

9.BigInteger

BigInteger表示大整数类。

10.BigDecimal

11.对象克隆技术

Java中支持对象的克隆操作，直接使用Object类中的 clone()方法即可。

方法定义： protected Object clone() throws CloneNotSupportedException

注意：

clone()方法是受保护的类型，所以在子类中必须覆写此方法，而且覆写之后应该扩大访问权限，这样才能被外部调用。
但是具体的克隆方法实现还是在Object类中，所以在覆写方法时只需要调用Object类中的clone()方法即可。
对象所在的类中必须实现Cloneable接口才可以完成对象的克隆操作。
1. 在JDK文档中会发现Cloneable接口中并没有任何的方法定义，所以此接口在设计上称为一种标识接口，表示对象可以被克隆。

对象的克隆操作

 class Person implements Cloneable{
    private String name;
    public Person(String name) {
        this.name = name;
    }
 
 
    public void setName(String name){
        this.name = name;
    }
 
    public String toString(){
        return "姓名：" + this.name;
    }
 
//    覆写子类覆盖clone()方法
    public Object clone() throws CloneNotSupportedException{
        return super.clone();  //具体的克隆操作由父类完成
    }
 
}
 
public class Demo01 {
    public static void main(String[] args) throws Exception{
        Person person1 = new Person("张三");
        Person person2 = (Person)person1.clone();
        person2.setName("李四");
        System.out.println("原始对象：" + person1);
        System.out.println("克隆后的对象：" + person2);
    }
}

12.Arrays

Arrays类是数组操作类，定义在java.util包中，主要功能是实现数组元素的查找、数组内的填充、排序等。

Arrays类常用方法：

序号	方法	类型	描述
1	public static boolean equals(int[]a,int[] a2)	普通	判断两个数组是否相等，此方法被重载多次，可以判断各种数据类型的数组
2	public static void fill(int[] a, int val)	普通	将指定的int值来指定数组的每个元素的值。此方法被重载多次，可以填充各种数据类型的数组
3	public static void sort(int[] a)	普通	将指定的数组排序为上升的数值顺序。此方法被重载多次，可以对各种类型的数组进行排序。
4	public static int binarySearch(int[] a, int key)	普通	对排序后的数组进行检索，此方法被重载多次，可以对各种类型的数组进行搜索
5	public static String toString(int[] a)	普通	输出数组，返回指定数组的内容的字符串表示形式。此方法被重载多次，可以对各种类型的数组进行输出。

 import java.util.*;
 
public class Demo01 {
    public static void main(String[] args){
        int[] temp = {3, 5, 7, 9, 1, 2, 6, 8};
        Arrays.sort(temp); //数组排序
        System.out.println("排序后的数组：");
        System.out.println(Arrays.toString(temp));
        int i = Arrays.binarySearch(temp, 3); //检索数据位置
        System.out.println("元素3的位置在：" + i);
        Arrays.fill(temp,4);
        System.out.println("数组填充：");
        System.out.println(Arrays.toString(temp));
    }
}

输出：

13.Comparable接口

比较器

Arrays类中的sort()方法被重载多次，可以对任意类型的数组进行排序，排序时会根据数值的大小进行排序。同样此方法也可以对Object数组进行排序，但是要求被排序的对象所在的类必须实现Comparable接口，这个接口就是用来指定对象排序规则的。

Comparable接口定义：

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

compareTo()方法的返回值有三种：

1：表示大于
-1：表示小于
0：表示等于

重写compareTo（obj）的规则：

如果当前对象this大于形参对象obj，则返回正整数
如果当前对象this小于形参对象obj，则返回负整数
如果当前对象this等于形参对象obj，则返回零

案例：设计一个学生类，此类中包含姓名、年龄、成绩，并产生一个对象数组，要求成绩由高到底排序，如果成绩相等，则按年龄由底到高排序。

使用Arrays类中的sort()方法进行排序。

 import java.util.*;
 
class Student implements Comparable<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 this.name + "\t\t" + age + "\t\t" + score;
    }
 
    @Override
    public int compareTo(Student student) {
        if (this.score > student.score){
            return -1;
        } else if (this.score < student.score) {
            return 1;
        }else {
            if (this.age > student.age){
                return 1;
            } else if (this.age < student.age) {
                return -1;
            }else {
                return 0;
            }
        }
    }
}
 
public class Demo01 {
    public static void main(String[] args){
        Student[] stu = {new Student("张三",20,90.0f),new Student("李四",22,90.0f),
                new Student("王五",20,99.0f),new Student("赵六",20,70.0f),
        new Student("孙七",22,100.0f)};
        Arrays.sort(stu);
        for(int i = 0; i < stu.length; i++){
            System.out.println(stu[i]);
        }
    }
}

输出：

注意：按照compareTo的返回值，进行排序的结果是升序的，如果需要逆序，则 如果当前对象this大于形参对象obj，则返回负整数；如果当前对象this小于形参对象obj，则返回正整数

比较器的排序原理：

就是数据结构中的二叉树排序算法，通过二叉树进行排序，然后利用中序遍历的方式把内容读取出来。

14.Comparator

如果一个类已经开发完成，但是在此类建立初期并没有实现Comparable接口，此时是无法进行对象排序操作的，为了解决这个问题，Java定义了另一个比较器操作接口： Comparator位与java.util包中。

接口定义：

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

此方法要接收两个对象，其返回值依然是0、-1、1

注意：

此接口在使用时，需要单独指定好一个比较器的比较规则类才可以完成数组排序。

案例：定义一个学生类，其中有姓名、年龄，并按照年龄进行排序。

 import java.util.*;
 
//定义学生类
class Student{
    private String name;
    private int age;
 
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }
 
    public boolean equals(Object obj){
        if (this == obj){
            return true;
        }
        if (!(obj instanceof Student)){
            return false;
        }
        Student stu = (Student) obj;
        if (stu.name.equals(this.name) && stu.age == this.age){
            return true;
        }else {
            return false;
        }
    }
 
    public String toString(){
        return this.name + "\t\t" + age;
    }
 
    public String getName(){
        return this.name;
    }
 
    public void setName(String name){
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
}
 
//定义比较规则
class StudentComparator implements Comparator<Student>{   //实现比较器接口
    @Override
    public int compare(Student o1, Student o2) {
        if (o1.equals(o2)){
            return 0;
        } else if (o1.getAge() < o2.getAge()) {
            return 1;  //降序排序
        }else {
            return -1;
        }
    }
}
//为对象数组排序
public class Demo01 {
    public static void main(String[] args){
        Student[] stu = {new Student("张三",20),new Student("李四",22),
                new Student("王五",20),new Student("赵六",20),
        new Student("孙七",22)};
        Arrays.sort(stu,new StudentComparator()); //排序，指定排序规则
        for(int i = 0; i < stu.length; i++){
            System.out.println(stu[i]);
        }
    }
}

输出：

Comparable和Comparator两个接口都可以实现相同的排序功能，但是与Comparable接口相比，Comparator接口明显是一种补救的做法。

15.观察者设计模式

1.什么叫观察者

举例：现在很多的购房者都在关注着房子的价格变化，每当房子价格变化时，所有的购房者都可以观察到，实际上以上的购房者都属于观察者，他们都在关注着房子的价格。

在Java中可以通过Observable类和Observer接口实现以上功能。

2.观察者模式实现

java.util包提供Observable类和Observer接口，使用它们就能完成观察者模式。

使用方法：

被观察的类必须继承Observable类。

Observable类常用方法

方法	类型	描述
public void addObserver(Observer o)	普通	添加一个观察者
public void deleteObserver(Observer o)	普通	删除一个观察者
protected void setChanged()	普通	被观察者状态发生改变
public void notifyObservers(Object arg)	普通	通知所有观察者状态改变

观察者需要实现Observer接口。
1. Observer接口定义：
  1. ```
   public interface Observer{
      void update(Observable o, Object arg);
  }
```
2. void update(Observable o, Object arg);第一个参数表示：被观察者实例，第二个参数表示：修改的内容。

案例：观察者模式的实现

 import java.util.Observable;
import java.util.Observer;
 
 
class House extends Observable{
    private float price;
 
    public House(float price){
        this.price = price;
    }
 
    public float getPrice() {
        return 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 Demo01 {
    public static void main(String[] args){
        House house = new House(1000000);
        HousePriceObserver a = new HousePriceObserver("购房者A");
        HousePriceObserver b = new HousePriceObserver("购房者B");
        HousePriceObserver c = new HousePriceObserver("购房者C");
        house.addObserver(a); //加入观察者
        house.addObserver(b); //加入观察者
        house.addObserver(c); //加入观察者
        System.out.println(house); //输出房子价格
        house.setPrice(666666);  //修改房子价格
        System.out.println(house);
    }
}

16.正则表达式

Pattern类和Matcher类
这两个类都在java.util.regex包中。

1.Pattern类

作用：

进行正则规范的编写。

Pattern类常用方法

序号	方法	类型	描述
1	public static Pattern compile(String regex)	普通	将给定的正则表达式编译成模式。
2	public Matcher matcher(CharSequence input)	普通	返回Matcher类实例,创建一个匹配
3	public String[] split(CharSequence input)	普通	将给定的输入序列拆分为这个模式的匹配。

注意：

在Pattern类中取得Pattern实例，必须使用compile()方法。

2.Matcher类

作用：

用于执行规范，验证一个字符串是否符合其规范。

Matcher类常用方法：

序号	方法	类型	描述
1	public boolean matches()	普通	执行验证，成功返回true
2	public String replaceAll(String replacement)	普通	字符串替换

3.常用正则规范定义

规范	描述	规范	描述
\\	表示反斜线（\）字符	\w	表示字母、数字、下划线
\t	表示制表符	\W	表示非字母、数字、下划线
\n	表示换行	\s	表示所有空白字符（换行、空格等）
[abc]	字符a、b或c	\S	表示所有非空白字符
[^abc]	表示除了a、b、c之外的任意字符	^	行的开头
[a-zA-Z0-9]	表示由字母、数字组成	$	行的结尾
\d	表示数字	.	匹配除换行符之外的任意字符
\D	表示非数字

数量表示（X表示一组规范）

规范	描述	规范	描述
X	必须出现一次	X	必须出现n次
X?	可以出现0次或1次	X	必须出现n次以上
X*	可以出现0次1次或多次	X	必须出现n~m次
X+	可以出现1次或多次

逻辑运算符（X、Y表示一组规范）

规范	描述	规范	描述
XY	X规范后跟着Y规范	(X)	作为一个捕获组规范
X\|Y	X规范或Y规范

案例1

日期格式要求：yyyy-mm-dd

正则表达式如下：

日期： 1983 - 07 - 27

格式：四位数字两位数字两位数字

正则： \d{4} - \d{2} - \d{2}

验证一个字符串是否是合法的日期格式

 import java.util.regex.Pattern;
import java.util.regex.Matcher;
 
 
public class Demo02 {
    public static void main(String[] args) {
        String str = "1983-07-27";
        String pat = "\\d{4}-\\d{2}-\\d{2}";  //定义替换规则
        Pattern pattern = Pattern.compile(pat); //实例化Pattern类
        Matcher matcher = pattern.matcher(str); //验证字符串内容是否合法
        if (matcher.matches()){
            System.out.println("日期格式合法！");
        }else {
            System.out.println("日期格式不合法！");
        }
    }
}

案例2
按照字符串的数字将字符串拆分

 import java.util.regex.Pattern;
import java.util.regex.Matcher;
 
 
public class Demo02 {
    public static void main(String[] args) {
        String str = "A1B22C333D4444E55555F";
        String pat = "\\d+";  //定义替换规则
        Pattern pattern = Pattern.compile(pat); //实例化Pattern类
        String[] s = pattern.split(str);  //进行字符串拆分
        for (int i = 0; i < s.length; i++) {
            System.out.print(s[i] + "\t");
        }
    }
}

案例3

将全部数字替换成 "_"

 import java.util.regex.Pattern;
import java.util.regex.Matcher;
 
 
public class Demo02 {
    public static void main(String[] args) {
        String str = "A1B22C333D4444E55555F";
        String pat = "\\d+";  //定义替换规则
        Pattern pattern = Pattern.compile(pat); //实例化Pattern类
        Matcher matcher = pattern.matcher(str);  //实例化Matcher类
        String s = matcher.replaceAll("_");
        System.out.println(s);
    }
}

4.String类对正则表达式的支持

String类中有三个方法支持正则操作：

序号	方法	类型	描述
1	public boolean matches(String regex)	普通	判断字符串是否匹配
2	public String replaceAll(String replacement)	普通	字符串替换
3	public String[] split(String regex)	普通	字符串拆分

案例：

 public class Demo02 {
    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.println("字符串拆分：");
        for (int i = 0; i < s.length; i++) {
            System.out.print(s[i] + "\t");
        }
    }
}

输出：

17.定时调度

1.Timer类

作用：

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

常用方法：

序号	方法	类型	描述
1	public Timer()	构造	用来创建一个定时器并启动该定时器
2	public void cancel()	普通	终止此计时器，丢弃任何当前计划的任务。不干扰当前执行的任务（如果它存在的话）。一旦一个计时器被终止了，它的执行线程就会优雅地终止
3	public int purge()	普通	从这个计时器的任务队列中移除所有已取消的任务。一般用来释放内存空间
4	public void schedule(TimerTask task,Date time)	普通	在指定的时间计划执行指定的任务。如果时间是过去的，任务将被安排立即执行。
5	public void schedule(TimerTask task,Date firstTime,long period)	普通	安排一个任务在指定的时间执行，然后以固定的频率（单位：毫秒）重复执行。
6	public void schedule(TimerTask task,long delay)	普通	安排一个任务在一段时间后执行。（单位：毫秒）
7	public void schedule(TimerTask task,long delay,long period)	普通	安排一个任务在一段时间（单位：毫秒）后执行，然后以固定的频率（单位：毫秒）重复执行。
8	public void scheduleAtFixedRate(TimerTask task,Date firstTime,long period)	普通	安排一个任务在指定的时间执行，然后以固定的频率（单位:毫秒）重复执行。
9	public void scheduleAtFixedRate(TimerTask task,long delay, long period)	普通	安排一个任务在一段时间（单位：毫秒）后执行，然后以固定的频率（单位：毫秒）重复执行。

注意：

schedule()与scheduleAtFixedRate()方法的区别在于重复执行任务时对于时间间隔出现延迟的情况处理：

schedule()：执行时间间隔永远是固定的，如果之前出现了延迟的情况，之后也会继续按照设定好的时间间隔时间来执行。
scheduleAtFixedRate():根据出现的延迟时间自动调整下一次间隔的执行时间。

2.TimerTask类

说明：

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

常用方法：

序号	方法	类型	描述
1	public boolean cancel()	普通	用来终止此任务，如果该任务只执行一次且还没有执行，则永远不会再执行如果为重复执行任务，则之后不会再执行（如果任务正在执行，则执行后不会再执行）
2	public abstract void run()	普通	该任务所要执行的具体操作，该方法为引入的接口Runable中的方法，子类需要覆写此方法。
3	public long scheduledExecutionTime()	普通	返回最近一次要执行该任务的时间（如果正在执行，则返回此任务的执行安排时间），一般在run()方法中调用，用来判断当前是否有足够的时间来执行完成该任务。

3.定时操作

案例：定时打印系统的当前时间。

 import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.TimerTask;
import java.util.Timer;
 
//建立TimerTask的子类
class MyTask extends TimerTask{
 
    @Override
    public void run() {
        SimpleDateFormat sdf = null;
        sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
        System.out.println("当前系统时间为： " + sdf.format(new Date()));
    }
}
 
//测试类进行任务调度
public class Demo02 {
    public static void main(String[] args) {
//        新建Timer类对象
        Timer timer = new Timer();
//        定义任务
        MyTask myTask = new MyTask();
//        设置任务的执行，1秒后开始，每2秒重复
        timer.schedule(myTask,1000,2000);
    }
}

输出：

posted @ 2022-07-21 23:12 e路有你阅读(6) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

阅读排行：
· DeepSeek 开源周回顾「GitHub 热点速览」
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 单线程的Redis速度为什么快？

公告

昵称： e路有你
园龄： 5年3个月
粉丝： 0
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

	public class Demo01 {
	public static void main(String[] args) {
	Runtime runtime = Runtime.getRuntime();

	System.out.println("JVM最大内存量：" + runtime.maxMemory());
	System.out.println("JVM空闲内存量：" + runtime.freeMemory());
	String str = "Hello" + "World" + "!!!" + "\t" + "Welcome" + "To" + "MLDN" + "~";
	for (int i = 0; i < 100; i++) { //循环修改String产生多个垃圾，会占用内存
	str += i;
	}
	System.out.println("操作String后，JVM空闲内存量：" + runtime.freeMemory());
	runtime.gc(); //垃圾回收
	System.out.println("垃圾回收之后，JVM剩余内存量：" + runtime.freeMemory());
	}
	}

	class Person{
	private String name;
	private int age;

	public Person(String name, int age) {
	this.name = name;
	this.age = age;
	}

	public String toString(){
	return "姓名：" + this.name + "年龄：" + this.age;
	}

	public void finalize() throws Throwable{ //对象释放空间时，默认调用此方法
	System.out.println("对象释放-->" + this);
	}
	}

	public class Demo01 {
	public static void main(String[] args) {
	Person person = new Person("张三", 18);
	person = null; //断开引用，释放空间
	System.gc(); //强制性释放空间
	}
	}

	class Person implements Cloneable{
	private String name;
	public Person(String name) {
	this.name = name;
	}


	public void setName(String name){
	this.name = name;
	}

	public String toString(){
	return "姓名：" + this.name;
	}

	// 覆写子类覆盖clone()方法
	public Object clone() throws CloneNotSupportedException{
	return super.clone(); //具体的克隆操作由父类完成
	}

	}

	public class Demo01 {
	public static void main(String[] args) throws Exception{
	Person person1 = new Person("张三");
	Person person2 = (Person)person1.clone();
	person2.setName("李四");
	System.out.println("原始对象：" + person1);
	System.out.println("克隆后的对象：" + person2);
	}
	}

	import java.util.*;

	public class Demo01 {
	public static void main(String[] args){
	int[] temp = {3, 5, 7, 9, 1, 2, 6, 8};
	Arrays.sort(temp); //数组排序
	System.out.println("排序后的数组：");
	System.out.println(Arrays.toString(temp));
	int i = Arrays.binarySearch(temp, 3); //检索数据位置
	System.out.println("元素3的位置在：" + i);
	Arrays.fill(temp,4);
	System.out.println("数组填充：");
	System.out.println(Arrays.toString(temp));
	}
	}

	import java.util.*;

	class Student implements Comparable<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 this.name + "\t\t" + age + "\t\t" + score;
	}

	@Override
	public int compareTo(Student student) {
	if (this.score > student.score){
	return -1;
	} else if (this.score < student.score) {
	return 1;
	}else {
	if (this.age > student.age){
	return 1;
	} else if (this.age < student.age) {
	return -1;
	}else {
	return 0;
	}
	}
	}
	}

	public class Demo01 {
	public static void main(String[] args){
	Student[] stu = {new Student("张三",20,90.0f),new Student("李四",22,90.0f),
	new Student("王五",20,99.0f),new Student("赵六",20,70.0f),
	new Student("孙七",22,100.0f)};
	Arrays.sort(stu);
	for(int i = 0; i < stu.length; i++){
	System.out.println(stu[i]);
	}
	}
	}

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

	import java.util.*;

	//定义学生类
	class Student{
	private String name;
	private int age;

	public Student(String name,int age){
	this.name = name;
	this.age = age;
	}

	public boolean equals(Object obj){
	if (this == obj){
	return true;
	}
	if (!(obj instanceof Student)){
	return false;
	}
	Student stu = (Student) obj;
	if (stu.name.equals(this.name) && stu.age == this.age){
	return true;
	}else {
	return false;
	}
	}

	public String toString(){
	return this.name + "\t\t" + age;
	}

	public String getName(){
	return this.name;
	}

	public void setName(String name){
	this.name = name;
	}

	public int getAge() {
	return age;
	}

	public void setAge(int age) {
	this.age = age;
	}
	}

	//定义比较规则
	class StudentComparator implements Comparator<Student>{ //实现比较器接口
	@Override
	public int compare(Student o1, Student o2) {
	if (o1.equals(o2)){
	return 0;
	} else if (o1.getAge() < o2.getAge()) {
	return 1; //降序排序
	}else {
	return -1;
	}
	}
	}
	//为对象数组排序
	public class Demo01 {
	public static void main(String[] args){
	Student[] stu = {new Student("张三",20),new Student("李四",22),
	new Student("王五",20),new Student("赵六",20),
	new Student("孙七",22)};
	Arrays.sort(stu,new StudentComparator()); //排序，指定排序规则
	for(int i = 0; i < stu.length; i++){
	System.out.println(stu[i]);
	}
	}
	}

	public interface Observer{
	void update(Observable o, Object arg);
	}

	import java.util.Observable;
	import java.util.Observer;


	class House extends Observable{
	private float price;

	public House(float price){
	this.price = price;
	}

	public float getPrice() {
	return 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 Demo01 {
	public static void main(String[] args){
	House house = new House(1000000);
	HousePriceObserver a = new HousePriceObserver("购房者A");
	HousePriceObserver b = new HousePriceObserver("购房者B");
	HousePriceObserver c = new HousePriceObserver("购房者C");
	house.addObserver(a); //加入观察者
	house.addObserver(b); //加入观察者
	house.addObserver(c); //加入观察者
	System.out.println(house); //输出房子价格
	house.setPrice(666666); //修改房子价格
	System.out.println(house);
	}
	}

	import java.util.regex.Pattern;
	import java.util.regex.Matcher;


	public class Demo02 {
	public static void main(String[] args) {
	String str = "1983-07-27";
	String pat = "\\d{4}-\\d{2}-\\d{2}"; //定义替换规则
	Pattern pattern = Pattern.compile(pat); //实例化Pattern类
	Matcher matcher = pattern.matcher(str); //验证字符串内容是否合法
	if (matcher.matches()){
	System.out.println("日期格式合法！");
	}else {
	System.out.println("日期格式不合法！");
	}
	}
	}

	public class Demo02 {
	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.println("字符串拆分：");
	for (int i = 0; i < s.length; i++) {
	System.out.print(s[i] + "\t");
	}
	}
	}

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

	//建立TimerTask的子类
	class MyTask extends TimerTask{

	@Override
	public void run() {
	SimpleDateFormat sdf = null;
	sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
	System.out.println("当前系统时间为： " + sdf.format(new Date()));
	}
	}

	//测试类进行任务调度
	public class Demo02 {
	public static void main(String[] args) {
	// 新建Timer类对象
	Timer timer = new Timer();
	// 定义任务
	MyTask myTask = new MyTask();
	// 设置任务的执行，1秒后开始，每2秒重复
	timer.schedule(myTask,1000,2000);
	}
	}

e路有你

Java常用类库

Java常用类库

1.StringBuffer

2.Runtime

3.Runtime类与Process类

4.System

5.日期操作类

1.Date

2.Calendar

3.DateFormat

4.SimpleDateFormat

6.Math

7.Random

8.NumberFormat

1.NumberFormat

2.DecimalFormat

9.BigInteger

10.BigDecimal

11.对象克隆技术

12.Arrays

13.Comparable接口

14.Comparator

15.观察者设计模式

1.什么叫观察者

2.观察者模式实现

16.正则表达式

1.Pattern类

2.Matcher类

3.常用正则规范定义

4.String类对正则表达式的支持

17.定时调度

1.Timer类

2.TimerTask类

3.定时操作

公告

搜索

常用链接

随笔分类

随笔档案

阅读排行榜