java常用类需要记吗_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
// ========
// 以下是調用了 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("\n種子為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
{
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("分割前：\n"+str);
System.out.println("分割后：");
for(int i=0; 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");
}
}
}
// ============
總結
以上是生活随笔為你收集整理的java常用类需要记吗_java 常用类的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 读《程序设计实践》之一 风格
- 下一篇： 【荐】中国最有潜力的十位企业家(IT行业