1.获取字符modelStr在字符串str中第count次出现时的下标

@Test
public void getCommaIndex() {
   
   String str = "0,1,61,";
   String modelStr = ",";    //代表要搜索的特定字符串
   int count = 3;            //代表要搜索的特定字符串出现第几次的索引位置
   //对子字符串进行匹配
   Matcher slashMatcher = Pattern.compile(modelStr).matcher(str);
   int index = 0;
   //matcher.find();尝试查找与该模式匹配的输入序列的下一个子序列
   while(slashMatcher.find()) {
   
       index++;
       //当modelStr字符第count次出现的位置
       if(index == count){
   
           break;
       }
   }
   //matcher.start();返回以前匹配的初始索引。
   System.out.println(slashMatcher.start());
}

2.java执行string返回boolean结果

==该方法针对逻辑与“&&” 和逻辑或“||” 也有效，对单个 “&” 或者“|” 执行结果无效，不过不影响真实结果。==

1. 引入依赖
2. 封装工具类方法

<!--js脚本解析字符串返回boolean值-->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-jexl3</artifactId>
    <version>3.1</version>
</dependency>

执行字符串返回boolean结果：↓
    /**
     *  执行字符串返回boolean结果
     * @param str 要执行的字符串
     * @return 执行结果
     * @throws ScriptException 抛异常
     * 注意：缺陷（单独&和|也会识别，不过是错误答案，没参考性）
     **/
    public static Boolean executeStringReturnBoolean(String str) {
   
        ScriptEngineManager manager = new ScriptEngineManager();
        // 得到javascript脚本引擎
        ScriptEngine se = manager.getEngineByName("js");
        Boolean result = false;
        try {
   
            // 开始运行脚本 -》 我们可以使用ScriptEngine的eval方法来执行脚本
            result = Boolean.parseBoolean(se.eval(str).toString());
        } catch (ScriptException e) {
   
            log.error(e.getMessage());
        }
        return result;
    }

3.String[] 转 List＜Integer＞

String ids = new String("111,22,33,44"); 
String[] items = ids.split(",");
List<Integer> appIdList = Stream.of(items).map(Integer::parseInt).collect(Collectors.toList());

4.检测一个字符串是否是时间格式

/**
*  检测一个字符串是否是时间格式
   * @param str 请求字符串
   * @author liudz
   * @date 2019/12/17
   * @return 执行结果
   **/
public static boolean isValidDate(String str) {
   
    boolean convertSuccess = true;
    // 指定日期格式为四位年/两位月份/两位日期，注意yyyy/MM/dd区分大小写；设置lenient为false. 否则SimpleDateFormat会比较宽松地验证日期，比如2007/02/29会被接受，并转换成2007/03/01
    SimpleDateFormat format = new SimpleDateFormat("HH:mm");
    try {
   
        format.setLenient(false);
        format.parse(str);
    } catch (Exception e) {
   
        convertSuccess = false;
    }
    return convertSuccess;
}

5.判断字符串是否是数值型，包括负数、0、正整数、浮点数等

测试方法1：使用org.apache.commons.lang3.StringUtils

@Test
void judgeStringType()  {
   
    String s0 = "123";
    String s1 = "adb123";
    String s2 = "-1";
    String s3 = "0";
    String s4 = "3.1415926";
    System.out.println("判断s0是否为数值类型：" + StringUtils.isNumeric(s0)); //true
    System.out.println("判断s1是否为数值类型：" + StringUtils.isNumeric(s1)); //false
    System.out.println("判断s2是否为数值类型：" + StringUtils.isNumeric(s2)); //false
    System.out.println("判断s3是否为数值类型：" + StringUtils.isNumeric(s3)); //true
    System.out.println("判断s4是否为数值类型：" + StringUtils.isNumeric(s4)); //false
}

测试结果表明：使用org.apache.commons.lang3.StringUtils，判断字符串是否是数值类型,数值只能判断0~正整数，有一个缺陷,负数和浮点数未正确判断，比如-1判断为false

测试方法2：采用正则表达式匹配，优点：除字符串外都能匹配

@Test
void judgeStringType2()  {
   
    Pattern pattern = Pattern.compile("-?\\d+(\\.\\d+)?");
    String s0 = "123";
    String s1 = "adb123";
    String s2 = "-1";
    String s3 = "0";
    String s4 = "3.1415926";
    System.out.println("判断s0是否为数值类型：" + pattern.matcher(s0).matches()); //true
    System.out.println("判断s1是否为数值类型：" + pattern.matcher(s1).matches()); //false
    System.out.println("判断s2是否为数值类型：" + pattern.matcher(s2).matches()); //true
    System.out.println("判断s3是否为数值类型：" + pattern.matcher(s3).matches()); //true
    System.out.println("判断s4是否为数值类型：" + pattern.matcher(s4).matches()); //true
}

