Как подсчитать количество вхождений символа в строку?

Рано или поздно что-нибудь должен зацикливаться. Вам гораздо проще написать (очень простой) цикл, чем использовать что-то вроде split, которое намного мощнее, чем вам нужно.

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

public static int countOccurrences(String haystack, char needle)
{
    int count = 0;
    for (int i=0; i < haystack.length(); i++)
    {
        if (haystack.charAt(i) == needle)
        {
             count++;
        }
    }
    return count;
}

Тогда вам не нужно иметь цикл в вашем основном коде - но цикл должен быть где-то там.

вот решение без цикла:

public static int countOccurrences(String haystack, char needle, int i){
    return ((i=haystack.indexOf(needle, i)) == -1)?0:1+countOccurrences(haystack, needle, i+1);}


System.out.println("num of dots is "+countOccurrences("a.b.c.d",'.',0));

ну есть петля, но это невидимый :-)

- Йонатан

String s = "a.b.c.d";
int charCount = s.length() - s.replaceAll("\\.", "").length();

ReplaceAll (".") Заменит все символы.

Решение PhiLho использует ReplaceAll ("[^.]", ""), Который не нужно экранировать, поскольку [.] Представляет собой символ "точка", а не "любой символ".

У меня была идея, похожая на Младена, но наоборот ...

String s = "a.b.c.d";
int charCount = s.replaceAll("[^.]", "").length();
println(charCount);

Хорошо, вдохновленный решением Йонатана, вот тот, который является рекурсивным чисто - единственные используемые библиотечные методы - это length() и charAt(), ни один из которых не выполняет никаких циклов:

public static int countOccurrences(String haystack, char needle)
{
    return countOccurrences(haystack, needle, 0);
}

private static int countOccurrences(String haystack, char needle, int index)
{
    if (index >= haystack.length())
    {
        return 0;
    }

    int contribution = haystack.charAt(index) == needle ? 1 : 0;
    return contribution + countOccurrences(haystack, needle, index+1);
}

Считается ли рекурсия зацикливанием, зависит от того, какое точное определение вы используете, но, вероятно, оно будет максимально точным.

Я не знаю, выполняет ли большинство JVM в наши дни хвостовую рекурсию ... в противном случае вы, конечно, получите одноименное переполнение стека для достаточно длинных строк.

Хотя методы могут скрыть это, нет способа подсчета без цикла (или рекурсии). Однако вы хотите использовать char [] по соображениям производительности.

public static int count( final String s, final char c ) {
  final char[] chars = s.toCharArray();
  int count = 0;
  for(int i=0; i<chars.length; i++) {
    if (chars[i] == c) {
      count++;
    }
  }
  return count;
}

Использование replaceAll (то есть RE) - не лучший вариант.

Вдохновленная Джоном Скитом, версия без цикла, которая не взорвет ваш стек. Также полезная отправная точка, если вы хотите использовать структуру fork-join.

public static int countOccurrences(CharSequeunce haystack, char needle) {
    return countOccurrences(haystack, needle, 0, haystack.length);
}

// Alternatively String.substring/subsequence use to be relatively efficient
//   on most Java library implementations, but isn't any more [2013].
private static int countOccurrences(
    CharSequence haystack, char needle, int start, int end
) {
    if (start == end) {
        return 0;
    } else if (start+1 == end) {
        return haystack.charAt(start) == needle ? 1 : 0;
    } else {
        int mid = (end+start)>>>1; // Watch for integer overflow...
        return
            countOccurrences(haystack, needle, start, mid) +
            countOccurrences(haystack, needle, mid, end);
    }
}

(Отказ от ответственности: не проверено, не скомпилировано, не имеет смысла.)

Возможно, лучший (однопоточный, без поддержки суррогатных пар) способ его написания:

public static int countOccurrences(String haystack, char needle) {
    int count = 0;
    for (char c : haystack.toCharArray()) {
        if (c == needle) {
           ++count;
        }
    }
    return count;
}

Где-то в коде что-то должно зацикливаться. Единственный способ обойти это - полностью развернуть цикл:

int numDots = 0;
if (s.charAt(0) == '.') {
    numDots++;
}

if (s.charAt(1) == '.') {
    numDots++;
}


if (s.charAt(2) == '.') {
    numDots++;
}

... и т.д., но тогда вы делаете цикл вручную в редакторе исходного кода, а не на компьютере, который будет его запускать. Смотрите псевдокод:

create a project
position = 0
while (not end of string) {
    write check for character at position "position" (see above)
}
write code to output variable "numDots"
compile program
hand in homework
do not think of the loop that your "if"s may have been optimized and compiled to

