Làm cách nào để tôi đếm số lần xuất hiện của một char trong Chuỗi?


547

Tôi có chuỗi

a.b.c.d

Tôi muốn đếm số lần xuất hiện của '.' một cách thành ngữ, tốt nhất là một lớp lót.

(Trước đây tôi đã thể hiện ràng buộc này là "không có vòng lặp", trong trường hợp bạn đang tự hỏi tại sao mọi người lại cố gắng trả lời mà không sử dụng vòng lặp).


1
Bài tập về nhà? Bởi vì nếu không tôi không thấy yêu cầu để tránh vòng lặp.
PhiLho

22
Không phản đối một vòng lặp nhiều như tìm kiếm một lớp lót thành ngữ.
Bart

2
Các vòng lặp được tạo ra cho một vấn đề như thế này, viết vòng lặp trong một lớp Utility chung sau đó gọi một lớp lót mới được đúc của bạn.
che javara

Câu hỏi tương tự cho chuỗi: stackoverflow.com/questions/767759/
koppor

Chỉ cần chỉ ra - Tôi đánh giá cao việc tìm kiếm một lớp lót, điều đó thật thú vị và (như một lợi thế thực sự) thường dễ nhớ, nhưng tôi muốn chỉ ra rằng một phương pháp riêng biệt và một vòng lặp tốt hơn về mọi mặt - khả năng đọc và thậm chí hiệu suất. Hầu hết các giải pháp "Thanh lịch" dưới đây sẽ không hoạt động tốt vì chúng liên quan đến việc cải cách chuỗi / sao chép bộ nhớ, trong khi đó, một vòng lặp chỉ quét chuỗi và các lần xuất hiện sẽ nhanh chóng và đơn giản. Hiệu suất nói chung không phải là một yếu tố, nhưng đừng nhìn vào một dòng trên một vòng lặp và cho rằng nó sẽ hoạt động tốt hơn.
Bill K

Câu trả lời:


722

'Thành ngữ một lót' của tôi cho điều này là:

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

Tại sao lại tự viết nó khi nó đã có dấu phẩy ?

Oneliner của Spring Framework cho điều này là:

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

44
Quả ổi tương đương: int count = CharMatcher.is('.').countIn("a.b.c.d");... Như được trả lời bởi dogbane trong một câu hỏi trùng lặp.
Jonik

25
Mặc dù tôi sẽ không đánh giá thấp điều này, nhưng nó (a) yêu cầu libs của bên thứ 3 và (b) đắt tiền.
javadba

Điều này chỉ làm việc với khung mùa xuân làm việc phải nhập khẩu.
Isuru Madusanka


19
Cái gì cũng đắt đỏ, ở mọi công ty nơi tôi làm việc, đều có rất nhiều lớp học "* Utils" được viết kém và được bảo trì kém. Một phần công việc của bạn là để biết những gì có sẵn trong Apache Commons.
AbuNassar

1016

Còn cái này thì sao. Nó không sử dụng regrec bên dưới nên sẽ nhanh hơn một số giải pháp khác và sẽ không sử dụng vòng lặp.

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

122
Cách dễ nhất. Khéo một cái. Và nó hoạt động trên Android, nơi không có lớp StringUtils
Jose_GD

43
Đây là câu trả lời tốt nhất. Lý do tốt nhất là vì bạn không phải nhập thư viện khác.
Alex Spencer

27
Rất thực tế nhưng xấu như địa ngục. Tôi không khuyên bạn vì nó dẫn đến mã khó hiểu.
Daniel San

32
Mã xấu có thể được giảm thiểu bằng cách biến nó thành một phương thức trong lớp "StringUtils" của riêng bạn. Sau đó, mã xấu xí ở chính xác một điểm, và mọi nơi khác đều có thể đọc được.
RonR

