Java and JavaScript Regular Expression Samples

public class EmailValidator {
    public static boolean validateEmail(String email) {
        String regex = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$";
        return email.matches(regex);
    }

    public static void main(String[] args) {
        System.out.println(validateEmail("example@domain.com")); // true
        System.out.println(validateEmail("invalid.email@")); // false
    }
}
                    

public class PhoneValidator {
    public static boolean validatePhone(String phone) {
        String regex = "^010-\\d{4}-\\d{4}$";
        return phone.matches(regex);
    }

    public static void main(String[] args) {
        System.out.println(validatePhone("010-1234-5678")); // true
        System.out.println(validatePhone("011-123-4567")); // false
    }
}
                    

public class NumberExtractor {
    public static String extractNumbers(String str) {
        return str.replaceAll("[^0-9]", "");
    }

    public static void main(String[] args) {
        System.out.println(extractNumbers("abc123def456")); // "123456"
        System.out.println(extractNumbers("no numbers")); // ""
    }
}
                    

public class EnglishExtractor {
    public static String extractEnglish(String str) {
        return str.replaceAll("[^a-zA-Z]", "");
    }

    public static void main(String[] args) {
        System.out.println(extractEnglish("hello안녕123world")); // "helloworld"
        System.out.println(extractEnglish("123가나다")); // ""
    }
}
                    

public class SpecialCharRemover {
    public static String removeSpecialChars(String str) {
        return str.replaceAll("[^a-zA-Z0-9가-힣\\s]", "");
    }

    public static void main(String[] args) {
        System.out.println(removeSpecialChars("hello@world! 안녕#")); // "helloworld 안녕"
        System.out.println(removeSpecialChars("@#$%")); // ""
    }
}
                    

public class SpaceRemover {
    // Remove all whitespace (spaces, tabs, newlines)
    public static String removeAllSpaces(String str) {
        return str.replaceAll("\\s", "");
    }

    // Remove whitespace from both ends only
    public static String trimSpaces(String str) {
        return str.replaceAll("^\\s+|\\s+$", "");
        // Or use the built-in method
        // return str.trim();
    }

    // Normalize multiple spaces to single spaces
    public static String normalizeSpaces(String str) {
        return str.replaceAll("\\s+", " ");
    }

    public static void main(String[] args) {
        String text = "  Hello   World  \n  ";
        System.out.println(removeAllSpaces(text)); // "HelloWorld"
        System.out.println(trimSpaces(text)); // "Hello   World"
        System.out.println(normalizeSpaces(text)); // " Hello World "
    }
}
                    

public class StringPadder {
    // Left padding (Lpadding)
    public static String leftPad(String str, int length, char padChar) {
        if (str.length() >= length) {
            return str;
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < length - str.length(); i++) {
            sb.append(padChar);
        }
        sb.append(str);
        return sb.toString();
    }

    // Java 11+ offers repeat() method
    public static String leftPadJava11(String str, int length, char padChar) {
        if (str.length() >= length) {
            return str;
        }
        return String.valueOf(padChar).repeat(length - str.length()) + str;
    }

    // Right padding (Rpadding)
    public static String rightPad(String str, int length, char padChar) {
        if (str.length() >= length) {
            return str;
        }
        StringBuilder sb = new StringBuilder(str);
        for (int i = 0; i < length - str.length(); i++) {
            sb.append(padChar);
        }
        return sb.toString();
    }

    // Java 11+ offers repeat() method
    public static String rightPadJava11(String str, int length, char padChar) {
        if (str.length() >= length) {
            return str;
        }
        return str + String.valueOf(padChar).repeat(length - str.length());
    }

