001/* 002 Copyright (c) 2009-2011 Olivier Chafik, All Rights Reserved 003 004 This file is part of JNAerator (http://jnaerator.googlecode.com/). 005 006 JNAerator is free software: you can redistribute it and/or modify 007 it under the terms of the GNU General Public License as published by 008 the Free Software Foundation, either version 3 of the License, or 009 (at your option) any later version. 010 011 JNAerator is distributed in the hope that it will be useful, 012 but WITHOUT ANY WARRANTY; without even the implied warranty of 013 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 014 GNU General Public License for more details. 015 016 You should have received a copy of the GNU General Public License 017 along with JNAerator. If not, see <http://www.gnu.org/licenses/>. 018*/ 019package com.ochafik.util.string; 020import java.util.ArrayList; 021import java.util.Arrays; 022import java.util.LinkedList; 023import java.util.List; 024import java.util.StringTokenizer; 025import java.util.regex.Matcher; 026import java.util.regex.Pattern; 027public class StringUtils { 028 public static String htmlize(String text) { 029 return text.startsWith("<?") || text.startsWith("<html>") ? 030 text : "<html><body>"+ 031 text.replace("&", "&").replace("<", "<").replace(">", ">").replace("\n","<br>")+ 032 "</body></html>"; 033 } 034 035 static Pattern spacePattern; 036 public static List<String> explode(String s) { 037 if (spacePattern == null) { 038 spacePattern = Pattern.compile("\\s+"); 039 } 040 return explode(s, spacePattern); 041 } 042 public static List<String> explode(String s, String sep) { 043 StringTokenizer st=new StringTokenizer(s,sep); 044 List<String> v = new ArrayList<String>(); 045 for (;st.hasMoreTokens();) { 046 v.add(st.nextToken()); 047 } 048 return v; 049 } 050 051/* 052 public static final String implode(Object[] strings, String separator) { 053 return implode(Arrays.asList(strings), separator); 054 } 055*/ 056 public static String implode(double[] array, String separator) { 057 StringBuffer out = new StringBuffer(); 058 boolean first = true; 059 for (double v : array) { 060 if (first) first = false; 061 else out.append(separator); 062 out.append(v); 063 } 064 return out.toString(); 065 } 066 067 public static String implode(Object[] values) { 068 return implode(values, ", "); 069 } 070 public static String implode(Object[] values, Object separator) { 071 return implode(Arrays.asList(values), separator); 072 } 073 public static final <T> String implode(Iterable<T> elements, Object separator) { 074 String sepStr = separator.toString(); 075 StringBuilder out = new StringBuilder(); 076 boolean first = true; 077 for (Object s : elements) { 078 if (s == null) 079 continue; 080 081 if (first) 082 first = false; 083 else 084 out.append(sepStr); 085 out.append(s); 086 } 087 return out.toString(); 088 } 089 public static final String implode(Iterable<?> strings) { 090 return implode(strings, ", "); 091 } 092 /* 093 public static final String implode(Collection<?> strings, String separator) { 094 int size = 0, n = strings.size(); 095 for (Object s : strings) 096 if (s != null) 097 size += s.toString().length(); 098 099 StringBuffer out = new StringBuffer(size + separator.length() * (n == 0 ? 0 : n - 1)); 100 boolean first = true; 101 for (Object s : strings) { 102 if (s == null) 103 continue; 104 105 if (first) first = false; 106 else out.append(separator); 107 out.append(s); 108 } 109 return out.toString(); 110 } 111 */ 112 public static final List<String> explode(String string, Pattern separator) { 113 int lastIndex = 0, len = string.length(); 114 115 Matcher matcher = separator.matcher(string); 116 List<String> ret = new LinkedList<String>(); 117 118 while (matcher.find()) { 119 String s = string.substring(lastIndex, matcher.start()); 120 if (s.length() > 0) ret.add(s); 121 lastIndex = matcher.end(); 122 } 123 String s = string.substring(lastIndex, len); 124 if (s.length() > 0) ret.add(s); 125 126 return ret; 127 } 128 129 public static String replace(String pattern, String replace, String s) { 130 return concatWithSeparator(explode(s,pattern).toArray(new String[0]),replace); 131 } 132 public static final String concat(String[] a) { 133 StringBuffer b=new StringBuffer(); 134 for (int i=0;i<a.length;i++) b.append(a[i]); 135 return b.toString(); 136 } 137 public static final String concatln(String[] a) { 138 StringBuffer b=new StringBuffer(); 139 int lenm=a.length-1; 140 for (int i=0;i<lenm;i++) { 141 b.append(a[i]); 142 b.append("\n"); 143 } 144 if (lenm!=-1) b.append(a[lenm]); 145 return b.toString(); 146 } 147 public static final String concatSpace(String[] a) { 148 StringBuffer b=new StringBuffer(); 149 int lenm=a.length-1; 150 for (int i=0;i<lenm;i++) { 151 b.append(a[i]); 152 b.append(" "); 153 } 154 if (lenm!=-1) b.append(a[lenm]); 155 return b.toString(); 156 } 157 public static final String concatWithSeparator(String[] a,String sep) { 158 StringBuffer b=new StringBuffer(); 159 int lenm=a.length-1; 160 for (int i=0;i<lenm;i++) { 161 b.append(a[i]); 162 b.append(sep); 163 } 164 if (lenm!=-1) b.append(a[lenm]); 165 return b.toString(); 166 } 167 public static final String javaEscape(String s) { 168 if (s == null) 169 return null; 170 char c; 171 int len=s.length(); 172 StringBuffer b=new StringBuffer(len); 173 for (int i=0;i<len;i++) { 174 c=s.charAt(i); 175 switch (c) { 176 case '\n': 177 b.append("\\n"); 178 break; 179 case '\t': 180 b.append("\\t"); 181 break; 182 case '\r': 183 b.append("\\r"); 184 break; 185 case '"': 186 b.append("\""); 187 break; 188 case '\\': 189 b.append("\\\\"); 190 break; 191 default: 192 if (c>127||Character.isISOControl(c)) { 193 b.append("\\u"); 194 String nb=Integer.toString((int)c,16); 195 int nblen=nb.length(); 196 switch (nblen) { 197 case 1: 198 b.append(0); 199 case 2: 200 b.append(0); 201 case 3: 202 b.append(0); 203 case 4: 204 b.append(nb); 205 break; 206 default: 207 throw new IllegalArgumentException("Should not happen !"); 208 } 209 } else b.append(c); 210 } 211 } 212 return b.toString(); 213 } 214 public static final String javaUnEscape(String s) { 215 char c; 216 int len=s.length(); 217 StringBuffer b=new StringBuffer(len); 218 for (int i=0;i<len;i++) { 219 c=s.charAt(i); 220 if (c=='\\') { 221 c=s.charAt(++i); 222 switch (c) { 223 case 'n': 224 b.append('\n'); 225 break; 226 case 'r': 227 b.append('\r'); 228 break; 229 case 't': 230 b.append('\t'); 231 break; 232 case '\\': 233 b.append('\\'); 234 break; 235 case '"': 236 b.append('"'); 237 break; 238 case '\'': 239 b.append('\''); 240 break; 241 case 'u': 242 try { 243 String nb=s.substring(i+1,i+5); 244 int n=Integer.parseInt(nb,16); 245 b.append((char)n); 246 i+=4; 247 } catch (Exception ex) { 248 throw new IllegalArgumentException("Illegal unicode escaping in string \"" + s + "\" at index " + i, ex); 249 } 250 break; 251 default: 252 throw new IllegalArgumentException("Unknown character: \"\\"+String.valueOf(c)+"...\""); 253 } 254 } else b.append(c); 255 } 256 return b.toString(); 257 } 258 259 public static String capitalize(String string) { 260 return string == null ? null : string.length() == 0 ? "" : Character.toUpperCase(string.charAt(0)) + string.substring(1); 261 } 262 public static String capitalize(List<String> strings, String separator) { 263 List<String> cap = new ArrayList<String>(strings.size()); 264 for (String s : strings) 265 cap.add(capitalize(s)); 266 return implode(cap, separator); 267 } 268 269 public static String uncapitalize(String string) { 270 return string.length() == 0 ? "" : Character.toLowerCase(string.charAt(0)) + string.substring(1); 271 } 272 public static final String LINE_SEPARATOR; 273 static { 274 LINE_SEPARATOR = System.getProperty("line.separator"); 275 } 276 277}