30
Phương pháp vòng lặp là nhiều nhanh hơn này. Đặc biệt là khi muốn đếm char thay vì String (vì không có phương thức String.replace (char, char)). Trên chuỗi 15 ký tự, tôi nhận được chênh lệch 6049 ns so với 26.739 ns (tính trung bình trên 100 lần). Số nguyên là sự khác biệt rất lớn, nhưng percetage khôn ngoan ... nó cộng lại. Tránh phân bổ bộ nhớ - sử dụng một vòng lặp!
Ben

282

Tóm tắt câu trả lời khác và những gì tôi biết tất cả các cách để làm điều này bằng cách sử dụng một lớp lót:

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

1) Sử dụng Apache Commons

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

2) Sử dụng Spring Framework's

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

3) Sử dụng thay thế

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

4) Sử dụng thay thế All (trường hợp 1)

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

5) Sử dụng thay thế All (trường hợp 2)

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

6) Sử dụng chia

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

7) Sử dụng Java8 (trường hợp 1)

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

8) Sử dụng Java8 (trường hợp 2), có thể tốt hơn cho unicode so với trường hợp 1

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

9) Sử dụng StringTokenizer

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

Từ nhận xét : Hãy cẩn thận với StringTokenizer, đối với abcd, nó sẽ hoạt động nhưng đối với ... bc ... d hoặc ... abcd hoặc a .... b ...... c ..... d ... Hoặc vv nó sẽ không hoạt động. Nó sẽ được tính cho. giữa các nhân vật chỉ một lần

Thêm thông tin trong github

Kiểm tra độ hoàn hảo (sử dụng JMH , mode = AverageTime, 0.010sau đó đạt điểm cao hơn 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

Các chuỗi in không khớp với các chuỗi ở trên và thứ tự nhanh nhất trước tiên khiến cho việc tra cứu ít nhất là khó khăn. Câu trả lời tốt đẹp khác!
Maarten Bodewes

trường hợp 2, được khái quát hóa cho các loại tiền mã hóa cần nhiều hơn một đơn vị mã UTF-16:"1🚲2🚲3 has 2".codePoints().filter((c) -> c == "🚲".codePointAt(0)).count()
Tom Blodget

174

Sớm hay muộn, một cái gì đó phải lặp lại. Việc viết vòng lặp (rất đơn giản) đơn giản hơn nhiều so với sử dụng một cái gì đó nhưsplit đó mạnh hơn bạn cần.

Bằng mọi cách đóng gói vòng lặp trong một phương thức riêng biệt, vd

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

Sau đó, bạn không cần phải có vòng lặp trong mã chính của mình - nhưng vòng lặp phải ở đâu đó.


5
for (int i = 0, l = haystack.length (); i <l; i ++) hãy tử tế với ngăn xếp của bạn
Chris

12
(Tôi thậm chí không chắc chắn nơi các "ngăn xếp" chút nhận xét xuất phát từ Nó không phải như thế nào. Này trả lời là một đệ quy của tôi, đó thực sự là khó chịu vào stack.)
Jon Skeet

2
không chỉ vậy mà đây có thể là một tối ưu hóa chống mà không cần xem những gì jit làm. Nếu bạn đã làm như trên trên một mảng cho vòng lặp chẳng hạn, bạn có thể làm mọi thứ tồi tệ hơn.
ShuggyCoUk

4
@sulai: Mối quan tâm của Chris là vô căn cứ, IMO, trước sự tối ưu hóa JIT tầm thường . Có bất kỳ lý do mà bình luận thu hút sự chú ý của bạn tại thời điểm này, hơn ba năm sau? Chỉ quan tâm.
Jon Skeet

1
Có lẽ @sulai chỉ bắt gặp câu hỏi như tôi đã làm (trong khi tự hỏi liệu Java có phương thức tích hợp sẵn cho việc này không) và không để ý ngày. Tuy nhiên, tôi tò mò làm thế nào để di chuyển length()cuộc gọi bên ngoài vòng lặp có thể làm cho hiệu suất kém hơn , như được đề cập bởi @ShuggyCoUk một vài bình luận.
JKillian

63

Tôi có một ý tưởng tương tự Mladen, nhưng ngược lại ...

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

Chính xác. Thay thế All (".") Sẽ thay thế bất kỳ ký tự nào, không chỉ dấu chấm. Thay thế All ("\\.") Sẽ hoạt động. Giải pháp của bạn đơn giản hơn.
VonC

jjnguy thực sự đã đề xuất một thay thế All ("[^.]") trước khi nhìn thấy "abcd" .split ("\\.") của tôi. Nhưng sau khi bị đánh 5 lần, tôi đã xóa câu trả lời của mình (và bình luận của anh ấy).
VonC

"... Bây giờ bạn có hai vấn đề" (bắt buộc.) Dù sao, tôi cá rằng có hàng chục vòng lặp thực thi trong replaceAll()length(). Chà, nếu nó không hiển thị, nó không tồn tại; o)
Piskvor rời khỏi tòa nhà vào

