java常用库_java常用类库

最新推荐文章于 2023-06-30 23:33:06 发布

weixin_39697096

最新推荐文章于 2023-06-30 23:33:06 发布

阅读量69

点赞数

文章标签： java常用库

本文链接：https://blog.csdn.net/weixin_39697096/article/details/114478559

版权

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 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

# - 数字不存在时忽略

。 - ，

可以加上必要的货币单位￥ $

% - 以百分号显示

\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{

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

return -1;

}

if(this.b>o.b){

return 1;

}

if(this.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规范描述

表示‘\’

制表

回车

４

[abc]

符a或b或c

[^abc]

取非

[a-zA-Z0-9]

字母数字组成的一个字符

表示数字

表示非数字

表示字母数字下划线

表示非字母数字下划线

空白字符

非空白字符

行的开头

行的结尾

除了换行符以外的任意字符

数量的表示

No规范描述

必须出现一次

出现0或1次

出现0、1、多次

X+

出现1或多次

X{n}

出现n次

X{n,}

出现n或更多次

X{m,n}

出现m-n次

逻辑运算

规范描述

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();

}

weixin_39697096

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java常用库_java常用类库

java常用类库System类这个类里面所有的方法都是静态的数组拷贝System.arraycopy(src,dest,srcindex,destindex, Length);获得系统的全部属性System.getProperties().list(System.out);获得系统的某一个属性System.getProperty("user.dir");//当前目录，还有很多其他的属性，可以在上面...
复制链接

扫一扫