java 基础知识总结
 

11.Java常用类：

  1. StringBuffer
    • StringBuffer 是使用缓冲区的,本身也是操作字符串的,但是与String类不同,String类的内容一旦声明之后则不可以改变,改变的只是其内存地址的指向,而StringBuffer中的内容是可以改变的,对于StringBuffer而言,本身是一个具体的操作类,所以不能像String那样采用直接赋值的方式进行对象的实例化,必须通过构造方法完成.
    • 在StringBuffer中使用append()方法,完成字符串的连接操作
    • public StringBuffer insert(int offset,String str)// 在第几个字符后面插入数据
public StringBuffer reverse() //字符串反转操作
public StringBuffer replace(int start,int end,String str)// 替换指定范围的内容
public String substring(int start,int end) //字符串截取
public StringBuffer delete(int start, int end) //移除此序列的字符串中的字符
public int indexOf(String str)//查找指定的内容是否存在,如果存在返回位置,否则否则返回-1.
public int length() //返回长度(字符数).
  2. Runtime
    • 运行时,是一个封装了JVM进程的类,每个JAVA程序实际上都是启动了一个JVM进程,那么每个JVM进程都是对应这个Runtime实例,此实例是由JVM为其实例化的.本类的定义中没有构造方法,构造方法被私有化了,在此类中肯定有一个方法可以返回本类的实例化对象.
    • public static Runtime getRuntime() //取得Runtime类的实例(如:Runtime run=Runtime.getRuntime();)
public long freeMemory() //返回Java虚拟机中的空闲内存量
public long maxMemory() //返回JVM的最大内存量
public void gc() //运行垃圾回收器,释放空间 (如: Runtime run=Runtime.getRuntime(); run.gc();)
public Process exec(String command)throws IOException //执行本机命令(如调用本机的记事本程序: Runtime run=Runtime.getRuntime();Process p=null; p=run.exec(“notepad.exe”);//需要异常处理 p.destroy();//结束进程)
  3. 国际化程序
    • 国际化的操作就是指一个程序可以同时适应多门语言
    • 想要实现Java程序的国际化操作必须通过以下的三个类完成
      • 1)java.util.Locale:用于表示一个国家语言类
      • 2)java.util.ResourceBundle:用于访问资源文件
      • 3)java.textMessageFormat:格式化资源文件的占位字符串
  4. 日期操作类
    • Date类:直接实例化Date对象:Date 名称=new Date();
      • Calendar类:可以按照自己需要的格式显示的时间,则就可以使用Calendar类
      • Calendar类是一个抽象类,既然是一个抽象类则肯定无法直接使用,此时就要利用对象多态性的概念.通过向上的转型关系实例化本类对象.
      • Calendar类取得一个完整的日期:
      • Calendar calendar=new GregorianCalendar();
calendar.get(Calendar.YEAR) ; //取得年份
calendar.get(Calendar.MONTH) ; //取得月份,注意:此处的月份比实际的少一个月,要打印时要+1;
calendar.get(Calendar.DAY_OF_MONTH) ; //取得日期calendar.get(Calendar.HOUR_OF_DAY) ; //取得小时calendar.get(Calendar.MINUTE) ; //取得分
calendar.get(Calendar.SECOND) ; //取得秒
calendar.get(Calendar.MILLISECOND) ; //取得毫秒
    • DateFormat类:此类是一个日期的格式化类,专门格式化日期的操作.此类是定义在java.text包中的.
    • public static final DateFormat getDateInstance() //得到日期的DateFormat对象
public static final DateFormat getDateTimeInstance() //得到日期时间的DateFormat对象
public final String format(Date date) //直接使用DateFormat类完成Date类的转换功能
    • SimpleDateFormat类:
      • (一)此类 功能是完成日期的显示格式化的
        • 1)y 表示年, 年份是四位数字,所以需要使用”yyyy”表示年.
        • 2)M 表示月, 月份是两位数字,所以需要使用”MM”表示月.
        • 3)d 表示日, 日是两位数字,所以需要使用”dd”表示日.
        • 4)H 表示时, 时是两位数字,所以需要使用”HH”表示时.
        • 5)m 表示分, 分是两位数字,所以需要使用”mm”表示分.
        • 6)s 表示秒, 秒是两位数字,所以需要使用”ss”表示秒.
        • 7)S 表示毫秒,毫秒是三位数字,所以需要使用”SSS”表示毫秒.
      • (二)在SimpleDateFormat类使用的时候,必须注意的是在构造对象时要传人匹配的模板
        • 1)构造方法:publicSimpleDateFormat(String pattern)
        • 2)转换: public Date parse(String source) throws ParseException 此时取得的是全部的时间数.
        • 3)格式化: public final String format(Date date) 将时间重新格式化成字符串显示.
      • (三)具体的一个示例:
      • String strDate = "2008-10-19 10:11:30.345" ;// 准备第一个模板，从字符串中提取出日期数字