2
Tôi không nghĩ nên sử dụng regex và tạo một chuỗi mới để đếm. tôi sẽ chỉ tạo một phương thức tĩnh lặp mỗi ký tự trong chuỗi để đếm số.
mingfai

1
@mingfai: thực sự, nhưng câu hỏi ban đầu là về việc tạo một lớp lót, và thậm chí, không có vòng lặp (bạn có thể thực hiện một vòng lặp trong một dòng, nhưng nó sẽ xấu!). Đặt câu hỏi, không phải câu trả lời ... :-)
PhiLho

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

Thay thế All (".") Sẽ thay thế tất cả các ký tự.

Giải pháp của PhiLho sử dụng Thay thế ("[^.]", ""), Không cần phải thoát, vì [.] Đại diện cho ký tự 'dấu chấm', không phải 'bất kỳ ký tự nào'.


Tôi thích cái này. Tất nhiên vẫn còn một vòng lặp ở đó, như phải có.
Archetypal Paul

Lưu ý rằng bạn cần chia số này nếu bạn muốn tìm chuỗi con có độ dài> 1
rogerdpack

30

Giải pháp 'thành ngữ một lót' của tôi:

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

Không biết tại sao một giải pháp sử dụng StringUtils được chấp nhận.


4
Có một giải pháp cũ tương tự như giải pháp này trong bài viết này.
JCalcines

7
Bởi vì giải pháp này thực sự không hiệu quả
András

Điều này tạo ra một chuỗi bổ sung chỉ để tạo ra một số lượng. Không biết tại sao mọi người thích điều này hơn StringUtils nếu StringUtils là một tùy chọn. Nếu đó không phải là một tùy chọn, họ chỉ nên tạo một vòng lặp đơn giản trong một lớp tiện ích.
đè bẹp

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

1
Bình chọn + cho một giải pháp bản địa.
Scadge

24

Một ví dụ ngắn hơn là

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

3
Cái này dường như có một chi phí tương đối lớn, được cảnh báo rằng nó có thể tạo ra rất nhiều chuỗi nhỏ. Thông thường điều đó không quan trọng lắm nhưng hãy cẩn thận.
Maarten Bodewes

19

Đây là một giải pháp không có vòng lặp:

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

tốt, có một vòng lặp, nhưng nó là vô hình :-)

- Yonatan


2
Trừ khi chuỗi của bạn quá dài, bạn sẽ nhận được OutOfMemoryError.
Spencer Kormos

Vấn đề nghe có vẻ đủ để làm bài tập về nhà, và nếu vậy, đệ quy này có lẽ là câu trả lời bạn được yêu cầu tìm.
erickson

Điều đó sử dụng indexOf, sẽ lặp lại ... nhưng một ý tưởng hay. Đăng một giải pháp thực sự "chỉ cần đệ quy" trong một phút ...
Jon Skeet

Nếu có nhiều lần xuất hiện các vị trí ngăn xếp có sẵn của bạn, bạn sẽ có ngoại lệ tràn ngăn xếp;)
Luca C.

15

Tôi không thích ý tưởng phân bổ một chuỗi mới cho mục đích này. Và vì chuỗi đã có một mảng char ở phía sau nơi lưu trữ giá trị của nó, String.charAt () thực tế là miễn phí.

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

