Серия исходных кодов Dead Hutool (1) - Анализ исходного кода StrUtil

Рамбл

Помню писал год назадStringРезюме анализа исходного кода класса, начать читатьStrUtilРаньше я пересматривал его снова, и заинтересованные друзья могут сначала прочитать его, чтобы почувствовать:

• Анализ исходного кода строк (1)
• Анализ исходного кода строк — заключительная глава

Поскольку вы прочиталиStringИсходный код, зачем его читать?StrUtilЧто насчет исходного кода? в реальном развитии проектаStringэто структура данных, которую мы используем чаще всего, что приводит нас кStringКодов операций довольно много, и эти операции являются общими кодами, не зависящими от конкретного бизнеса.Для простоты и читабельности кода кодStringРазличные операции пакета инкапсулированы в статические классы инструментов, которые являются главными героями этой статьи:StrUtil, который охватывает почти все распространенные методы манипуляции со строками, которые вы можете или не можете придумать.

Предварительное изучение исходного кода

Эта статья правильнаяStrUtilПервое резюме интерпретации исходного кода,StrUtilОн упакован правильноStringКласс статического инструмента для работы, который полон статических методов и статических констант:

Вы можете увидеть автора вStrUtilПредустановить множество символов, которые мы можем придумать в процессе разработки, например нулевые символы, пробелы, табуляции и т. д., очень удобно. Чтобы предотвратить жесткое кодирование, мы можем вызывать его напрямую через этот класс вместо жесткого кодирования символа непосредственно в бизнес-коде.

Я кратко взял классифицированную карту мозга (часть метода), чтобы подытожить:

Как видно из карты мозга метода, каждый метод в основном известен своим названием.

Пустой метод класса

• Определите, является ли строка пустой, определение пробела: нуль, пустой символ

  public static boolean isBlank(CharSequence str) {
      //字符串长度
  		int length;
  
    	//如果字符串为null 或者字符串长度等于0，直接返回 true
  		if ((str == null) || ((length = str.length()) == 0)) {
  			return true;
  		}
  
  		for (int i = 0; i < length; i++) {
  			// 迭代检查字符串每个字符，只要有一个非空字符即为非空字符串
  			if (false == CharUtil.isBlankChar(str.charAt(i))) {
  				return false;
  			}
  		}
  
  		return true;
  	}
  

• Если объект является строкой, проверьте, пусто ли оно.

  public static boolean isBlankIfStr(Object obj) {
      //对象为null,直接返回 true
  		if (null == obj) {
  			return true;
  		} else if (obj instanceof CharSequence) {
        //如果是字符串，调用 isBlank 方法进行判断
  			return isBlank((CharSequence) obj);
  		}
  		return false;
  	}
  

• Проверить, не пуста ли строка

  	public static boolean isNotBlank(CharSequence str) {
      //isBlank 方法返回 false 即可
  		return false == isBlank(str);
  	}
  

• Определите, содержит ли данный массив строк пустые строки, параметры здесь становятся параметрамиhasBlank(CharSequence... strs)

  public static boolean hasBlank(CharSequence... strs) {
      //如果数组为空，则返回true
  		if (ArrayUtil.isEmpty(strs)) {
  			return true;
  		}
  
      //遍历检查数组中的字符串，只要满足一个为空白字符串，则返回true
  		for (CharSequence str : strs) {
  			if (isBlank(str)) {
  				return true;
  			}
  		}
      //默认为false
  		return false;
  	}
  

• Определите, является ли данная строка массива пустыми строками

  public static boolean isAllBlank(CharSequence... strs) {
      //如果数组为空，则返回true
  		if (ArrayUtil.isEmpty(strs)) {
  			return true;
  		}
  		//遍历检查数组中的字符串，只要满足一个不是空白字符串，则返回false
  		for (CharSequence str : strs) {
  			if (isNotBlank(str)) {
  				return false;
  			}
  		}
      //默认返回true
  		return true;
  	}
  

• Проверить, пуста ли строка

  public static boolean isEmpty(CharSequence str) {
      //字符串为null或者长度等于0
  		return str == null || str.length() == 0;
  	}
  

