Introduction aux opérations String en Java (exemple de code)

Cet article vous présente une introduction aux opérations String en Java (exemples de code). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

1. Classe de chaîne d'opération de chaîne

1. Présentation

La chaîne est un type de données de référence spécial, il est final. classe.

2. Méthode de construction

String str = "abc";

est équivalent à : char date[] = {'a',' b ','c'};

String str = new String{data};

3. Méthode principale

char charAt(int index ) Renvoie la valeur à l'index spécifié de char.

boolean contain(CharSequence s) Renvoie vrai si et seulement si la chaîne contient la séquence de valeurs de caractères spécifiée

boolean equals(Object anObject) Compare la sous-chaîne avec l'objet spécifié

int indexOf(int ch)　Renvoie la valeur d'index de la première occurrence du caractère spécifié

int length()　Renvoie la longueur de la chaîne, principalement utilisée pour les conditions de fin de boucle

correspondances booléennes (String regex) Déterminer si une chaîne correspond à l'expression régulière donnée

String replace(char oldChar,char newChar) Remplacer tous les oldChar de la chaîne par newChar

String split(String regex) Diviser le chaîne selon les règles

String subString(int BeginIndex) Renvoie la chaîne après l'index de début d'index de la chaîne

String toLowerCase() Remplace toutes les lettres majuscules de la chaîne Remplace les lettres minuscules

String toUpperCase() Change toutes les lettres minuscules de la chaîne en lettres majuscules

String trim() Supprime tous les espaces de début et de fin de la chaîne et renvoie

/*Conversion de type* /
static String valueOf(boolean b)
Renvoie la forme booléenne de chaîne du paramètre booléen.
static String valueOf(char c)
Renvoie la forme de chaîne char du paramètre char.
static String valueOf(char[] data)
Renvoie la forme de chaîne char du paramètre de tableau de caractères.
static String valueOf(char[] data, int offset, int count)
Renvoie la forme de chaîne char d'un sous-tableau spécifique du paramètre char array.
static String valueOf(double d)
Renvoie la forme chaîne double du paramètre double.
static String valueOf(float f)
Renvoie la forme flottante de chaîne du paramètre float.
static String valueOf(int i)
Renvoie la chaîne int du paramètre int.
static String valueOf(long l)
Renvoie la forme longue de chaîne du paramètre long.
static String valueOf(Object obj)
Renvoie la forme String Object du paramètre Object.

Remarque : La différence entre la méthode String "==" et la méthode equals :

Si elle est déclarée via String str = "", les deux == et equals peuvent être utilisés

S'il est déclaré via une nouvelle chaîne (""), == ne peut pas être utilisé, seuls les égaux peuvent être utilisés.

4. Cas de démonstration

Exigence 1 : Compter le nombre de lettres majuscules, minuscules et chiffres dans une chaîne

Idée : Passez la chaîne via une boucle for, utilisez la méthode charAt pour obtenir chaque caractère, puis comparez chaque caractère avec la valeur correspondant au code AscII pour déterminer s'il s'agit d'une lettre majuscule, d'une lettre minuscule ou d'un nombre, et imprimez le décompte.

/**
 * @ author: PrincessHug
 * @ date: 2019/2/7, 17:09
 * @ Blog: https://www.cnblogs.com/HelloBigTable/
 */
public class StringAPIDemo {
    /**
     * 需求：计算字符串中大写字母、小写字母、数字出现的次数
     * @param args 参数
     */
    public static void main(String[] args) {
        //通过用户输入得到一个字符串
        String str = getString();
        getCount(str);
    }
    private static void getCount(String str) {
        int upperNum = 0;
        int lowerNum = 0;
        int digit = 0;
        for (int i = 0;i< str.length();i++){
            char c = str.charAt(i);
            /**
             * AscII码数字1-9(48-57),A-Z(65-91),a-z(97-123)
             */
            if (c>=48 && c<=57){
                digit++;
            }
            if (c>=65 && c<=91){
                upperNum++;
            }
            if (c>=97 && c<=123){
                lowerNum++;
            }
        }
        System.out.println("数字出现的次数为：" + digit);
        System.out.println("大写字母出现的次数为：" + upperNum);
        System.out.println("小写字母出现的次数为：" + lowerNum);
    }
    private static String getString() {
        System.out.println("请输入一个字符串:");
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        return s;
    }
}

Exigence 2 : interroger le nombre d'occurrences d'une certaine sous-chaîne dans la chaîne parent

Idée 1 : utiliser la méthode indexOf pour interroger l'index a de la première occurrence de la sous-chaîne , puis utilisez la méthode subString pour renvoyer la chaîne après l'index de la chaîne parent (a + longueur de la sous-chaîne), et comptez +1 jusqu'à ce que la valeur de retour de la méthode indexOf soit -1 et arrêtez-vous, obtenez simplement la valeur de comptage. .