thực hiện thủ thuật, không có phân bổ bổ sung cần thu thập, trong 1 dòng hoặc ít hơn, chỉ với J2SE.


Trao một số tình yêu cho cái này bởi vì nó là người duy nhất thực hiện một lần vượt qua chuỗi. Tôi quan tâm đến hiệu suất.
javadba

1
charAtLặp lại qua 16 điểm mã không phải ký tự! A chartrong Java không phải là một ký tự. Vì vậy, câu trả lời này ngụ ý rằng không được có biểu tượng Unicode có đại diện thay thế cao bằng điểm mã của delim. Tôi không chắc liệu nó có đúng với dấu chấm không, nhưng nói chung nó có thể không đúng.
ceving

14

Được rồi, lấy cảm hứng từ giải pháp của Yonatan, đây là một phương pháp hoàn toàn đệ quy - phương thức thư viện duy nhất được sử dụng length()charAt(), không phương pháp nào thực hiện bất kỳ vòng lặp nào:

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

Việc đệ quy có được tính là lặp hay không phụ thuộc vào định nghĩa chính xác mà bạn sử dụng, nhưng có lẽ nó gần như bạn sẽ nhận được.

Tôi không biết liệu hầu hết các JVM có đệ quy đuôi trong những ngày này hay không ... nếu không, bạn sẽ có được tràn ngăn xếp cùng tên cho các chuỗi dài phù hợp, tất nhiên.


Không, đệ quy đuôi có thể sẽ có trong Java 7, nhưng nó chưa được phổ biến rộng rãi. Phép đệ quy đuôi trực tiếp đơn giản này có thể được dịch thành một vòng lặp trong thời gian biên dịch, nhưng công cụ Java 7 thực sự được tích hợp sẵn trong JVM để xử lý chuỗi thông qua các phương thức khác nhau.
erickson

3
Bạn sẽ có nhiều khả năng nhận được đệ quy đuôi hơn nếu phương thức của bạn trả về một cuộc gọi đến chính nó (bao gồm cả một tham số tổng thể đang chạy), thay vì trả về kết quả của việc thực hiện bổ sung.
Stephen Denne

12

Lấy cảm hứng từ Jon Skeet, một phiên bản không vòng lặp sẽ không thổi tung ngăn xếp của bạn. Cũng là điểm khởi đầu hữu ích nếu bạn muốn sử dụng khung kết nối ngã ba.

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

(Tuyên bố miễn trừ trách nhiệm: Không được kiểm tra, không được biên dịch, không hợp lý.)

Có lẽ cách tốt nhất (đơn luồng, không hỗ trợ cặp thay thế) để viết nó:

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

11

Không chắc chắn về hiệu quả của việc này, nhưng đó là mã ngắn nhất tôi có thể viết mà không cần đưa vào libs của bên thứ 3:

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

4
Để tính cả số lần xuất hiện ở cuối chuỗi, bạn sẽ phải gọi tách bằng một đối số giới hạn âm như thế này : return (content.split(target, -1).length - 1);. Theo mặc định xuất hiện ở cuối chuỗi được bỏ qua trong Mảng do chia tách (). Xem Doku
vlz

10

Với bạn cũng có thể sử dụng các luồng để đạt được điều này. Rõ ràng có một sự lặp lại đằng sau hậu trường, nhưng bạn không cần phải viết nó một cách rõ ràng!

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

Sử dụng .codePoints()thay vì .chars()sau đó sẽ hỗ trợ bất kỳ giá trị Unicode nào (bao gồm cả những giá trị yêu cầu cặp thay thế)
Luke Usherwood

10

Cũng có thể sử dụng giảm trong Java 8 để giải quyết vấn đề này:

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

Đầu ra:

3

8

Mẫu hoàn chỉnh:

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

Gọi:

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

mã sai của nó không hoạt động khi tôi thử int xảy ra = CharacterCount.countOccurrences ("1", "101"); System.out.println (lần xuất hiện); // 1
Jayesh

Tôi cam kết sửa lỗi cho mã hoạt động với cùng logic
MaanooAk

