Häufig verwendete Java-APIs: Objektklasse, Datums- und Uhrzeitklasse, StringBuilder-Klasse, Verpackungsklasse

In diesem Artikel werden mehrere häufig verwendete Java-APIs vorgestellt, z. B. die Objektklasse, die Datums- und Zeitklasse, die StringBuilder-Klasse und die Verpackungsklasse, die in zukünftigen Entwicklungen häufig verwendet werden.

Objektklasse

Die Klasse Java.lang.Object ist die Stammklasse in der Java-Sprache, die die übergeordnete Klasse aller Klassen ist . Alle darin beschriebenen Methoden können von Unterklassen verwendet werden. Wenn ein Objekt instanziiert wird, ist die letzte übergeordnete Klasse, nach der es sucht, Object.

Die Object-Klasse enthält 11 Mitgliedsmethoden. Ich werde nur zwei häufig verwendete Methoden auflisten:

- public String toString()：返回该对象的字符串表示。
- public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。

1.toString-Methode

public String toString(): Gibt die Zeichen des Objekts zurück String-Darstellung.

Die toString-Methode gibt die Zeichenfolgendarstellung des Objekts zurück. Tatsächlich ist der Inhalt der Zeichenfolge der Objekttyp + @ + Speicheradressenwert. Da das von der toString-Methode zurückgegebene Ergebnis die Speicheradresse ist Bei der Entwicklung ist es häufig erforderlich, den Objekteigenschaften zu folgen und eine entsprechende Zeichenfolgendarstellung zu erhalten, die im Allgemeinen überschrieben wird.

Methodenüberschreibung:

    //重写toString方法
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

2.equals-Methode

public boolean equals(Object obj): Gibt an, ob ein anderes Objekt diesem Objekt „gleich“ ist.

Rufen Sie die Mitgliedsmethode equal auf und geben Sie den Parameter als ein anderes Objekt an. Sie können feststellen, ob die beiden Objekte gleich sind. Hier gibt es zwei Möglichkeiten für „gleich“: Standard und benutzerdefiniert.

Wenn die Methode equal nicht überschrieben wird, wird der Objektadressenvergleich des Operators == standardmäßig in der Object-Klasse durchgeführt. Solange es sich nicht um dasselbe Objekt handelt, muss das Ergebnis falsch sein.

Methodenumschreibung:

/*
        Object类的equals方法，默认比较的是两个对象的地址值
        重写equals方法，比较两个对象的属性
        问题：
            隐含这一个多态，无法使用子类特有的内容(属性和方法)
        解决：
            可以使用向下转型(强制类型转换)把o类型转换为Person
     */
    //重写equals方法
    @Override
    public boolean equals(Object o){
        //增加一个判断，如果传递的参数是this本身，直接返回true
        if(this==o) return true;

        //增加一个判断，如果传递的参数是null，直接返回false
        if(o==null) return  false;

        //增加一个判断，防止类型转换一次ClassCastException
        if(o instanceof Person){
            //使用向下转型，把o转换为Person类型
            Person p=(Person)o;
            //比较两个对象的属性，一个对象是this(p1),一个对象是p(o->p2)
            boolean b=this.name.equals(p.name) && this.age==p.age;
            return  b;
        }

        //不是Person类型，返回false
        return false;

Datums- und Zeitklasse

1.Date-Klasse

java.util.Date-Klasse stellt einen bestimmten Zeitpunkt dar, der auf Millisekunden genau ist .

Gemeinsame Methoden:

public long getTime() 把日期对象转换成对应的时间毫秒值。

Instanz:

    /*
        long getTime() 把日期转换为毫秒值（相当于System.currentTimeMillis()方法）
        返回自1970年1月1日0点0分0秒 GMT以来此Date对象表示的毫秒数
     */
    public static void demo3(){
        Date date =new Date();
        long time=date.getTime();
        System.out.println(time);
    }

    //结果值
    1533119389083

2.DateFormat-Klasse

java.text.DateFormat ist eine abstrakte Klasse der Datums-/Uhrzeitformatierungsunterklasse, We Mit dieser Klasse können wir die Konvertierung zwischen Datumsangaben und Text abschließen, d. h. wir können zwischen Datumsobjekten und String-Objekten hin und her konvertieren.

Formatierung: Konvertieren vom Datumsobjekt in ein String-Objekt gemäß dem angegebenen Format.

Parsing: Konvertieren vom String-Objekt in ein Date-Objekt gemäß dem angegebenen Format.

Zwei häufig verwendete Methoden:

- public String format(Date date)：将Date对象格式化为字符串。
- public Date parse(String source)：将字符串解析为Date对象。

Beispiel:

package demo2_Date;

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

public class Test02_Dateformat {
    public static void main(String[] args) throws ParseException {
        //将date对象格式化为字符串
        find_Date01();
        
        //将字符串解析为date对象
        find_Date02();
    }


    //将字符串解析为date对象
    public static void  find_Date01() throws ParseException {
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
        String str="2018年8月1日 7点12分23秒";
        Date s=sdf.parse(str);
        System.out.println(new Date());
    }

    //将date对象格式化为字符串
    public static void  find_Date02(){
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        String s=sdf.format(new Date());
        System.out.println(s);
    }
}

Berechnen Sie die Anzahl der Geburtstage:

package demo2_Date;

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

/*
    计算出生天数
        1.键盘录入出生日期，并转换date类型（毫秒值）
        2.获取当前日期毫秒值
        3.相减得到差值毫秒值，转换得到天数
 */
public class Test03_FindBirthday {
    public static void main(String[] args) throws ParseException {
        //录入出生日期
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入你的出生日期：格式（yyyy-MM-dd）");
        String bithDateString=sc.next();

        //使用DateFormat类中的parse方法，把字符串类型的出生日期，转换成为date类型
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
        Date birthDate=sdf.parse(bithDateString);

        //把出生日期转换为毫秒值
        long birthDateTime=birthDate.getTime();
        long nowDateTime=new Date().getTime();

        long daysTime=nowDateTime-birthDateTime;
        //获取天数
        System.out.println(daysTime/1000/60/60/24);
    }
}

Ausgabeergebnis:

请输入你的出生日期：格式（yyyy-MM-dd）
1996-05-24
8104

Process finished with exit code 0

3. Kalenderklasse

Konzept:

java.util.Calendar ist eine Kalenderklasse, die nach Date erscheint und viele Date-Methoden ersetzt. Diese Klasse kapselt alle möglichen Zeitinformationen als statische Mitgliedsvariablen für einen einfachen Zugriff. Die Kalenderklasse eignet sich zum Abrufen verschiedener Zeitattribute.

Erfassungsmethode:

Calendar ist eine abstrakte Klasse, die Unterklassenobjekte über statische Methoden erstellt und zurückgibt:

public static Calendar getInstance()：使用默认时区和语言环境获得一个日历

Gemeinsame Methoden: Es gibt hauptsächlich vier gängige Methoden von Calendar Beherrschen der get-Methode und der getTime-Methode

- public int get(int field)：返回给定日历字段的值。
- public void set(int field, int value)：将给定的日历字段设置为给定值。
- public abstract void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。
- public Date getTime()：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象

Instanz:

package demo2_Date;
import java.util.Calendar;
import java.util.Date;

/*
    四种常用成员方法：
    - public int get(int field)：返回给定日历字段的值。
    - public void set(int field, int value)：将给定的日历字段设置为给定值。
    - public abstract void add(int field, int amount)：根据日历的规则，
        为给定的日历字段添加或减去指定的时间量。
    - public Date getTime()：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。
 */
public class Test04_Calendar {
    public static void main(String[] args) {
//        demo1();
//        demo2();
        demo3();
        demo4();
    }

    /*
    - public Date getTime()：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。
     */
    public static void demo4(){
        Calendar cal=Calendar.getInstance();
        Date date=cal.getTime();
        System.out.println(date);   //Wed Aug 01 19:20:51 CST 2018
    }


    /*
     public abstract void add(int field, int amount)：根据日历的规则，
        为给定的日历字段添加或减去指定的时间量。
     参数：设定指定的日历字段以及修改量
     返回值：修改过后的日历字段代表的值
     */
    public static void demo3(){
        Calendar cal =Calendar.getInstance();

        //加两年，减两月
        cal.add(Calendar.YEAR,+2);
        cal.add(Calendar.MONTH,-2);

        int year =cal.get(Calendar.YEAR);
        int month=cal.get(Calendar.MONTH)+1;
        int day=cal.get(Calendar.DAY_OF_MONTH);
        System.out.println(year+"年"+month+"月"+day+"日");//   2020年6月1日
    }

    /*
     public void set(int field, int value)：将给定的日历字段设置为给定值。
     参数：设定指定的日历字段以及设置值
     返回值：重新设定的日历字段代表的值
     */
    public static void demo2(){
        //创建Calendar对象
        Calendar cal= Calendar.getInstance();
        cal.set(Calendar.YEAR ,2020);
        int year=cal.get(Calendar.YEAR);
        System.out.println(year+"年");       //2020年
    }

    /*
        public int get(int field):返回给定日历字段的值。
        参数：传递指定的日历字段（YEAR,MONTH）
        返回值：日历字段代表的具体的值
     */
    public static void demo1(){
        //创建Calendar对象
        Calendar cal= Calendar.getInstance();
        //获取年份
        int year =cal.get(Calendar.YEAR);
        //获取月份
        int month=cal.get(Calendar.MONTH)+1;
        int day=cal.get(Calendar.DAY_OF_MONTH);
        System.out.println(year+"年"+month+"月"+day+"日"); //2018年8月1日
    }
}

Systemklasse

1. currentTimeMillis-Methode

Gibt die aktuelle Zeit in Millisekunden zurück, was oft verwendet wird Testcode-Effizienz, z. B. Schleifencode.

2.arraycopy-Methode

Kopieren Sie die im Array angegebenen Daten in ein anderes Array.

Instanz:

package demo3_System;

import java.util.Arrays;

/*
    两个常用方法：
        1.currentTimeMillis
        2.arraycopy
 */
public class Test01_System {
    public static void main(String[] args) {
        demo1();
        demo2();
    }

    //将数组中指定的数据拷贝到另一个数组中。
    public static void demo2(){
        int[] arr1={1,2,3,4,5};
        int[] arr2={6,7,8,9,10};
        System.arraycopy(arr1,0,arr2,0,3);
        System.out.println(Arrays.toString(arr2));      //[1, 2, 3, 9, 10]
    }

    //返回以毫秒为单位的时间
    public static void demo1(){
        long begin=System.currentTimeMillis();
        int sum=0;
        for(int i=0;i<10000;i++){
            System.out.println(i);
        }
        long end=System.currentTimeMillis();
        System.out.println(end-begin);  //205毫秒
    }

StringBuilder-Klasse

1. Übersicht

StringBuilder wird auch als variable Zeichenfolge bezeichnet. Es handelt sich um eine Zeichenfolge, die String Buffer ähnelt. Länge und Inhalt der Sequenz können durch bestimmte Methodenaufrufe geändert werden. Es stellt sich heraus, dass StringBuilder ein String-Puffer ist, also ein Container, der viele Strings aufnehmen kann. Und kann verschiedene Operationen an den darin enthaltenen Zeichenfolgen ausführen. Es verfügt über ein internes Array zum Speichern von String-Inhalten. Beim Verketten von Strings werden neue Inhalte direkt zum Array hinzugefügt. StringBuilder behält automatisch die Erweiterung des Arrays bei. Das Prinzip ist in der folgenden Abbildung dargestellt: (Standard 16 Zeichen, überschreitet die automatische Erweiterung)

2. Gängige Methoden:

- public StringBuilder append(...)：添加任意类型数据的字符串形式，并返回当前对象自身。
- public String toString()：将当前StringBuilder对象转换为String对象。

3. Beispiel:

package demo4_StringBufilder;

public class Test01_StringBuilder {
    public static void main(String[] args) {
//        demo1();
        demo2();
    }

    //通过toString方法，StringBuilder对象将会转换为不可变的String对象
    public static void  demo2(){
        //创建对象
        StringBuilder str=new StringBuilder("会发光").append("的小太阳");
        //调用方法
        String atr1=str.toString();
        System.out.println(atr1);   //会发光的小太阳
    }

    //StringBuilder类的append方法，返回值是一个StringBuilder对象
    public static void demo1(){
        //创建对象
        StringBuilder str=new StringBuilder();
        //返回的是一个StringBuilder对象
        StringBuilder str2= str.append("会发光的");
        str2.append("小太阳");
        System.out.println("str2: "+str2);      //str2: 会发光的小太阳

        //调用一个方法返回值是一个对象的时候，可以使用返回值对象继续调用方法
        //链式编程
        str2.append("会吸光").append("小月亮");
        System.out.println("str2==: "+str2);    //str2==: 会发光的小太阳会吸光小月亮
    }
}

Verpackung Klasse

1. Grundtypen und entsprechende Verpackungsklassen

基本类型--包装类

基本类型	对应包装类（位于java.lang包下）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
chart	Charter
boolean	Boolean

2. Unboxing und Packen

Der Prozess des Hin- und Herkonvertierens zwischen Basistypen und entsprechenden Verpackungsklassenobjekten wird „Boxing“ und „Unboxing“ genannt:

Boxing: Vom Basistyp in das entsprechende Verpackungsklassenobjekt konvertieren.

Unboxing: Konvertieren von einem Wrapper-Klassenobjekt in den entsprechenden Basistyp.

3. Automatisches Unboxing und automatisches Boxen

Da wir ab Java 5 (JDK 1.5) häufig zwischen Basistypen und Wrapper-Klassen konvertieren müssen, sind das Packen und Unboxen die Grundtypen und Wrapper-Klassen Aktionen können automatisch abgeschlossen werden, wir müssen dies jedoch nicht tun. Das ist richtig, das ist automatisches Verpacken und automatisches Verpacken. Überraschend oder nicht.

Verwandte Artikel:

Erklärung gängiger Datumsklassen in Java

Verwendung von Datumsklassen und Kalenderklassen in Java

[Java-Tutorial] Java StringBuffer- und StringBuilder-Klassen

Das obige ist der detaillierte Inhalt vonHäufig verwendete Java-APIs: Objektklasse, Datums- und Uhrzeitklasse, StringBuilder-Klasse, Verpackungsklasse. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!