测试结果表明：采用正则表达式匹配，优点：除字符串外都能匹配，推荐使用第二种方法。

6.java正则表达式截取两字符串之间的内容

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

public class StringExtractor {
   
    public static void main(String[] args) {
   
        String input = "这是开始字符串ABC这是要截取的内容DEF这是结束字符串";
        String startString = "ABC";
        String endString = "DEF";

        String patternString = Pattern.quote(startString) + "(.*?)" + Pattern.quote(endString);
        Pattern pattern = Pattern.compile(patternString);
        Matcher matcher = pattern.matcher(input);

        if (matcher.find()) {
   
            String extractedString = matcher.group(1).trim();
            System.out.println("截取的内容: " + extractedString);
        } else {
   
            System.out.println("未找到匹配的内容");
        }
    }
}

结果打印：这是要截取的内容

在上述代码中，我们定义了一个输入字符串 input，以及要截取的开始字符串 startString 和结束字符串 endString。

我们使用 Pattern.quote() 方法对开始字符串和结束字符串进行转义，以确保其作为字面量被正则表达式解释。

然后，我们构建了正则表达式模式 patternString，将开始字符串和结束字符串嵌入其中，并使用 .*? 来匹配两个字符串之间的任意内容（非贪婪模式）。

接下来，我们通过 Pattern.compile() 创建了一个正则表达式模式对象 pattern，并使用 pattern.matcher() 方法将其应用于输入字符串。

最后，我们使用 matcher.find() 方法查找匹配的内容。如果找到了匹配项，则使用 matcher.group(1) 获取截取的内容，并输出结果。使用trim()方法清除字符串左右两边的空格，如果未找到匹配项，则输出未找到匹配的提示。

你可以根据需要修改输入字符串以及开始和结束字符串来进行测试。

7.正则表达式匹配:匹配不包含@特殊字符的字符串

String regular = "^((?!@).)*$";
String str1 = "jxs2611@sop.com";
// 正则表达式
Pattern pattern = Pattern.compile(regular);
System.out.println("是否匹配str1：" + pattern.matcher(str1).find());

8.字符串占位符使用

    @Test
    void parseString12() {
        String str = "out of BusyTimeIndicatorAlarmThreshold! upperLimitOfTheBusyTimeThreshold=%s,lowerLimitOfTheBusyTimeThreshold=%s,reportValue=%s";
        str = String.format(str, 1, 2, 3);
        System.out.println(str);
    }

输出结果：out of BusyTimeIndicatorAlarmThreshold! upperLimitOfTheBusyTimeThreshold=1,lowerLimitOfTheBusyTimeThreshold=2,reportValue=3

9.返回字符串非零的最后一个层级

比如字符串1.2.3.0.0.0，那么最后一个层级是3

/**
     * 返回vpn非零的最后一个层级
     * 例如 1.2.3.0.0.0 -> 3
     * 0.0.0.0.0.0 -> -1
     * @param vpnNodeString
     * @return
     */
public static int getLastLevel(String vpnNodeString) {
        int index = vpnNodeString.indexOf("0") / 2;
        return "0.0.0.0.0.0".equals(vpnNodeString) ? -1 : index;
}

10.根据传入的组织节点，取出非0节点，为了后续sql中查询其子项

例如 1.1.1.0.0.0 -> 1.1.1 计算结果为1.1.1

/**
* 根据传入的组织节点，取出非0节点，为了后续sql中查询其子项
 * 例如 1.1.1.0.0.0 -> 1.1.1  vpn like '1.1.1%'
 * 根节点0.0.0.0.0.0 -> %
 * @param vpnNodeString
 * @return
 */
public static String getVpnMax(String vpnNodeString) {
    // 截取出vpn节点的最大节点用于后续查询所有子节点,根节点取所有
    int index = vpnNodeString.indexOf(".0");
    String vpnMax = index == -1 ? vpnNodeString : vpnNodeString.substring(0, index);
    return "0".equals(vpnMax) ? "%" : vpnMax;
}

11.根据开始日期字符串、结束日期字符串，按15分钟力度返回结束日期字符串集合，举例：开始时间20240318120000、结束时间20240319120000，返回集合[20240318121500, 20240318123000, 20240318124500...]

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