Вот немного другое решение для рекурсии стиля:

public static int countOccurrences(String haystack, char needle)
{
    return countOccurrences(haystack, needle, 0);
}

private static int countOccurrences(String haystack, char needle, int accumulator)
{
    if (haystack.length() == 0) return accumulator;
    return countOccurrences(haystack.substring(1), needle, haystack.charAt(0) == needle ? accumulator + 1 : accumulator);
}

Более короткий пример:

String text = "a.b.c.d";
int count = text.split("\\.",-1).length-1;

Мой идиоматический однострочник:

int count = StringUtils.countMatches("a.b.c.d", ".");

Зачем писать самому, когда он уже в общий язык?

Единственный пример Spring Framework для этого:

int occurance = StringUtils.countOccurrencesOf("a.b.c.d", ".");

Попробуйте этот метод:

StringTokenizer stOR = new StringTokenizer(someExpression, "||");
int orCount = stOR.countTokens()-1;

Если вы используете платформу Spring, вы также можете использовать класс StringUtils. Метод будет «countOccurrencesOf».

Почему бы просто не разделить на символ, а затем получить длину результирующего массива. длина массива всегда будет равна числу экземпляров +1. Верно?

public static int countOccurrences(String container, String content){
    int lastIndex, currIndex = 0, occurrences = 0;
    while(true) {
        lastIndex = container.indexOf(content, currIndex);
        if (lastIndex == -1) {
            break;
        }
        currIndex = lastIndex + content.length();
        occurrences++;
    }
    return occurrences;
}

Как насчет этого. Он не использует регулярное выражение внизу, поэтому должен быть быстрее, чем некоторые другие решения, и не будет использовать цикл.

int count = line.length() - line.replace(".", "").length();

Полный образец:

public class CharacterCounter
{

  public static int countOccurrences(String find, String string)
  {
    int count = 0;
    int indexOf = 0;

    while (indexOf > -1)
    {
      indexOf = string.indexOf(find, indexOf + 1);
      if (indexOf > -1)
        count++;
    }

    return count;
  }
}

Вызов:

int occurrences = CharacterCounter.countOccurrences("l", "Hello World.");
System.out.println(occurrences); // 3

import java.util.Scanner;

class apples {

    public static void main(String args[]) {    
        Scanner bucky = new Scanner(System.in);
        String hello = bucky.nextLine();
        int charCount = hello.length() - hello.replaceAll("e", "").length();
        System.out.println(charCount);
    }
}//      COUNTS NUMBER OF "e" CHAR´s within any string input

Не уверен в эффективности этого, но это самый короткий код, который я мог бы написать без использования сторонних библиотек:

public static int numberOf(String target, String content)
{
    return (content.split(target).length - 1);
}

Мне не нравится идея выделения для этой цели новой строки. И поскольку строка уже имеет массив символов в задней части, где она хранит свое значение, String.charAt () практически бесплатна.

for(int i=0;i<s.length();num+=(s.charAt(i++)==delim?1:0))

справляется с задачей без дополнительных выделений, требующих сбора, в 1 строке или меньше, только с J2SE.

Следующий исходный код даст вам количество вхождений данной строки в слово, введенное пользователем: -

import java.util.Scanner;

public class CountingOccurences {

    public static void main(String[] args) {

        Scanner inp= new Scanner(System.in);
        String str;
        char ch;
        int count=0;

        System.out.println("Enter the string:");
        str=inp.nextLine();

        while(str.length()>0)
        {
            ch=str.charAt(0);
            int i=0;

            while(str.charAt(i)==ch)
            {
                count =count+i;
                i++;
            }

            str.substring(count);
            System.out.println(ch);
            System.out.println(count);
        }

    }
}

 public static int countSubstring(String subStr, String str) {

    int count = 0;
    for (int i = 0; i < str.length(); i++) {
        if (str.substring(i).startsWith(subStr)) {
            count++;
        }
    }
    return count;
}

Почему вы пытаетесь избежать петли? Я имею в виду, что вы не можете сосчитать точки «numberOf», не проверив каждый отдельный символ строки, и если вы вызовете любую функцию, она каким-то образом зациклится. То есть String.replace должен выполнить цикл, проверяющий, появляется ли строка, чтобы она могла заменить каждое отдельное вхождение.

Если вы пытаетесь уменьшить использование ресурсов, вы этого не сделаете, потому что вы создаете новую строку только для подсчета точек.

Теперь, если мы говорим о рекурсивном методе «введите код здесь», кто-то сказал, что он не сработает из-за OutOfMemmoryException, я думаю, он забыл StackOverflowException.