    public static void main(String[] args) {
        String num = "42";
        System.out.println(leftPad(num, 5, '0')); // "00042"
        // System.out.println(leftPadJava11(num, 5, '0')); // "00042" (Java 11+)
        System.out.println(rightPad(num, 5, '0')); // "42000"
        // System.out.println(rightPadJava11(num, 5, '0')); // "42000" (Java 11+)
    }
}
                    

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class UrlExtractor {
    // Pattern for general URL detection
    private static final String URL_REGEX = "https?:\\/\\/(www\\.)?[-a-zA-Z0-9@:%._\\+~#=]{1,256}\\.[a-zA-Z0-9()]{1,6}\\b([-a-zA-Z0-9()@:%_\\+.~#?&//=]*)";
    private static final Pattern URL_PATTERN = Pattern.compile(URL_REGEX);
    
    // Extract URLs from text
    public static List extractUrls(String text) {
        List urls = new ArrayList<>();
        Matcher matcher = URL_PATTERN.matcher(text);
        
        while (matcher.find()) {
            urls.add(matcher.group());
        }
        
        return urls;
    }
    
    // Validate if a string is a valid URL
    public static boolean isValidUrl(String url) {
        return URL_PATTERN.matcher(url).matches();
    }
    
    public static void main(String[] args) {
        String text = "Visit https://example.com and http://github.com/user/repo for more info.";
        
        List urls = extractUrls(text);
        System.out.println(urls); 
        // [https://example.com, http://github.com/user/repo]
        
        System.out.println(isValidUrl("https://example.com")); // true
        System.out.println(isValidUrl("not-a-url")); // false
    }
}
                    

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class DateValidator {
    // YYYY-MM-DD format (ISO)
    private static final Pattern ISO_DATE_PATTERN = Pattern.compile("^\\d{4}-\\d{2}-\\d{2}$");
    
    // MM/DD/YYYY format (US)
    private static final Pattern US_DATE_PATTERN = 
        Pattern.compile("^(0[1-9]|1[0-2])\\/(0[1-9]|[12]\\d|3[01])\\/\\d{4}$");
    
    // DD/MM/YYYY format (UK/EU)
    private static final Pattern EU_DATE_PATTERN = 
        Pattern.compile("^(0[1-9]|[12]\\d|3[01])\\/(0[1-9]|1[0-2])\\/\\d{4}$");
    
    // Combined pattern for extraction
    private static final Pattern ANY_DATE_PATTERN = 
        Pattern.compile("\\b(\\d{4}-\\d{2}-\\d{2}|\\d{1,2}\\/\\d{1,2}\\/\\d{4}|\\d{1,2}-\\d{1,2}-\\d{4})\\b");
    
    // Validate date string against a specific format
    public static boolean validateDate(String date, String format) {
        switch(format) {
            case "iso":
                return ISO_DATE_PATTERN.matcher(date).matches();
            case "us":
                return US_DATE_PATTERN.matcher(date).matches();
            case "eu":
                return EU_DATE_PATTERN.matcher(date).matches();
            default:
                return false;
        }
    }
    
    // Extract dates from text
    public static List extractDates(String text) {
        List dates = new ArrayList<>();
        Matcher matcher = ANY_DATE_PATTERN.matcher(text);
        
        while (matcher.find()) {
            dates.add(matcher.group());
        }
        
        return dates;
    }
    
    public static void main(String[] args) {
        System.out.println(validateDate("2023-01-15", "iso")); // true
        System.out.println(validateDate("01/15/2023", "us")); // true
        System.out.println(validateDate("15/01/2023", "eu")); // true
        
        String text = "Meeting on 2023-01-15 and deadline is 02/28/2023.";
        System.out.println(extractDates(text)); // [2023-01-15, 02/28/2023]
    }
}
                    

public class HtmlTagRemover {
    // 간단한 HTML 태그 제거
    public static String stripHtmlTags(String html) {
        return html.replaceAll("<[^>]*>", "");
    }
    