public static void main(String[] args) {
   
        String start = "20240318120000";
        String end = "20240319120000";
        System.out.println(listSumsDateStr(start,end));
    }

    /**
     * 根据开始日期字符串、结束日期字符串，按15分钟力度返回结束日期字符串集合，举例：开始时间20240318120000、结束时间20240319120000，返回集合[20240318121500, 20240318123000, 20240318124500...]
     * @param start 开始日期字符串
     * @param end 结束日期字符串
     * @return 按15分钟力度返回结束日期字符串集合
     */
    public static  List<String> listSumsDateStr(String start, String end) {
   
        long dateStamp = 0l;
        try {
   
            dateStamp = parseTime(start);
        } catch (ParseException e) {
   
            throw new RuntimeException(e);
        }
        Calendar calendar = Calendar.getInstance();
        calendar.setTimeInMillis(dateStamp);
        calendar.set(Calendar.SECOND,00);
        if(calendar.get(Calendar.MINUTE) <=15){
   
            calendar.set(Calendar.MINUTE,15);
        }else if(calendar.get(Calendar.MINUTE) <=30) {
   
            calendar.set(Calendar.MINUTE,30);
        }else if(calendar.get(Calendar.MINUTE) <=45) {
   
            calendar.set(Calendar.MINUTE,45);
        }else if(calendar.get(Calendar.MINUTE) <59) {
   
            calendar.set(Calendar.MINUTE,0);
            calendar.add(Calendar.HOUR,1);
        }

        long reportStartTime = calendar.getTimeInMillis();
        System.out.println(formatTime(reportStartTime + ""));
        long enddateStamp = 0l;
        try {
   
            enddateStamp = parseTime(end);
        } catch (ParseException e) {
   
            throw new RuntimeException(e);
        }
        Calendar endcalendar = Calendar.getInstance();
        endcalendar.setTimeInMillis(enddateStamp);
        endcalendar.set(Calendar.SECOND,00);
        if(endcalendar.get(Calendar.MINUTE) <=15){
   

            endcalendar.set(Calendar.MINUTE,0);
            endcalendar.add(Calendar.HOUR,-1);
        }else if(endcalendar.get(Calendar.MINUTE) <=30) {
   
            endcalendar.set(Calendar.MINUTE,15);

        }else if(endcalendar.get(Calendar.MINUTE) <=45) {
   

            endcalendar.set(Calendar.MINUTE,30);
        }else if(endcalendar.get(Calendar.MINUTE) <59) {
   
            endcalendar.set(Calendar.MINUTE,45);
        }
        System.out.println(formatTime(endcalendar.getTimeInMillis() + ""));
        List<String> list = new ArrayList<String>();
        while (reportStartTime < enddateStamp) {
   
            reportStartTime = calendar.getTimeInMillis();
            calendar.add(Calendar.MINUTE, 15);
            if(reportStartTime<=enddateStamp) {
   
                list.add(formatTime(reportStartTime + ""));
            }

        }
        return list;
    }
    public static String formatTime(String time) {
   

        SimpleDateFormat sf1 = new SimpleDateFormat("yyyyMMddHHmmss");

        long tmpTime = Long.parseLong(time);

        time = sf1.format(new Date(tmpTime));

        return time;
    }


    public static long parseTime(String time) throws ParseException {
   

        SimpleDateFormat sf1 = new SimpleDateFormat("yyyyMMddHHmmss");

        Date tmpTime = sf1.parse(time);

        return tmpTime.getTime();
    }

12. 提取字符串中提取出时区的偏移量

举例说明：比如我给定的时间字符串为“GMT+08:00”，而我最后想提取的结果是“+08:00”

public static void main(String[] args) {
   
    String timeZone2 = "GMT+08:00";
    String patternStr1 = "XXX";
    DateFormat f = new SimpleDateFormat(patternStr1);
    f.setTimeZone(TimeZone.getTimeZone(timeZone2));
    String zone = f.format(new Date());
    System.out.println(zone);
}

本人其他文章链接

1.java小工具util系列1：日期毫秒数转日期字符串
https://blog.csdn.net/a924382407/article/details/121955349

2.java小工具util系列2：获取字符modelStr在字符串str中第count次出现时的下标
https://blog.csdn.net/a924382407/article/details/121955455

3.java小工具util系列3：正则表达式匹配:匹配不包含@特殊字符的字符串
https://blog.csdn.net/a924382407/article/details/121955737

4.java小工具util系列4：String[] 转 List＜ Integer ＞
https://blog.csdn.net/a924382407/article/details/121956201

5.java小工具util系列5：基础工具代码(Msg、PageResult、Response、常量、枚举)
https://blog.csdn.net/a924382407/article/details/120952865

6.java小工具util系列6：java执行string返回boolean结果
https://blog.csdn.net/a924382407/article/details/117124536

7.java小工具util系列7：集合中实体对象转换 list中Enrey转Dto
https://blog.csdn.net/a924382407/article/details/121957545

8.java小工具util系列8：JSONObject获取key
https://blog.csdn.net/a924382407/article/details/121957607

9.java小工具util系列9：检测一个字符串是否是时间格式
https://blog.csdn.net/a924382407/article/details/123948881

10.java小工具util系列10：时间毫秒数、时间格式字符串、日期之间相互转化
https://blog.csdn.net/a924382407/article/details/124581851