Question

我试图在一个长度为10000个字符的大字符串中查找子字符串的计数。最后我需要删除其中的所有子字符串。示例s = abacacac, substr = ac，num of occurrence = 3和最终字符串为s = ab。我的代码如下，对于长度为10000个字符的数据效率不高。

int count =0;
while(s.contains(substr))
{
   s= s.replaceFirst(substr,"");
   count++;    
}

Answer 1

怎么样：

var data = getData().map(function (d) {
            return d;
        });

        var canvas = document.querySelector("canvas"),
            context = canvas.getContext("2d");

        var margin = { top: 20, right: 20, bottom: 30, left: 50 },
            width = canvas.width - margin.left - margin.right,
            height = canvas.height - margin.top - margin.bottom;

        var parseTime = d3.timeParse("%d-%b-%y");

        // setup scales
        var x = d3.scaleTime()
            .range([0, width]);
        var x2 = d3.scaleTime().range([0, width]);
        var y = d3.scaleLinear()
            .range([height, 0]);

        // setup domain
        x.domain(d3.extent(data, function (d) { return moment(d.Ind, 'YYYYMM'); }));
        y.domain(d3.extent(data, function (d) { return d.KSum; }));
        x2.domain(x.domain());

        // get day range
        var dayDiff = daydiff(x.domain()[0],x.domain()[1]);

        // line generator
        var line = d3.line()
            .x(function (d) { return x(moment(d.Ind, 'YYYYMM')); })
            .y(function (d) { return y(d.KSum); })
            .curve(d3.curveMonotoneX)
            .context(context);

        // zoom
        var zoom = d3.zoom()
            .scaleExtent([1, dayDiff * 12])
            .translateExtent([[0, 0], [width, height]])
            .extent([[0, 0], [width, height]])
            .on("zoom", zoomed);

        d3.select("canvas").call(zoom)

        context.translate(margin.left, margin.top);

        draw();


        function draw() {
            context.clearRect(0-margin.left, 0, canvas.width, canvas.height);
            xAxis();
            yAxis();

            context.beginPath();
            line(data);
            context.lineWidth = 1.5;
            context.strokeStyle = "steelblue";
            context.stroke();
        }

        function zoomed() {
            console.log(d3.event);
            t = d3.event.transform;
            x.domain(t.rescaleX(x2).domain());
            context.save();
            context.clearRect(0, 0, width, height);
            // context.translate(d3.event.translate[0], d3.event.translate[1]);
            // context.scale(d3.event.scale, d3.event.scale);
            draw();
            context.restore();
        }

        function xAxis() {
            var tickCount = 10,
                tickSize = 6,
                ticks = x.ticks(tickCount),
                tickFormat = x.tickFormat();

            context.beginPath();
            ticks.forEach(function (d) {
                context.moveTo(x(d), height);
                context.lineTo(x(d), height + tickSize);
            });
            context.strokeStyle = "black";
            context.stroke();

            context.textAlign = "center";
            context.textBaseline = "top";
            ticks.forEach(function (d) {
                context.fillText(tickFormat(d), x(d), height + tickSize);
            });
        }

        function yAxis() {
            var tickCount = 10,
                tickSize = 6,
                tickPadding = 3,
                ticks = y.ticks(tickCount),
                tickFormat = y.tickFormat(tickCount);

            context.beginPath();
            ticks.forEach(function (d) {
                context.moveTo(0, y(d));
                context.lineTo(-6, y(d));
            });
            context.strokeStyle = "black";
            context.stroke();

            context.beginPath();
            context.moveTo(-tickSize, 0);
            context.lineTo(0.5, 0);
            context.lineTo(0.5, height);
            context.lineTo(-tickSize, height);
            context.strokeStyle = "black";
            context.stroke();

            context.textAlign = "right";
            context.textBaseline = "middle";
            ticks.forEach(function (d) {
                context.fillText(tickFormat(d), -tickSize - tickPadding, y(d));
            });

            context.save();
            context.rotate(-Math.PI / 2);
            context.textAlign = "right";
            context.textBaseline = "top";
            context.font = "bold 10px sans-serif";
            context.fillText("Price (US$)", -10, 10);
            context.restore();
        }

        function getDate(d) {
            return new Date(d.Ind);
        }

        function daydiff(first, second) {
            return Math.round((second - first) / (1000 * 60 * 60 * 24));
        }

        function getData() {
            return [
                {
                    "BriteID": "BI-43dd32fe-ecbc-48d4-a8dc-e1f66110a542",
                    "Ind": 201501,
                    "TMin": 30.43,
                    "TMax": 77.4,
                    "KMin": 0.041,
                    "KMax": 1.364,
                    "KSum": 625.08
                },
                {
                    "BriteID": "BI-43dd32fe-ecbc-48d4-a8dc-e1f66110a542",
                    "Ind": 201502,
                    "TMin": 35.3,
                    "TMax": 81.34,
                    "KMin": 0.036,
                    "KMax": 1.401,
                    "KSum": 542.57
                },
                {
                    "BriteID": "BI-43dd32fe-ecbc-48d4-a8dc-e1f66110a542",
                    "Ind": 201503,
                    "TMin": 32.58,
                    "TMax": 81.32,
                    "KMin": 0.036,
                    "KMax": 1.325,
                    "KSum": 577.83
                },
                {
                    "BriteID": "BI-43dd32fe-ecbc-48d4-a8dc-e1f66110a542",
                    "Ind": 201504,
                    "TMin": 54.54,
                    "TMax": 86.55,
                    "KMin": 0.036,
                    "KMax": 1.587,
                    "KSum": 814.62
                },
                {
                    "BriteID": "BI-43dd32fe-ecbc-48d4-a8dc-e1f66110a542",
                    "Ind": 201505,
                    "TMin": 61.35,
                    "TMax": 88.61,
                    "KMin": 0.036,
                    "KMax": 1.988,
                    "KSum": 2429.56
                },
                {
                    "BriteID": "BI-43dd32fe-ecbc-48d4-a8dc-e1f66110a542",
                    "Ind": 201506,
                    "TMin": 69.5,
                    "TMax": 92.42,
                    "KMin": 0.037,
                    "KMax": 1.995,
                    "KSum": 2484.93
                },
                {
                    "BriteID": "BI-43dd32fe-ecbc-48d4-a8dc-e1f66110a542",
                    "Ind": 201507,
                    "TMin": 71.95,
                    "TMax": 98.62,
                    "KMin": 0.037,
                    "KMax": 1.864,
                    "KSum": 2062.05
                },
                {
                    "BriteID": "BI-43dd32fe-ecbc-48d4-a8dc-e1f66110a542",
                    "Ind": 201508,
                    "TMin": 76.13,
                    "TMax": 99.59,
                    "KMin": 0.045,
                    "KMax": 1.977,
                    "KSum": 900.05
                },
                {
                    "BriteID": "BI-43dd32fe-ecbc-48d4-a8dc-e1f66110a542",
                    "Ind": 201509,
                    "TMin": 70,
                    "TMax": 91.8,
                    "KMin": 0.034,
                    "KMax": 1.458,
                    "KSum": 401.39
                }];
        }

