java常用类库

java常用类库

System类

这个类里面所有的方法都是静态的

数组拷贝

System.arraycopy(src,dest,srcindex,destindex, Length);

获得系统的全部属性

    System.getProperties().list(System.out);

获得系统的某一个属性

    System.getProperty("user.dir");//当前目录，还有很多其他的属性，可以在上面的获得系统全部属性那里面查看

exit(status) status非0就是退出

  System.exit(1);

垃圾回收

   这个方法就是封装了java.lang.Runtime.getRuntime().gc()二者的功能是一致的
   System.gc();
   在对象的生命周期救赎之后，系统会在一定时间的时候对对象进行垃圾处理，调用gc()方法就是立即回收垃圾

时间

   System.currentTimeMillis();
   获得1970.1.1到现在的毫秒数

类要想在回收之前做一些操作，可以重写Object里面的finalize方法，

//这个方法就是重写的Object里面的方法，当实例被回收的时候调用
@Override
protected void finalize() throws Throwable {
    super.finalize();
}

日期操作类

Date

    Date date=new Date();
    System.out.println(date);//格式不能自己决定

Calendar

    //Calendar 是一个接口
    Calendar cal=new GregorianCalendar();

    //get方法获得当前时间的一些域，这些域都在Calendar里面定义好了
    System.out.println(cal.get(Calendar.MONTH)+1);//这个是从0开始算的
    System.out.println(cal.get(Calendar.MILLISECOND));
    System.out.println(cal.get(Calendar.DAY_OF_MONTH));

可以比较方便的获得各个域的内容，但是要想获得具体时间就是需要字符串的拼接，比较麻烦

DateFormat

抽象类，用于对于Date数据的格式化，但是可以通过getDateInstance直接获得他的实例

    DateFormat df=DateFormat.getDateInstance();//获得日期实例
    DateFormat df1=DateFormat.getDateTimeInstance();//获得时间日期实例

SimpleDateFormat

    //就是DateFormat的子类，更加好用。就是有重复的前面的就是大写的，否则就是小写的。y-M-d-H-m-s-S
    SimpleDateFormat sf1=new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss-SS");
    SimpleDateFormat sf2=new SimpleDateFormat("yy-M-dd-HH-mm-ss");
    SimpleDateFormat sf3=new SimpleDateFormat("yyyyMMddHHmmssSS");
    System.out.println(sf1.format(new Date()));
    System.out.println(sf2.format(new Date()));
    System.out.println(sf3.format(new Date()));//获得时间戳

Math和random类

Math

Math类中的方法都是静态方法，直接使用“类.方法名称()”的形式调用即可

    System.out.println("求平方根：" + Math.sqrt(9.0)) ;
    System.out.println("求两数的最大值：" + Math.max(10,30)) ;
    System.out.println("求两数的最小值：" + Math.min(10,30)) ;
    System.out.println("2的3次方：" + Math.pow(2,3)) ;
    System.out.println("四舍五入：" + Math.round(33.6)) ;
   想要精确位数的四舍五入，要用BigDecimal

Random

    Random rd=new Random();
    System.out.println(rd.nextInt(100));//1-100之间的int
    System.out.println(rd.nextDouble()); //获得0-1之间的值
    System.out.println(rd.nextBoolean());

NumberFormat

NumberFormat

这个是可以根据区域的不一样来决定格式

    NumberFormat nf=NumberFormat.getInstance();
    System.out.println(nf.format(100000000));//100,000,000
    System.out.println(nf.format(100000.1234));//100,000.123

DecimalFormat

DecimalFormat是NumberFormat的子类，使用更加灵活

   //模板详情
    /*
    0  - 数字不存在时补足0
    #  - 数字不存在时忽略
    。 - ，
    E
    可以加上必要的货币单位 ￥ $
    %       - 以百分号显示
    u2030  -千分数显示
    * */

    DecimalFormat df=new DecimalFormat("u2030");
    System.out.println(df.format(1167));

    df=new DecimalFormat("###,###.###￥");
    System.out.println(df.format(111222.34567));

大数操作

