java 常用类

java 常用类库
Object 类：clone(), equals(), toString()
Runtime 类：代表 java 程序的运行环境
定时器： Timer 和 TimerTask 类
System 类：
日期操作类:
Math 类：可以进行一些常用的数学运算
正则式：
Random 类：随机数的获取
常用方法：

//创建并返回与该对象相同的新对象，即克隆该对象
protected native Object clone() throws CloneNotSupportedException

//比较两个对象是否相等
public boolean equals(Object obj)

//当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法
protected void finalize() throws Throwable

//返回一个对象的运行时类
public final Class<? extends Object> getClass()

//返回该对象的哈希码值
public int hashCode()

//唤醒等待池中的线程
public final void notify()

//唤醒等待池中的所有线程
public final void notifyAll()

//返回该对象的字符串表示
public String toString()

//使当前的线程等待
public final void wait(long timeout) throws InterruptedException

// 重写 toString() 方法
class Person
{
    private String name;
    private int age;
    public Person(){}
    public Person(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
    public String toString()
    {
        return ("姓名:"+this.name+",年龄："+this.age);
    }
}
public class Hi
{
    public static void main(String[] args)
    {
        Person p = new Person("小二", 27);
        System.out.println(p.toString());
        System.out.println(p);
    }
}
/**
姓名:小二,年龄：27
姓名:小二,年龄：27
*/
看到结果一样，所以都是调用 重写的 toString() 的方法
// ============
//重写 equals() 方法
class Person
{
    private String name;
    private int age;
    public Person(){}
    public Person(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
    // 重写equals() 方法
    public boolean equals(Object o)
    {
        // 判断当前对象与指定对象是否相等
        if(o == this)
        {
            return true;
        }
        // 判断指定的对象是否为空
        if(o == null)
        {
            return false;
        }
        // 判断指定对象是否为 Person 的实例
        if(!(o instanceof Person))
        {
            return false;
        }
        // 将指定对象转为 Person 实例
        Person per = (Person)o;
        // 比较对象的属性是否相等
        if(this.name.equals(per.name) && this.age == per.age)
        {
            return true;
        }else
        {
            return false;
        }
    }
}
public class Hi
{
    public static void main(String[] args)
    {
        //创建对象实例
        Person p1 = new Person("小二", 27);
        Person p2 = new Person("小二", 27);
        Person p3 = new Person("小小", 30);
        if(p1.equals(p2))
        {
            System.out.println("p1与p2相等");
        }else
        {
            System.out.println("p1与p2不相等");
        }
        if(p1.equals(p3))
        {
            System.out.println("p1与p3相等");
        }else
        {
            System.out.println("p1与p3不相等");
        }
    }
}
/**
p1与p2相等
p1与p3不相等
*/
// ------------
class Person
{
    private String name;
    private int age;
    public Person(){}
    public Person(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
    public boolean equals(Object o)
    {
        if(this == o)
        {
            return true;
        }
        if(o == null)
        {
            return false;
        }
        if(!(o instanceof Person))
        {
            return false;
        }
        Person per = (Person)o;
        if(this.name.equals(per.name) && this.age == per.age)
        {
            return true;
        }else
        {
            return false;
        }
    }
    public int hashCode()
    {
        final int prime = 13;
        int result = 13;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        result = prime * result + age;
        return result;
    }
}
public class Hi
{
    public static void main(String[] args)
    {
        Person p1 = new Person("小二", 27);
        Person p2 = new Person("小二", 27);
        Person p3 = new Person("小小", 30);
        System.out.println("p1的哈希值："+p1.hashCode());
        System.out.println("p2的哈希值："+p2.hashCode());
        System.out.println("p3的哈希值:"+p3.hashCode());
        if(p1.equals(p2))
        {
            System.out.println("p1,p2相等");
        }else
        {
            System.out.println("p1,p2不相等");
        }
        if(p1.equals(p3))
        {
            System.out.println("p1,p3相等");
        }else
        {
            System.out.println("p1,p3不相等");
        }
        
    }
}
/*
p1的哈希值：97
p2的哈希值：97
p3的哈希值:980
p1,p2相等
p1,p3不相等
*/
 // =============
// 克隆对象
class Person implements Cloneable
{
    private String name;
    private int age;
    public Person(){}
    public Person(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
    public boolean equals(Object o)
    {
        if(this == o)
        {
            return true;
        }
        if(o == null)
        {
            return false;
        }
        if(!(o instanceof Person))
        {
            return false;
        }
        Person per = (Person)o;
        if(this.name.equals(per.name) && this.age == per.age)
        {
            return true;
        }else
        {
            return false;
        }
    }
    public int hashCode()
    {
        final int prime = 13;
        int result = 13;
        result = prime * result+((name == null) ? 0 : name.hashCode());
        result = prime *result + age;
        return result;
    }
    // 重写 clone() 方法
    public Object clone() throws CloneNotSupportedException
    {
        return super.clone();
    }
    public String toString()
    {
        return ("姓名："+this.name+",年龄:"+this.age);
    }
}
public class Hi
{
    public static void main(String[] args) throws CloneNotSupportedException
    {
        Person p1 = new Person("小二", 27);
        Person p2 = (Person)p1.clone();
        System.out.println(p1+",p1的哈希码："+p1.hashCode());
        System.out.println(p2+",p2的哈希值："+p2.hashCode());
        if(p1.equals(p2))
        {
            System.out.println("p1和p2相等");
        }else
        {
            System.out.println("p1和p2不相等");
        }
    }
}
/*
姓名：小二,年龄:27,p1的哈希码：9761129
姓名：小二,年龄:27,p2的哈希值：9761129
p1和p2相等
*/
// ==========
java.lang.Runtime 类封装了运行时的环境
常用方法：

//向java虚拟机返回可用处理器的数目
public int availableProcessors()

//在单独的进程中执行指定的字符串命令
public Process exec(String command) throws IOException

//
public void exit(int status)

//返回 java 虚拟机中的空闲内存量
public long freeMemory()

//运行垃圾回收
public void gc()

//返回与当前 java 应用程序相关的运行时对象
public static Runtime getRuntime()

//强行终止目前正在运行的 java虚拟机
public void halt(int status)

//加载具有指定库名的动态库
public void load(String libname)

//返回 java虚拟机试图使用的最大内存量
public long maxMemory()

//返回 java虚拟机中的内存总量
public long totalMemory()

// ===========
public class Hi
{
    public static void main(String[] args)
    {
        // 获取当前运行的对象
        Runtime rt = Runtime.getRuntime();
        System.out.println("JVM处理器的数目："+rt.availableProcessors());
        System.out.println("JVM空闲内存量："+rt.freeMemory());
        System.out.println("JVM内存总量："+rt.totalMemory());
        System.out.println("JVM最大内存量："+rt.maxMemory());
        String str = null;
        for(int i=0; i<10000; i++)
        {
            str =""+i;
        }
        System.out.println("操作 str后,jvm空闲内存量："+rt.freeMemory());
        // 回收
        rt.gc();
        System.out.println("回收垃圾后,JVM空闲内存量："+rt.freeMemory());
    }
}
/*
JVM处理器的数目：2
JVM空闲内存量：62455464
JVM内存总量：64487424
JVM最大内存量：947388416
操作 str后,jvm空闲内存量：61448808
回收垃圾后,JVM空闲内存量：63341168
*/
// ==========

Process 类
可用来控制进程并获取相关信息
常用方法：
//关闭子进程
public abstract void destory()

//返回子进程的出口值
public abstract int exitValue()

//获得子进程的错误流
public abstract InputStream getErrorStream()

//获得子进程的输入流
public abstract InputStream getInputStream()

//获得子进程的输出流
public abstract OutputStream getOutputStream()

//导致当前进程等待
public abstract int waitFor() throws InterruptedExeption