Introduction aux classes et méthodes courantes JavaSE (avec code)

Le contenu de cet article est une introduction aux classes et méthodes JavaSE courantes (avec code). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

1. Les types de données de base sont comparés à l'aide de : ==

2. Les types de données de référence sont comparés : méthode égale

Si les types de données de référence sont comparés à l'aide de ==, le la comparaison est C'est la valeur de l'adresse

toString classe

l'objet appelant toString() doit remplacer cette méthode : dans la classe encapsulée, sinon l'adresse sera sortie

égal àméthode

appels 'Object' equals() doit être répété Méthode d'écriture : Réécrire dans la classe encapsulée, sinon la comparaison sera l'adresse

String class

String a un fractionnement, est divisé en fonction d'une chaîne et renvoie le tableau de chaînes après le fractionnement

String[] split (String regex)

public int length() : renvoie la longueur de cette chaîne.

public String concat (String str) : Concatène la chaîne spécifiée à la fin de la chaîne.

public char charAt (int index) : renvoie la valeur char à l'index spécifié.

public int indexOf (String str) : renvoie l'index de la première occurrence de la sous-chaîne spécifiée dans la chaîne.

public int indexOf(String str, int fromIndex) : renvoie l'index de la première occurrence de la sous-chaîne spécifiée dans cette chaîne, à partir de l'index spécifié.

public String substring (int BeginIndex) : renvoie une sous-chaîne, interceptant la chaîne commençant par BeginIndex jusqu'à la fin de la chaîne.

sous-chaîne de chaîne publique (int beginIndex, int endIndex) : renvoie une sous-chaîne, interceptant la chaîne de beginIndex à endIndex. Contient BeginIndex mais n’inclut pas EndIndex.

public String replace (CharSequence target, CharSequence replacement) : remplacez la chaîne correspondant à la cible par la chaîne de remplacement.

StringBuilderClass

String Builder est équivalent à un conteneur tampon en mémoire et sera fermé au fur et à mesure que la mémoire est fermé Disparaître, Ne créez pas l'adresse mémoire des caractères ajoutés lors de l'épissage des caractères dans la mémoire d'adresse, économisant ainsi de l'espace mémoire

StringBuilder() Construit un générateur de chaînes sans caractères, avec une capacité initiale de 16 caractères.

StringBuilder(String str) Construit un générateur de chaîne initialisé avec le contenu de chaîne spécifié

StringBuilder sb = new StringBuilder();