//BigInteger 和BigDecimal都是不可变的，在进行每一步运算时，都会产生一个新的对象，由于创建对象会引起开销，所以它们不适合于大量的数学计算，应尽量使用long、float、double等基本类型做科学计算或者工程计算。

BigInteger 操作整形

    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 操作小数

    BigDecimal bd1=new BigDecimal("123213.12123");
    BigDecimal bd2=new BigDecimal("1233");
    System.out.println("bd2"+bd1.divide(bd2));

    double d=bd1.doubleValue();  //获得他的double值

    double dd=bd1.divide(bd2,2,BigDecimal.ROUND_HALF_UP).doubleValue();
    //保留两位小数四舍五入，这就是精确位数的四舍五入的方法
    System.out.println(dd);

注意divide的时候如果结果是循环的就会报错，最好显式的控制小数点

java 克隆技术

被克隆的类必须实现cloneable方法，覆盖父类的clone()方法

class toClone implements  Cloneable{
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

假设x是一个非空对象,应该有: x.clone()!=x 为true,就是说他们不是同一个对象. x.clone().getClass()==x.getClass() 为true,他们是同一个类型Class. x.equals(x.clone()) 为true,逻辑上应该相当.

Arrays

    int temp[]={5,12,4,21,46,3,1,85,3,6,1,5,31};

判断是不是相等

    System.out.println(Arrays.equals(temp,temp1));

排序

    Arrays.sort(temp);

直接将数组内容转换

    System.out.println(Arrays.toString(temp));

二分查找，找到数字对应的位置。注意查找之前一定要先排序

    System.out.println(Arrays.binarySearch(temp,21));

填充数组

    Arrays.fill(temp,12);

比较器

对对象进行排序的时候，首先这个类必须是可以比较的！！ 有两种方法指定类的比较 1，实现Comparable接口 2, 新建一个实现了Compaprator接口的比较类

Comparable

接口要实现的方法是compareTo

class shuzi implements Comparable<shuzi>{
    int a;
    int b;
    public  shuzi(int a,int b){
        this.a=a;
        this.b=b;
    }
    //1-大于 0-等于 -1-小于
    @Override
    public int compareTo(shuzi o) {
        if(this.a>o.a){
            return 1;
        }
        if(this.a<o.a){
            return  -1;
        }
        if(this.b>o.b){
            return 1;
        }
        if(this.b<o.b)
            return -1;
        return 0;
    }
}   
public static void main(String[] args) {
    shuzi s[]={new shuzi(1,2),new shuzi(1,3)};
     Arrays.sort(s);
}

比较器的原理上就是一个二叉排序的算法，之后按照中序遍历给出结果,下面手写代码来实现这个内容。

class TreeSort{

    class Node{
        //内部类，指定树节点 
        Comparable data;
        Node left;
        Node right;
        public Node(Comparable data){
            this.data=data;
        }
        public void  addNode(Node node){
            if(node.data.compareTo(data)<0){
                if(left==null){
                    left=node;
                }
                else
                    left.addNode(node);
            }
            else
                if(right==null){
                    right=node;
                }
                else
                    right.addNode(node);
        }
    }
    Node rootNode;
    public void add(Comparable data){
        Node newNode=new Node(data);
        if(rootNode==null) {
            rootNode = newNode;
        }
        else
            rootNode.addNode(newNode);

    }

    public void SearchTree(){
        search(rootNode);
    }
    private void search(Node node){
        if (node==null) return;
        search(node.left);
        System.out.println(((shuzi)node.data).a+" "+((shuzi)node.data).b);
        search(node.right);
    }
}

Comparator

一般情况下使用Comparable最好，但是如果你的累原来没有实现该接口，也不方便修改，那么可以选择新建一个用于比较的类

class myComparator implements Comparator{
    @Override
    public int compare(Object o1, Object o2) {
        return 0;
    }
}
调用的时候，可以在sort指定比较器
shuzi s[]={new shuzi(1,2),new shuzi(1,3)};
Arrays.sort(s,new myComparator());

观察者模式

被观察的类继承Observable
观察者实现接口Observer 主要的作用是在被观察的对象发生一些变化的时候，可以通知所有的观察者，观察者就可以做出相应的回应

class obserable_Objrct extends Observable{
    int x;
    int y;

