Cet article présente plusieurs API Java couramment utilisées, telles que la classe Object, la classe date et heure, la classe StringBuilder et la classe d'empaquetage, qui seront fréquemment utilisées dans le développement futur.
Classe d'objet
La classe Java.lang.Object est la classe racine du langage Java, qui est la classe parent de toutes les classes . Toutes les méthodes décrites par celui-ci peuvent être utilisées par les sous-classes. Lorsqu'un objet est instancié, la classe parent finale qu'il recherche est Object.
La classe Object contient 11 méthodes membres. Je ne listerai que deux méthodes couramment utilisées :
- public String toString()：返回该对象的字符串表示。 - public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。
public String toString() : renvoie la chaîne de l'objet. représentation.
La méthode toString renvoie la représentation sous forme de chaîne de l'objet. En fait, le contenu de la chaîne est le type de l'objet +@+valeur de l'adresse mémoire puisque le résultat renvoyé par la méthode toString est l'adresse mémoire. , en développement, il est souvent nécessaire de suivre Les propriétés de l'objet obtiennent la représentation sous forme de chaîne correspondante, qui est généralement remplacée.
remplacement de la méthode :
//重写toString方法
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}public boolean equals(Object obj) : Indique si un autre objet est "égal" à cet objet.
Appelez la méthode membre égale et spécifiez le paramètre comme un autre objet, vous pouvez déterminer si les deux objets sont identiques. Il existe deux manières de procéder ici : par défaut et personnalisée.
Si la méthode equals n'est pas remplacée, alors la comparaison des adresses d'objet de l'opérateur == est effectuée par défaut dans la classe Object. Tant qu'il ne s'agit pas du même objet, le résultat doit être faux.
Réécriture de méthode :
/*
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;La classe java.util.Date représente un instant spécifique, précis en millisecondes.
Méthodes courantes :
public long getTime() 把日期对象转换成对应的时间毫秒值。
Instance :
/*
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);
}
//结果值
1533119389083java.text.DateFormat est une sous-classe de formatage de date/heure Résumé classe, nous pouvons utiliser cette classe pour nous aider à terminer la conversion entre les dates et le texte, c'est-à-dire que nous pouvons effectuer des conversions entre les objets Date et les objets String.
Formatage : Convertir de l'objet Date en objet String selon le format spécifié.
Parsing : Convertir de l'objet String en objet Date selon le format spécifié.
Deux méthodes couramment utilisées :
- public String format(Date date)：将Date对象格式化为字符串。 - public Date parse(String source)：将字符串解析为Date对象。
Exemple :
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);
}
}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);
}
}Résultat de sortie :
请输入你的出生日期：格式（yyyy-MM-dd） 1996-05-24 8104 Process finished with exit code 0
Concept :
java.util.Calendar est une classe calendrier qui apparaît après Date et remplace de nombreuses méthodes Date. Cette classe encapsule toutes les informations temporelles possibles sous forme de variables membres statiques pour un accès facile. La classe calendrier est pratique pour obtenir divers attributs temporels.
Méthode d'acquisition :
Calendar est une classe abstraite, qui crée et renvoie des objets de sous-classe via des méthodes statiques :
public static Calendar getInstance()：使用默认时区和语言环境获得一个日历
Méthodes courantes : il existe quatre méthodes courantes de Calendar , Maîtrisez principalement la méthode get et la méthode getTime
- 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对象
instance :
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日
}
}Renvoie le courant. temps en millisecondes Le temps est souvent utilisé pour tester l'efficacité du code, comme le code en boucle.
Copiez les données spécifiées dans le tableau vers un autre tableau.
Instance :
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毫秒
}1 Présentation
StringBuilder est également appelé une séquence de caractères variable, c'est un A de type chaîne. tampon de chaîne dont la longueur et le contenu peuvent être modifiés via certains appels de méthode. Il s'avère que StringBuilder est un tampon de chaînes, c'est-à-dire qu'il s'agit d'un conteneur pouvant contenir plusieurs chaînes. Et peut effectuer diverses opérations sur les chaînes qu'il contient. Il dispose d'un tableau interne pour stocker le contenu de la chaîne. Lors de la concaténation des chaînes, le nouveau contenu est ajouté directement au tableau. StringBuilder maintiendra automatiquement l'expansion du tableau. Le principe est le suivant : (espace de 16 caractères par défaut, dépasse l'expansion automatique)
2. Méthodes courantes :
- public StringBuilder append(...)：添加任意类型数据的字符串形式，并返回当前对象自身。 - public String toString()：将当前StringBuilder对象转换为String对象。
3. Exemple :
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==: 会发光的小太阳会吸光小月亮
}
}| 基本类型 | 对应包装类（位于java.lang包下） |
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| chart | Charter |
| boolean | Boolean |
Le processus de conversion entre les types de base et les objets de classe d'emballage correspondants est appelé « boxing » et « unboxing » :
Boxing : Conversion du type de base en objet de classe d'emballage correspondant.
Unboxing : Convertissez d'un objet de classe wrapper au type de base correspondant.
Comme nous avons souvent besoin de convertir entre les types de base et les classes wrapper, à partir de Java 5 (JDK 1.5), les types de base et les classes wrapper L'emballage et le déballage les actions peuvent être effectuées automatiquement, mais nous n'avons pas besoin de le faire. C'est vrai, c'est un emballage automatique et une mise en boîte automatique. Surprenant ou pas.
Articles connexes :
Explication des classes de date courantes en Java
Utilisation des classes de date et des classes de calendrier en Java
[Tutoriel Java] Classes Java StringBuffer et StringBuilder
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
