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
// ========
// 以下是调用了 process
public class Hi
{
public static void main(String[] args)
{
// 获取 Runtime 运行时的对象
Runtime rt = Runtime.getRuntime();
Process process = null;
try
{
// 调用本机的计算器
process = rt.exec("calc.exe");
}catch(Exception e)
{
e.printStackTrace();
}
}
}
// --------------
//以下 5秒后不会关闭计算器
public class Hi
{
public static void main(String[] args)
{
Runtime rt = Runtime.getRuntime();
try
{
rt.exec("calc.exe");
}catch(Exception e)
{
e.printStackTrace();
}
try
{
Thread.sleep(5000);
}catch(Exception e)
{
e.printStackTrace();
}
}
}
//以下5秒后会关闭计算器
public class Hi
{
public static void main(String[] args)
{
Runtime rt = Runtime.getRuntime();
Process process = null;
try
{
process = rt.exec("calc.exe");
}catch(Exception e)
{
e.printStackTrace();
}
try
{
Thread.sleep(5000);
}catch(Exception e)
{
e.printStackTrace();
}
process.destroy();
}
}
// ==========
定时器， Timer 与 TimerTask 类
java.util.Timeer
java.util.TimerTask
Timer 类的常用方法
//创建一个新计时器
public Timer()
//创建一个新计时器，并指定相关线程作为守护线程
public Timer(boolean isDaemon)
//创建一个新计时器，并为指定的相关线程设置名称
public Timer(String name)
//创建一个新计时器，指定相关线程作为守护线程，并为指定的相关线程设置名称
public Timer(String name, boolean isDaemon)
//终止此计时器
public void cancel()
//移除所有已取消的任务,用于释放内存空间
public int purge()
//安排在指定的时间执行指定的任务，若已超过该时间，则立即执行
public void schedule(TimerTask task, Date time)
//安排在指定的时间执行指定的任务，然后以固定的频率（单位 ms）重复执行
public void schedule(TimerTask task, Date firstTIME, long period)
//安排指定的任务在一段时间后（ms）执行
public void schedule(TimerTask task, long delay)
//安排指定的任务在一段时间后执行，然后以固定的频率重复执行
public void schedule(TimerTask task,long delay, long period)
// 安排在指定的时间执行指定的任务，以后以近似的频率重复执行
public void scheduleAtFixedRate(TimerTask task, Date firstTime, long period)
//安排指定的任务在指定的时间后执行，并重复执行
public void scheduleAtFirstRate(TimerTask task, long delay, long period)
// TimerTask 类
常用方法
// 取消此计时器任务
public boolean cancel()
//此计时器任务要执行的操作编写在该方法中，子类必须重写该方法
public abstract void run()
//返回此任务最近要执行的任务时间
public long scheduledExceptionTime()
// ==========
// 定时操作
import java.util.Date;
import java.util.Random;
import java.util.Timer;
import java.util.TimerTask;
// 任务调度类继承 TimerTask
class RemindTask extends TimerTask
{
public void run()
{
System.out.println("执行时间："+(new Date()));
}
}
public class Hi
{
Timer timer;
public Hi(int seconds, int lenTimer)
{
// 建立 Timer类对象
timer = new Timer();
// 执行任务
timer.schedule(new RemindTask(),seconds, lenTimer);
}
public static void main(String[] args)
{
System.out.println("任务调度开始....");
// 设置任务， 500 ms 后开始，每 1s 重复一次
new Hi(500,1000);
}
}
// ------------
System 类常用属性和方法
// 常量，“标准”错误输出流
public static PrintStream err
//常量，“标准”输入流
public static PrintStream in
//常量，“标准”输出流
public static PrintStream out
//从指定的源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束，
//其中，src为源数组，srcPos表示源数组的起始索引
// dest 表示目的数组， destPos表示目的数组的起始索引，
// length 表示提制数组 的长度
public static void arraycopy(Object src, int srcPos, Object dest,
int destPos, int length)
//返回以 ms 为单位的当前时间
public static long currentTimeMillis()
//
public static void exit(int status)
//运行垃圾回收器
public static void gc()
//获得指定的环境变量值
public static String getenv(String name)
//确定当前的系统属性
public static Properties getProperties()
//
public static void load(String filename)
// =========
// 获取系统属性
import java.util.Properties;
public class Hi
{
public static void main(String[] args)
{
// 取得系统属性
Properties pr = System.getProperties();
//列出属性
pr.list(System.out);
}
}
// ----------
//复制数组
public class Hi
{
public static void main(String[] args)
{
char src[] = {'A', 'B', 'C', 'D', 'E', 'F'};
char dest[] = {'1','2','3', '4', '5'};
System.arraycopy(src, 1, dest, 1, 2);
for (char c:dest)
{
System.out.print(c+" ");
}
}
}
//1 B C 4 5
// ==============
//程序运行计时
public class Hi
{
public static void main(String[] args)
{
long startTime = System.currentTimeMillis();
long result = 0;
for (long i=0; i<888888888L; i++)
{
result += i;
}
System.out.println("程序运行时间："+(System.currentTimeMillis()-startTime));
}
}
//程序运行时间：732
// --------------
/*
* 垃圾对象的回收
* System.gc() 可用于垃圾回收器，实际是调用了 Runtime 类的 gc() 方法
* 可用 Object类的 finalize() 方法来释放一个对象占用的内存空间
*/
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 void finalize() throws Throwable
{
System.out.println("释放对象："+this);
super.finalize();
}
}
public class Hi
{
public static void main(String[] args)
{
Person p = new Person("小二", 27);
System.out.println(p);
p = null;
System.gc();
}
}
/*
姓名：小二,年龄：27
释放对象：姓名：小二,年龄：27
*/
// ===========
Date类常用方法：
//生成一个 Date对象，以表示分配它的时间，精确到毫秒
//该构造方法调用 System.currentTimeMillis()方法获取当前时间
//即 new Date() 等价于 new Date(System.currentTimeMillis())
public Date()
//根据指定的 long 类型值来生成一个 Date对象，表示时间戳，以 ms 为单位
public Date(long date)
//测试此日期是否指定日期之后
public boolean after(Date when)
//测试此日期是否在指定日期之前
public boolean before(Date when)
//比较两个日期的顺序，早为 -1,相等为0.晚为 1
public int compareTo(Date anotherDate)
//比较两日期相等性
public boolean equals(Object obj)
//返回自 1970-01-01到 Date 对象的时间差，单位为 ms
public long getTime()
//设置此 Date对象，惟 1970-01-01以后 time毫秒的时间点
public setTime(long time)
//把 Date对象转换为以下形式 down mon dd hh:mm:ss zzz yyy
public String toString()
// ---------
// 验证 Date类
import java.util.Date;
public class Hi
{
public static void main(String[] args)
{
//攻取当前时间
Date date1 = new Date();
//当前时间+123ms
Date date2 = new Date(System.currentTimeMillis()+123);
System.out.println("时间："+date1);
//输出date2，以时间差表示
System.out.println("时间差："+date2.getTime()+"ms");
System.out.println("date1是date2是否相同："+date1.compareTo(date2));
System.out.println("date1是否比 date2早："+date1.before(date2));
}
}
/*
时间：Sun Mar 01 13:43:52 CST
时间差：1425188632171ms
date1是date2是否相同：-1
date1是否比 date2早：true
*/
// ===========
// 不推荐使用 Date表示日期和时间，应用用 Calendar 类,这个是抽象类，所以不能直接实例化，
//可用两种：子类 GregorianCalendar 为其实例化，通过 Calendar 类中的 getInstance() 方法
// =======
//验证 Calendar 类
import java.util.Calendar;
import java.util.GregorianCalendar;
public class Hi
{
public static void main(String[] args)
{
Calendar call = Calendar.getInstance();
Calendar cal2 = new GregorianCalendar();
System.out.println("年份："+call.get(Calendar.YEAR));
System.out.println("月分："+(call.get(Calendar.MONTH)+1));
System.out.println("号数："+(call.get(Calendar.DATE)));
System.out.println("今年的第"+(call.get(Calendar.DAY_OF_YEAR))+"天");
System.out.println("本月的第"+(call.get(Calendar.DAY_OF_MONTH))+"天");
System.out.println("本月的第"+(call.get(Calendar.DAY_OF_WEEK_IN_MONTH))+"周");
System.out.println("星期："+(call.get(Calendar.DAY_OF_WEEK)-1));
System.out.println("24小时制："+call.get(Calendar.HOUR_OF_DAY));
System.out.println("12小时制："+call.get(Calendar.HOUR));
System.out.println("分钟："+call.get(Calendar.MINUTE));
System.out.println("秒："+call.get(Calendar.SECOND));
System.out.println("毫秒："+call.get(Calendar.MILLISECOND));
System.out.println("日期："+call.getTime());
cal2.set(2015,10,3);
long time = cal2.getTimeInMillis() - call.getTimeInMillis();
long day = time/(24*60*60*1000);
System.out.println("天数："+day);
}
}
/*
年份：2015
月分：3
号数：1
今年的第60天
本月的第1天
本月的第1周
星期：0
24小时制：15
12小时制：3
分钟：24
秒：13
毫秒：672
日期：Sun Ma
天数：247
*/
// ----------
日期格式类： DateFormat 类,为抽象类
可使用 DateFormat类中的静态方法 getDateFormat()实例化
import java.util.Date;
import java.text.DateFormat;
public class Hi
{
public static void main(String[] args)
{
DateFormat df1 = DateFormat.getInstance();
DateFormat df2 = DateFormat.getDateInstance();
DateFormat df3 = DateFormat.getTimeInstance();
DateFormat df4 = DateFormat.getDateTimeInstance();
System.out.println("默认："+df1.format(new Date()));
System.out.println("Date 默认："+df2.format(new Date()));
System.out.println("Time默认："+df3.format(new Date()));
System.out.println("DateTime默认："+df4.format(new Date()));
}
}
/*
默认：15-3-1 下午3:41
Date 默认：2015-3-1
Time默认：15:41:13
DateTime默认：2015-3-1 15:41:13
*/
// --------------
//中文时间格式
import java.util.Date;
import java.util.Locale;
import java.text.DateFormat;
public class Hi
{
public static void main(String[] args)
{
DateFormat dfShort = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT,Locale.CHINA);
DateFormat dfMedium = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM, Locale.CHINA);
DateFormat dfFull = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL, Locale.CHINA);
DateFormat dfLong = DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG,Locale.CHINA);
DateFormat dfDefault = DateFormat.getDateTimeInstance(DateFormat.DEFAULT, DateFormat.DEFAULT, Locale.CHINA);
System.out.println("short型："+dfShort.format(new Date()));
System.out.println("medium型："+dfMedium.format(new Date()));
System.out.println("Full 型:"+dfFull.format(new Date()));
System.out.println("Long型："+dfLong.format(new Date()));
System.out.println("DEFAULT型"+dfDefault.format(new Date()));
}
}
/*
short型：15-3-1 下午4:23
medium型：2015-3-1 16:23:42
Full 型:2015年3月1日 星期日 下
Long型：2015年3月1日 下午04时2
DEFAULT型2015-3-1 16:23:42
*/
// ============
//自定义日期格式类
//SimpleDateFormat 类
import java.util.Date;
import java.text.SimpleDateFormat;
public class Hi
{
public static void main(String[] args)
{
String format1 = "yyyy年MM月dd日 HH:mm:ss E";
String format2 = "yyyy-MM-dd HH:mm:ss";
SimpleDateFormat sdf1 = new SimpleDateFormat(format1);
SimpleDateFormat sdf2 = new SimpleDateFormat(format2);
String date1 = sdf1.format(new Date());
String date2 = sdf2.format(new Date());
System.out.println(date1);
System.out.println(date2);
}
}
/*
2015年03月01日 16:48:04 星期日
2015-03-01 16:48:04
*/
// ------------
//追念日期的字符串转换为日期 Date类型
import java.util.Date;
import java.text.SimpleDateFormat;
import java.text.ParseException;
public class Hi
{
public static void main(String[] args)
{
String strDate = "2015-03-01 16:06:06";
String format = "yyyy-MM-dd HH:mm:ss";
SimpleDateFormat sdf = new SimpleDateFormat(format);
Date date = null;
try
{
date = sdf.parse(strDate);
}catch(ParseException e)
{
e.printStackTrace();
}
System.out.println(date);
}
}
//Sun Mar 01 16:06:06 CST 2015
// ============
Math 数学运算
public class Hi
{
public static void main(String[] args)
{
System.out.println("绝对值函数：10.02 = "+Math.abs(10.02D)+", -10.02="+Math.abs(-10.02D));
System.out.println("最大值最小值（23,12）:最大值："+Math.max(23, 12)+",最小值："+Math.min(23, 12));
System.out.println("四舍五入：13.6 ="+Math.round(13.6)+",13.4="+Math.round(13.4));
System.out.println("三角函数： sin(30)="+Math.sin(30)+",cos(30)="+Math.cos(30));
System.out.println("开方函数：16的开方="+Math.sqrt(16)+",8的立方根="+Math.cbrt(8));
System.out.println("对数函数：ln(10)="+Math.log(10));
System.out.println("随机数：0-10 = "+Math.random()*10);
}
}
// ========
//随机数类，Random 类，其实可以通过 Math.random()生成
常用方法：
public Random(),
public Random(long seed),
protected int next(int bits),
public boolean nextBoolean(),
public void nextBytes(byte[] bytes)
public double nextDouble()
public float nextFloat()
public double nextGaussian()
public int nextInt()
public int nextInt(int n)
public long nextLong()
public void setSeed(long seed)
// ---------
// 生成指定区域的随机数
import java.util.Random;
public class Hi
{
public static void main(String[] args)
{
Random random = new Random();
System.out.println("生成0-1的随机小数："+random.nextDouble());
System.out.println("生成0-10.0的随机小数："+random.nextDouble()*10);
System.out.println("生成5-15的随机整数："+random.nextInt(10)+5);
System.out.println("生成0-100的随机数：");
for(int i=0;i<10; i++)
{
System.out.print(random.nextInt(100)+" ");
}
}
}
// =========
// 具有相同种子数
import java.util.Random;
public class Hi
{
public static void main(String[] args)
{
Random random1 = new Random(100);
Random random2 = new Random(100);
System.out.println("种子数为100的random对象:");
for(int i=0; i<10; i++)
{
System.out.print(random1.nextInt(100)+" ");
}
System.out.println("
种子为100的random对象:");
for(int i=0; i<10; i++)
{
System.out.print(random2.nextInt(100)+" ");
}
}
}
/*
种子数为100的random对象:
15 50 74 88 91 66 36 88 23 13
种子为100的random对象:
15 50 74 88 91 66 36 88 23 13
*/
//以上初始化种子数一样，所以结果一样，为了不一样，只能实例化一次 Random
// ----------
NumberFormat
java.text.NumberFormat类用于数字格式化,用于各种格式化
//返回所有语言环境的数组
public static Locale[] getAvailableLocales()
//获取格式化货币值时此数字格式使用的货币符号
public Currency getCurrency()
//规范格式
public String format(double number)
//返回当前默认语言环境的货币格式符号
public static NumberFormat getCurrencyInstance()
//返回指定语言环境的货币格式符号
public static NumberFormat getCurrencyInstance(Locale inLocale)
//返回当前默认语言环境的数字格式
public static NumberFormat getInstance()
//返回指定语言环境的数字格式
public static NumberFormat getInstance(Locale inLocale)
//返回当前默认语言环境的整数格式
public static NumberFormat getIntegerInstance()
//返回指定语言环境的整数格式
public static NumberFormat getIntegerInstance(Locale inLocale)
//返回当前默认语言环境的通用数字格式
public static NumberFormat getNumberInstance()
//返回指定语言环境的通用数字格式
public static NumberFormat getNumberInstance(Locale inLocale)
//返回当前默认语言环境的百分比格式
public static NumberFormat getPercentInstance()
//返回指定语言环境的百分比格式
public static NumberFormat getPercentInstance(Locale inLocale)
//将给定追念数字的字符串，解析为一个数字
public Number parse(String source)
//获取格式化货币值时此数字格式使用的货币
public void setCurrency(Currency currency)
// ============
import java.text.NumberFormat;
import java.util.Locale;
public class Hi
{
public static void main(String[] args)
{
System.out.println("----------默认格式（中文）------");
NumberFormat nfm1 = NumberFormat.getInstance();
System.out.println(nfm1.format(99999));
System.out.println(nfm1.format(9999.3601));
System.out.println("----------指定格式(美国)-------");
NumberFormat nfm2 = NumberFormat.getCurrencyInstance(Locale.US);
System.out.println(nfm2.format(9998774));
System.out.println(nfm2.format(9999.3366));
System.out.println("-----------默认格式(中文)--------");
NumberFormat nfm3 = NumberFormat.getPercentInstance();
System.out.println(nfm3.format(0.123));
}
}
/*
----------默认格式（中文）------
99,999
9,999.36
----------指定格式(美国)-------
$9,998,774.00
$9,999.34
-----------默认格式(中文)--------
*/
// --------------
decimalFormat 是 NumberFormat的一个子类，用于格式化,但得有格式化模板标记
import java.text.DecimalFormat;
import java.util.Locale;
public class Hi
{
public static void main(String[] args)
{
// 实例化
DecimalFormat dfm1 = new DecimalFormat("000,000.000");
System.out.println("000,000.000格式："+dfm1.format(123456.789));
DecimalFormat dfm2 = new DecimalFormat("###,###.###");
System.out.println("###,###.###格式："+dfm2.format(123456.789));
DecimalFormat dfm3 = new DecimalFormat("￥000,000.000");
System.out.println("￥000,000.000格式："+dfm3.format(123456.789));
DecimalFormat dfm4 = new DecimalFormat("$000,000.000");
System.out.println("$000,000.000格式："+dfm4.format(123456.789));
DecimalFormat dfm5 = new DecimalFormat("###,###.###%");
System.out.println("###,###.###%格式："+dfm5.format(123456.789));
DecimalFormat dfm6 = new DecimalFormat("000.###u2030");
System.out.println("000.###u2030格式："+dfm6.format(123456.789));
DecimalFormat dfm7 = new DecimalFormat("###.###");
System.out.println("###.###格式："+dfm7.format(123456.789));
}
}
/*
值为 123456.789
结果如下：
000,000.000格式：123,456.789
###,###.###格式：123,456.789
￥000,000.000格式：￥123,456.789
$000,000.000格式：$123,456.789
###,###.###%格式：12,345,678.9%
000.###‰格式：123456789‰
###.###格式：123456.789
*/
//-------------
大数类
BigInteger:无限大的整数
BigDecimal:无限大的浮点数
//BigInteger 类
import java.math.BigInteger;
public class Hi
{
public static void main(String[] args)
{
String strNumber1 = "123456789987654321";
String strNumber2 = "987654321123456789";
BigInteger big1 = new BigInteger(strNumber1);
BigInteger big2 = new BigInteger(strNumber2);
System.out.println("加法操作："+big1.add(big2));
System.out.println("减法操作："+big2.subtract(big1));
System.out.println("乘法操作："+big1.multiply(big2));
System.out.println("除法操作："+big2.divide(big1));
System.out.println("取模操作："+big2.mod(big1));
System.out.println("最大公约数："+big1.gcd(big2));
System.out.println("最大值："+big1.max(big2)+",最小值："+big1.min(big2));
byte b[] = big1.toByteArray();
System.out.println("二进制补码：");
for(int i=0; i<b.length;i++)
{
System.out.print(b[i]+" ");
}
}
}
/*
加法操作：1111111111111111110
减法操作：864197531135802468
乘法操作：121932632103337905662094193112635269
除法操作：8
取模操作：1222222221
最大公约数：1222222221
最大值：987654321123456789,最小值：123456789987654321
二进制补码：
1 -74 -101 75 -32 82 -6 -79
*/
// ==============
//精确的大数类： BigDecimal类
因为 float double 不适合精确运算
import java.math.BigDecimal;
public class Hi
{
public static double add(double d1, double d2)
{
BigDecimal dbl1 = new BigDecimal(d1);
BigDecimal dbl2 = new BigDecimal(d2);
return dbl1.add(dbl2).doubleValue();
}
public static double sub(double d1, double d2)
{
BigDecimal dbl1 = new BigDecimal(d1);
BigDecimal dbl2 = new BigDecimal(d2);
return dbl1.subtract(dbl2).doubleValue();
}
public static double mul(double d1, double d2)
{
BigDecimal dbl1 = new BigDecimal(d1);
BigDecimal dbl2 = new BigDecimal(d2);
return dbl1.multiply(dbl2).doubleValue();
}
public static double div(double d1, double d2, int len)
{
BigDecimal dbl1 = new BigDecimal(d1);
BigDecimal dbl2 = new BigDecimal(d2);
return dbl1.divide(dbl2,len, BigDecimal.ROUND_HALF_UP).doubleValue();
}
public static double round(double d1, int len)
{
BigDecimal dbl1 = new BigDecimal(d1);
BigDecimal dbl2 = new BigDecimal(1);
return dbl1.divide(dbl2,len,BigDecimal.ROUND_HALF_UP).doubleValue();
}
public static void main(String[] args)
{
System.out.println("加法操作："+round(add(9.87645321, 1.2369875), 1));
System.out.println("减法操作："+round(sub(9.87654321,1.23456789), 1));
System.out.println("乘法操作(保留5位小数："+round(mul(9.87654321,1.23456789), 5));
System.out.println("除法操作(保留10位小数）："+div(9.87654321,1.23456789,10));
}
}
/*
加法操作：11.1
减法操作：8.6
乘法操作(保留5位小数：12.19326
除法操作(保留10位小数）：8.0000000729
*/
// ===========
正则表达式，由 java.util.regex 包
该包中只有两个类 Pattern类和Match类
Pattern类的对象是正则表达式编译在内存的表示形式，而 Matcher对象是状态机，它依据 Pattern对象作为匹配模式，
对字符串展开匹配操作
执行流程如下：
首先创建 Pattern对象，再由已定义的正则表达式对它进行编译。最后再利用
Pattern对象创建对应的 Matcher对象，执行匹配所涉及的状态保存在 Matcher对象中
// =============
Pattern类常用方法
//编译并创建一个Pattern类的对象
public static Pattern compile(String regex)
//同上，但增加一个 flags参数标志模式
public static Pattern compile(String regex, int flags)
//返回当前Pattern对象的 flags参数
public int flags()
//创建一个给定名称的 Matcher对象
public Matcher matcher(CharSequence input)
//编译给定正则表达式，并输入的字符串以正则表达式为模展开匹配
public static boolean matcher(String regex, CharSequence input)
//返回 该 Pattern对象所编译的正则表达式
public String pattern()
//将字符串按指定的正则分割
public String[] split(CharSequence input)
//将字符串进行分割，并增加分割段数
public String[] split(CharSequence input, int limit)
// =================
//拆分字符串
import java.util.regex.Pattern;
public class Hi
{
public static void main(String[] args)
{
String str = "好的/雷劈/去你的/恩";
//创建 Pattern实例
Pattern pat = Pattern.compile("[/]");
//分割字符串
String rse[] = pat.split(str);
System.out.println("分割前：
"+str);
System.out.println("分割后：");
for(int i=0; i<rse.length; i++)
{
System.out.println(rse[i]);
}
}
}
/*
分割前：
好的/雷劈/去你的/恩
分割后：
好的
雷劈
去你的
恩
*/
// ==============
Mathcher类需要配合 pattern类使用
以下是部分方法：
//将当前的子字符串替换为指定的字符串
public Matcher appendReplacement(StringBuffer sb, String replacement)
//在最后一镒匹配后，将剩余的字符串添加到指定的 StringBuffer对象中
public StringBuffer appendTail(StringBuffer sb)
//返回最后匹配的索引位置
public int end()
//返回最后与指定组匹配的位置
public int end(int group)
//在目标字符串查找下一个匹配的字符串，找到则 true
public boolean find()
//重新查找下一个匹配的字符串
public boolean find(int start)
// =============
import java.util.Scanner;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class Hi
{
public static void main(String[] args)
{
//定义规则
String regex = "^(\d{2})$";
Scanner scan = new Scanner(System.in);
String str = scan.next();
// 实例化 Pattern
Pattern pat = Pattern.compile(regex);
// 实例化 Matcher
Matcher mat = pat.matcher(str);
if(mat.matches())
{
System.out.println("Yes");
}else
{
System.out.println("No");
}
}
}
// ============