001
014
015 package com.liferay.portal.kernel.util;
016
017 import java.net.MalformedURLException;
018 import java.net.URL;
019
020 import java.util.Arrays;
021 import java.util.regex.Matcher;
022 import java.util.regex.Pattern;
023
024
030 public class Validator {
031
032
040 public static boolean equals(boolean boolean1, boolean boolean2) {
041 if (boolean1 == boolean2) {
042 return true;
043 }
044 else {
045 return false;
046 }
047 }
048
049
057 public static boolean equals(byte byte1, byte byte2) {
058 if (byte1 == byte2) {
059 return true;
060 }
061 else {
062 return false;
063 }
064 }
065
066
074 public static boolean equals(char char1, char char2) {
075 if (char1 == char2) {
076 return true;
077 }
078 else {
079 return false;
080 }
081 }
082
083
091 public static boolean equals(double double1, double double2) {
092 if (Double.compare(double1, double2) == 0) {
093 return true;
094 }
095 else {
096 return false;
097 }
098 }
099
100
108 public static boolean equals(float float1, float float2) {
109 if (Float.compare(float1, float2) == 0) {
110 return true;
111 }
112 else {
113 return false;
114 }
115 }
116
117
125 public static boolean equals(int int1, int int2) {
126 if (int1 == int2) {
127 return true;
128 }
129 else {
130 return false;
131 }
132 }
133
134
142 public static boolean equals(long long1, long long2) {
143 if (long1 == long2) {
144 return true;
145 }
146 else {
147 return false;
148 }
149 }
150
151
160 public static boolean equals(Object obj1, Object obj2) {
161 if ((obj1 == null) && (obj2 == null)) {
162 return true;
163 }
164 else if ((obj1 == null) || (obj2 == null)) {
165 return false;
166 }
167 else {
168 return obj1.equals(obj2);
169 }
170 }
171
172
180 public static boolean equals(short short1, short short2) {
181 if (short1 == short2) {
182 return true;
183 }
184 else {
185 return false;
186 }
187 }
188
189
197 public static boolean equalsSorted(
198 boolean[] booleanArray1, boolean[] booleanArray2) {
199
200 Boolean[] booleanObjArray1 = ArrayUtil.toArray(booleanArray1);
201
202 Arrays.sort(booleanObjArray1);
203
204 Boolean[] booleanObjArray2 = ArrayUtil.toArray(booleanArray2);
205
206 Arrays.sort(booleanObjArray2);
207
208 return Arrays.equals(booleanObjArray1, booleanObjArray2);
209 }
210
211
219 public static boolean equalsSorted(byte[] byteArray1, byte[] byteArray2) {
220 byteArray1 = ArrayUtil.clone(byteArray1);
221
222 Arrays.sort(byteArray1);
223
224 byteArray2 = ArrayUtil.clone(byteArray2);
225
226 Arrays.sort(byteArray2);
227
228 return Arrays.equals(byteArray1, byteArray2);
229 }
230
231
239 public static boolean equalsSorted(char[] charArray1, char[] charArray2) {
240 charArray1 = ArrayUtil.clone(charArray1);
241
242 Arrays.sort(charArray1);
243
244 charArray2 = ArrayUtil.clone(charArray2);
245
246 Arrays.sort(charArray2);
247
248 return Arrays.equals(charArray1, charArray2);
249 }
250
251
259 public static boolean equalsSorted(
260 double[] doubleArray1, double[] doubleArray2) {
261
262 doubleArray1 = ArrayUtil.clone(doubleArray1);
263
264 Arrays.sort(doubleArray1);
265
266 doubleArray2 = ArrayUtil.clone(doubleArray2);
267
268 Arrays.sort(doubleArray2);
269
270 return Arrays.equals(doubleArray1, doubleArray2);
271 }
272
273
281 public static boolean equalsSorted(
282 float[] floatArray1, float[] floatArray2) {
283
284 floatArray1 = ArrayUtil.clone(floatArray1);
285
286 Arrays.sort(floatArray1);
287
288 floatArray2 = ArrayUtil.clone(floatArray2);
289
290 Arrays.sort(floatArray2);
291
292 return Arrays.equals(floatArray1, floatArray2);
293 }
294
295
303 public static boolean equalsSorted(int[] intArray1, int[] intArray2) {
304 intArray1 = ArrayUtil.clone(intArray1);
305
306 Arrays.sort(intArray1);
307
308 intArray2 = ArrayUtil.clone(intArray2);
309
310 Arrays.sort(intArray2);
311
312 return Arrays.equals(intArray1, intArray2);
313 }
314
315
323 public static boolean equalsSorted(long[] longArray1, long[] longArray2) {
324 longArray1 = ArrayUtil.clone(longArray1);
325
326 Arrays.sort(longArray1);
327
328 longArray2 = ArrayUtil.clone(longArray2);
329
330 Arrays.sort(longArray2);
331
332 return Arrays.equals(longArray1, longArray2); }
333
334
342 public static boolean equalsSorted(Object[] objArray1, Object[] objArray2) {
343 objArray1 = ArrayUtil.clone(objArray1);
344
345 Arrays.sort(objArray1);
346
347 objArray2 = ArrayUtil.clone(objArray2);
348
349 Arrays.sort(objArray2);
350
351 return Arrays.equals(objArray1, objArray2); }
352
353
361 public static boolean equalsSorted(
362 short[] shortArray1, short[] shortArray2) {
363
364 shortArray1 = ArrayUtil.clone(shortArray1);
365
366 Arrays.sort(shortArray1);
367
368 shortArray2 = ArrayUtil.clone(shortArray2);
369
370 Arrays.sort(shortArray2);
371
372 return Arrays.equals(shortArray1, shortArray2);
373 }
374
375
384 public static boolean isAddress(String address) {
385 if (isNull(address)) {
386 return false;
387 }
388
389 String[] tokens = address.split(StringPool.AT);
390
391 if (tokens.length != 2) {
392 return false;
393 }
394
395 for (String token : tokens) {
396 for (char c : token.toCharArray()) {
397 if (Character.isWhitespace(c)) {
398 return false;
399 }
400 }
401 }
402
403 return true;
404 }
405
406
414 public static boolean isAlphanumericName(String name) {
415 if (isNull(name)) {
416 return false;
417 }
418
419 for (char c : name.trim().toCharArray()) {
420 if (!isChar(c) && !isDigit(c) && !Character.isWhitespace(c)) {
421 return false;
422 }
423 }
424
425 return true;
426 }
427
428
437 public static boolean isAscii(char c) {
438 int i = c;
439
440 if ((i >= 32) && (i <= 126)) {
441 return true;
442 }
443 else {
444 return false;
445 }
446 }
447
448 public static boolean isBlank(String s) {
449 if (s == null) {
450 return true;
451 }
452
453 if (s.length() == 0) {
454 return true;
455 }
456
457 return false;
458 }
459
460
468 public static boolean isChar(char c) {
469 int x = c;
470
471 if (((x >= _CHAR_LOWER_CASE_BEGIN) && (x <= _CHAR_LOWER_CASE_END)) ||
472 ((x >= _CHAR_UPPER_CASE_BEGIN) && (x <= _CHAR_UPPER_CASE_END))) {
473
474 return true;
475 }
476
477 return false;
478 }
479
480
488 public static boolean isChar(String s) {
489 if (isNull(s)) {
490 return false;
491 }
492
493 for (char c : s.toCharArray()) {
494 if (!isChar(c)) {
495 return false;
496 }
497 }
498
499 return true;
500 }
501
502
511 public static boolean isDate(int month, int day, int year) {
512 return isGregorianDate(month, day, year);
513 }
514
515
523 public static boolean isDigit(char c) {
524 int x = c;
525
526 if ((x >= _DIGIT_BEGIN) && (x <= _DIGIT_END)) {
527 return true;
528 }
529
530 return false;
531 }
532
533
541 public static boolean isDigit(String s) {
542 if (isNull(s)) {
543 return false;
544 }
545
546 for (char c : s.toCharArray()) {
547 if (!isDigit(c)) {
548 return false;
549 }
550 }
551
552 return true;
553 }
554
555
564 public static boolean isDomain(String domainName) {
565
566
567
568
569 if (isNull(domainName)) {
570 return false;
571 }
572
573 if (domainName.length() > 255) {
574 return false;
575 }
576
577 if (domainName.startsWith(StringPool.PERIOD) ||
578 domainName.endsWith(StringPool.PERIOD)) {
579
580 return false;
581 }
582
583 if (!domainName.contains(StringPool.PERIOD) &&
584 !domainName.equals(_LOCALHOST)) {
585
586 return false;
587 }
588
589 String[] domainNameArray = StringUtil.split(
590 domainName, CharPool.PERIOD);
591
592 for (String domainNamePart : domainNameArray) {
593 char[] domainNamePartCharArray = domainNamePart.toCharArray();
594
595 for (int i = 0; i < domainNamePartCharArray.length; i++) {
596 char c = domainNamePartCharArray[i];
597
598 if ((i == 0) && (c == CharPool.DASH)) {
599 return false;
600 }
601
602 if ((i == (domainNamePartCharArray.length - 1)) &&
603 (c == CharPool.DASH)) {
604
605 return false;
606 }
607
608 if (!isChar(c) && !isDigit(c) && (c != CharPool.DASH)) {
609 return false;
610 }
611 }
612 }
613
614 return true;
615 }
616
617
624 public static boolean isEmailAddress(String emailAddress) {
625 Matcher matcher = _emailAddressPattern.matcher(emailAddress);
626
627 return matcher.matches();
628 }
629
630
638 public static boolean isEmailAddressSpecialChar(char c) {
639
640
641
642 for (char specialChar : _EMAIL_ADDRESS_SPECIAL_CHAR) {
643 if (c == specialChar) {
644 return true;
645 }
646 }
647
648 return false;
649 }
650
651
658 public static boolean isFileExtension(String fileExtension) {
659 if (isNull(fileExtension) ||
660 fileExtension.contains(StringPool.BACK_SLASH) ||
661 fileExtension.contains(StringPool.NULL_CHAR) ||
662 fileExtension.contains(StringPool.SLASH)) {
663
664 return false;
665 }
666
667 return true;
668 }
669
670 public static boolean isFileName(String name) {
671 if (isNull(name) || name.equals(StringPool.PERIOD) ||
672 name.equals(StringPool.DOUBLE_PERIOD) ||
673 name.contains(StringPool.BACK_SLASH) ||
674 name.contains(StringPool.NULL_CHAR) ||
675 name.contains(StringPool.SLASH)) {
676
677 return false;
678 }
679
680 return true;
681 }
682
683 public static boolean isFilePath(String path, boolean isParentDirAllowed) {
684 if (Validator.isNull(path)) {
685 return false;
686 }
687
688 if (path.contains(StringPool.NULL_CHAR)) {
689 return false;
690 }
691
692 if (isParentDirAllowed) {
693 return true;
694 }
695
696 if (path.equals(StringPool.DOUBLE_PERIOD)) {
697 return false;
698 }
699
700 String normalizedPath = path.replace(
701 CharPool.BACK_SLASH, CharPool.SLASH);
702
703 if (normalizedPath.startsWith(
704 StringPool.DOUBLE_PERIOD.concat(StringPool.SLASH))) {
705
706 return false;
707 }
708
709 if (normalizedPath.endsWith(
710 StringPool.SLASH.concat(StringPool.DOUBLE_PERIOD))) {
711
712 return false;
713 }
714
715 if (normalizedPath.contains(
716 StringPool.SLASH.concat(
717 StringPool.DOUBLE_PERIOD).concat(StringPool.SLASH))) {
718
719 return false;
720 }
721
722 return true;
723 }
724
725
734 public static boolean isGregorianDate(int month, int day, int year) {
735 if ((month < 0) || (month > 11)) {
736 return false;
737 }
738
739 int[] months = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
740
741 if (month == 1) {
742 int febMax = 28;
743
744 if (((year % 4) == 0) && ((year % 100) != 0) ||
745 ((year % 400) == 0)) {
746
747 febMax = 29;
748 }
749
750 if ((day < 1) || (day > febMax)) {
751 return false;
752 }
753 }
754 else if ((day < 1) || (day > months[month])) {
755 return false;
756 }
757
758 return true;
759 }
760
761
771 public static boolean isHex(String s) {
772 if (isNull(s)) {
773 return false;
774 }
775
776 return true;
777 }
778
779
786 public static boolean isHostName(String name) {
787 if (isNull(name)) {
788 return false;
789 }
790
791 char[] nameCharArray = name.toCharArray();
792
793 if ((nameCharArray[0] == CharPool.DASH) ||
794 (nameCharArray[0] == CharPool.PERIOD) ||
795 (nameCharArray[nameCharArray.length - 1] == CharPool.DASH)) {
796
797 return false;
798 }
799
800 for (char c : nameCharArray) {
801 if (!isChar(c) && !isDigit(c) && (c != CharPool.CLOSE_BRACKET) &&
802 (c != CharPool.COLON) && (c != CharPool.DASH) &&
803 (c != CharPool.OPEN_BRACKET) && (c != CharPool.PERIOD)) {
804
805 return false;
806 }
807 }
808
809 return true;
810 }
811
812
820 public static boolean isHTML(String s) {
821 if (isNull(s)) {
822 return false;
823 }
824
825 if ((s.contains("<html>") || s.contains("<HTML>")) &&
826 (s.contains("</html>") || s.contains("</HTML>"))) {
827
828 return true;
829 }
830
831 return false;
832 }
833
834
841 public static boolean isIPAddress(String ipAddress) {
842 Matcher matcher = _ipAddressPattern.matcher(ipAddress);
843
844 return matcher.matches();
845 }
846
847
856 public static boolean isJulianDate(int month, int day, int year) {
857 if ((month < 0) || (month > 11)) {
858 return false;
859 }
860
861 int[] months = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
862
863 if (month == 1) {
864 int febMax = 28;
865
866 if ((year % 4) == 0) {
867 febMax = 29;
868 }
869
870 if ((day < 1) || (day > febMax)) {
871 return false;
872 }
873 }
874 else if ((day < 1) || (day > months[month])) {
875 return false;
876 }
877
878 return true;
879 }
880
881
889 public static boolean isLUHN(String number) {
890 if (number == null) {
891 return false;
892 }
893
894 number = StringUtil.reverse(number);
895
896 int total = 0;
897
898 for (int i = 0; i < number.length(); i++) {
899 int x = 0;
900
901 if (((i + 1) % 2) == 0) {
902 x = GetterUtil.getInteger(number.substring(i, i + 1)) * 2;
903
904 if (x >= 10) {
905 String s = String.valueOf(x);
906
907 x =
908 GetterUtil.getInteger(s.substring(0, 1)) +
909 GetterUtil.getInteger(s.substring(1, 2));
910 }
911 }
912 else {
913 x = GetterUtil.getInteger(number.substring(i, i + 1));
914 }
915
916 total = total + x;
917 }
918
919 if ((total % 10) == 0) {
920 return true;
921 }
922 else {
923 return false;
924 }
925 }
926
927
935 public static boolean isName(String name) {
936 if (isNull(name)) {
937 return false;
938 }
939
940 for (char c : name.trim().toCharArray()) {
941 if (!isChar(c) && !Character.isWhitespace(c)) {
942 return false;
943 }
944 }
945
946 return true;
947 }
948
949
958 public static boolean isNotNull(Long l) {
959 return !isNull(l);
960 }
961
962
971 public static boolean isNotNull(Object obj) {
972 return !isNull(obj);
973 }
974
975
983 public static boolean isNotNull(Object[] array) {
984 return !isNull(array);
985 }
986
987
996 public static boolean isNotNull(String s) {
997 return !isNull(s);
998 }
999
1000
1008 public static boolean isNull(Long l) {
1009 if ((l == null) || (l.longValue() == 0)) {
1010 return true;
1011 }
1012 else {
1013 return false;
1014 }
1015 }
1016
1017
1026 public static boolean isNull(Object obj) {
1027 if (obj instanceof Long) {
1028 return isNull((Long)obj);
1029 }
1030 else if (obj instanceof String) {
1031 return isNull((String)obj);
1032 }
1033 else if (obj == null) {
1034 return true;
1035 }
1036 else {
1037 return false;
1038 }
1039 }
1040
1041
1049 public static boolean isNull(Object[] array) {
1050 if ((array == null) || (array.length == 0)) {
1051 return true;
1052 }
1053 else {
1054 return false;
1055 }
1056 }
1057
1058
1067 public static boolean isNull(String s) {
1068 if (s == null) {
1069 return true;
1070 }
1071
1072 int counter = 0;
1073
1074 for (int i = 0; i < s.length(); i++) {
1075 char c = s.charAt(i);
1076
1077 if (c == CharPool.SPACE) {
1078 continue;
1079 }
1080 else if (counter > 3) {
1081 return false;
1082 }
1083
1084 if (counter == 0) {
1085 if (c != CharPool.LOWER_CASE_N) {
1086 return false;
1087 }
1088 }
1089 else if (counter == 1) {
1090 if (c != CharPool.LOWER_CASE_U) {
1091 return false;
1092 }
1093 }
1094 else if ((counter == 2) || (counter == 3)) {
1095 if (c != CharPool.LOWER_CASE_L) {
1096 return false;
1097 }
1098 }
1099
1100 counter++;
1101 }
1102
1103 if ((counter == 0) || (counter == 4)) {
1104 return true;
1105 }
1106
1107 return false;
1108 }
1109
1110
1118 public static boolean isNumber(String number) {
1119 if (isNull(number)) {
1120 return false;
1121 }
1122
1123 for (char c : number.toCharArray()) {
1124 if (!isDigit(c)) {
1125 return false;
1126 }
1127 }
1128
1129 return true;
1130 }
1131
1132
1141 public static boolean isPassword(String password) {
1142 if (isNull(password)) {
1143 return false;
1144 }
1145
1146 if (password.length() < 4) {
1147 return false;
1148 }
1149
1150 for (char c : password.toCharArray()) {
1151 if (!isChar(c) && !isDigit(c)) {
1152 return false;
1153 }
1154 }
1155
1156 return true;
1157 }
1158
1159
1168 public static boolean isPhoneNumber(String phoneNumber) {
1169 return isNumber(StringUtil.extractDigits(phoneNumber));
1170 }
1171
1172
1180 public static boolean isUrl(String url) {
1181 if (Validator.isNotNull(url)) {
1182 if (url.indexOf(CharPool.COLON) == -1) {
1183 return false;
1184 }
1185
1186 try {
1187 new URL(url);
1188
1189 return true;
1190 }
1191 catch (MalformedURLException murle) {
1192 }
1193 }
1194
1195 return false;
1196 }
1197
1198
1205 public static boolean isVariableName(String variableName) {
1206 if (isNull(variableName)) {
1207 return false;
1208 }
1209
1210 Matcher matcher = _variableNamePattern.matcher(variableName);
1211
1212 if (matcher.matches()) {
1213 return true;
1214 }
1215 else {
1216 return false;
1217 }
1218 }
1219
1220
1228 public static boolean isVariableTerm(String s) {
1229 if (s.startsWith(_VARIABLE_TERM_BEGIN) &&
1230 s.endsWith(_VARIABLE_TERM_END)) {
1231
1232 return true;
1233 }
1234 else {
1235 return false;
1236 }
1237 }
1238
1239
1248 public static boolean isWhitespace(char c) {
1249 int i = c;
1250
1251 if ((i == 0) || Character.isWhitespace(c)) {
1252 return true;
1253 }
1254 else {
1255 return false;
1256 }
1257 }
1258
1259
1268 public static boolean isXml(String s) {
1269 if (s.startsWith(_XML_BEGIN) || s.startsWith(_XML_EMPTY)) {
1270 return true;
1271 }
1272 else {
1273 return false;
1274 }
1275 }
1276
1277 private static final int _CHAR_LOWER_CASE_BEGIN = 97;
1278
1279 private static final int _CHAR_LOWER_CASE_END = 122;
1280
1281 private static final int _CHAR_UPPER_CASE_BEGIN = 65;
1282
1283 private static final int _CHAR_UPPER_CASE_END = 90;
1284
1285 private static final int _DIGIT_BEGIN = 48;
1286
1287 private static final int _DIGIT_END = 57;
1288
1289 private static final char[] _EMAIL_ADDRESS_SPECIAL_CHAR = new char[] {
1290 '.', '!', '#', '$', '%', '&', '\'', '*', '+', '-', '/', '=', '?', '^',
1291 '_', '`', '{', '|', '}', '~'
1292 };
1293
1294 private static final String _LOCALHOST = "localhost";
1295
1296 private static final String _VARIABLE_TERM_BEGIN = "[$";
1297
1298 private static final String _VARIABLE_TERM_END = "$]";
1299
1300 private static final String _XML_BEGIN = "<?xml";
1301
1302 private static final String _XML_EMPTY = "<root />";
1303
1304 private static Pattern _emailAddressPattern = Pattern.compile(
1305 "[\\w!#$%&'*+/=?^_`{|}~-]+(?:\\.[\\w!#$%&'*+/=?^_`{|}~-]+)*@" +
1306 "(?:[\\w](?:[\\w-]*[\\w])?\\.)+[\\w](?:[\\w-]*[\\w])?");
1307 private static Pattern _ipAddressPattern = Pattern.compile(
1308 "\\b" +
1309 "((?!\\d\\d\\d)\\d+|1\\d\\d|2[0-4]\\d|25[0-5])\\." +
1310 "((?!\\d\\d\\d)\\d+|1\\d\\d|2[0-4]\\d|25[0-5])\\." +
1311 "((?!\\d\\d\\d)\\d+|1\\d\\d|2[0-4]\\d|25[0-5])\\." +
1312 "((?!\\d\\d\\d)\\d+|1\\d\\d|2[0-4]\\d|25[0-5])" +
1313 "\\b");
1314 private static Pattern _variableNamePattern = Pattern.compile(
1315 "[_a-zA-Z]+[_a-zA-Z0-9]*");
1316
1317 }