Java常用类（持续更新）

原创

二月二日 2022-01-18 14:00:44 博主文章分类：储备知识 ©著作权

文章标签 数组外部类 java Java 文章分类 OpenStack 云计算

©著作权归作者所有：来自51CTO博客作者二月二日的原创作品，请联系作者获取转载授权，否则将追究法律责任

Java常用类

内部类

在一个类的内部在定义一个完整的类

特点：1.编译之后可以产生独立的字节码文件

2.可以调用外部类的私有属性，不破坏类的封装性

3.可以为外部类提供必要的内部组件

成员内部类

public class Main{
    public static void main(String[] args){
        A.B s = new A().new B();
        s.in();	//内部类最重要特点，可以调用外部类的私有属性
    }
}
public class A{
    private int id = 10;
    public void say(){
        System.out.println("hi");
    }
    class B{
        public void in(){
            System.out.println("in");
            System.out.println(id);
        }
    }
}

静态内部类

不依赖外部类，使用与外部类无异，可以直接使用

特点：1.仍然可以调用外部类的私有属性，但需要将外部类实例化再调用

2.在调用时，实例化与正常内部类不同

正常：A.B s =new A().new B();
静态内部类: A.B s = new A.B(); 表示包含关系

public class Main{
    public static void main(String[] args){
        A.B s = new A.B();
        s.in();	//内部类最重要特点，可以调用外部类的私有属性
    }
}
public class A{
    private int id = 10;
    public void say(){
        System.out.println("hi");
    }
    static class B{	//与外部类相同
        static int s = 100;
        public void in(){
            System.out.println("in");
            A a = new A();
            System.out.println(a.id);	
        }
    }
}

局部内部类

1.只能在类中的方法定义和调用

2.调用方法的局部变量时，1.8之后默认会为变量加上final修饰符

3.局部内部类不能有任何修饰符

public class Main{
    public static void main(String[] args){
        A s = new A();
        s.say();	//
    }
}
public class A{
    private int id = 10;
    public void say(){
        String name = "chenchenchen"
        class B{
            public void hehe(){
            	System.out.println(id);	//id == A.this.id
            	System.out.println(name);
            }
        }
        System.out.println("hi");
        B b = new B();
        b.hehe();
    }
}

匿名内部类

1.没有类名的局部内部类（一切特征与局部内部类相同）

2.必须继承一个父类或者在一个接口中实现

3.定义类、实现类、创建对象的语法合并，只能创建一个该类的对象

public class Main{
    public static void main(String[] args){
        Usb s = new Test();
        s.serive;
        Usb usb = new Usb(){
             public static void serive(){
        			System.out.println("123");	//不用重写一个输出123的类
    		};//正常的接口不能直接实例化，可以使用匿名内部类优化（相当于创建了一个局部内部类）
        }
    }
}
public interface Usb{
    void serive();
}
class Test implements Usb{
    String name = "chenchenchen";
    int id = 10;
    public static void serive(){
        System.out.println("Test");
    }
}

Object类

1.基类，所有类的父类

2.默认继承object类

3.object中定义的方法全部可以直接使用

4.object作为参数，可以储存任何对象，作为返回值，可以返回任何对象

getClass()方法

返回引用中存储的实际对象类型，通常用于判断两个引用中存储的对象类型是否相同