public StringBuilder append (n'importe quel type ) : Ajoutez des données et renvoyez l'objet lui-même (les appels chaînés sont pris en charge).

public StringBuilder reverse() : inverse la séquence de caractères

public String toString() : renvoie la représentation sous forme de chaîne des données dans cette séquence. Convertir en String

Méthode Append Inconvénients : elle peut épisser n'importe quel type, mais une fois l'épissage terminé, elle devient String

Classe Arrays

public static String toString(int[] a) : Convertit le tableau en chaîne

public static void sort(int[] a) : Trie le tableau par ordre croissant

Convertit la classe wrapper en La classe String

le type int peut être directement épissé en type chaîne et peut être converti en type String

int->String

1+""

Méthode String.valueOf() Les données de type de base peuvent être converties en type String

String.valueOf(data);

classe wrapper.La méthode ParseXXX peut convertir le type de base en type String. Notez que le type de base doit être converti en classe Packaging correspondante, voici un exemple de conversion de int en String

int->String (point clé)

Integer.parseInt(" 100")

Classe Date

En Java, il existe un java.util.Date, qui représente la date et l'heure, avec une précision en millisecondes

Méthode de construction de la classe Date :

Date() sans paramètres Méthode de construction : Créer un objet Date basé sur l'heure actuelle du système

Date (long date) : Créer un objet Date basé sur l'heure spécifiée valeur en milliseconde. La valeur en millisecondes spécifiée, la valeur en millisecondes qui s'est écoulée depuis le 1er janvier 1970 (l'heure de base de l'ordinateur)

Méthodes courantes :

public long getTime() Convertit l'objet date en l'heure correspondante valeur en millisecondes.

void setTime(long time) Définissez cet objet Date sur la valeur en millisecondes qui s'est écoulée depuis 00:00:00 le 1er janvier 1970

//请打印出1970年1月2号的时间的对象
　　　　Date date2 = new Date(24 * 60 * 60 * 1000);
　　　　System.out.println(date2);
　　//获取当前时间的毫秒值
　　　　Date date = new Date();
　　　　System.out.println(date.getTime());
　　//将date，改成1970年1,月1号 　　
　　　　date.setTime(0);
　　　　System.out.println(date);

SimpleDateFormatClass

Vous pouvez utiliser la classe DateFormat, mais c'est une classe abstraite, nous devons donc utiliser son constructeur de sous-classe SimpleDateFormat

SimpleDateFormat(String pattern) Construit un SimpleDateFormat en utilisant le modèle donné. Le symbole de format de date par défaut est la locale FORMAT par défaut.

Le paramètre motif est le motif

Mode lettre : y représente la surface M représente le mois d représente le jour H représente l'heure m représente les minutes s représente les secondes S représente les millisecondes

Heure chinoise : 11 mars 2019 11:09:33 secondes 333 millisecondes

Modèle alphabétique du code : aaaa année MM mois jj jour HH point mm minute ss seconde SSS milliseconde

Méthode membre :

Formatage (Date-> Texte) : Date -- Chaîne

Format de chaîne final public (Date date)

Analyse (Texte-> Date) : Chaîne -- Date

analyse de date publique (source de la chaîne)

//根据系统时间创建Date对象
        Date date = new Date();
        System.out.println(date);

        //date不好看，格式化为中国式时间
　　　　 //SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日  HH点mm分ss秒 SSS毫秒");
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM-dd  HH:mm:ss");
        //将date格式化为String
        String time = sdf.format(date);
        System.out.println(time);

        //注意，我们一般人不会记忆毫秒值，能不能根据具体的时间(2019-03-11  11:16:02)解析成毫秒值
        //ParseException: Unparseable date: "2018年03-11  11:18:57",注意，模式必须与之前一致
        Date date1 = sdf.parse("2018年03-11  11:18:57");
        System.out.println(date1);
        System.out.println(date1.getTime());

CalendrierClasse

Calendar Il s'agit d'une classe abstraite En raison de la sensibilité du langage, la classe Calendar n'est pas créée directement lors de la création d'un objet, mais est créée via une méthode statique et renvoie un objet de sous-classe

Selon le document API du. Classe Calendrier, les méthodes courantes sont :

public int get(int field) : renvoie la valeur du champ de calendrier donné.

public void set(int field, int value) : Définissez le champ de calendrier donné sur la valeur donnée.

public abstract void add(int field, int montant) : ajoutez ou soustrayez la durée spécifiée à un champ de calendrier donné selon les règles du calendrier.

public Date getTime() : renvoie un objet Date représentant cette valeur de l'heure du calendrier (le décalage en millisecondes entre l'époque et le présent).

La classe Calendar fournit de nombreuses constantes membres, représentant des champs de calendrier donnés :

ANNÉE

字段值	含义
YEAR	年
MONTH	月（从0开始，可以+1使用）
DAY_OF_MONTH	月中的天（几号）
HOUR	时（12小时制）
HOUR_OF_DAY	时（24小时制）
MINUTE	分
SECOND	秒
DAY_OF_WEEK	周中的天（周几，周日为1，可以-1使用）

Valeur du champ

import java.util.Calendar;
public class CalendarUtil {
    public static void main(String[] args) {
        //get方法
        // 创建Calendar对象
        Calendar cal = Calendar.getInstance();
        // 设置年 
        int year = cal.get(Calendar.YEAR);
        // 设置月
        int month = cal.get(Calendar.MONTH) + 1;
        // 设置日
        int dayOfMonth = cal.get(Calendar.DAY_OF_MONTH);
        //set方法
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.YEAR, 2020);
        //add方法
        cal.add(Calendar.DAY_OF_MONTH, 2); // 加2天
        cal.add(Calendar.YEAR, -3); // 减3年
        //getTime方法
        Date date = cal.getTime();
    }    
}

Signification

Année

MOIS

Mois (commence à partir de 0, peut être utilisé par +1)

DAY_OF_MONTH

Jour du mois (jour)

HEURE

Heure (format 12 heures)

HOUR_OF_DAY

Heure (horloge 24 heures)

import java.util.Date;

public class SystemDemo {
    public static void main(String[] args) {
           //获取当前时间毫秒值
        System.out.println(System.currentTimeMillis()); // 1516090531144
    }
}

MINUTE

MIN

SECOND

Secondes

DAY_OF_WEEK

Jour de la semaine (jour de la semaine), dimanche est 1, vous pouvez utiliser -1)

参数序号	参数名称	参数类型	参数含义
1	src	Object	源数组
2	srcPos	int	源数组索引起始位置
3	dest	Object	目标数组
4	destPos	int	目标数组索引起始位置
5	length	int	复制元素个数