8

Cách đơn giản nhất để có câu trả lời như sau:

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

2
Đoạn mã này không trả về số lượng chấm chính xác cho "abc" đầu vào đã cho
dekaru

@dekaru Bạn có thể vui lòng dán sting của bạn trong bình luận để chúng tôi có thể xem.
Amar Magar

5

Trong trường hợp bạn đang sử dụng khung công tác Spring, bạn cũng có thể sử dụng lớp "StringUtils". Phương thức sẽ là "CountOccurrencesOf".


5

Bạn có thể sử dụng split()hàm chỉ trong một mã dòng

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

Split thực sự tạo ra chuỗi các chuỗi, tiêu tốn nhiều thời gian.
Palec

Bạn nói đúng, đó là một mối quan tâm thực sự . Theo một cách khác, nó tránh mang lib của bên thứ ba trong dự án của bạn (nếu chưa được thực hiện). Nó phụ thuộc vào những gì bạn muốn làm và kỳ vọng hiệu suất là gì.
Ngày

3
Giải pháp này sẽ KHÔNG bao gồm các lần truy cập trống theo dõi, bởi vì đối số limitđược đặt thành 0 trong lệnh gọi phương thức phân tách quá tải này. Một ví dụ: "1##2#3#####".split("#")sẽ chỉ mang lại một mảng có kích thước 4 ( [0:"1";1:""; 2:"2"; 3:"3"]) thay vì kích thước 9 ( [0:"1"; 1:""; 2:"2"; 3:"3"; 4:""; 5:""; 6:""; 7:""; 8:""]).
klaar

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

4
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

3

Trong khi các phương thức có thể ẩn nó, không có cách nào để đếm mà không có vòng lặp (hoặc đệ quy). Bạn muốn sử dụng char [] vì lý do hiệu suất.

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

Sử dụng thay thế All (đó là RE) có vẻ không phải là cách tốt nhất để đi.


Tôi nghĩ rằng đây là giải pháp thanh lịch nhất. Tại sao bạn sử dụng toCharArray mà không trực tiếp charAt?
Panayotis

Vòng lặp với charAt ít nhất được sử dụng để chậm hơn. Có thể phụ thuộc vào nền tảng, quá. Cách duy nhất để thực sự tìm ra sẽ là đo lường sự khác biệt.
tcurdt

3

Vâng, với một nhiệm vụ khá giống nhau, tôi tình cờ thấy Chủ đề này. Tôi không thấy bất kỳ hạn chế ngôn ngữ lập trình nào và vì Groovy chạy trên java vm: Đây là cách tôi có thể giải quyết Vấn đề của mình bằng Groovy.

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

làm xong.


3

Một giải pháp dễ dàng hơn nhiều là chỉ cần tách chuỗi dựa trên ký tự bạn khớp với nó.

Ví dụ,

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

Điều này sẽ trả về 4 trong trường hợp: getOccurences("o", "something about a quick brown fox");


Vấn đề ở đây là một mảng phải được phân bổ, tốc độ cực kỳ chậm.
Palec

2

Ở đâu đó trong mã, một cái gì đó phải lặp lại. Cách duy nhất để giải quyết vấn đề này là hoàn toàn không kiểm soát vòng lặp:

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

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


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

... vv, nhưng sau đó, bạn là người thực hiện vòng lặp, theo cách thủ công, trong trình chỉnh sửa nguồn - thay vì máy tính sẽ chạy nó. Xem mã giả:

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

2

Đây là một giải pháp đệ quy phong cách hơi khác nhau:

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

2

Tại sao không chỉ phân chia trên ký tự và sau đó lấy chiều dài của mảng kết quả. độ dài mảng sẽ luôn là số lượng phiên bản + 1. Phải không?


2

Mã nguồn sau đây sẽ cung cấp cho bạn số lần xuất hiện của một chuỗi đã cho trong một từ được nhập bởi người dùng: -

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

    }
}

2
int count = (line.length() - line.replace("str", "").length())/"str".length();
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.