常用类

2022/5/4 23:15:28

编程Tag： string 常用 Java out system public println

本文主要是介绍常用类，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

Object类

超类、基类，所有类的直接或间接父类，位于继承树的最顶层。
任何类，如没有书写extends显示继承某个类，都默认直接继承0bject类，
否则为间接继承。
Object类中所定义的方法，是所有对象都具备的方法。
Object类型可以存储任何对象。
- 作为参数，可接受任何对象。
- 作为返回值，可返回任何对象。

getClass()方法

public final Class<?>getClass(){}
返回引用中存储的实际对象类型。

应用：通常用于判断两个引用中实际存储对象类型是否一致。

Student.java

package com.cclass.demo05;

public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student(){

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

TestStudent.java

package com.cclass.demo05;

public class TestStudent {
    public static void main(String[] args) {
        //getClass方法
        Student s1 = new Student("abc",20);
        Student s2 = new Student("zxc",29);
        //判断s1和s2是不是同一个类型
        Class<? extends Student> aClass = s1.getClass();
        Class<? extends Student> aClass1 = s2.getClass();
        if (aClass==aClass1){
            System.out.println("s1和s2属于同一个类型");
        }else {
            System.out.println("s1和s2不属于同一个类型");
        }
		//s1和s2属于同一个类型
    }
}

hashCode()方法

public int hashCode(){}
返回该对象的哈希码值。
哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值。
一般情况下相同对象返回相同哈希码。

toString()方法

public String toString(){}
返回该对象的字符串表示（表现形式）
可以根据程序需求覆盖该方法，如：展示对象各个属性值。

equals()方法

public boolean equals(Object obj){}
默认实现为（this == obj），比较两个对象地址是否相同。
可进行覆盖，比较两个对象的内容是否相同。

equals()方法覆盖步骤

比较两个引用是否指向同一个对象。
判断obj是否为null。
判断两个引用指向的实际对象是否一致。
强制类型转换。

依次比较各个属性值是否相同。

public boolean equals (Object obj){
    //1.比较两个引用是否指向同一个对象
    if (this==obj){
        return true;
    }
    //2.判断obj是否为null
    if (obj==null){
        return false;
    }
    //3.判断是否是t同一个类型
    //instanceof 可判断对象是否是某种类型
    if (obj instanceof Student){
        //4.强制类型转换
        Student s = (Student)obj;
        //5.比较属性
        if (this.name.equals(s.getName())&&this.age==s.getAge()){
            return true;
    }
    return false;
}

finalize()方法

当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，
进入回收队列。
垃圾对象：没有有效引用指向此对象时，为垃圾对象。
垃圾回收：由GC销毁垃圾对象，释放数据存储空间。
自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象。
手动回收机制：使用System.gc();通知JVM执行垃圾回收。

包装类

什么是包装类？

基本数据类型所对应的引用数据类型。
Object可统一所有数据，包装类的默认值是null。
包装类对应

8种包装类提供不同类型间的转换方式：

Number父类种提供的6个共性方法。
parseXXX()静态方法。
valueof()静态方法。
注意：需保证类型兼容，否则抛出NumberFormatException异常。

类型转换与装箱、拆箱

装箱：将栈里的基本类型转为堆里的对象基本类型 ----> 引用类型

Integer.valueOf(num1);

拆箱：将堆里的对象拿到栈里引用类型 ----> 基本类型

integer3.intValue();

Demo01.java

package com.cclass.demo06;

public class Demo01 {
    public static void main(String[] args) {
        //类型转换：装箱，基本类型转成引用类型的过程
        //基本类型
        int num1 = 18;
        //使用Integer类创建对象
        Integer integer1 = new Integer(num1);
        Integer integer2 = Integer.valueOf(num1);
        System.out.println("装箱");
        System.out.println(integer1);
        System.out.println(integer2);


        //类型转换：拆箱，引用类型转成基本类型
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();
        System.out.println("拆箱");
        System.out.println(num2);
        //以上方式在jdk1.5之前使用

        //jdk1.5之后，提供了自动装箱和拆箱
        int age = 30;
        //自动装箱
        Integer integer4 = age;
        System.out.println("自动装箱");
        System.out.println(integer4);
        //自动拆箱
        int age2 = integer4;
        System.out.println("自动拆箱");
        System.out.println(age2);


    }
}

反编译对比代码

Demo01.class

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.cclass.demo06;

public class Demo01 {
    public Demo01() {
    }

    public static void main(String[] args) {
        int num1 = 18;
        Integer integer1 = new Integer(num1);
        Integer integer2 = Integer.valueOf(num1);
        System.out.println("装箱");
        System.out.println(integer1);
        System.out.println(integer2);
        
        Integer integer3 = new Integer(100);
        int num2 = integer3;
        System.out.println("拆箱");
        System.out.println(num2);
        
        int age = 30;
        
        Integer integer4 = Integer.valueOf(age);
        System.out.println("自动装箱");
        System.out.println(integer4);
        
        int age2 = integer4;
        System.out.println("自动拆箱");
        System.out.println(age2);
    }
}

基本类型和字符串转换

parseXXX()静态方法

package com.cclass.demo06;

public class Demo01 {
    public static void main(String[] args) {
        //基本类型和字符串之间转换
        //1.基本类型转成字符串
        int n1 = 100;
        //1.1使用+号
        String s1 = n1+"";
        //1.2使用Integer中的toString()方法
        String s2 = Integer.toString(n1);//radix进制
        System.out.println(s1);//100
        System.out.println(s2);//100

        //2.字符串转成基本类型
        String str = "150";
        //使用Integer.parseXXX();
        int n2 = Integer.parseInt(str);
        System.out.println(n2);//150

        //boolean字符串形式转成基本类型，"true" ---> true  非"true" ---> false
        String str2 = "true";//treu ---> false
        boolean b1 = Boolean.parseBoolean(str2);
        System.out.println(b1);//true
    }
}

Integer缓冲区

整数缓冲区

Java预先创建了256个常用的整数包装类型对象。

在实际应用当中，对已创建的对象进行复用。

package com.cclass.demo06;

public class Demo02 {
    public static void main(String[] args) {
        //面试题
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1==integer2);//引用类型变量integer1、integer2在栈中，
                                              // 对应100、100在堆中，地址不同，所以为false
        Integer integer3=Integer.valueOf(100);//自动装箱Integer integer3=100
        Integer integer4=Integer.valueOf(100);//查看valueof源码，整数缓冲区i落在-127~127之间，地址相同
        System.out.println(integer3==integer4);//true

        Integer integer5=Integer.valueOf(200);//自动装箱Integer integer5=200
        Integer integer6=Integer.valueOf(200);//200超过范围，会new Integer(i),地址不同
        System.out.println(integer5==integer6);//false

    }
}

String概述

字符串是常量，创建之后不可改变。
字符串字面值存储在字符串池中，可以共享。
String s = "Hello";产生一个对象，字符串池中存储。

String s = new String("Hello");//产生两个对象，堆、池各存储一个

package com.cclass.demo06;

public class Demo03 {
    public static void main(String[] args) {
        String name = "大白很白";//"大白很白”常量存储在字符串池中
        name="kazesan";//"kazesan"赋值给name，给字符串赋值时，并没有修改数据，而是重新开辟一个空间
        String name2 = "kazesan";

        //演示字符串的另一种创建方式，new String();
        String str=new String("java");
        String str2=new String("java");
        System.out.println(str==str2);//false
        System.out.println(str.equals(str2));//true

    }
}

常用方法

public int length():返回字符串的长度。
public char charAt(int index):根据下标获取字符。
public boolean contains(String str):判断当前字符串中是否包含str。

package com.cclass.demo06;

public class Demo03 {
    public static void main(String[] args) {
        //字符串方法的使用
        //1. length();返回字符串的长度
        //2. charAt(int index);返回某个位置的字符,下标从0开始
        //3. contain(String str);判断是否包含这个字符串

        String content="java是世界上最好的编程语言";
        System.out.println(content.length());//15
        System.out.println(content.charAt(content.length()-1));//言
        System.out.println(content.contains("java"));//true
        System.out.println(content.contains("php"));//false
    }
}

public char[] toCharArray():将字符串转换成数组。
public int indexOf(String str):查找str首次出现的下标，存在，则返回该下标，不存在，则返回-1。

public int lastIndexOf(String str):查找字符串在当前字符串中最后一次出现的下标索引。

package com.cclass.demo06;

import java.util.Arrays;

public class Demo03{
    public static void main(String[] args){
        String content="java是世界上java最好的编程语言,java牛逼";
        //字符串方法的使用
        //4.toCharArray();返回字符串对应的数组
        //5.indexOf();返回字符串首次出现的位置
        //6.lastIndexOf();返回字符串最后一次出现的位置
        System.out.println(Arrays.toString(content.toCharArray()));
        System.out.println(content.indexOf("java"));
        System.out.println(content.indexOf("java",4));
        System.out.println(content.lastIndexOf("java"));
        /*
        [j, a, v, a, 是, 世, 界, 上, j, a, v, a, 最, 好, 的, 编, 程, 语, 言, ,, j, a, v, a, 牛, 逼]
		0
		8
		20
        */
    }
}

public String trim():去掉字符串前后的空格。
public String toUpperCase():将小写转成大写。

public boolean endWith(String str):判断字符串是否以Str结尾。

package com.cclass.demo06;
public class Demo03{
    public static void main(String[] args){
        //7.trim();去掉字符串前后的空格
        //8.toUpperCase;//把小写转换成大写。toLowerCase();把大写转成小写
        //9.endWith(str);判断是否以str结尾，startWith(str);判断是否以str开头

        String content2 = "  hello,world  ";
        System.out.println(content2.trim());//hello,world
        System.out.println(content2.toUpperCase());//HELLO,WORLD
        System.out.println(content2.toLowerCase());//hello,world

        String filename = "hello.java";
        System.out.println(filename.endsWith(".java"));//true
        System.out.println(filename.startsWith("hello"));//true
    }
}

public String replace(char oldChar, char newChar):将旧字符串替换成新字符串

public String[] split(String str):根据str做拆分。

package com.cclass.demo06;
public class Demo03{
     public static void main(String[] args){
         //10.replace(char oldChar, char newCha); 用新的字符或字符串替换旧的字符或字符串
        //11.split();对字符串进行拆分

        System.out.println(content.replace("java","php"));

        String say = "java is the best programing language,java xiang";
        String[] arr = say.split("[ ,]+");//[]表示选择，+表示出现一个或多个
        System.out.println(arr.length);
        for(String String : arr){
            System.out.println(String);
        }

        System.out.println("------------------------------------------");
        //补充两个方法equals、compareTo();比较大小 编码表里的位置
        String s1 = "hello";
        String s2 = "HELLO";
        System.out.println(s1.equals(s2));//false
        System.out.println(s1.equalsIgnoreCase(s2));//true,忽略大小写的比较

        String s3 = "abc";//a:97
        String s4 = "xyz";//x:120
        System.out.println(s3.compareTo(s4));//-23

        String s5 = "abc";
        String s6= "abcxyz";
        System.out.println(s5.compareTo(s6));//-3,比较长度
     }
}

String案例

需求：
- 已知String str = "this is a text";
- 1. 将str中的单词单独获取出来
  2. 将str中的text替换为practice
  3. 在text前面插入一个easy
  4. 将每个单词的首字母改为大写

package com.cclass.demo06;

/*
 已知String str = "this is a text";
  1. 将str中的单词单独获取出来
  2. 将str中的text替换为practice
  3. 在text前面插入一个easy
  4. 将每个单词的首字母改为大写
 */
public class demo04 {
    public static void main(String[] args){
        String str = "this is a text";
        // 1. 将str中的单词单独获取出来
        String[] arr=str.split(" ");
        System.out.println("---------- 1. 将str中的单词单独获取出来--------------");
        for (String s : arr){
            System.out.println(s);
        }
        //2. 将str中的text替换为practice
        System.out.println("---------- 2. 将str中的text替换为practice--------------");
        String str2=str.replace("text","practice");
        System.out.println(str2);
        //3. 在text前面插入一个easy
        System.out.println("---------- 3. 在text前面插入一个easy--------------");
        String str3=str.replace("text","easy text");
        System.out.println(str3);
        //4. 将每个单词的首字母改为大写
        System.out.println("---------- 4. 将每个单词的首字母改为大写--------------");
        for (int i=0;i<arr.length;i++){
            char first=arr[i].charAt(0);
            //把第一个字母转成大写
            char upperfirst=Character.toUpperCase(first);
            String news=upperfirst+arr[i].substring(1);//substring截取
            System.out.println(news);

        }
    }
}

可变字符串

StringBuffer：可变长字符串，JDK1.0提供，运行效果慢、线程安全。
StringBuilder：可变长字符串，JDK5.0提供，运行效率快、线程不安全。

package com.cclass.demo06;

/**
 * StringBuffer和StringBuilder的使用
 * 和String的区别 (1)效率比String高 (2)比String节省内存
 * @author 大白很白
 */
public class demo05 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();//或者StringBuilder sb = StringBuilder()
        //1.append();追加
        sb.append("java世界第一");//java世界第一
        System.out.println(sb.toString());
        sb.append("java真香");
        System.out.println(sb.toString());//java世界第一java真香
        sb.append("java不错");
        System.out.println(sb.toString());//java世界第一java真香java不错

        //2.insert();添加
        sb.insert(0,"我在最前面");
        System.out.println(sb.toString());//我在最前面java世界第一java真香java不错

        //3.replace();替换
        sb.replace(0,5,"hello");
        System.out.println(sb.toString());//hellojava世界第一java真香java不错

        //4.delete();删除
        sb.delete(0,5);
        System.out.println(sb.toString());//java世界第一java真香java不错

        //清空
        sb.delete(0,sb.length());
        System.out.println(sb.toString());//空白，sb.length();//0

    }
}