public class Person {
	 int id;
	private String name;
	public Person(int id, String name) {
		super();
		this.id = id;
		this.name = name;
	}

public class Test {
 
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Person p = new Person(1,"zdb");
		System.out.println(p.getClass());
		System.out.println(p.getClass().getName());
		System.out.println(p.getClass().getSimpleName());
		System.out.println(p.id);
	}
 
//运行结果
    
class 基础语法.Person
基础语法.Person
Person
1

hashCode()方法

返回对象的哈希值码

当对象相等时，hashCode返回值也是相同的

class Main {
    public static void main(String[] args) {
 
        // Object 使用 hashCode()
        Object obj1 = new Object();
        System.out.println(obj1.hashCode()); 
 
        Object obj2 = new Object();
        System.out.println(obj2.hashCode());
 
        Object obj3 = new Object();
        System.out.println(obj3.hashCode()); 
    }
}

clone

创建并返回一个对象的拷贝

需要重写

public class Main{
        String name;
        int id;
    public static void main(String[] args){
        Main a = new Main();
        a.name = "陈琛琛";
        a.id = 100;

        try {
         Main b = (Main) a.clone();
         System.out.println(b.name+"is "+b.id);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

    }
}//报错

equals（）

比较对象是否相等，返回值类型为布尔型

xx.equals(xx)

public class Main{
    public static void main(String[] args){
        String s1 = new String();
		String s2 = new String();
        System.out.pritln(s1.equals(s2));//true 初始化都为空
    }
}

finalize()

程序员一般不调用，当对象被判定为垃圾对象时，由JVM自动调用此方法

垃圾对象：没有有效引用指向此对象

垃圾回收，由GC销毁垃圾对象，释放数据存储空间

自动回收：JVM的内存耗尽，一次性回收所有对象

手动回收：使用System.gc();通知JVM回收，是否回收由JVM判断

public class Main{
    public static void main(String[] args){
        new Student("aaa");
        new Student("bbb");
        new Student("ccc");
        new Student("ddd");
        new Student("eee");
        System.gc();
        System.out.println("回收成功")
    }
}
class Student{
    String name;
    public Student(String name){
        this.name = name;
    }
    protected void finalize() throws Throwable{
        System.out.println(this.name+"对象被回收了")
    }
}

toString()

打印输出数组

public class Main{
    public static void main(String[] args){
        int[] a={1,5,456,12,566,12,3};
        System.out.println(a);//得到的是一个哈希数
        System.out.println(Arrays.toString(a));//输出数组a
    }
    public static void printArray(int [] array){//自己写一个与toString相似的方法
        for(int i =0;i<array.length;i++){
            if(i==0){
                System.out.println("["+array[i]+",")
            }else if(i==array.length-1){
                System.out.println(array[i]+"]")
            }else
            System.out.println(array[i]+",")
        }
    }
}

Arrays类

该类包包含用于操作数组的各种方法（如排序和搜索），此外包括一些静态方法，可以直接调用

toString()

打印输出数组

public class Main{
    public static void main(String[] args){
        int[] a={1,5,456,12,566,12,3};
        System.out.println(a);//得到的是一个哈希数
        System.out.println(Arrays.toString(a));//输出数组a
    }
    public static void printArray(int [] array){//自己写一个与toString相似的方法
        for(int i =0;i<array.length;i++){
            if(i==0){
                System.out.println("["+array[i]+",")
            }else if(i==array.length-1){
                System.out.println(array[i]+"]")
            }else
            System.out.println(array[i]+",")
        }
    }
}

sort()

对数组进行排序，默认为升序

public class Main{
    public static void main(String[] args){
        int[] a={1,5,456,12,566,12,3};
        System.out.println(Arrays.sort(a));//输出从小到大的数组
    }
}

fill()

填充数组

public class Main{
    public static void main(String[] args){
        int[] a= new in[10];
        Array.fill(a,0);	//将数组全部填充为0
        Array.fill(a,2,4,0);	//将第二到第四个元素填充为0
    }
}

剩余可查看jdk文档

包装类

基本数据类型所对应的引用数据类型，默认值为null 博客

特点：基本类型数据存放在栈中，变成引用类型后，栈中存放的是引用，数据存放在堆中

优点：变成引用类型后，可以使用一些方法对其进行处理

Java常用类（持续更新）_java

装箱：将基本类型转换为引用类型

public class Main{
    public static void main(String[] args){
        int num = 10;
        Integer a = new Integer(num);
        Integer b = Integer.valueOf(num)
    }
}

拆箱：将引用类型转换为基本类型

public class Main{
    public static void main(String[] args){
        int num = 10;
        Integer a = new Integer(num);
        int b = a.intValue();
    }
}

s.xxValue()

以xx形式返回指定的数值s

注意点

public class Main{
    public static void main(String[] args){
        Integer a = new Integer(100);
        Integer b = new Integer(100);
        System.out.println(a==b);	//false
        //new 是创建新的对象，a和b引用指向堆中不同的地址
        Integer c = 100;
        Integer d = 100;
        System.out.println(c==d);	//true
        //此时c d引用指向同一个地址，返回的是IntegerCache数组，当超过范围时，返回的是对象地址，则会出错
        Integer e = 200;
        Integer f = 200;
        System.out.println(e==f);	//false
        //因为堆中存放了一个-128-127的IntegerCache数组，直接赋值则先在里面找
    }
}

JDK8以后自动拆箱和装箱

基本类型与字符串之间的转换

使用加号
使用integer中的toString方法

使用integer中的parsexxx转换为字符串

注意点：当布尔型转换为字符串时，非true均为false

public class Main{
    public static void main(String[] args){
        int num = 15;
        String s = num + "";
        String s1 = Integer.toString(num);
        
        String s2 = "150";
        int num1 = Integer.parseInt(s2);       
    }
}

String类

Java程序中所有的字符串文本都是String类的实例

创建方式

字面量赋值

public class Main{
    public static void main(String[] args){
        String name = "zhangsan";
        //name是zhangsan的地址存放在栈中，在方法区中开辟一个常量池，存放zhangsan
        name = "hi";
        //重新开辟一个空间存放hi，name的地址改变
        name2 = "zhangsan"
        //不开辟新空间，而是指向之前的张三
    }
}

使用new创建

public class Main{
    public static void main(String[] args){
        String s = new String("haha");
        //将“haha”作为char数组存放到方法区中，在堆中存放数组地址，s存放的是堆中存放数组地址的变量的地址
        String s1 = new String("haha");
        System.out.println(s==s1);	//false
        //s s1中存放的是变量，每次创建都会在堆中开辟一个新的空间存放指向haha这个数组的地址
        System.out.println(s.equals(s1));	//true
        //此时比较的是数值
    }
}

常用方法

legtn()

返回字符串长度

charAt(int index)

返回某个位置的字符

contains(String str)

判断是否包含某个子字符串

public class Main{
    public static void main(String[] args){
        String s1 = "wwww123";
        String s2 = "123";
        System.out.println(s1.contains(s2));
    }
}

toCharArray()

将字符串转换成数组

public class Main{
    public static void main(String[] args){
        String s1 = "wwww123";
        System.out.println(Array.toString(s1.toCharArray()));
    }
}

indexOf lastIndexOf

返回字符串首次出现的位置

public class Main{
    public static void main(String[] args){
        String s1 = "wwww123";
        System.out.println(s1.indexOf("w"));
    }
}

trim()

去掉字符串空格,只能去掉前后空格

public class Main{
    public static void main(String[] args){
        String s1 = "  wwww   123  ";
        System.out.println(s1.trim());
    }
}

replace(new str,old str)

用新的字符或者字符串替换旧的字符或者字符串

public class Main{
    public static void main(String[] args){
        String s1 = "wwww123";
        System.out.println(s1.replace("123","456"));
    }
}

split()

拆分字符串

扩展

1.split("[ ,]"),此时遇到空格或者逗号就会拆分

2.split("[ ,]+")此时遇到多个空格或者多个逗号也会拆分

public class Main{
    public static void main(String[] args){
        String s1 = "www.w12.3";
        String[] s = s1.split(".")
        System.out.println(s1.indexOf("w"));
    }
}

compareTo

比较字典大小

public class Main{
    public static void main(String[] args){
        String s1 = "abc";	//a为97
        String s2 = "xyz";	//x为120
        System.out.println(s1.compareTo(s2));	//-23
        String s3 = "abc";	//a为97
        String s4 = "abcxyz";	//x为120
        System.out.println(s3.compareTo(s4));	//-3
        //比较完位置之后就比较长度
    }
}

案例

public class Main{
    public static void main(String[] args){
        String s1 = "this is a text";
        System.out.println(s1.split(" "));
        System.out.println(s1.replace("text","haha"));
        System.out.println(s1.replace(" text","easy text"));
    }
}

可变字符串

区别

1.效率比String高

public class Main{
    public static void main(String[] args){
        long start = System.currentTimeMillis();
        String s = "";
        for (int i = 0; i <99999 ; i++) {
            s+=i;
        }
        long end = System.currentTimeMillis();
        System.out.println("String用时："+(end-start));
        long start1 = System.currentTimeMillis();
        StringBuffer s1 = new StringBuffer();
        for (int i = 0; i <99999 ; i++) {
            s1.append(i);
        }
        long end1 = System.currentTimeMillis();
        System.out.println("StringBuffer用时："+(end1-start1));
    }
}

2.比String节省内存

StringBuffer

运行效率慢，线程安全

StringBuilder

运行效率快，线程不安全

常用方法

append

public class Main{
    public static void main(String[] args){
        StringBuffer s = new StringBuffer();
        System.out.println(s.append("hello"));
    }
}

insert()

在某个位置添加

public class Main{
    public static void main(String[] args){
        StringBuffer s = new StringBuffer();
        System.out.println(s.append("hello"));
        System.out.println(s.insert(5," world"));
    }
}

replace

public class Main{
    public static void main(String[] args){
        StringBuffer s = new StringBuffer();
        System.out.println(s.append("hello"));
        System.out.println(s.insert(5," world"));
        System.out.println(s.replace(0,5,"he"));
    }
}

delete

public class Main{
    public static void main(String[] args){
        StringBuffer s = new StringBuffer();
        System.out.println(s.append("hello"));
        System.out.println(s.insert(5," world"));
        System.out.println(s.replace(0,5,"he"));
        System.out.println(s.delete(0,s.length()));
    }
}

BigDecimal类

浮点数类型的数据是相对精确的数据，进行运算时，会出现精度丢失问题

此时BigDecimal就出现了，用于大的浮点数精确计算

import java.math.BigDecimal;

public class Main{
    public static void main(String[] args){
        double a = 1.0;
        double b = 0.9;
        System.out.println(a-b);
        BigDecimal c = new BigDecimal("1.0");	//使用ab时，输出结果将为更高精度的浮点数，而不是0.1
        BigDecimal d = new BigDecimal("0.9");
        BigDecimal e = c.subtract(d);
        BigDecimal f = c.subtract(d);
        System.out.println(e);
    }
}

注意点：

使用除法时，主要写舍入模式

c.divide(d,2,BigDecimal.ROUND_HALF_UP)	//四舍五入

Date

Date表示特定的瞬间，精确到毫秒，现大部分被Calendar类中的方法所取代

import java.math.BigDecimal;
import java.util.Date;

public class Main{
    public static void main(String[] args){
        Date a = new Date();        //获取时间
        System.out.println(a);
        Date b = new Date(a.getTime()-(60*60*24*1000));     //getTime 从1970到现在的毫秒数
        System.out.println(b);
        boolean c = a.after(b);
        System.out.println(c);

        int d = a.compareTo(b);
        System.out.println(d);  //a>b d=1,  a<b d=-1
    }
}

Calendar

Canlendar提供了获取或者设置各种日历字段的方法

该类的修饰符为protected 所以无法直接创建该对象

import java.math.BigDecimal;
import java.util.Calendar;
import java.util.Date;

public class Main{
    public static void main(String[] args){
        Calendar a = Calendar.getInstance();        //获取指定时间
        System.out.println(a.getTime().toLocaleString());
        System.out.println(a.getTimeInMillis());

        int year = a.get(Calendar.YEAR);            //获取想要的时间数据
        int month = a.get(Calendar.MONTH);
        int day = a.get(Calendar.DAY_OF_MONTH);
        System.out.println(year+" "+(month+1)+" "+day);

        Calendar b = Calendar.getInstance();
        b.set(Calendar.DAY_OF_MONTH,12);            //通过set改变时间，如年月日
        System.out.println(b.getTime().toLocaleString());

        b.add(Calendar.HOUR,-1);            //通过add改变时间，当前为减少一个小时
        System.out.println(b.getTime().toLocaleString());

        int max = b.getActualMaximum(Calendar.DAY_OF_MONTH);    //获取年月日的最大值
        int min = b.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max+" "+min);
    }
}

SimpleDateFormat

将日期数据在文本与日期间转换

步骤：

创建对象
创建Date
格式化、

import java.text.SimpleDateFormat;
import java.util.Date;
public class Main {
    public static void main(String[] args) throws Exception {
        SimpleDateFormat myFmt = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        SimpleDateFormat myFmt1 = new SimpleDateFormat("yy/MM/dd HH:mm");
        SimpleDateFormat myFmt2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//等价于now.toLocaleString()
        SimpleDateFormat myFmt3 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 E ");
        SimpleDateFormat myFmt4 = new SimpleDateFormat("一年中的第 D 天 一年中第w个星期 一月中第W个星期 在一天中k时 z时区");
        Date now = new Date();
        System.out.println(myFmt.format(now));
        System.out.println(myFmt1.format(now));
        System.out.println(myFmt2.format(now));
        System.out.println(myFmt3.format(now));
        System.out.println(myFmt4.format(now));
        System.out.println(now.toGMTString());
        System.out.println(now.toLocaleString());
        System.out.println(now.toString());

        Date first = myFmt.parse("2020/12/12");
        System.out.println(first);
    }
}

System类

系统类，用于获取一些系统的属性数据和其他操作

arraycopy

复制数组

System.arraycopy(原数组，开始位置，目标数组，目标数组开始位置，复制长度)

System.currentTimeMillis();

系统此刻时间，一般用于计算运行时间

public class Main{
    public static void main(String[] args){
        long start = System.currentTimeMillis();
        String s = "";
        for (int i = 0; i <99999 ; i++) {
            s+=i;
        }
        long end = System.currentTimeMillis();
        System.out.println("String用时："+(end-start));
        long start1 = System.currentTimeMillis();
        StringBuffer s1 = new StringBuffer();
        for (int i = 0; i <99999 ; i++) {
            s1.append(i);
        }
        long end1 = System.currentTimeMillis();
        System.out.println("StringBuffer用时："+(end1-start1));
    }
}