java.util.regex - Pattern.compile () öğesinin önemi?

Pattern.compile()Yöntemin önemi nedir ? Nesneyi
almadan önce neden normal ifade dizesini derlemem gerekiyor Matcher?

Örneğin :

String regex = "((\\S+)\\s*some\\s*";

Pattern pattern = Pattern.compile(regex); // why do I need to compile
Matcher matcher = pattern.matcher(text);

compile()Yöntem her zaman bir noktada denir; bir Pattern nesnesi oluşturmanın tek yolu budur. Öyleyse soru gerçekten, neden açıkça adlandırmalısınız ? Bunun nedenlerinden biri group(int), yakalama gruplarının içeriğini almak gibi yöntemlerini kullanabilmeniz için Matcher nesnesine bir referansa ihtiyacınız olmasıdır . Matcher nesnesine ulaşmanın tek yolu, Pattern nesnesinin matcher()yöntemini kullanmaktır ve Pattern nesnesine ulaşmanın tek yolu compile()yöntemdir. Ardından , String veya Pattern sınıflarında find()aksine matches(), yinelenmeyen bir yöntem var .

Diğer neden, aynı Pattern nesnesini tekrar tekrar oluşturmaktan kaçınmaktır. String'de regex destekli yöntemlerden birini (veya matches()Pattern'deki statik yöntemi) her kullandığınızda, yeni bir Desen ve yeni bir Eşleştirici oluşturur. Yani bu kod pasajı:

for (String s : myStringList) {
    if ( s.matches("\\d+") ) {
        doSomething();
    }
}

... tam olarak buna eşdeğerdir:

for (String s : myStringList) {
    if ( Pattern.compile("\\d+").matcher(s).matches() ) {
        doSomething();
    }
}

Açıkçası, bu çok fazla gereksiz iş yapıyor. Aslında, regex'i derlemek ve Pattern nesnesini somutlaştırmak, gerçek bir eşleştirme yapmaktan kolayca daha uzun sürebilir. Bu nedenle, genellikle bu adımı döngüden çıkarmak mantıklıdır. Eşleştiriciyi, neredeyse o kadar pahalı olmasalar da, önceden de oluşturabilirsiniz:

Pattern p = Pattern.compile("\\d+");
Matcher m = p.matcher("");
for (String s : myStringList) {
    if ( m.reset(s).matches() ) {
        doSomething();
    }
}

.NET regexlerine aşina iseniz, Java compile()yönteminin .NET'in RegexOptions.Compileddeğiştiricisiyle ilişkili olup olmadığını merak ediyor olabilirsiniz ; cevap hayır. Java'nın Pattern.compile()yöntemi yalnızca .NET'in Regex yapıcısına eşdeğerdir. CompiledSeçeneği belirttiğinizde :

Regex r = new Regex(@"\d+", RegexOptions.Compiled); 

... regex'i doğrudan CIL bayt koduna derler ve çok daha hızlı çalışmasına izin verir, ancak ön işlem ve bellek kullanımında önemli bir maliyetle - bunu regexler için steroidler olarak düşünün. Java'nın eşdeğeri yoktur; Perde arkasında yaratılan bir Kalıp String#matches(String)ile açıkça oluşturduğunuz bir Kalıp arasında hiçbir fark yoktur Pattern#compile(String).

(DÜZENLEME: Başlangıçta tüm .NET Regex nesnelerinin önbelleğe alındığını söyledim, bu yanlış. .NET 2.0'dan beri, otomatik önbelleğe alma, Regex.Matches()doğrudan bir Regex yapıcısını çağırdığınızda değil, yalnızca statik yöntemlerle gerçekleşir . Ref )

Compile , normal ifadeyi ayrıştırır ve bir bellek içi gösterim oluşturur . Derlenecek ek yük, bir eşleşmeye kıyasla önemlidir. Bir kalıbı tekrar tekrar kullanıyorsanız , derlenen kalıbı önbelleğe almak biraz performans kazanacaktır.

PatternJava'yı derlediğinizde, eşlemeleri Stringdaha hızlı bulmak için bazı hesaplamalar yapar . (Normal ifadenin bellek içi temsilini oluşturur)

Birden Patternçok kez yeniden kullanacaksanız, Patternher seferinde yeni bir tane oluşturmaya göre büyük bir performans artışı göreceksiniz .

Kalıp'ı yalnızca bir kez kullanmak durumunda, derleme adımı fazladan bir kod satırı gibi görünür, ancak aslında genel durumda çok yardımcı olabilir.

Önemli olan performans ve bellek kullanımıdır, çok fazla kullanmanız gerekiyorsa uygun modeli derleyin ve saklayın. Düzenli ifadenin tipik bir kullanımı, doğrulanmış kullanıcı girdisi (biçim) ve ayrıca , bu sınıflarda kullanıcılar için çıktı verilerini biçimlendirmektir , uyumlu örüntüyü kaydetmek, genellikle çok dedikleri için oldukça mantıklı görünür.

Aşağıda, gerçekten çok adlandırılan örnek bir doğrulayıcı var :)

public class AmountValidator {
    //Accept 123 - 123,456 - 123,345.34
    private static final String AMOUNT_REGEX="\\d{1,3}(,\\d{3})*(\\.\\d{1,4})?|\\.\\d{1,4}";
    //Compile and save the pattern  
    private static final Pattern AMOUNT_PATTERN = Pattern.compile(AMOUNT_REGEX);


    public boolean validate(String amount){

         if (!AMOUNT_PATTERN.matcher(amount).matches()) {
            return false;
         }    
        return true;
    }    
}

@Alan Moore tarafından belirtildiği gibi, kodunuzda yeniden kullanılabilir regex varsa (örneğin bir döngüden önce), yeniden kullanım için deseni derlemeniz ve kaydetmeniz gerekir.

Pattern.compile()bir normal ifadenin birden çok kez yeniden kullanılmasına izin verin (iş parçacığı güvenlidir). Performans avantajı oldukça önemli olabilir.

Hızlı bir kıyaslama yaptım:

    @Test
    public void recompile() {
        var before = Instant.now();
        for (int i = 0; i < 1_000_000; i++) {
            Pattern.compile("ab").matcher("abcde").matches();
        }
        System.out.println("recompile " + Duration.between(before, Instant.now()));
    }

    @Test
    public void compileOnce() {
        var pattern = Pattern.compile("ab");
        var before = Instant.now();
        for (int i = 0; i < 1_000_000; i++) {
            pattern.matcher("abcde").matches();
        }
        System.out.println("compile once " + Duration.between(before, Instant.now()));
    }

compileOnce 3x ile 4x arasında daha hızlıydı . Sanırım bu büyük ölçüde normal ifadenin kendisine bağlıdır, ancak sıklıkla kullanılan bir normal ifade içinstatic Pattern pattern = Pattern.compile(...)

Düzenli ifadeyi önceden derlemek hızı artırır. Eşleştiriciyi yeniden kullanmak size biraz daha hız kazandırır. Yöntem sık sık çağrılırsa, bir döngü içinde çağrılırsa, genel performans kesinlikle artacaktır.

'Pattern.compile'a benzer şekilde' RECompiler.compile 'vardır [com.sun.org.apache.regexp.internal'dan] burada:
1. [az] kalıbı için derlenmiş kodda' az 'vardır
2. için derlenmiş kod [0-9] kalıbı içinde '09' var
3. [abc] kalıbı için derlenmiş kod içinde 'aabbcc' var.

Bu nedenle derlenmiş kod, birden çok durumu genelleştirmek için harika bir yoldur. Böylece, farklı kod işleme durumu 1,2 ve 3'e sahip olmak yerine. Sorun, derlenen koddaki mevcut ve sonraki öğenin ascii ile karşılaştırılmasına, dolayısıyla çiftlere indirgenir. Böylece
a. a ve z arasında ascii olan her şey a ile z
b arasındadır . ascii 'a ve a arasında olan herhangi bir şey kesinlikle' a'dır

Pattern sınıfı, normal ifade motorunun giriş noktasıdır. Pattern.matches () ve Pattern.comiple () aracılığıyla kullanabilirsiniz. # Bu ikisi arasındaki fark. eşleşmeler () - bir metnin (Dize) belirli bir düzenli ifade comiple () ile eşleşip eşleşmediğini hızlıca kontrol etmek için - Pattern başvuru oluşturun. Böylece, normal ifadeyi birden çok metinle eşleştirmek için birden çok kez kullanılabilir.

Referans için:

public static void main(String[] args) {
     //single time uses
     String text="The Moon is far away from the Earth";
     String pattern = ".*is.*";
     boolean matches=Pattern.matches(pattern,text);
     System.out.println("Matches::"+matches);

    //multiple time uses
     Pattern p= Pattern.compile("ab");
     Matcher  m=p.matcher("abaaaba");
     while(m.find()) {
         System.out.println(m.start()+ " ");
     }
}