String pat1 = "yyyy-MM-dd HH:mm:ss.SSS" ;// 准备第二个模板，将提取后的日期数字变为指定的格式
String pat2 = "yyyy年MM月dd日 HH时mm分ss秒SSS毫秒" ;
SimpleDateFormat sdf1 = new SimpleDateFormat(pat1) ;    // 实例化模板对象
SimpleDateFormat sdf2 = new SimpleDateFormat(pat2) ;    // 实例化模板对象
Date d = null ;
try{
    d = sdf1.parse(strDate) ;    // 将给定的字符串中的日期提取出来
}catch(Exception e){    // 如果提供的字符串格式有错误，则进行异常处理
    e.printStackTrace() ;    // 打印异常信息
}
System.out.println(sdf2.format(d)) ;    // 将日期变为新的格式
      • (四)得到系统时间:
      • SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS") ;
System.out.println("系统日期："+sdf.format(new Date()) );
      • (五)得到中文时间:
      • SimpleDateFormat sdf= new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒SSS毫秒") ;
System.out.println("中文日期："+sdf.format(new Date()) );
      • (六)得到时间戳:
      • SimpleDateFormat sdf= new SimpleDateFormat("yyyyMMddHHmmssSSS") ;
System.out.println("时间戳："+sdf.format(new Date()) );
  5. Math与Random类
    • Math类 
      • Math.abs(-1);//求-1的绝对值
Math.cbrt(8);//求2的立方根
Math.max(1,5);//求两个数的最大值
Math.min(2,4);//求两个数的最小值
Math.sqrt(9);//求9的平方根
Math.pow(2,3);//求2的3次方
Math.round(2.6);//2.6的四舍五入(这个四舍五入是将小数点后面的全忽略掉了,要想准确的四舍五入则使用BigDecimal类完成)
    • Random类:Random类的主要功能是产生随机数,可以产生一个指定范围的随机数. 
      • public int nextInt(int n);//产生一个0到n之间的一个整数
  6. NumberFormat类
    • 表示数字的格式化类.
    • 定义格式: public abstract class NumberFormat extends Format
    • 方法:
    1. public static Locale[] getAVailableLocales() 返回所有语言环境的数组
public static final NumberFormat getInstance() 返回当前默认语言环境的数字格式
public static NumberFormat getInstance(Locale inLocale) 返回指定语言环境的数字格式
public static final NumberFormat getCurrencyInstance() 返回当前默认环境的货币格式
public static NumberFormat getCurrencyInstance(Locale inLocale) 返回指定语言环境的数字格式
  • NumberFormat nf = null ;    // 声明一个NumberFormat对象
nf = NumberFormat.getInstance() ;    // 得到默认的数字格式化显示
System.out.println("格式化之后的数字：" + nf.format(10000000)) ;
System.out.println("格式化之后的数字：" + nf.format(1000.345)) ;
  • DecimalFormat的基本使用:可以按照自己的格式格式化数字
    • (一)格式化模板:
    • 　标记   位置   描述
      1) 0 　　数字 //每个0表示一位,如果该位不存在则显示0
2) # 　　数字 //每个#表示一位,如果该位不存在则不显示
3) . 　　数字 //小数点分隔符或货币的小数分隔符
4) - 　　数字 //代表负号
5) , 　　数字 //分组分隔符
6) E 　　数字 //分隔科学计数法中的尾数和指数
7) ; 　　子模式边界 //分隔正数和负数子模式
8) % 　　前缀或后缀 //数字乘以100并显示为百分数
9) \u2030 　　前缀或后缀 //数字乘以1000兵显示为千分数
10) ¤ (\u00A4) 　　前缀或后缀 //货币记号，由货币符号替换。如果两个同时出现，则用国际货币符号替换。如果出现在某个模式中，则使用货币小数分隔符，而不使用小数分隔符。
11) ‘ 　　前缀或后缀 //用于在前缀或或后缀中为特殊字符加引号，例如 "'#'#" 将 123 格式化为 "#123"。要创建单引号本身，请连续使用两个单引号："# o''clock"。
    • (二)示例:
    • DecimalFormat df = null ;