String和StringBuilder对比

package com.cclass.demo06;

/**
 *  验证StringBuilder效率高于String，也高于StringBuffer
 * @大白很白
 */
public class demo06 {
    public static void main(String[] args) {
        //开始时间
        long start = System.currentTimeMillis();
//       String string="";
//        for (int i=0;i<99999;i++){
//            string+=i;
//        }
//        System.out.println(string);
        StringBuilder sb=new StringBuilder();
        for (int i=0;i<99999;i++){
            sb.append(i);
        }
        //结束时间
        long end=System.currentTimeMillis();
        System.out.println("用时："+(end-start));//String用时：20386
                                                // StringBuilder用时：16

    }
}

BigDecimal的使用

位置：java.math包中。
作用：精确计算浮点数。
创建方式：BigDecimal bd=new BigDecimal("1.0");
方法：
- BigDecimal add(BigDecimal bd) 加
- BigDecimal subtract(BigDecimal bd) 减
- BigDecimal multiply(BigDecimal bd) 乘
- BigDecimal divide(BigDecimal bd) 除
进行除法运算时，如果不能准确的计算出结果时需要指定保留的位数和取舍方式。
除法：divide(BigDecimal bd,int scale,RoundingMode mode)
参数scale：指定精确到小数点后几位。

参数mode：