Idée 2 : utilisez la méthode split pour diviser la chaîne parent en sous-chaînes afin d'obtenir un tableau String. Utilisez la méthode subString pour savoir si la dernière chaîne de la chaîne parent est égale à la sous-chaîne. la longueur du tableau String ; si elle n'est pas égale, la longueur-1 du tableau String est renvoyée

**
 * @ author: PrincessHug
 * @ date: 2019/2/7, 17:34
 * @ Blog: https://www.cnblogs.com/HelloBigTable/
 */
public class FindChildStringCount {
    /**
     * 需求：查询父字符串中某一个子字符串的数量
     * @param args
     */
    public static void main(String[] args) {
        String parent = "itstar123qweritstar()%%dfitstarsdgji";
        String child = "itstar";

        int num1 = getChildStringCount01(parent, child);
        int num2 = getChildStringCount02(parent,child);
        int num3 = getChildStringCount03(parent,child);
        System.out.println("方法一：" + num1 + "次。");
        System.out.println("方法二：" + num2 + "次。");
        System.out.println("方法三：" + num3 + "次。");
    }

    private static int getChildStringCount02(String parent, String child) {
        String[] s = parent.split(child);
        if (child.equals(parent.substring(parent.length()-child.length()))){
            return s.length;
        }else {
            return s.length-1;
        }
    }

    private static int getChildStringCount01(String parent,String child) {
        int num = 0;
        int index = 0;
        while ((index = parent.indexOf(child)) != -1){
            num++;
            parent = parent.substring(index + child.length());
        }

        return num;
    }
    private static int getChildStringCount03(String parent,String child){
        String[] s = parent.split(child);
        int sum = 0;
        for (int i = 0;i < s.length;i++){
            sum += s[i].length();
        }
        return sum==parent.length()-(s.length-1)*child.length()?s.length-1:s.length;
    }
}

5. >Les expressions régulières sont souvent utilisées pour vérifier les numéros d'identification, les numéros QQ, les adresses e-mail, etc.
Classes de caractères et significations :

[abc]　=>　 Abc peut être utilisé

[ a-zA-Z] =>　 A-z ou A-Z peuvent être utilisés, les deux extrémités sont des intervalles fermés

[0-9]　=> Identique à [0-9]

D　 => Ce ne peut pas être un chiffre

w　 => Cela signifie que les lettres, les chiffres et les traits de soulignement sont acceptables, égaux à [a-zA-Z0-9_]

x ? => Indique que x apparaît une ou plusieurs fois

x*　 => Indique que x apparaît zéro ou plusieurs fois

X{n} => ; >

X{n,m} => Indique que x apparaît n à m fois

X+ 🎜>^　 => Représente la fin de l'expression régulière

Exigence 1 : Vérifier si le numéro qq est correct

Conditions du numéro qq :

(1) Le nombre de chiffres est de 5 à 15 chiffres

（2）开头数字不能为0

正则表达式为：regex = [1-9]\\d{4-14}

需求二：验证手机号码是否正确

手机号条件：

（1）位数为11位

（2）第一位为1

（3）第二位为3-9

正则表达式为：regex = [1]][3-9]\\d{9}　　

需求三：验证邮箱是否正确

邮箱条件：

（1）@之前为邮箱名，字母、数字、下划线都可以

（2）@符号

（3）@之后为邮箱域名(qq.com/163.com.cn)

正则表达式为：regex = \\w+@[a-zA-Z0-9]+(\\.\\w{2,3})+

以下为需求一：验证qq号码是否正确，需求二、三只需将regex修改为对应的正则表达式即可。

/**
 * @ author: PrincessHug
 * @ date: 2019/2/7, 21:51
 * @ Blog: https://www.cnblogs.com/HelloBigTable/
 */
public class MatchQQ {
    public static void main(String[] args) {
        while (true) {
            String qq = getQQ();
            if (qq.equals("stop")){
                break;
            }else {
                matchQQ(qq);
            }
        }
    }

    /**
     * @return 返回获取的qq号
     */
    private static String getQQ() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的qq号");
        String s = sc.nextLine();
        return s;
    }

    /**
     * 验证qq号是否匹配regex表达式
     * @param qq 获得用户输入的qq号
     */
    private static void matchQQ(String qq) {
        String regex = qqRegex();
        if (qq.matches(regex)) {
            System.out.println("QQ号正确！");
        } else {
            System.out.println("QQ号错误！");
        }
    }

    /**
     * @return 返回qq的正则表达式
     */
    private static String qqRegex() {
        String regex = "[1-9][0-9]{4,14}";
        return regex;
    }
}

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!