    // HTML 태그 제거 및 엔티티 처리
    public static String stripHtmlTagsAndEntities(String html) {
        // 먼저 일반적인 HTML 엔티티 치환
        String withoutEntities = html
            .replaceAll(" ", " ")
            .replaceAll("&", "&")
            .replaceAll("<", "<")
            .replaceAll(">", ">")
            .replaceAll(""", "\"")
            .replaceAll("'", "'");
        
        // 그 다음 모든 HTML 태그 제거
        return withoutEntities.replaceAll("<[^>]*>", "");
    }
    
    public static void main(String[] args) {
        String htmlContent = "
이것은 굵은 그리고 이탤릭 텍스트와 링크입니다.
";
        System.out.println(stripHtmlTags(htmlContent));
        // "이것은 굵은 그리고 이탤릭 텍스트와 링크입니다."
        
        String htmlWithEntities = "
이것 & 저것 "따옴표"와 <태그>.
";
        System.out.println(stripHtmlTagsAndEntities(htmlWithEntities));
        // "이것 & 저것 "따옴표"와 <태그>."
    }
}
                    

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class IPv4Validator {
    // IPv4 주소 패턴
    private static final String IPV4_PATTERN = 
        "\\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\b";
    
    private static final Pattern IPV4_REGEX = Pattern.compile(IPV4_PATTERN);
    
    // IPv4 주소 검증
    public static boolean isValidIpv4(String ip) {
        return IPV4_REGEX.matcher(ip).matches();
    }
    
    // 텍스트에서 IPv4 주소 추출
    public static List extractIpv4Addresses(String text) {
        List ipAddresses = new ArrayList<>();
        Matcher matcher = IPV4_REGEX.matcher(text);
        
        while (matcher.find()) {
            ipAddresses.add(matcher.group());
        }
        
        return ipAddresses;
    }
    
    public static void main(String[] args) {
        System.out.println(isValidIpv4("192.168.1.1")); // true
        System.out.println(isValidIpv4("255.255.255.255")); // true
        System.out.println(isValidIpv4("256.256.256.256")); // false (유효하지 않은 값)
        System.out.println(isValidIpv4("192.168.1")); // false (불완전)
        
        String networkLog = "클라이언트 192.168.1.5가 게이트웨이 192.168.1.1을 통해 서버 10.0.0.1에 연결되었습니다";
        System.out.println(extractIpv4Addresses(networkLog));
        // [192.168.1.5, 10.0.0.1, 192.168.1.1]
    }
}
                    

import java.util.HashMap;
import java.util.Map;
import java.util.regex.Pattern;

public class PasswordStrengthChecker {
    // Patterns for different criteria
    private static final Pattern HAS_LOWERCASE = Pattern.compile("[a-z]");
    private static final Pattern HAS_UPPERCASE = Pattern.compile("[A-Z]");
    private static final Pattern HAS_DIGIT = Pattern.compile("\\d");
    private static final Pattern HAS_SPECIAL = Pattern.compile("[@$!%*?&]");
    
    // Combined strong password pattern
    private static final Pattern STRONG_PASSWORD = 
        Pattern.compile("^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@$!%*?&])[A-Za-z\\d@$!%*?&]{8,}$");
    
    // Check if password is strong
    public static boolean isStrongPassword(String password) {
        return STRONG_PASSWORD.matcher(password).matches();
    }
    
    // Get detailed password strength
    public static Map getPasswordStrength(String password) {
        Map checks = new HashMap<>();
        checks.put("length", password.length() >= 8);
        checks.put("lowercase", HAS_LOWERCASE.matcher(password).find());
        checks.put("uppercase", HAS_UPPERCASE.matcher(password).find());
        checks.put("number", HAS_DIGIT.matcher(password).find());
        checks.put("special", HAS_SPECIAL.matcher(password).find());
        
        // Count passed checks
        long passedChecks = checks.values().stream().filter(Boolean::booleanValue).count();
        
        // Create result map
        Map result = new HashMap<>();
        result.put("strength", (double) passedChecks / 5); // 0 to 1 scale
        result.put("isStrong", passedChecks == 5);
        result.put("details", checks);
        
        return result;
    }
    
    public static void main(String[] args) {
        System.out.println(isStrongPassword("Weak123")); // false (특수 문자 없음)
        System.out.println(isStrongPassword("Strong123!")); // true
        
        String password1 = "password";
        String password2 = "Password1";
        String password3 = "Password1!";
        
        System.out.println(getPasswordStrength(password1)); 
        // {strength=0.4, details={...}, isStrong=false}
        
        System.out.println(getPasswordStrength(password2)); 
        // {strength=0.8, details={...}, isStrong=false}
        
        System.out.println(getPasswordStrength(password3)); 
        // {strength=1.0, details={...}, isStrong=true}
    }
}
                    

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class WordBoundaryMatcher {
    // 모든 단어 추출
    public static List extractWords(String text) {
        List words = new ArrayList<>();
        Pattern pattern = Pattern.compile("\\b\\w+\\b");
        Matcher matcher = pattern.matcher(text);
        
        while (matcher.find()) {
            words.add(matcher.group());
        }
        
        return words;
    }
    
    // 특정 패턴과 일치하는 단어 찾기
    public static List findWords(String text, String wordPattern) {
        List matchedWords = new ArrayList<>();
        Pattern pattern = Pattern.compile("\\b(" + wordPattern + ")\\b");
        Matcher matcher = pattern.matcher(text);
        
        while (matcher.find()) {
            matchedWords.add(matcher.group());
        }
        
        return matchedWords;
    }
    
    // 최소 길이를 가진 단어 찾기
    public static List findLongWords(String text, int minLength) {
        List longWords = new ArrayList<>();
        Pattern pattern = Pattern.compile("\\b\\w{" + minLength + ",}\\b");
        Matcher matcher = pattern.matcher(text);
        
        while (matcher.find()) {
            longWords.add(matcher.group());
        }
        
        return longWords;
    }
    
    public static void main(String[] args) {
        String text = "안녕 세계! 이것은 몇 가지 길고 짧은 단어가 포함된 샘플 텍스트입니다.";
        
        System.out.println(extractWords(text));
        // [안녕, 세계, 이것은, 몇, 가지, 길고, 짧은, 단어가, 포함된, 샘플, 텍스트입니다]
        
        System.out.println(findWords(text, "세계|텍스트|샘플"));
        // [세계, 샘플, 텍스트]
        
        System.out.println(findLongWords(text, 3));
        // [안녕, 세계, 이것은, 가지, 길고, 짧은, 단어가, 포함된, 샘플, 텍스트입니다]
    }
}