• Если объект является строкой, проверьте, пуста ли она.

  public static boolean isEmptyIfStr(Object obj) {
      //对象是null，返回true
  		if (null == obj) {
  			return true;
  		} else if (obj instanceof CharSequence) {
        //对象是字符串，判断长度是否等于0
  			return 0 == ((CharSequence) obj).length();
  		}
      //默认false
  		return false;
  	}
  

• Проверить, не пуста ли строка

  public static boolean isNotEmpty(CharSequence str) {
      //调用isEmpty方法满足false即可
  		return false == isEmpty(str);
  	}
  

• Если строка пуста, вернуть значение по умолчанию

  public static String nullToDefault(CharSequence str, String defaultStr) {
      //就是一个简单的三目运算
  		return (str == null) ? defaultStr : str.toString();
  	}
  

• Если строка пуста, вернуть значение по умолчанию

  public static String emptyToDefault(CharSequence str, String defaultStr) {
     //三目运算判断字符串是否为空
  		return isEmpty(str) ? defaultStr : str.toString();
  	}
  

• Если строка является пустой строкой, вернуть значение по умолчанию

  public static String blankToDefault(CharSequence str, String defaultStr) {
      //三目运算判断字符串是否为空白字符串
  		return isBlank(str) ? defaultStr : str.toString();
  	}
  

• Определяет, содержит ли указанный массив строк пустую строку

  public static boolean hasEmpty(CharSequence... strs) {
    
    	//数组为空，返回true
  		if (ArrayUtil.isEmpty(strs)) {
  			return true;
  		}
  
    	//遍历检查字符串数组中的字符串，其中一个为空，则为true
  		for (CharSequence str : strs) {
  			if (isEmpty(str)) {
  				return true;
  			}
  		}
      //默认false
  		return false;
  	}
  

• Проверить, все ли строки в указанном массиве строк пусты

  public static boolean isAllEmpty(CharSequence... strs) {
      //数组为空，返回true
  		if (ArrayUtil.isEmpty(strs)) {
  			return true;
  		}
  
      //遍历检查字符串数组中的字符串，其中一个不为空，则为false
  		for (CharSequence str : strs) {
  			if (isNotEmpty(str)) {
  				return false;
  			}
  		}
     //默认true
  		return true;
  	}
  

• Убедитесь, что все строки в указанном массиве строк не пусты.

  public static boolean isAllNotEmpty(CharSequence... args) {
      //只要调用 hasEmpty 检查数组中是否包含空字符串就行了
  		return false == hasEmpty(args);
  	}
  

• Определяет, что все строки в указанном массиве строк не являются пустыми символами.

  public static boolean isAllNotBlank(CharSequence... args) {
      //只要调用 hasBlank 检查数组中是否包含空字符串就行了
  		return false == hasBlank(args);
  	}
  

Удалить метод класса начальных и конечных пробелов

• Удалить пробелы до и после строки

  public static String trim(CharSequence str) {
      //三目运算判断字符串为null返回 null ,否则调用 trim(CharSequence str, int mode) 方法去除前后空格
  		return (null == str) ? null : trim(str, 0);
  	}
  

• Удалить пробелы до и после всех строк заданного массива строк

  public static void trim(String[] strs) {
      //如果数组为null，不做任何处理
  		if (null == strs) {
  			return;
  		}
      //初始化动态字符串变量
  		String str;
      //迭代字符串数组
  		for (int i = 0; i < strs.length; i++) {
        //获取每个字符串
  			str = strs[i];
        //字符串不为null,调用String的trim方法处理每个字符串，并重新赋值给当前数组指定索引处的字符串
  			if (null != str) {
  				strs[i] = str.trim();
  			}
  		}
  	}
  

• Удалите пробелы в начале и в конце строки, если строка равна нулю, верните нулевой символ.

  public static String trimToEmpty(CharSequence str) {
      //字符串为null返回空字符串，否则调用 trim(str)方法去首尾空格
  		return str == null ? EMPTY : trim(str);
  	}
  

• Удалите начальные и конечные пробелы из строки или верните значение null, если строка является нулевым символом.

  public static String trimToNull(CharSequence str) {
      //先调用 trim(str) 去除前后空格
  		final String trimStr = trim(str);
      //如果是空白字符则返回null,否则返回处理后的结果
  		return EMPTY.equals(trimStr) ? null : trimStr;
  	}
  