Classe systèmepublic static long currentTimeMillis() : renvoie l'heure actuelle en millisecondes. public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) : copiez les données spécifiées dans le tableau dans un autre tableau. currentTimeMillisméthodearraycopyméthodeSignification du paramètreObjetsrcPos longueur tbody>

Numéro du paramètre	Nom du paramètre	Type de paramètre
1	src	Tableau source
2	int	Position de départ de l'index du tableau source
3	dest	Objet	Tableau de destination
4	destPos	int	Position de départ de l'index du tableau cible
5	int	Nombre d'éléments copiés

import java.util.Arrays;
public class Demo11SystemArrayCopy {
    public static void main(String[] args) {
        int[] src = new int[]{1,2,3,4,5};
        int[] dest = new int[]{6,7,8,9,10};
        System.arraycopy( src, 0, dest, 0, 3);
        /*代码运行后：两个数组中的元素发生了变化
         src数组元素[1,2,3,4,5]
         dest数组元素[1,2,3,9,10]
        */
    }
}

Random类

构造方法：

Random() 创建一个新的随机数生成器。

成员方法 :

int nextInt() 从这个随机数生成器的序列返回下一个伪随机数，均匀分布的 int值。

int nextInt(int bound) ，均匀分布 返回值介于0（含）和指定值bound（不包括），从该随机数生成器的序列绘制

Random random = new Random();
        /*for (int i = 0; i < 10; i++) {
            System.out.println(random.nextInt());
        }*/
        /*for (int i = 0; i < 10; i++) {
            int j = random.nextInt(10);
            System.out.println(j);
        }*/
        //来一个随机值，这个数据的范围必须是1~100,33~66 54~78
        //random.nextInt(100);//0~99 +1 -> 1~100
        /*33~66 - 33 -> 0~33
        for (int i = 0; i < 10; i++) {
            System.out.println(random.nextInt(34) + 33);
        }*/
        //54~78 - 54 -> 0~24
        for (int i = 0; i < 10; i++) {
            System.out.println(random.nextInt(25) + 54);
        }

比较器Comparable8742468051c85b06f0a0af9e3e506b5c 和 Comparator8742468051c85b06f0a0af9e3e506b5c

java.lang Comparable8742468051c85b06f0a0af9e3e506b5c : 该接口对实现它的每个类的对象强加一个整体排序。 这个排序被称为类的自然排序 ，类的compareTo方法被称为其自然比较方法 。

java中规定 某个类只要实现了Comparable 接口之后,才能通过重写compareTo()具备比较的功能。

抽象方法:

int compareTo(T o) 将此对象(this)与 指定( o )的对象进行比较以进行排序。

this > o : 返回正数

this = o : 返回0

this < o : 返回负数

' this - o : 表示按照升序排序。 o - this : 表示按照降序排序。

' 小结 : 如果Java中的对象需要比较大小，那么对象所属的类要实现Comparable接口，然后重写compareTo(T o)实现比较的方式。

public class Student implements Comparable<Student>{
    ....
    @Override
    public int compareTo(Student o) {
        return this.age-o.age;//升序
    }
}

java.util Comparator8742468051c85b06f0a0af9e3e506b5c : 比较器接口。

抽象方法:

int compare( T o1, T o2 ) 比较其两个参数的大小顺序。

比较器接口的使用场景:

1. Arrays.sort() : static 8742468051c85b06f0a0af9e3e506b5c void sort( T[] a, Comparator c)

2. Collections 集合工具类 : void sort(List8742468051c85b06f0a0af9e3e506b5c list, Comparatora8093152e673feb7aba1828c43532094 c) 根据指定的比较器给集合中的元素进行排序。

3. TreeSet 集合 : 构造方法 TreeSet( Comparator c )

补充 : 在后面我还会介绍JDK1.8 的新特性(Lambda  函数式代码优化)  进行优化此类接口 

ArrayList<String> list = new ArrayList<String>();
        list.add("cba");
        list.add("aba");
        list.add("sba");
        list.add("nba");
        //排序方法  按照第一个单词的降序
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                int rs = o2.getCj() - o1.getCj();
                return rs==0 ? o1.getAge()-o2.getAge():rs;
//                return o2.charAt(0) - o1.charAt(0);
            }
        });
        System.out.println(list);

Comparable 和 Comparator 区别:

Comparable : 对实现了它的类进行整体排序。

Comparator : 对传递了此比较器接口的集合或数组中的元素进行指定方式的排序。

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!