指定小数部分的取舍模式，通常采用四舍五入的模式，
取值为BigDecimal.ROUND_HALF_UP。

package com.cclass.demo06;

import java.math.BigDecimal;

public class demo07 {
    public static void main(String[] args) {
        double d1 = 1.0;
        double d2 = 0.9;
        System.out.println(d1-d2);//0.09999999999999998
        /*
        很多实际应用中需要精确运算，而double是近似值存储，不在符合要求，
        需要借助BigDecimal
         */

        BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");
        //减法
        BigDecimal r1=bd1.subtract(bd2);
        System.out.println(r1);//0.1

        //加法
        BigDecimal r2 = bd1.add(bd2);
        System.out.println(r2);//1.9

        //乘法
        BigDecimal r3 = bd1.multiply(bd2);
        System.out.println(r3);//0.90

        //除法
        BigDecimal r4 = new BigDecimal("1.4")
                .subtract(new BigDecimal("0.5"))
                .divide(new BigDecimal("0.9"));
        System.out.println(r4);//1

        BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);//四舍五入
        System.out.println(r5);//3.33


    }
}

Date类

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

时间单位

1秒=1000毫秒
1毫秒=1000微秒
1微秒=1000纳秒（毫微秒）

package com.cclass.demo06;

import java.util.Date;

