1 /** 2 * Logback: the reliable, generic, fast and flexible logging framework. 3 * Copyright (C) 1999-2015, QOS.ch. All rights reserved. 4 * 5 * This program and the accompanying materials are dual-licensed under 6 * either the terms of the Eclipse Public License v1.0 as published by 7 * the Eclipse Foundation 8 * 9 * or (per the licensee's choosing) 10 * 11 * under the terms of the GNU Lesser General Public License version 2.1 12 * as published by the Free Software Foundation. 13 */ 14 package ch.qos.logback.core.util; 15 16 import java.util.Arrays; 17 import java.util.ArrayList; 18 import java.util.Collection; 19 import java.util.List; 20 import java.util.regex.Pattern; 21 22 /** 23 * Static utility methods for working with collections of strings. 24 * 25 * @author Carl Harris 26 */ 27 public class StringCollectionUtil { 28 29 /** 30 * Retains all values in the subject collection that are matched by at least one 31 * of a collection of regular expressions. 32 * <p> 33 * This method is a convenience overload for 34 * {@link #retainMatching(Collection, Collection)}. 35 * 36 * @param values subject value collection 37 * @param patterns patterns to match 38 */ 39 public static void retainMatching(Collection<String> values, String... patterns) { 40 retainMatching(values, Arrays.asList(patterns)); 41 } 42 43 /** 44 * Retains all values in the subject collection that are matched by at least one 45 * of a collection of regular expressions. 46 * <p> 47 * The semantics of this method are conceptually similar to 48 * {@link Collection#retainAll(Collection)}, but uses pattern matching instead 49 * of exact matching. 50 * 51 * @param values subject value collection 52 * @param patterns patterns to match 53 */ 54 public static void retainMatching(Collection<String> values, Collection<String> patterns) { 55 if (patterns.isEmpty()) 56 return; 57 List<String> matches = new ArrayList<String>(values.size()); 58 for (String p : patterns) { 59 Pattern pattern = Pattern.compile(p); 60 for (String value : values) { 61 if (pattern.matcher(value).matches()) { 62 matches.add(value); 63 } 64 } 65 } 66 values.retainAll(matches); 67 } 68 69 /** 70 * Removes all values in the subject collection that are matched by at least one 71 * of a collection of regular expressions. 72 * <p> 73 * This method is a convenience overload for 74 * {@link #removeMatching(Collection, Collection)}. 75 * 76 * @param values subject value collection 77 * @param patterns patterns to match 78 */ 79 public static void removeMatching(Collection<String> values, String... patterns) { 80 removeMatching(values, Arrays.asList(patterns)); 81 } 82 83 /** 84 * Removes all values in the subject collection that are matched by at least one 85 * of a collection of regular expressions. 86 * <p> 87 * The semantics of this method are conceptually similar to 88 * {@link Collection#removeAll(Collection)}, but uses pattern matching instead 89 * of exact matching. 90 * 91 * @param values subject value collection 92 * @param patterns patterns to match 93 */ 94 public static void removeMatching(Collection<String> values, Collection<String> patterns) { 95 List<String> matches = new ArrayList<String>(values.size()); 96 for (String p : patterns) { 97 Pattern pattern = Pattern.compile(p); 98 for (String value : values) { 99 if (pattern.matcher(value).matches()) { 100 matches.add(value); 101 } 102 } 103 } 104 values.removeAll(matches); 105 } 106 107 }