df = new DecimalFormat("###,###.###") ;
String str = df.format(111222.34567) ;
System.out.println(str) ;
df = new DecimalFormat("000,000.000") ;
String str = df.format(111222.34567) ;
System.out.println(str) ;
df = new DecimalFormat("###,###.###￥") ;
String str = df.format(111222.34567) ;
System.out.println(str) ;
df = new DecimalFormat("000,000.000￥") ;
String str = df.format(111222.34567) ;
System.out.println(str) ;
df = new DecimalFormat("##.###%") ;
String str = df.format(0.345678) ;
System.out.println(str) ;
df = new DecimalFormat("00.###%") ;
String str = df.format(0.345678) ;
System.out.println(str) ;
df = new DecimalFormat("##.###%") ;
String str = df.format(0.0345678) ;
System.out.println(str) ;
df = new DecimalFormat("###.###\u2030") ;
String str = df.format(0.345678) ;
System.out.println(str) ;
  • 大操作数(BigIntger,BigDecimal)
    • 操作整型:BigInteger
    • public BigInteger(String val) //将一个字符串变形为BigInteger类型的数据
public BigInteger add(BigInteger val) //加法
public BigInteger subtract(BigInteger val)// 减法
public BigInteger muItiply(BigInteger val) //乘法
public BigInteger divide(BigInteger val) //除法
public BigInteger max(BigInteger val) //返回两个大数字中的最大值
public BigInteger min(BigInteger val) //返回两个大数字中的最小值
public BigInteger[] divideAndRemainder(BigInteger val)// 除法操作,数组的第一个元素为除法的商,第二个为元素为除法的余数
    • 示例:
    • BigInteger bi1 = new BigInteger("123456789") ;// 声明BigInteger对象
BigInteger bi2 = new BigInteger("987654321") ;// 声明BigInteger对象
System.out.println("加法操作：" + bi2.add(bi1)) ;    // 加法操作
System.out.println("减法操作：" + bi2.subtract(bi1)) ;    // 减法操作
System.out.println("乘法操作：" + bi2.multiply(bi1)) ;    // 乘法操作
System.out.println("除法操作：" + bi2.divide(bi1)) ;    // 除法操作
System.out.println("最大数：" + bi2.max(bi1)) ;    // 求出最大数
System.out.println("最小数：" + bi2.min(bi1)) ;    // 求出最小数
BigInteger result[] = bi2.divideAndRemainder(bi1) ;// 求出余数的除法操作
System.out.println("商是：" + result[0] + "；余数是：" + result[1]) ;
    • 操作小数:BigDecimal
    • public BigDecimal(double val)// 将double表示形式转换为BigDecimal
public BigDecimal(int val) //将int表示形式转换为BigDecimal
public BigDecimal(String val) //将字符串表示形式转换为BigDecimal
public BigDecimal add(BigDecimal augend)// 加法
public BigDecimal subtract(BigDecimal Subtrahend) //减法
public BigDecimal multiply(BigDecimal multiplicand) //乘法
public BigDecimal divide(BigDecimal divisor) //除法
  • Arrays数组类:Arrays表示数组的操作类,是直接定义在java.util包中的.
  • pubic static boolean equals(int[] a,int[] a2) //判断两个数组是否相等,此方法被重载多次,可判断各种数据类型的数组
public static void fill(int[] a,int val)// 将指定内容填充到数组之中,此方法被重载多次,可以填充各种数据类型的数组
public static void sort(int[] a)// 数组排序,此方法被重载多次,可以对各种类型的数组进行排序
public static int binarySearch(int[] a,int key) //对排序后的数组进行检索,此方法被重新多次,可以对各种类型数组进行搜索
public static String toString(int[] a) //输出数组信息,此方法被重载多次,可以输出各种数据类型的数组.
  • 比较器
    • Comparable接口的作用
      • 定义:  
        • public interface Comparable<T>{
　　public int compareTo(T o);
}

           

      • 此方法返回一个int类型的数据,但是此int的值只能是一下三种:
        • 1: 表示大于
        • -1:表示小于
        • 0:表示相等
    • Comparator
    • 定义格式:  
      public interface Comparator<T>{
    public int compare(T o1,T o2);
    boolean equals(Object obj);
}
  • 正则表达式
    • 正则表达式可以方便的对数据进行匹配,可以执行更加复杂的字符串验证,拆分,替换功能.
    • Pattern:主要作用是进行正则规范(如”[0-9]”就属于正则规范)的编写,在Pattern类中如果要想取得Pattern类实例,则必须调用compile()方法
    • public static Pattern compile(String regex) //指定正则表达式规则