• удалить пробел из заголовка строки

  public static String trimStart(CharSequence str) {
     // 调用 trim(CharSequence str, int mode) 方法处理，mode 参数传 -1 即可
  		return trim(str, -1);
  	}
  

• Удалить конечные пробелы из строк

  public static String trimEnd(CharSequence str) {
      //调用 trim(CharSequence str, int mode) 方法处理，mode 参数传 1 即可
  		return trim(str, 1);
  	}
  

• Уберите пробелы до и после строки, вы можете управлять режимом, передавая параметры

  /**
  	 * 除去字符串头尾部的空白符，如果字符串是<code>null</code>，依然返回<code>null</code>。
  	 *
  	 * @param str  要处理的字符串
  	 * @param mode <code>-1</code>表示trimStart，<code>0</code>表示trim全部， <code>1</code>表示trimEnd
  	 * @return 除去指定字符后的的字符串，如果原字串为<code>null</code>，则返回<code>null</code>
  	 */
  	public static String trim(CharSequence str, int mode) {
      //字符串为null,直接返回null
  		if (str == null) {
  			return null;
  		}
  
      //字符串长度
  		int length = str.length();
      //开始位置索引为0
  		int start = 0;
      //结束位置索引为字符串长度
  		int end = length;
  
  		// 当 mode<=0 时，扫描字符串头部，确定开始裁剪的索引位置
  		if (mode <= 0) {
        //当 start < end 并且索引除的字符为空字符的时候，不停的向后迭代扫描，直到扫描到的字符不是空字符或者索引越界为止
  			while ((start < end) && (CharUtil.isBlankChar(str.charAt(start)))) {
          //不停的累加起始索引位置
  				start++;
  			}
  		}
  
  		// 当 mode>=0 时， 扫描字符串尾部，确定结束裁剪的索引位置
  		if (mode >= 0) {
        // 当 start < end并且从字符串往后扫描到的字符为空字符时，不停的向前迭代扫描，直到扫描到的字符不是空字符或者扫描到字符串长度结束为止
  			while ((start < end) && (CharUtil.isBlankChar(str.charAt(end - 1)))) {
          //不停的递减结束索引位置
  				end--;
  			}
  		}
  
      //如果开始裁剪的所有位置大于0，或者 结束位置索引小于字符串长度，说明存在空白字符
  		if ((start > 0) || (end < length)) {
        //直接调用字符串的substring方法进行裁剪，即可移除前后空白字符
  			return str.toString().substring(start, end);
  		}
      
      //字符串前后不存在空白字符串情况下，直接返回原字符串
  		return str.toString();
  	}
  

найти метод класса

• начинается ли строка с заданного символа

  public static boolean startWith(CharSequence str, char c) {
      //获取字符串第一个字符判断是否等于目标字符
  		return c == str.charAt(0);
  	}
  

• Следует ли начинать с указанной строки, вы можете контролировать, игнорировать ли регистр

  public static boolean startWith(CharSequence str, CharSequence prefix, boolean isIgnoreCase) {
      //字符串为null 或者 待检测的开头字符串为null
  		if (null == str || null == prefix) {
        //直接返回两个字符串是否都为null 就行，因为 null 肯定以null 开头啊，哈哈哈
  			return null == str && null == prefix;
  		}
      
      //如果忽略大小写
  		if (isIgnoreCase) {
        //全部转为小写，再调用字符串的 startsWith 方法进行判断
  			return str.toString().toLowerCase().startsWith(prefix.toString().toLowerCase());
  		} else {
        //不忽略大小写，直接调用 startsWith 方法判断即可
  			return str.toString().startsWith(prefix.toString());
  		}
  	}
  

• Начинать ли с указанной строки, не игнорируя регистр

  public static boolean startWith(CharSequence str, CharSequence prefix) {
      //直接调用 startWith(CharSequence str, CharSequence prefix, boolean isIgnoreCase) 方法，isIgnoreCase 传 false 即可
  		return startWith(str, prefix, false);
  	}
  

• Начинать ли с указанной строки, игнорируя регистр

  public static boolean startWithIgnoreCase(CharSequence str, CharSequence prefix) {
      //直接调用 startWith(CharSequence str, CharSequence prefix, boolean isIgnoreCase) 方法，isIgnoreCase 传 true 即可
  		return startWith(str, prefix, true);
  	}
  