Итак, мой метод будет таким (я знаю, что он похож на другие, но для этой проблемы требуется цикл):

public static int numberOf(String str,int c) {
    int res=0;
    if (str==null)
        return res;
    for(int i=0;i<str.length();i++)
        if (c==str.charAt(i))
            res++;
    return res;
}

String s = "a.b.c.d";
long result = s.chars().filter(ch -> ch == '.').count();

Мое "идиоматическое однострочное" решение:

int count = "a.b.c.d".length() - "a.b.c.d".replace(".", "").length();

Понятия не имею, почему принято решение, использующее StringUtils.

int count = (line.length() - line.replace("str", "").length())/"str".length();

С java-8 вы также можете использовать потоки для достижения этого. Очевидно, что за кулисами есть итерация, но вам не нужно писать ее явно!

public static long countOccurences(String s, char c){
    return s.chars().filter(ch -> ch == c).count();
}

countOccurences("a.b.c.d", '.'); //3
countOccurences("hello world", 'l'); //3

А как насчет ниже рекурсивного алгоритма, который также является линейным временем.

import java.lang.*;
import java.util.*;

class longestSubstr{

public static void main(String[] args){
   String s = "ABDEFGABEF";


   int ans=calc(s);

   System.out.println("Max nonrepeating seq= "+ans);

}

public static int calc(String s)
{//s.s
      int n=s.length();
      int max=1;
      if (n==1)
          return 1;
      if (n==2)
      {
          if (s.charAt(0)==s.charAt(1)) return 1;
          else return 2;


      }
      String s1=s;
    String a=s.charAt(n-1)+"";
          s1=s1.replace(a,"");
         // System.out.println(s+" "+(n-2)+" "+s.substring(0,n-1));
         max=Math.max(calc(s.substring(0,n-1)),(calc(s1)+1));


return max;
}


}


</i>

Я вижу, что используется много уловок и тому подобных. Я не против красивых трюков, но лично мне нравится просто вызывать методы имел в виду для выполнения работы, поэтому я создал еще один ответ.

Обратите внимание, что если производительность является какой-либо проблемой, используйте вместо этого Ответ Джона Скита. Этот вариант немного более обобщен и поэтому, на мой взгляд, немного более читабелен (и, конечно же, его можно использовать повторно для строк и шаблонов).

public static int countOccurances(char c, String input) {
    return countOccurancesOfPattern(Pattern.quote(Character.toString(c)), input);
}

public static int countOccurances(String s, String input) {
    return countOccurancesOfPattern(Pattern.quote(s), input);
}

public static int countOccurancesOfPattern(String pattern, String input) {
    Matcher m = Pattern.compile(pattern).matcher(input);
    int count = 0;
    while (m.find()) {
        count++;
    }
    return count;
}

public class OccurencesInString { public static void main(String[] args) { String str = "NARENDRA AMILINENI"; HashMap occur = new HashMap(); int count =0; String key = null; for(int i=0;i<str.length()-1;i++){ key = String.valueOf(str.charAt(i)); if (occur.containsKey(key)){ count = (Integer)occur.get(key); occur.put(key,++count); }else{ occur.put(key,1); } } System.out.println(occur); } }

Я попытался решить ваш вопрос с помощью оператора switch, но мне все еще нужен цикл for для анализа строки. не стесняйтесь комментировать, могу ли я улучшить код

public class CharacterCount {
public static void main(String args[])
{
    String message = "hello how are you";
    char[] array=message.toCharArray();
    int a=0;
    int b=0;
    int c=0;
    int d=0;
    int e=0;
    int f=0;
    int g=0;
    int h=0;
    int i=0;
    int space=0;
    int j=0;
    int k=0;
    int l=0;
    int m=0;
    int n=0;
    int o=0;
    int p=0;
    int q=0;
    int r=0;
    int s=0;
    int t=0;
    int u=0;
    int v=0;
    int w=0;
    int x=0;
    int y=0;
    int z=0;


    for(char element:array)
    {
        switch(element)
        {
        case 'a':
        a++;
        break;
        case 'b':
        b++;
        break;
        case 'c':c++;
        break;

        case 'd':d++;
        break;
        case 'e':e++;
        break;
        case 'f':f++;
        break;

        case 'g':g++;
        break;
        case 'h':
        h++;
        break;
        case 'i':i++;
        break;
        case 'j':j++;
        break;
        case 'k':k++;
        break;
        case 'l':l++;
        break;
        case 'm':m++;
        break;
        case 'n':m++;
        break;
        case 'o':o++;
        break;
        case 'p':p++;
        break;
        case 'q':q++;
        break;
        case 'r':r++;
        break;
        case 's':s++;
        break;
        case 't':t++;
        break;
        case 'u':u++;
        break;
        case 'v':v++;
        break;
        case 'w':w++;
        break;
        case 'x':x++;
        break;
        case 'y':y++;
        break;
        case 'z':z++;
        break;
        case ' ':space++;
        break;
        default :break;
        }
    }
    System.out.println("A "+a+" B "+ b +" C "+c+" D "+d+" E "+e+" F "+f+" G "+g+" H "+h);
    System.out.println("I "+i+" J "+j+" K "+k+" L "+l+" M "+m+" N "+n+" O "+o+" P "+p);
    System.out.println("Q "+q+" R "+r+" S "+s+" T "+t+" U "+u+" V "+v+" W "+w+" X "+x+" Y "+y+" Z "+z);
    System.out.println("SPACE "+space);
}

}