public Matcher matcher(CharSequence input)// 返回Matcher类实例
public String[] split(CharSequence input) //字符串拆分
    • Matcher:主要是执行规范,验证一个字符串是否符合其规范.
    • public boolean matches() //执行验证
public String replaceAll(String replacement //字符串替换
    • 示例:
      • (一) 匹配
      • 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("日期格式不合法！") ;
}
      • (二) 拆分
      • 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") ;
}
      • (三) 拆分替换
      • 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 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") ;
}
      • (五) 拆分
      • 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]) ;
}

         

12.定时调度

  1. 定时调度:每当一端时间,程序会自动执行,称为定时调度.必须保证程序始终运行着才可以,也就是说是想当于定时调度是在程序之外又启动了一个新的线程.
  2. Timer：是一种线程设施,可以用来实现在某一个时间或某一端时间后,安排某一个任务执行一次,或定期重复执行.该功能要与TimerTask配合使用,TimerTask类用来实现由Timer安排的一次或重复执行的某一个任务.每个Timer对象对应的是一个线程,因为次计时器所执行的任务应该迅速完成,否则可能会延迟后续任务的执行,而这些后续的任务就有可能堆在一起,等到该任务完成后才能快速连续执行.
  3. public Timer() //用来创建一个计时器并启动该计时器
public void cancel() //用来终止该计时器,并放弃所有已安排的任务.对当前正在执行的任务没有影响
public int purge() //将所有已经取消的任务移除,一般用来释放内存空间
public void schedule(TimerTask task,Date time) //安排一个任务在指定的时间执行,如果已经超过该时间,则立即执行.
public void schedule(TimerTask task,Date firstTime,long period) //安排一个任务在指定的时间执行,之后以固定的频率(单位:毫秒)重复执行.
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 scheduleAtFixedRate(TimerTask task,long delay,long period) //安排一个任务在一段时间(单位:毫秒)后执行,之后以近似固定的频率(单位:毫秒)重复执行.
  4. schedule()与scheduleAtFixedRate()方法的区别:
    • 两者的区别在与重复执行任务时,对于时间间隔出现延迟的情况处理:
      • schedule() 方法的执行时间间隔永远是固定的,如果之前出现了延迟的情况,之后也会继续按照设定好的时间间隔时间来执行
      • scheduleAtFixedRate()方法可以根据出现的延迟时间自动调整下一次间隔的执行时间.
  5. TimerTask:要想执行具体的任务,则必须使用TimerTask类. TimerTask类是一个抽象类.如果要使用该类,需要自己建立一个类来继承此类,并实现其中的抽象方法.
  6. public void cancel() //用来终止此任务,如果该任务只执行一次且还没有执行,则永远不会再执行,如果为重复执行任务,则之后不会再执行(如果任务正在执行,则执行完成不会再执行).
public void run() //该任务所要执行的具体操作,该方法为引入的接口Runnable中的方法,子类需要覆写此方法.
public long scheduleExecutionTime() //返回最近一次要执行该任务的时间(如果正在执行,则返回此任务的执行安排时间),一般在run()方法中调用,用来判断当前是否有足够的时间来执行完成该任务.
  7. 示例:
  8. import java.util.TimerTask ;
import java.util.Date ;
import java.text.SimpleDateFormat ;
class MyTask extends TimerTask{    // 任务调度类都要继承TimerTask
    public void run(){
        SimpleDateFormat sdf = null ;
        sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS") ;
        System.out.println("当前系统时间为：" + sdf.format(new Date())) ;
    }
};
    import java.util.Timer ;
public class TestTask{
public static void main(String args[]){
    Timer t = new Timer() ;    // 建立Timer类对象
    MyTask mytask = new MyTask() ;    // 定义任务
    t.schedule(mytask,1000,2000) ;    // 设置任务的执行，1秒后开始，每2秒重复
    }
};