• начинается ли данная строка с любой из строк в массиве строк

  	public static boolean startWithAny(CharSequence str, CharSequence... prefixes) {
      //字符串为空 或者 数组为空，直接返回false
  		if (isEmpty(str) || ArrayUtil.isEmpty(prefixes)) {
  			return false;
  		}
  
      //遍历检查字符串是否以数组中任意一个字符串开头，并且不忽略大小写
  		for (CharSequence suffix : prefixes) {
        //只要查找到一个成立，直接返回 true
  			if (startWith(str, suffix, false)) {
  				return true;
  			}
  		}
      //找不到则默认返回false
  		return false;
  	}
  

• заканчиваться ли данным символом

  	public static boolean endWith(CharSequence str, char c) {
      //获取字符串最后一个字符，判断是否与给定字符相等就行了
  		return c == str.charAt(str.length() - 1);
  	}
  

• Заканчиваться ли данной строкой, может контролировать, игнорировать ли регистр

  public static boolean endWith(CharSequence str, CharSequence suffix, boolean isIgnoreCase) {
      //待检查字符串等于null 或者 前缀字符串等于null
  		if (null == str || null == suffix) {
        //只要其中一个等于null ,直接判断两个都等于null ,就成立了，毕竟 null 肯定以null 结尾嘛
  			return null == str && null == suffix;
  		}
      
      //如果忽略大小写
  		if (isIgnoreCase) {
        //先转为小写，再调用字符串的 endsWith 方法判断即可
  			return str.toString().toLowerCase().endsWith(suffix.toString().toLowerCase());
  		} else {
        //不忽略大小写，直接调用字符串的 endsWith 方法判断即可
  			return str.toString().endsWith(suffix.toString());
  		}
  	}
  

• Заканчиваться ли указанной строкой, не игнорируя регистр

  public static boolean endWith(CharSequence str, CharSequence suffix) {
    //直接调用 endWith(CharSequence str, CharSequence suffix, boolean isIgnoreCase)，isIgnoreCase传 false 即可
  		return endWith(str, suffix, false);
  	}
  

• Заканчиваться ли указанной строкой, игнорируя регистр

  public static boolean endWithIgnoreCase(CharSequence str, CharSequence suffix) {
    //直接调用 endWith(CharSequence str, CharSequence suffix, boolean isIgnoreCase)，isIgnoreCase传 true 即可
  		return endWith(str, suffix, true);
  	}
  

• заканчивается ли данная строка любой строкой в ​​массиве строк

  public static boolean endWithAny(CharSequence str, CharSequence... suffixes) {
      //字符串为空 或者数组为空，直接返回false
  		if (isEmpty(str) || ArrayUtil.isEmpty(suffixes)) {
  			return false;
  		}
  
      //遍历字符串数组，检查给定字符串中是否以该字符串结尾，不忽略大小写
  		for (CharSequence suffix : suffixes) {
        //一旦找到一个成立的字符串，直接返回true
  			if (endWith(str, suffix, false)) {
  				return true;
  			}
  		}
     //没找到，默认返回false
  		return false;
  	}
  

• Указывает, появился ли символ в строке

  public static boolean contains(CharSequence str, char searchChar) {
      //直接调用 indexOf 方法获取字符索引位置，大于 -1 表示存在
  		return indexOf(str, searchChar) > -1;
  	}
  

• Указывает, появилась ли строка в строке

  public static boolean contains(CharSequence str, CharSequence searchStr) {
      //字符串等于null或者被查找的字符串等于null 直接返回false
  		if (null == str || null == searchStr) {
  			return false;
  		}
     //调用字符串的 contains 方法判断是否存在查找的字符串
  		return str.toString().contains(searchStr);
  	}
  

• Находит, содержит ли указанная строка какую-либо строку в указанном списке строк

  public static boolean containsAny(CharSequence str, CharSequence... testStrs) {
      //直接调用 getContainsStr 获取字符串数组中存在的字符串，不为null表示存在
  		return null != getContainsStr(str, testStrs);
  	}
  

• Определяет, содержит ли указанная строка какой-либо символ из указанного списка символов.

  public static boolean containsAny(CharSequence str, char... testChars) {
      //字符串不为空进行处理
  		if (false == isEmpty(str)) {
        //字符串长度
  			int len = str.length();
        //遍历字符串字符，查找包含字符列表中是否包含该字符
  			for (int i = 0; i < len; i++) {
          //检查到一个直接返回true
  				if (ArrayUtil.contains(testChars, str.charAt(i))) {
  					return true;
  				}
  			}
  		}
      //默认返回false
  		return false;
  	}
  