Попробуйте этот код:

package com.java.test;

import java.util.HashMap;
import java.util.Map;

public class TestCuntstring {

    public static void main(String[] args) {

        String name = "Bissssmmayaa";
        char[] ar = new char[name.length()];
        for (int i = 0; i < name.length(); i++) {
            ar[i] = name.charAt(i);
        }
        Map<Character, String> map=new HashMap<Character, String>();
        for (int i = 0; i < ar.length; i++) {
            int count=0;
            for (int j = 0; j < ar.length; j++) {
                if (ar[i]==ar[j]){
                    count++;
                }
            }
            map.put(ar[i], count+" no of times");
        }
        System.out.println(map);
    }

}

Ну, с довольно похожей задачей наткнулся на эту тему. Я не видел никаких ограничений языка программирования, и поскольку groovy работает на java vm: Вот как я смог решить свою проблему с помощью Groovy.

"a.b.c.".count(".")

Готово.

Обобщите другой ответ и то, что я знаю, все способы сделать это с помощью однострочника:

   String testString = "a.b.c.d";

1) Использование Apache Commons

int apache = StringUtils.countMatches(testString, ".");
System.out.println("apache = " + apache);

2) Использование Spring Framework's

int spring = org.springframework.util.StringUtils.countOccurrencesOf(testString, ".");
System.out.println("spring = " + spring);

3) Использование заменять

int replace = testString.length() - testString.replace(".", "").length();
System.out.println("replace = " + replace);

4) Использование заменить все (случай 1)

int replaceAll = testString.replaceAll("[^.]", "").length();
System.out.println("replaceAll = " + replaceAll);

5) Использование заменить все (случай 2)

int replaceAllCase2 = testString.length() - testString.replaceAll("\\.", "").length();
System.out.println("replaceAll (second case) = " + replaceAllCase2);

6) Использование расколоть

int split = testString.split("\\.",-1).length-1;
System.out.println("split = " + split);

7) Использование Java8 (случай 1)

long java8 = testString.chars().filter(ch -> ch =='.').count();
System.out.println("java8 = " + java8);

8) Использование Java8 (случай 2) может быть лучше для юникода, чем случай 1

long java8Case2 = testString.codePoints().filter(ch -> ch =='.').count();
System.out.println("java8 (second case) = " + java8Case2);

9) Использование StringTokenizer

int stringTokenizer = new StringTokenizer(" " +testString + " ", ".").countTokens()-1;
System.out.println("stringTokenizer = " + stringTokenizer);

Из комментария: Будьте осторожны с StringTokenizer, для abcd он будет работать, но для a ... bc ... d или ... abcd или a .... b ...... c ..... d. .. или т.д. не получится. Это просто будет считаться. между персонажами только один раз

Больше информации в github

Тест производительности (с использованием JMH, mode = AverageTime, оценка 0.010 лучше, чем 0.351):

Benchmark              Mode  Cnt  Score    Error  Units
1. countMatches        avgt    5  0.010 ±  0.001  us/op
2. countOccurrencesOf  avgt    5  0.010 ±  0.001  us/op
3. stringTokenizer     avgt    5  0.028 ±  0.002  us/op
4. java8_1             avgt    5  0.077 ±  0.005  us/op
5. java8_2             avgt    5  0.078 ±  0.003  us/op
6. split               avgt    5  0.137 ±  0.009  us/op
7. replaceAll_2        avgt    5  0.302 ±  0.047  us/op
8. replace             avgt    5  0.303 ±  0.034  us/op
9. replaceAll_1        avgt    5  0.351 ±  0.045  us/op

Вы можете использовать функцию split() всего в одной строке кода

int noOccurence=string.split("#",-1).length-1;

Если вы хотите посчитать «нет». того же символа в строке «SELENIUM» или вы хотите напечатать уникальные символы строки «SELENIUM».

