Regex để chuyển đổi CamelCase thành camel_case trong java

Tôi hiểu tại sao sản lượng mong muốn không được đưa ra cho việc chuyển đổi sử dụng regex một chuỗi như FooBarđể Foo_Barmà thay vào đó đưa ra Foo_Bar_. Tôi có thể đã làm điều gì đó với String.substring substring(0, string.length() - 2)hoặc chỉ thay thế ký tự cuối cùng, nhưng tôi nghĩ có một giải pháp tốt hơn cho một kịch bản như vậy.

Đây là mã:

String regex = "([A-Z][a-z]+)";
String replacement = "$1_";

"CamelCaseToSomethingElse".replaceAll(regex, replacement); 

/*
outputs: Camel_Case_To_Something_Else_
desired output: Camel_Case_To_Something_Else
*/

Câu hỏi: Tìm kiếm một cách gọn gàng hơn để có được đầu ra mong muốn?

Xem câu hỏi này và CaseFormattừ ổi

trong trường hợp của bạn, một cái gì đó như:

CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, "SomeInput");

ràng buộc chữ thường và chữ hoa thành hai nhóm, nó sẽ ổn

public  class Main
{
    public static void main(String args[])
    {
        String regex = "([a-z])([A-Z]+)";
        String replacement = "$1_$2";
        System.out.println("CamelCaseToSomethingElse"
                           .replaceAll(regex, replacement)
                           .toLowerCase());
    }
}

Bạn có thể sử dụng đoạn mã dưới đây:

String replaceAll = key.replaceAll("(.)(\\p{Upper})", "$1_$2").toLowerCase();

Tôi không thể cung cấp RegEx, dù sao thì nó cũng sẽ rất phức tạp.

Hãy thử chức năng này với tính năng tự động nhận dạng các từ viết tắt.

Rất tiếc, Guava lib không tự động phát hiện các từ viết tắt chữ hoa, vì vậy "bigCAT" sẽ được chuyển đổi thành "BIG_C_A_T"

/**
 * Convert to UPPER_UNDERSCORE format detecting upper case acronyms
 */
private String upperUnderscoreWithAcronyms(String name) {
    StringBuffer result = new StringBuffer();
    boolean begin = true;
    boolean lastUppercase = false;
    for( int i=0; i < name.length(); i++ ) {
        char ch = name.charAt(i);
        if( Character.isUpperCase(ch) ) {
            // is start?
            if( begin ) {
                result.append(ch);
            } else {
                if( lastUppercase ) {
                    // test if end of acronym
                    if( i+1<name.length() ) {
                        char next = name.charAt(i+1);
                        if( Character.isUpperCase(next) ) {
                            // acronym continues
                            result.append(ch);
                        } else {
                            // end of acronym
                            result.append('_').append(ch);
                        }
                    } else {
                        // acronym continues
                        result.append(ch);
                    }
                } else {
                    // last was lowercase, insert _
                    result.append('_').append(ch);
                }
            }
            lastUppercase=true;
        } else {
            result.append(Character.toUpperCase(ch));
            lastUppercase=false;
        }
        begin=false;
    }
    return result.toString();
}

Tại sao không chỉ cần đối sánh ký tự trước như một ký tự không phải là đầu dòng $?

String text = "CamelCaseToSomethingElse";
System.out.println(text.replaceAll("([^_A-Z])([A-Z])", "$1_$2"));

Lưu ý rằng phiên bản này an toàn để thực hiện trên một thứ gì đó đã được bọc bằng vỏ camel.

Thêm xác nhận trên đầu nhìn có chiều rộng bằng không.

http://docs.oracle.com/javase/6/docs/api/java/util/regex/Pattern.html

Đọc tài liệu cho (?=X)v.v.

Cá nhân tôi thực sự sẽ chia chuỗi, sau đó kết hợp lại. Điều này thậm chí có thể nhanh hơn khi được thực hiện đúng và nó làm cho mã dễ hiểu hơn nhiều so với phép thuật biểu thức chính quy. Đừng hiểu sai ý tôi: Tôi thích biểu thức chính quy. Nhưng đây không thực sự là một biểu thức chính quy gọn gàng, cũng như việc chuyển đổi này không phải là một tác vụ regexp cổ điển. Sau khi tất cả, có vẻ như bạn cũng muốn làm chữ thường?

Một cách hack xấu xí nhưng nhanh chóng sẽ là thay thế (.)([A-Z]+)bằng $1_$2và sau đó viết thường toàn bộ chuỗi sau đó (trừ khi bạn có thể thực hiện regexps cực đoan kiểu perl, nơi bạn có thể viết thường trực tiếp thay thế!). Tôi vẫn coi việc chia tách ở chuyển tiếp từ dưới lên trên, sau đó chuyển đổi, rồi nối là cách thích hợp và dễ đọc nhất để thực hiện việc này.

public class ReplaceFromCameltoSnake {
    public static void main(String args[]){
        String s1=" totalAmountWithoutDiscount";  
        String replaceString=s1.replaceAll("([A-Z]+)","\\_$1").toLowerCase(); 
        System.out.println(replaceString);  
    }
}

Không chắc có thể có thứ gì đó thực sự hòa tan với regex nguyên chất. Đặc biệt là hỗ trợ các từ viết tắt.

Tôi đã tạo một hàm nhỏ, lấy cảm hứng từ câu trả lời @radzimir, hỗ trợ các từ viết tắt và không có ký tự chữ cái:

Từ https://gist.github.com/ebuildy/cf46a09b1ac43eea17c7621b7617ebcd :

private static String snakeCaseFormat(String name) {
    final StringBuilder result = new StringBuilder();

    boolean lastUppercase = false;

    for (int i = 0; i < name.length(); i++) {
        char ch = name.charAt(i);
        char lastEntry = i == 0 ? 'X' : result.charAt(result.length() - 1);
        if (ch == ' ' || ch == '_' || ch == '-' || ch == '.') {
            lastUppercase = false;

            if (lastEntry == '_') {
                continue;
            } else {
                ch = '_';
            }
        } else if (Character.isUpperCase(ch)) {
            ch = Character.toLowerCase(ch);
            // is start?
            if (i > 0) {
                if (lastUppercase) {
                    // test if end of acronym
                    if (i + 1 < name.length()) {
                        char next = name.charAt(i + 1);
                        if (!Character.isUpperCase(next) && Character.isAlphabetic(next)) {
                            // end of acronym
                            if (lastEntry != '_') {
                                result.append('_');
                            }
                        }
                    }
                } else {
                    // last was lowercase, insert _
                    if (lastEntry != '_') {
                        result.append('_');
                    }
                }
            }
            lastUppercase = true;
        } else {
            lastUppercase = false;
        }

        result.append(ch);
    }
    return result.toString();
}

([A-Z][a-z\d]+)(?=([A-Z][a-z\d]+))

Nên tìm kiếm một ký tự viết hoa theo sau là các ký tự viết thường. Trang đầu tích cực sẽ tìm kiếm một từ khác bắt đầu bằng chữ in hoa theo sau là chữ thường nhưng KHÔNG đưa nó vào kết quả phù hợp.

Xem tại đây: http://regexr.com?30ooo

Tôi đã phải triển khai điều này để chuyển đổi một số khóa ở định dạng chữ hoa camel thành chữ thường với dấu gạch dưới. Biểu thức chính quy mà tôi đã nghĩ ra là:

(?<!^|_|[A-Z])([A-Z])

Trong tiếng Anh, nó là viết tắt của ký tự viết hoa không đứng trước đầu chuỗi, một dấu gạch dưới hoặc một ký tự viết hoa khác .

Trong các mẫu bên dưới, ký tự in đậm là những ký tự sẽ tạo ra kết quả khớp bằng cách sử dụng biểu thức chính quy nói trên:

• Lạc đà C ase T o S omething E lse
• lạc đà C ase T o S omething E lse
• camel_case_to_something_else
• Camel_Case_To_Something_Else
• CAMEL_CASE_TO_SOMETHING_ELSE

Lưu ý rằng biểu thức không ảnh hưởng đến chuỗi đã ở định dạng chữ thường + dấu gạch dưới.

Mẫu thay thế sẽ là:

_l$1

Có nghĩa là viết thường của nhóm bắt đầu tiên, nhóm bắt đầu tiên là chữ cái viết hoa. Bạn cũng có thể viết thường toàn bộ chuỗi sau đó để chuẩn hóa hai mẫu cuối cùng từ danh sách ở trên.