java常用类库

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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 \t 制表
3 \n 回车
[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();
    }
}

 



以上是关于java常用类库的主要内容,如果未能解决你的问题,请参考以下文章

java常用第三方类库

java常用类库

Java基础类库简介

Java程序员常用工具类库 - 目录

推荐一个强大的Java开发工具类库!

JAVA的常用的类库都有哪些?