public class Count_Characters_In_String{

     public static void main(String []args){

        String s = "SELENIUM";
        System.out.println(s);
        int counter;

       String g = "";

        for( int i=0; i<s.length(); i++ ) { 

        if (g.indexOf(s.charAt(i)) == - 1){
           g=g+s.charAt(i); 
          }

       }
       System.out.println(g + " ");



        for( int i=0; i<g.length(); i++ ) {          
          System.out.print(",");

          System.out.print(s.charAt(i)+ " : ");
          counter=0; 
          for( int j=0; j<s.length(); j++ ) { 

        if ( g.charAt(i) == s.charAt(j) ) {
           counter=counter+1;

           }      

          }
          System.out.print(counter); 
       }
     }
}

/******************** ВЫХОД **********************/

СЕЛЕН

СЕЛНИУМ

S: 1, E: 2, L: 1, E: 1, N: 1, I: 1, U: 1

Самый простой способ получить ответ:

public static void main(String[] args) {
    String string = "a.b.c.d";
    String []splitArray = string.split("\\.",-1);
    System.out.println("No of . chars is : " + (splitArray.length-1));
}

Также можно использовать сокращение в Java 8 для решения этой проблемы:

int res = "abdsd3$asda$asasdd$sadas".chars().reduce(0, (a, c) -> a + (c == '$' ? 1 : 0));
System.out.println(res);

Выход:

3

Использование Коллекции Eclipse

int count = Strings.asChars("a.b.c.d").count(c -> c == '.');

Если у вас есть более одного символа для подсчета, вы можете использовать CharBag следующим образом:

CharBag bag = Strings.asChars("a.b.c.d").toBag();
int count = bag.occurrencesOf('.');

Примечание: я являюсь приверженцем коллекций Eclipse.

String[] parts = text.split(".");
int occurances = parts.length - 1;

" It's a great day at O.S.G. Dallas! "
     -- Famous Last Words

Что ж, это случай знания вашей Java, особенно вашего базового понимания классов коллекций, уже доступных в Java. Если вы просмотрите всю публикацию здесь, есть почти все, кроме объяснения Стивена Хокинга о Происхождении Вселенной, мягкой обложки Дарвина об эволюции и выбора актерского состава Джина Родденберри из Звездного пути о том, почему они пошли с Уильямом Шатнером, не дожидаясь, как это сделать это быстро и легко ...

... мне нужно больше говорить?

public static void getCharacter(String str){

        int count[]= new int[256];

        for(int i=0;i<str.length(); i++){


            count[str.charAt(i)]++;

        }
        System.out.println("The ascii values are:"+ Arrays.toString(count));

        //Now display wht character is repeated how many times

        for (int i = 0; i < count.length; i++) {
            if (count[i] > 0)
               System.out.println("Number of " + (char) i + ": " + count[i]);
        }


    }
}

Использование Java 8 и HashMap без какой-либо библиотеки для подсчета всех разных символов:

private static void countChars(String string) {
    HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();
    string.chars().forEach(letter -> hm.put(letter, (hm.containsKey(letter) ? hm.get(letter) : 0) + 1));
    hm.forEach((c, i) -> System.out.println(((char)c.intValue()) + ":" + i));
}

используйте лямбда-функцию, которая удаляет все символы для подсчета
счетчик - это разница между длиной до и после

String s = "a.b.c.d";
int count = s.length() - deleteChars.apply( s, "." ).length();  // 3

найдите здесь deleteChars

если вам нужно подсчитать появление более чем одного символа, это можно сделать одним махом:
например. для bc и .:

int count = s.length() - deleteChars.apply( s, "bc." ).length();  // 5

Гораздо более простым решением было бы просто разделить строку на основе символа, с которым вы ее сопоставляете.

Например,

int getOccurences(String characters, String string) { String[] words = string.split(characters); return words.length - 1; }

Это вернет 4 в случае: getOccurences("o", "something about a quick brown fox");

Это то, что я использую для подсчета вхождений строки.

Надеюсь, кто-то сочтет это полезным.

    private long countOccurrences(String occurrences, char findChar){
        return  occurrences.chars().filter( x -> {
            return x == findChar;
        }).count();
    }

однострочное лямбда
без необходимости во внешней библиотеке. Создает карту с количеством каждого символа:

Map<Character,Long> counts = "a.b.c.d".codePoints().boxed().collect(
    groupingBy( t -> (char)(int)t, counting() ) );

получает: {a=1, b=1, c=1, d=1, .=3}
количество определенного символа, например. '.' отдан:
counts.get( '.' )

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