    public void setX(int x) {
        //只有在setChange()被调用后，notifyObservers()才会去调用update()
        super.setChanged();  //在这里设置观察点.当有变化的时候会通知他的观察者
        notifyObservers(x);//可以增加参数，在观察者update里面根据参数来判断要做的处理是一种常见的方法 
        this.x = x;
    }
    public void setY(int y) {
        super.setChanged();  //在这里设置观察点.当有变化的时候会通知他的观察者
        notifyObservers();
        this.y = y;
    }
}
class Observer_Object implements Observer{

    @Override
    public void update(Observable o, Object arg) {
        //o调用Observable的toString方法，告诉你是那个类发生的变化
        //arg是notifyObservers(data)告诉你的数据，无参数的时候就是null
        System.out.println(o);
        System.out.println(arg);
    }
}

public class _观察者模式 {
    public static void main(String[] args) {
        obserable_Objrct oO=new  obserable_Objrct();
        oO.addObserver(new Observer_Object());//添加一个观察者
        oO.setX(121);
        oO.setY(121);
    }
}

正则表达式

常见的正则表达式的语法

no	规范	描述
1		表示‘’
2		制表
3		回车
４	[abc]	符a或b或c
5	[^abc]	取非
6	[a-zA-Z0-9]	字母数字组成的一个字符
7	d	表示数字
8	D	表示非数字
9	w	表示字母数字下划线
10	W	表示非字母数字下划线
11	s	空白字符
12	S	非空白字符
13	^	行的开头
14	$	行的结尾
15	.	除了换行符以外的任意字符

数量的表示

No	规范	描述
0	X	必须出现一次
1	X?	出现0或1次
2	X*	出现0、1、多次
3	X+	出现1或多次
4	X{n}	出现n次
5	X{n,}	出现n或更多次
6	X{m,n}	出现m-n次

逻辑运算

规范	描述
XY	X后面跟上Y
X|Y	X或者Y

关键的类的是Pattern-用来指定编译正则 Matcher-用来匹配

    String str="2012-12-23";
    String pat="\d{4}-\d{2}-\d{2}";  //  \表示一个
    Pattern pattern=Pattern.compile(pat);  //先编译一下正则表达式
    Matcher matcher=pattern.matcher(str);

    while(matcher.find()){
        //查找匹配    
    }

    if(matcher.matches()){
        System.out.println("匹配成功");
    }

    String res[]=Pattern.compile("-").split(str);
    for (int i = 0; i < res.length; i++) {
        System.out.println(res[i]);
    }

String中对于正则表达式有很多的支持，因此在很多时候，你并不需要使用上面的两个类了

matches - replaceAll - split 注意相关操作之后String本身没有变化

    //一定要注意转义，比如 | -->\| 一个是字符串的，一个是正则表达式的转义
    String string="qweooqeo-1231-33213=++waqend-213";
    System.out.println(string.matches("-\d{4}"));
    System.out.println(string.replaceAll("-\d{2}","+++"));//返回替换后的字符串
    String res1[]= string.split("-");
    for (int i = 0; i < res1.length; i++) {
        System.out.println(res1[i]);
    }

计时器操作

对于每一个Timer，相当于启动了一个新的线程，做定时处理，既然是线程，就不可避免的有延迟
Timer是计时器，TimerTask是要分配的任务，要重写这个抽象类中的抽象方法Mytimertask

class Mytimertask extends TimerTask{
    @Override
    public void run() {
        SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd hh-mm-ss");
        System.out.println(df.format(new Date()));
    }
}
public class _计时器 {

    public static void main(String[] args) {
        //对于每一个Timer，相当于启动了一个新的线程，做定时处理，既然是线程，就不可避免的有延迟
        Timer timer=new Timer();
        timer.scheduleAtFixedRate(new Mytimertask(),1000,100);//如果中间发生了延迟，会调整间隔，尽量满足预期执行的时间
        timer.schedule(new Mytimertask(),1000);//延迟不考虑了，还是按照规定秒数间隔等待下一个操作
        timer.schedule(new Mytimertask(),1000,1000);
        //取消计时器
        timer.cancel();
    }
}