Einführung in String-Operationen in Java (Codebeispiel)

Dieser Artikel bietet Ihnen eine Einführung in String-Operationen in Java (Codebeispiele). Ich hoffe, dass er für Freunde hilfreich ist.

1. String-Operation String-Klasse

Übersicht

String ist ein spezieller Referenzdatentyp, er ist endgültig Klasse.

2. Konstruktionsmethode

String str = "abc";

entspricht: char date[] = {'a',' b ','c'};

String str = new String{data};

3. Hauptmethode

char charAt(int index ) Gibt den Wert am angegebenen Index von char zurück.

boolean enthält(CharSequence s) Gibt genau dann „true“ zurück, wenn die Zeichenfolge die angegebene Zeichenwertsequenz enthält

boolean equal(Object anObject) Vergleicht die Teilzeichenfolge mit dem angegebenen Objekt

int indexOf(int ch)　Gibt den Indexwert des ersten Vorkommens des angegebenen Zeichens zurück

int length()　Gibt die Länge der Zeichenfolge zurück, die hauptsächlich für Schleifenbeendigungsbedingungen verwendet wird

boolesche Übereinstimmungen (String-Regex) Bestimmen Sie, ob ein String mit dem angegebenen regulären Ausdruck übereinstimmt

String replace(char oldChar,char newChar) Ersetzen Sie alle oldChar im String durch newChar

String split(String-Regex) Teilen Sie den string gemäß den Regeln

String subString(int beginIndex) Gibt den String nach dem beginindex-Index des Strings zurück

String toLowerCase() Ersetzen Sie alle Großbuchstaben im String. Wechseln Sie zu Kleinbuchstaben

String toUpperCase() Alle Kleinbuchstaben in der Zeichenfolge in Großbuchstaben ändern

String trim() Alle führenden und nachgestellten Leerzeichen aus der Zeichenfolge entfernen und

/*Typkonvertierung* zurückgeben /
statischer String valueOf(boolean b)
Gibt die boolesche String-Form des booleschen Parameters zurück.
statischer String-WertOf(char c)
Gibt die String-Char-Form des char-Parameters zurück.
static String valueOf(char[] data)
Gibt die String-Char-Form des char-Array-Parameters zurück.
static String valueOf(char[] data, int offset, int count)
Gibt die String-Char-Form eines bestimmten Subarrays des char-Array-Parameters zurück.
statischer String-WertOf(double d)
Gibt die String-Double-Form des Double-Parameters zurück.
statischer String-WertOf(float f)
Gibt die String-Float-Form des Float-Parameters zurück.
statischer String valueOf(int i)
Gibt die String-Int-Form des int-Parameters zurück.
statischer String-WertOf(long l)
Gibt die String-Langform des Long-Parameters zurück.
statischer String-WertOf(Object obj)
Gibt die String-Objektform des Objektparameters zurück.

Hinweis: Der Unterschied zwischen der String-Zeichenfolge „==" und der Equals-Methode:

Wenn sie über String str = „“ deklariert wird, können sowohl == als auch equal verwendet werden 🎜>

Wenn es durch einen neuen String ("") deklariert wird, kann == nicht verwendet werden, es können nur Gleichheiten verwendet werden.

4. Demonstrationsfall

Anforderung 1: Zählen Sie die Anzahl der Großbuchstaben, Kleinbuchstaben und Zahlen in einer Zeichenfolge

Idee: Führen Sie die Zeichenfolge durch eine for-Schleife, verwenden Sie die charAt-Methode, um jedes Zeichen abzurufen, und vergleichen Sie dann jedes Zeichen mit dem Wert, der dem AsciI-Code entspricht, um festzustellen, ob es sich um einen Großbuchstaben, einen Kleinbuchstaben oder eine Zahl handelt, und drucken Sie die Anzahl aus.

/**
 * @ 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;
    }
}

Anforderung 2: Fragen Sie die Anzahl der Vorkommen einer bestimmten Teilzeichenfolge in der übergeordneten Zeichenfolge ab

Idee 1: Verwenden Sie die indexOf-Methode, um den Index a des ersten Vorkommens der Teilzeichenfolge abzufragen, und dann verwenden subString Die Methode gibt die Zeichenfolge nach dem übergeordneten Zeichenfolgenindex (a + Teilzeichenfolgenlänge) zurück und zählt +1. Schleife diesen Vorgang, bis der Rückgabewert der indexOf-Methode -1 ist, und halte an, erhalte einfach den Zählwert.

Idee 2: Verwenden Sie die Split-Methode, um die übergeordnete Zeichenfolge in Teilzeichenfolgen aufzuteilen, um ein String-Array zu erhalten. Verwenden Sie die SubString-Methode, um zu ermitteln, ob die letzte Zeichenfolge der übergeordneten Zeichenfolge mit der Teilzeichenfolge übereinstimmt das String-Array. Wenn nicht, wird die Länge 1 des String-Arrays zurückgegeben.

**
 * @ 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 Reguläre Ausdrücke werden häufig zur Überprüfung von ID-Nummern, QQ-Nummern, E-Mail-Adressen usw. verwendet. Zeichenklassen und Bedeutungen:

[abc]　=>　 abc kann verwendet werden

[a- zA-Z] =>　 A-z oder A-Z können verwendet werden, beide Enden sind geschlossene Intervalle

[0-9]　=>　 Die Zahlen 0-9 können

d sein =>　 Und [ 0-9] Dasselbe wie

D　 => Es kann keine Zahl sein

w　 => Es bedeutet, dass Buchstaben, Zahlen und Unterstriche akzeptabel sind, gleich [a -zA-Z0-9_]

x? => Zeigt an, dass x einmal oder gar nicht vorkommt.

x*　 => Zeigt an, dass x null oder mehrmals vorkommt

X{n,m} => Dies bedeutet, dass x n bis m-mal vorkommt.

X+ ^　　 =>　 Gibt den Anfang des regulären Ausdrucks an

&　 => ;  Zeigt das Ende des regulären Ausdrucks an

Anforderung 1: Überprüfen Sie, ob die qq-Nummer korrekt ist

qq-Nummernbedingungen:

(1) Die Anzahl der Ziffern beträgt 5- 15 Ziffern

（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;
    }
}

Das obige ist der detaillierte Inhalt vonEinführung in String-Operationen in Java (Codebeispiel). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!