public class demo08 {
    public static void main(String[] args) {
        //1创建Date对象
        //今天
        Date date1 = new Date();
        System.out.println(date1.toString());//Wed May 04 16:53:31 CST 2022
        System.out.println(date1.toLocaleString());//2022-5-4 16:53:31
        //昨天
        Date date2 = new Date(date1.getTime()-(60*60*24*1000));
        System.out.println(date2.toLocaleString());//2022-5-3 16:53:31
        //2方法after before
        boolean b1 = date1.after(date2);
        System.out.println(b1);//true
        boolean b2 = date1.before(date2);
        System.out.println(b2);//false

        //比较compareTo();
        int d = date1.compareTo(date2);
        System.out.println(d);//1
        //比较是否相等equals()
        boolean b3 = date1.equals(date2);
        System.out.println(b3);//false


    }
}

Calendar类

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

package com.cclass.demo06;

import java.util.Date;

public class demo08 {
    public static void main(String[] args) {
        //1创建Date对象
        //今天
        Date date1 = new Date();
        System.out.println(date1.toString());//Wed May 04 16:53:31 CST 2022
        System.out.println(date1.toLocaleString());//2022-5-4 16:53:31
        //昨天
        Date date2 = new Date(date1.getTime()-(60*60*24*1000));
        System.out.println(date2.toLocaleString());//2022-5-3 16:53:31
        //2方法after before
        boolean b1 = date1.after(date2);
        System.out.println(b1);//true
        boolean b2 = date1.before(date2);
        System.out.println(b2);//false

        //比较compareTo();
        int d = date1.compareTo(date2);
        System.out.println(d);//1
        //比较是否相等equals()
        boolean b3 = date1.equals(date2);
        System.out.println(b3);//false


    }
}

