Bagaimana cara menghitung jumlah kemunculan char di String?

Saya punya talinya

a.b.c.d

Saya ingin menghitung kemunculan '.' dengan cara yang idiomatis, lebih disukai satu kalimat.

(Sebelumnya saya telah menyatakan batasan ini sebagai "tanpa loop", jika Anda bertanya-tanya mengapa semua orang mencoba menjawab tanpa menggunakan loop).

'One-liner idiomatik' saya untuk ini adalah:

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

Mengapa menulis sendiri ketika sudah di commons lang ?

Oneliner Spring Framework untuk ini adalah:

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

Bagaimana dengan ini. Itu tidak menggunakan regexp di bawahnya jadi harus lebih cepat daripada beberapa solusi lain dan tidak akan menggunakan loop.

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

Ringkas jawaban lain dan apa yang saya tahu semua cara untuk melakukan ini menggunakan satu-baris:

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

1) Menggunakan Apache Commons

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

2) Menggunakan Spring Framework's

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

3) Menggunakan ganti

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

4) Menggunakan replaceAll (case 1)

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

5) Menggunakan replaceAll (case 2)

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

6) Menggunakan split

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

7) Menggunakan Java8 (kasus 1)

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

8) Menggunakan Java8 (case 2), mungkin lebih baik untuk unicode daripada case 1

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

9) Menggunakan StringTokenizer

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

Dari komentar : Hati-hati untuk StringTokenizer, karena abcd itu akan berfungsi tetapi untuk ... bc ... d atau ... abcd atau ... b ...... c ..... d ... atau dll. itu tidak akan berfungsi. Itu hanya akan dihitung. antar karakter sekali saja

Info lebih lanjut di github

Tes kinerja (menggunakan JMH , mode = AverageTime, skor 0.010lebih baik dari itu 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

Cepat atau lambat, sesuatu harus berulang. Jauh lebih mudah bagi Anda untuk menulis loop (sangat sederhana) daripada menggunakan sesuatu sepertisplit yang jauh lebih kuat daripada yang Anda butuhkan.

Dengan segala cara merangkum loop dalam metode yang terpisah, misalnya

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;
}

Maka Anda tidak perlu memiliki loop di kode utama Anda - tetapi loop harus ada di suatu tempat.

Saya punya ide yang mirip dengan Mladen, tetapi sebaliknya ...

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

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

ReplaceAll (".") Akan menggantikan semua karakter.

Solusi PhiLho menggunakan ReplaceAll ("[^.]", ""), Yang tidak perlu diloloskan, karena [.] Mewakili karakter 'titik', bukan 'karakter apa pun'.

Solusi 'satu baris idiomatik' saya:

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

Tidak tahu mengapa solusi yang menggunakan StringUtils diterima.

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

Contoh yang lebih pendek adalah

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

di sini adalah solusi tanpa loop:

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));

baik, ada loop, tetapi tidak terlihat :-)

- Yonatan

Saya tidak suka gagasan mengalokasikan string baru untuk tujuan ini. Dan karena string sudah memiliki array char di belakang di mana ia menyimpan nilainya, String.charAt () praktis gratis.

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

melakukan trik, tanpa alokasi tambahan yang perlu pengumpulan, dalam 1 baris atau kurang, dengan hanya J2SE.

Oke, terinspirasi oleh solusi Yonatan, inilah yang murni rekursif - satu-satunya metode perpustakaan yang digunakan adalah , length()dan charAt()tidak ada yang melakukan perulangan:

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);
}

Apakah rekursi dianggap sebagai pengulangan tergantung pada definisi pasti yang Anda gunakan, tetapi mungkin sedekat yang Anda dapatkan.

Saya tidak tahu apakah sebagian besar JVM melakukan rekursi ekor akhir-akhir ini ... jika tidak, Anda akan mendapatkan stack overflow eponymous untuk string yang panjang, tentu saja.

Terinspirasi oleh Jon Skeet, versi non-loop yang tidak akan meniup stack Anda. Juga titik awal yang berguna jika Anda ingin menggunakan kerangka kerja 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);
    }
}

(Penafian: Tidak diuji, tidak dikompilasi, tidak masuk akal.)

Mungkin cara terbaik (single-threaded, no surrogate-pair support) cara untuk menulisnya:

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

Tidak yakin tentang efisiensi ini, tetapi ini adalah kode terpendek yang dapat saya tulis tanpa membawa lib pihak ke-3:

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

Dengan java-8Anda juga bisa menggunakan stream untuk mencapai ini. Jelas ada iterasi di balik layar, tetapi Anda tidak harus menulisnya secara eksplisit!

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

Juga dimungkinkan untuk menggunakan pengurangan di Java 8 untuk mengatasi masalah ini:

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

Keluaran:

3

Sampel lengkap:

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;
  }
}

Panggilan:

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

Cara paling sederhana untuk mendapatkan jawabannya adalah sebagai berikut:

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));
}

Jika Anda menggunakan kerangka kerja Spring, Anda mungkin juga menggunakan kelas "StringUtils". Metode ini akan menjadi "countOccurrencesOf".

Anda dapat menggunakan split()fungsi ini hanya dalam satu kode baris

int noOccurence=string.split("#",-1).length-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;
}

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

Sementara metode dapat menyembunyikannya, tidak ada cara untuk menghitung tanpa loop (atau rekursi). Anda ingin menggunakan char [] untuk alasan kinerja.

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;
}

Menggunakan replaceAll (yaitu RE) tidak terdengar seperti cara terbaik untuk pergi.

Nah, dengan tugas yang sangat mirip saya menemukan Thread ini. Saya tidak melihat batasan bahasa pemrograman dan karena groovy berjalan pada java vm: Berikut adalah bagaimana saya dapat menyelesaikan Masalah saya menggunakan Groovy.

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

selesai

Solusi yang jauh lebih mudah adalah dengan membagi string berdasarkan karakter yang cocok dengan Anda.

Contohnya,

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

Ini akan menghasilkan 4 jika: getOccurences("o", "something about a quick brown fox");

Di suatu tempat dalam kode, sesuatu harus diulang. Satu-satunya cara untuk mengatasi ini adalah membuka gulungan sepenuhnya loop:

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

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


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

... dll, tapi kemudian kaulah yang melakukan loop, secara manual, di editor sumber - bukan komputer yang akan menjalankannya. Lihat kodesemu:

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

Berikut adalah solusi rekursi gaya yang sedikit berbeda:

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);
}

Mengapa tidak hanya membagi karakter dan kemudian mendapatkan panjang array yang dihasilkan panjang array akan selalu menjadi jumlah instance + 1. Benar?

Kode sumber berikut akan memberi Anda no.of kemunculan string yang diberikan dalam kata yang dimasukkan oleh pengguna: -

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);
        }

    }
}

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