字符串或Map转List对象&&JAVA正则获取括号内的数据与排除括号内的数据

相思比梦长

已于 2022-12-14 15:56:30 修改

阅读量684

点赞数

分类专栏： JAVA 文章标签： string map list stream iterator

于 2022-12-13 16:24:37 首次发布

原文链接：https://blog.csdn.net/allway2/article/details/115433931

版权

JAVA 专栏收录该内容

215 篇文章 15 订阅

订阅专栏

    public static void main(String[] args) {
        //字符串转List对象
        String fromIds = "88-10,89-2,90-3,91-6,92-4";
        List<PointsEvent> pointsEventList = Arrays.stream(fromIds.split(",")).map(id -> new PointsEvent(Integer.valueOf(id.split("-")[0]), Integer.valueOf(id.split("-")[1]))).collect(Collectors.toList());
        System.out.println(JSON.toJSONString(pointsEventList));
        //[{"number":10,"pid":88},{"number":2,"pid":89},{"number":3,"pid":90},{"number":6,"pid":91},{"number":4,"pid":92}]

        //字符串转Map，转List对象
        String[] fromIdArr = fromIds.split(",");
        Map<Integer, Integer> map = new HashMap<>(16);
        for (String s : fromIdArr) {
            String[] idStrArr = s.split("-");
            map.put(Integer.valueOf(idStrArr[0]), Integer.valueOf(idStrArr[1]));
        }
        List<PointsEvent> pointsEventList2 = map.entrySet().stream().map(mi -> new PointsEvent(mi.getKey(), mi.getValue())).collect(Collectors.toList());
        System.out.println(JSON.toJSONString(pointsEventList2));
        //[{"number":10,"pid":88},{"number":2,"pid":89},{"number":3,"pid":90},{"number":6,"pid":91},{"number":4,"pid":92}]

        // key 转 List
        List<Integer> keyList = new ArrayList<>(map.keySet());
        List<Integer> keyList2 = map.keySet().stream().collect(Collectors.toList());
        System.out.println(JSON.toJSONString(keyList));
        //[88,89,90,91,92]
        System.out.println(JSON.toJSONString(keyList2));
        //[88,89,90,91,92]

        // value 转 List
        List<Integer> valueList = new ArrayList<>(map.values());
        List<Integer> valueList2 = map.values().stream().collect(Collectors.toList());
        System.out.println(JSON.toJSONString(valueList));
        //[10,2,3,6,4]
        System.out.println(JSON.toJSONString(valueList2));
        //[10,2,3,6,4]

        // Iterator转List
        List<PointsEvent> keyValueList = new ArrayList<>();
        Iterator<Integer> it = map.keySet().iterator();
        while (it.hasNext()) {
            Integer k = (Integer) it.next();
            keyValueList.add(new PointsEvent(k, map.get(k)));
        }
        System.out.println(JSON.toJSONString(keyValueList));
        //[{"number":10,"pid":88},{"number":2,"pid":89},{"number":3,"pid":90},{"number":6,"pid":91},{"number":4,"pid":92}]

        // Java8 Stream
        List<PointsEvent> list = map.entrySet().stream().map(c -> new PointsEvent(c.getKey(), c.getValue())).collect(Collectors.toList());
        System.out.println(JSON.toJSONString(list));
        //[{"number":10,"pid":88},{"number":2,"pid":89},{"number":3,"pid":90},{"number":6,"pid":91},{"number":4,"pid":92}]

        //Iterator转List
        List<PointsEvent> pointsEvents = new ArrayList<>();
        Iterator<Map.Entry<Integer, Integer>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<Integer, Integer> next = iterator.next();
            PointsEvent pointsEvent = new PointsEvent(next.getKey(), next.getValue());
            pointsEvents.add(pointsEvent);
        }
        System.out.println(JSON.toJSONString(pointsEvents));
        //[{"number":10,"pid":88},{"number":2,"pid":89},{"number":3,"pid":90},{"number":6,"pid":91},{"number":4,"pid":92}]

        //字符串转List对象
        String fromIds2 = "88-{10},89-{2},90-{3},91-{6},92-{4}";
        List<PointsEvent> pointsEventList3 = Arrays.stream(fromIds2.split(",")).map(id -> new PointsEvent(Integer.valueOf(id.split("-")[0]), Integer.valueOf(id.split("-")[1].substring(1, id.split("-")[1].length() - 1)))).collect(Collectors.toList());
        System.out.println(JSON.toJSONString(pointsEventList3));
        //[{"number":10,"pid":88},{"number":2,"pid":89},{"number":3,"pid":90},{"number":6,"pid":91},{"number":4,"pid":92}]

        //字符串转List对象
        String fromIds3 = "88{10},89{2},90{3},91{6},92{4}";
        List<PointsEvent> pointsEventList4 = Arrays.stream(fromIds3.split(",")).map(id -> new PointsEvent(Integer.valueOf(id.replaceAll("[\\{][^\\{\\}]+[\\}]", "")), bracketContent(id))).collect(Collectors.toList());
        System.out.println(JSON.toJSONString(pointsEventList4));
        //[{"number":10,"pid":88},{"number":2,"pid":89},{"number":3,"pid":90},{"number":6,"pid":91},{"number":4,"pid":92}]
        System.out.println(JSON.toJSONString(getBracketContent(fromIds3)));
        //[10,2,3,6,4]
        System.out.println(JSON.toJSONString(getBracketContentStr(fromIds3)));
        //["10","2","3","6","4"]

        String keyStr = fromIds3.replaceAll("[\\{][^\\{\\}]+[\\}]", "");
        System.out.println(keyStr);
        //88,89,90,91,92
        String fromIds4 = "88{10}[10](10),89{2}[2](2),90{3}[3](3),91{6}[6](6),92{4}[4](4)";
        System.out.println(getWords(fromIds4));
        //88,89,90,91,92
        String fromIds5 = "88{10},89{2},90{3},91{6},92{4}";
        System.out.println(getWords1(fromIds5));
        //88,89,90,91,92
        String fromIds6 = "88[10],89[2],90[3],91[6],92[4]";
        System.out.println(getWords2(fromIds6));
        //88,89,90,91,92
        String fromIds7 = "88(10),89(2),90(3),91(6),92(4)";
        System.out.println(getWords3(fromIds7));
        //88,89,90,91,92
    }

    /**
     * 正则获取括号内的数据
     * 获取指定字符串中括号内的内容，返回整型
     *
     * @param content "88{10}"
     * @return Integer
     */
    public static Integer bracketContent(String content) {
        Integer bracketInt = 0;
        Pattern p = Pattern.compile("(?<=\\{)[^\\}]+");
        Matcher m = p.matcher(content);
        while (m.find()) {
            bracketInt = Integer.valueOf(m.group());
        }
        return bracketInt;
    }

    /**
     * 正则获取括号内的数据
     * 获取指定字符串中括号内的内容，返回字符串
     *
     * @param content "88{10}"
     * @return String
     */
    public static String bracketContentStr(String content) {
        String bracketStr = "";
        Pattern p = Pattern.compile("(?<=\\{)[^\\}]+");
        Matcher m = p.matcher(content);
        while (m.find()) {
            bracketStr = m.group();
        }
        return bracketStr;
    }

    /**
     * 正则获取指定字符串中括号内的内容，返回整型数组
     *
     * @param content "88{10},89{2},90{3},91{6},92{4}"
     * @return Integer[]
     */
    public static Integer[] getBracketContent(String content) {
        Integer[] intArr = new Integer[0];
        Pattern p = Pattern.compile("(?<=\\{)[^\\}]+");
        Matcher m = p.matcher(content);
        while (m.find()) {
            intArr = Arrays.copyOf(intArr, intArr.length + 1);
            intArr[intArr.length - 1] = Integer.valueOf(m.group());
        }
        return intArr;
    }

    /**
     * 正则获取指定字符串中括号内的内容，返回字符串数组
     *
     * @param content "88{10},89{2},90{3},91{6},92{4}"
     * @return String[]
     */
    public static String[] getBracketContentStr(String content) {
        String[] strArr = new String[0];
        Pattern p = Pattern.compile("(?<=\\{)[^\\}]+");
        Matcher m = p.matcher(content);
        while (m.find()) {
            strArr = Arrays.copyOf(strArr, strArr.length + 1);
            strArr[strArr.length - 1] = m.group();
        }
        return strArr;
    }

    /**
     * 排除括号及括号内的数据
     * 大括号、中括号、小括号
     *
     * @param content "88{10}[10](10),89{2}[2](2),90{3}[3](3),91{6}[6](6),92{4}[4](4)"
     * @return String
     */
    private static String getWords(String content) {
        return content.replaceAll("[\\{][^\\{\\}]+[\\}]|[\\[][^\\[\\]]+[\\]]|[\\(][^\\(\\)]+[\\)]", "");
    }

    /**
     * 排除括号及括号内的数据
     * 大括号
     *
     * @param content "88{10},89{2},90{3},91{6},92{4}"
     * @return String
     */
    private static String getWords1(String content) {
        return content.replaceAll("[\\{][^\\{\\}]+[\\}]", "");
    }

    /**
     * 排除括号及括号内的数据
     * 中括号
     *
     * @param content "88[10],89[2],90[3],91[6],92[4]"
     * @return String
     */
    private static String getWords2(String content) {
        return content.replaceAll("[\\[][^\\[\\]]+[\\]]", "");
    }

    /**
     * 排除括号及括号内的数据
     * 小括号
     *
     * @param content "88(10),89(2),90(3),91(6),92(4)"
     * @return String
     */
    private static String getWords3(String content) {
        return content.replaceAll("[\\(][^\\(\\)]+[\\)]", "");
    }

@Data
public class PointsEvent implements Serializable {

    private Integer pid;
    private Integer number;

    public PointsEvent(Integer pid, Integer number) {
        this.pid = pid;
        this.number = number;
    }
}