构造方法
- protected Calendar()：由于修饰符是protected，所以无法直接创建该对象。
其他方法

package com.cclass.demo06;

import java.util.Calendar;

public class demo09 {
    public static void main(String[] args) {
        //1创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis());
        //2获取时间信息
        //获取年
        int year = calendar.get(calendar.YEAR);
        //获取月
        int month = calendar.get(Calendar.MONTH);
        //获取日
        int day = calendar.get(Calendar.DAY_OF_MONTH);//or Date
        //获取小时
        int hour = calendar.get(Calendar.HOUR);//HOUR 12小时制， HOUR_OF_DAY 24小时制
        //分钟
        int minute = calendar.get(Calendar.MINUTE);
        //秒
        int second = calendar.get(Calendar.SECOND);
        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second);//国外月份从0开始
        //3修改时间
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(calendar.DAY_OF_MONTH,3);
        System.out.println(calendar2.getTime().toLocaleString());//2022-5-3 18:01:55

        //4add方法修改时间
        calendar2.add(Calendar.HOUR,1);
        System.out.println(calendar2.getTime().toLocaleString());//2022-5-3 19:03:23

        //5补充方法
        int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max);//31
        System.out.println(min);//1


    }
}

SimpleDateFormat类

SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类。
进行格式化（日期->文本）、解析（文本->日期）。
常用的时间模式字母

package com.cclass.demo06;

import java.text.SimpleDateFormat;
import java.util.Date;

public class demo10 {
    public static void main(String[] args) throws Exception{
        //1创建SimpleDateFormat对象 y 年 M 月 d 日
        //SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        //2创建Date
        Date date = new Date();
        //格式化date（把日期转成字符串）
        String str=sdf.format(date);
        System.out.println(str);
        //解析（把字符串转成日期）
        Date date2 = sdf.parse("1990/05/01");//后面格式需统一，以后学，先抛出异常
        System.out.println(date2);
    }
}

System类

System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的。

package com.cclass.demo06;

public class demo11 {
    public static void main(String[] args) {
        //arraycopy:数组的复制
        //src：源数组
        //srcPos：从哪个位置开始复制0
        //dest:目标数组
        //destPos：目标数组的位置
        //length:复制的长度
        int[] arr={20,18,15,8,35,26,45,90};
        int[] dest=new int[8];
        System.arraycopy(arr,0,dest,0,arr.length);

        for (int i=0;i<dest.length;i++){
            System.out.print(dest[i]+" ");//20 18 15 8 35 26 45 90
        }
        //Arrays.copyOf(original, newLength);//看源码，使用的System.arraycopy

        System.out.println(System.currentTimeMillis());//1651673215261

        long start=System.currentTimeMillis();
        for (int i=0;i<99999;i++){
            for (int j=0;j<99999;j++){
                int result=i+j;
            }
        }
        long end=System.currentTimeMillis();
        System.out.println("用时:"+(end-start));//用时:13

        //System.gc();告诉垃圾回收器回收

        //4推出JVM
        System.exit(0);
        System.out.println("程序结束了");


    }
}

这篇关于常用类的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

常用类