• Проверяет, содержит ли указанная строка только заданные символы

  	public static boolean containsOnly(CharSequence str, char... testChars) {
      //字符串不为空进行处理
  		if (false == isEmpty(str)) {
        //字符串长度
  			int len = str.length();
        //遍历字符串字符，查找字符串中的字符是否在字符列表中
  			for (int i = 0; i < len; i++) {
          //检查到一个不存在直接返回false
  				if (false == ArrayUtil.contains(testChars, str.charAt(i))) {
  					return false;
  				}
  			}
  		}
      //默认返回true
  		return true;
  	}
  

• содержит ли данная строка пробельные символы

  public static boolean containsBlank(CharSequence str) {
      //字符串等于null,直接返回false
  		if (null == str) {
  			return false;
  		}
      //字符串长度
  		final int length = str.length();
      //字符串长度等于0，返回false
  		if (0 == length) {
  			return false;
  		}
  		
    	//遍历检查字符串中字符是否存在空字符
  		for (int i = 0; i < length; i += 1) {
        //检查到一个空字符，直接返回true
  			if (CharUtil.isBlankChar(str.charAt(i))) {
  				return true;
  			}
  		}
      //默认false
  		return false;
  	}
  

• Находит, содержит ли указанная строка какую-либо строку в указанном списке строк, и возвращает первую строку, если она есть.

  public static String getContainsStr(CharSequence str, CharSequence... testStrs) {
      //指定字符串为空 或者字符串列表为空，直接返回null
  		if (isEmpty(str) || ArrayUtil.isEmpty(testStrs)) {
  			return null;
  		}
      //遍历字符串列表，检查是否在指定字符串中
  		for (CharSequence checkStr : testStrs) {
        //检查到在指定的字符串中，直接返回该字符串
  			if (str.toString().contains(checkStr)) {
  				return checkStr.toString();
  			}
  		}
      //获取不到则默认返回null
  		return null;
  	}
  

• содержать ли данную строку, игнорируя регистр

  	public static boolean containsIgnoreCase(CharSequence str, CharSequence testStr) {
  		if (null == str) {
  			// 如果被监测字符串和
  			return null == testStr;
  		}
      //先转换为小写再调用 contains 方法判断
  		return str.toString().toLowerCase().contains(testStr.toString().toLowerCase());
  	}
  

• Определяет, содержит ли указанная строка какую-либо строку в указанном списке строк, игнорируя регистр

  public static boolean containsAnyIgnoreCase(CharSequence str, CharSequence... testStrs) {
      //调用getContainsStrIgnoreCase查找包含的第一个字符串，不为null表示存在
  		return null != getContainsStrIgnoreCase(str, testStrs);
  	}
  

• Определяет, содержит ли указанная строка какую-либо строку из указанного списка строк, и возвращает первую строку, если она существует, без учета регистра.

  public static String getContainsStrIgnoreCase(CharSequence str, CharSequence... testStrs) {
      //字符串为空 或者字符串列表为空，直接返回null
  		if (isEmpty(str) || ArrayUtil.isEmpty(testStrs)) {
  			return null;
  		}
      //遍历查找字符串列表中是都存在字符串，包含在指定的字符串中，并忽略大小写
  		for (CharSequence testStr : testStrs) {
        //检查到一个存在，直接返回该字符串
  			if (containsIgnoreCase(str, testStr)) {
  				return testStr.toString();
  			}
  		}
      //找不到则默认返回null
  		return null;
  	}
  

наконец

StrUtilСлишком много статических методов, я запишу эти методы в начале, а позже обновлю...

Рекомендуемое чтение

• Анализ исходного кода строк (1)
• Анализ исходного кода строк — заключительная глава

Ссылаться на:

• HutoolОфициальный сайт:hutool.cn/
• github:GitHub.com/Оооооооооооооооооооооооооооооооооооооооооо…

Больше оригинальных статей будет размещено в общедоступном аккаунте как можно скорее, пожалуйста, отсканируйте код, чтобы следоватьЧжан Шаолинь