只需删除所有子字符串，然后检查删除前后字符串长度的差异。将临时字符串与子字符串中的字符数除以给出事件。

Answer 2

对于countung子串，我会使用indexOf：

<script>
    $('th').on('click', function() {
        alert("Hi");
        print();
        $("#form1").load(location.href + " #form1");
    });
</script>

Answer 3

计算匹配的子字符串

System.out.println(s.split(substr, -1).length-1);

要获取替换字符串，您可以使用以下代码

System.out.println(Pattern.compile(s).matcher(substr).replaceAll(""));

Answer 4

这是我制作的一种方法，应该可以立即使用，并且不会引发任何错误，

    private static int countMatches(String str, String sub) {
    int count = 0;
    if(!str.isEmpty() && !sub.isEmpty()) {
        for (int i = 0; (i = str.indexOf(sub, i)) != -1; i += sub.length()) {
            count++;
        }
    }
    return count;
}

我现在将继续解释该方法对初学者的作用。

我们从计数0开始。然后，我们检查两个字符串是否都不为空，知道它们都不为空，我们继续为子字符串计数，我们进行一个简单的循环以计算子字符串，并在indexOf返回时循环结束-1，表示未找到子字符串。

只需将其复制并粘贴到您的项目中，然后通过执行即可运行

int count = countMatches("Hello World", "World");

现在count如果正在执行，应返回索引1。

快乐编码：）

如何在java中查找子字符串的数量

4 个答案: