Java comum objetos 06

· Expressões regulares objeto comum e outros objetos

Visão geral de expressões regulares e simples de usar

* A: a expressão regular
　　* refere-se a uma cadeia utilizada para descrever um único ou uma série de sintaxe da linha de correspondência regras corda Houge. É realmente uma regra, têm as suas próprias aplicações especiais
　　* efeito: por exemplo, correio registado, nome de usuário e senha do correio, geralmente limitar a duração dessa coisa é limitar o comprimento da expressão regular para fazer

* B: apresentação de um caso
　　* Requisitos:
　　* número do cheque qq
　　* 1, que apela a uma 5--15 dígitos
　　* 2, não pode começar um 0
　　* 3, devem todos ser digital

　　* A: Expressão Non-Regular
　　* b: Expressões Regulares

empacotar com.heima.regex; 

público  classe Demo1_Regex { 
    
    pública  estáticos  vazios principais (String [] args) { 
        System.out.println (checkQQ ( "0123"));    // falso 
        System.out.println (checkQQ ( "a123456"));    // falso 
        System.out.println (checkQQ ( "123456"));    // verdadeiro 
        System.out.println (checkQQ ( "12345678910101010"));    // falso 
        System.out.println ( "-----------------------------" ); 
        
        Corda regex = "[1-9] \\ d {4,14}" ; 
        System.out.println (.matches "A12345" (regex));     // falso 
        System.out.println ( "12345" .matches (regex));     // a verdadeira 
        System.out.println ( "012345" .matches (regex));     // false 
        System.out.println ( "345" .matches (REGEX));     // false 
        
    } 
    / * 
     * qq análise de soma de verificação número método: 
     * 1, clara tipo de valor de retorno: Boolean 
     * 2, limpar a lista de parâmetros: corda qq 
     * / 
    público  estático  booleana checkQQ (string QQ) {
         booleana flag = true ; // Se o cheque não cumprir os requisitos, colocar a bandeira é redefinido para Falso, ou retorno direto 

        IF (qq.length ()> = 5 && qq.length. () <= 15) {
             IF (Qq.startsWith ( "0"! )) {
                 Char [] = ARR qq.toCharArray (); // converter a string para um array de caracteres 
                para ( int i = 0; I <arr.Length; i ++ ) {
                     Char CH = ARR [I]; // gravar cada personagem 
                    IF ((CH> = '0' && CH <=' 9' .! {)) 
                        Flag In = false ;    
                         INTERVALO ;     // se você não atender aos requisitos, diretamente 
                    } 
                } 
            } else { 
                Em Flag =para false ; // começar com 0, não atende aos critérios de registo número qq 
            } 
        } else { 
            Em Flag = false ; // comprimento não se encaixa 
        }
         return na bandeira; 
    } 
}

regex

 

 

apresentação classe de personagem

* R: classe de caracteres
　　* [ABC]: a, b, ou C (simples)
　　* [^ ABC]: carácter, além de a, b ou C (negativo)
　　* [A-Za-Z]: A a Z ou é o de a a Z, incluindo dois legendas (intervalo)
　　* [0-9]: caracteres de 0 a 9 são incluídos

 

 

Pacote com.heima.regex; 


pública  classe Demo2_Regex { 

    / * 
     * enfatizou: os suportes representa um único caractere 
     * [abc] a, b, ou C (simples) 
     * [^ ABC] qualquer personagem, além de a, b ou C (Negative ) 
     * [a-zA-z] z para um ou para um z, incluindo duas letras (intervalo) 
     * [AD [MP]] m para um ou para d p: [a-DM-p ] ( e conjunto) 
     * [AZ && [DEF]] D, e ou F (intersecção) 
     * [AZ && [^ aC]] A a Z, excepto que b e c: [ad-Z] (subtraindo) 
     * [AZ && [^ MP] ] a a Z, e m não por p: [a-lq-Z ] ( subtraindo) 
     * / 

    público  estático  vazios principais (String [] args) {
         // o demo1 ();
         // demo2 ();
         // demo3 ();
         // demo4 ();
         //demo5 ();
        // demo6 ();
        // DEMO7 (); 
        
    } 


    Público  estático  vazio DEMO7 () { 
        Cadeia regex = "[az && [^ mp]]" ; 
        System.out.println ( "a" .matches (regex));    // verdadeiros 
        System.out.println ( "m" .matches (regex));    // falsos 
        System.out.println ( "O" .matches (regex));    // false 
    } 


    público  estático  vazio demo6 () { 
        string regex = "[az && [^ bc]]" ; 
        System.out.println ( "a".    // verdadeiros 
        System.out.println ( "B" .matches (regex));    // falso 
        System.out.println ( "1" .matches (regex));    // false 
    } 


    público  estático  vazio demo5 () { 
        string regex = "[az && [def]]";    // 取交集 
        System.out.println ( "a" .matches (regex));    // falsos 
        System.out.println ( "d" .matches (regex));    // verdadeiro 
    } 


público  estático  vazio demo4 () { 
    Cadeia Restring = "[ad [mp]]";    // 等于[a-DM-p]
    System.out.println ( "a" .matches (Restring));    // verdadeiros 
    System.out.println ( "m" .matches (Restring));    // verdadeiros 
    System.out.println ( "E" .matches (Restring));    // falsos 
    System.out.println (.matches "q" (Restring));    // false 
} 

público  estático  vazio demo3 () { 
    Cadeia regexString = "[a-zA-Z]"; // 范围内的字符,头尾都包括在内 
    System.out.println ( "a" .matches (regexString));    // verdadeiros 
    System.out.println (.matches "z" (regexString));    // verdadeiro 
    System.out.println ("    // verdadeiros 
    System.out.println (.matches "Z" (regexString));    // verdadeiro 
    System.out.println ( "1" .matches (regexString));    // false 
} 

público  estático  vazio demo2 () { 
    string regex = "[^ abc]"; // 除了um或b或c都行 
    System.out.printlnl ( "D" .matches (regex));    // verdadeiro 
    System.out.println ( "a" .matches (regex));    // falso 
    System.out.println ( "1" .matches (regex));    // verdadeiros 
    System.out.println (. "%" Partidas (regex));    // verdadeiro 
    System.out.@ 10 representa um personagem e um personagem 0, uma pluralidade de caráter -> false 
    System.out.println ( "" Os jogos (REGEX).); // string nula -> false 
} 

    pública  estática  anular o demo1 () { 
        Cadeia REGEX = "[ABC]"; // [] representa um único caracter, ou b, ou a representa um grupo C 
        System.out.printlnl ( "a" .matches (REGEX));     // a verdadeiros 
        System.out.println (.matches "b" (REGEX));     // a verdadeira 
        System.out.printlnl ( "C" .matches (REGEX));     // a verdadeiros 
        System.out.println (.matches "D" (REGEX));     // false 
    } 
}

regex