java - 在另一个字符串中找到该字符串的字符有多少次

Question

我的教授给我做了一个练习，以查找在名为“查询”的第二个字符串中找到“过滤器”字符串的字符有多少次。
在我开始之前，我是java noob，英语不是我的母语。

例：

String filter="kjasd";
String query="kjg4t";

Output:2

在另一个字符串中找到一个字符有多少次不是我的问题，但是教授给了我们一些遵守的规则：


类过滤器。该课程必须是以下公众人士
提供接口：


公共过滤器（字符串字母）（→类的构造方法）
代表过滤器的字符串应存储在字母字符串中
公共布尔包含（字符）
如果传递的字符包含在查询字符串中，则返回true；否则返回false
-public字符串toString（）
返回该类的适当的字符串表示形式（为清楚起见，我不知道他对这个类的含义！）
为了实际确定查询中过滤器的出现，将创建另一个类QueryResolver。
该类应能够按以下方式使用：

QueryResolver resolver = new QueryResolver();
int count = resolver.where(query).matches(filter).count();
过滤器和查询由用户给出。
（我无法理解这一点！）方法“ where”和“ matches”将“ QueryResolver”配置为包括基于先前传递的变量的对计算的后续调用“ count”
“查询”和“过滤器”执行。
计数方法应使用过滤器先前创建的方法。

不允许使用修饰符static！
我不知道他是否意味着我们不能使用 static {}或我们不能使用 public (static) boolean contains (char character){}
我们不允许使用void


所以遇到我的问题
-我不能将char传递给包含的方法，只要它不是静态的即可。
错误“无法从静态上下文中引用非静态变量”


我不明白我应该用tostirng方法做什么！


到目前为止，我所做的是：


方法Nr 1：
因此，我只是在main方法中编写了所有内容，以检查我的代码原理是否起作用，然后我想使用构造函数和其他方法来创建整个函数，但不幸的是我没有成功。
方法二：
然后我尝试像练习中那样用小mthoden编写代码，但没有成功！


在这两种方式中，我都违反了运动规则，但是我似乎无法独自完成运动，这就是为什么我在这里发布问题。

第一步：

public class filter{
    public filter(String letters) {
        //constructor of the class
        String filter;
        int count;
    }
    public boolean contains (char character){
        /*Subprogram without static!
         *the problem that I can't pass any char to this method if it wasn't static
         *and I will get the following error"Non-static variable cannot be referenced from a static context"
         *I understand why I'm getting the error but I don't know how to get around it X(   */

       return true ;    
    }

    public String toString (){
        /*he told us to include it in the program but honestly, I don't know what shall I write in it -_-
         *I make it to null because you have to return something and I don't know what to do yet 
         *so, for now, I let it null. */
        return null;
    }

    public static void main(String[] args) {

        Scanner in =new Scanner (System.in);

        System.out.println("please enter the query string! ");

        String query= in.next();
        System.out.println("please enter the filter stirng!");

        String filter= in.next();
        System.out.println("the query string is : [" + query+ "]");
        System.out.println("the filter string is : [" + filter+ "]");

        int count=0;

        // I initialized it temporarily because I wanted to print it!
        //later I need to use it with the boolean contains as a public method
        boolean contains=false;

        //to convert each the query and the filter strings to chars
        char [] tempArray=query.toCharArray();
        char [] tempArray1=filter.toCharArray();

        //to iterate for each char in the query string! 
        for (int i = 0; i < tempArray.length; i++) {

            char cc = tempArray[i];
            //to iterate for each char in the filter string!
            for (int j = 0; j < tempArray1.length; j++) {
                // if the value in the filter string matches the value in the temp array then increment the counter by one!
                if(tempArray1[j] == cc){
                    count++;
                    contains=true;
                }
            }
        }

        System.out.println("the characters of the String ["+filter+"] has been found in the forworded string ["+query+"] exactly "+count+" times!" );
        System.out.println("the boolean value : "+ contains);
        in.close();

    }

}

第二种方法
-但是我在这里也很残酷地违反了任务规则:(
-首先，我使用void而不使用tostring方法。
-其次，我没有使用构造函数。
-我没有添加评论，因为这与我的第一次尝试是相同的。

public class filter2 {

    public static void main(String[] args) {
        Scanner in = new Scanner (System.in);
        System.out.println("enter the filter string:");
        String filterStr=in.next();
        System.out.println("enter the query string:");
        String querystr =in.next();

        Filter(filterStr, querystr);
        in.close();
    }
    public static void Filter(String filterstr , String querystr){

        char [] tempArray1 = filterstr.toCharArray();
        contains(tempArray1, querystr);
    }   

    public static void contains(char[]tempArray1, String querystr){
        boolean isThere= false ;
        int counter=0;

        char [] tempArray = querystr.toCharArray(); 

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

            char cc = tempArray[i];

            for (int j = 0; j < tempArray1.length; j++) {
                if(tempArray1[j] == cc){
                    counter++;
                    isThere=true;
                }
            }
        }
        System.out.println("the letters of the filter string has been found in the query string exactly "+counter+" times!\nthus the boolean value is "+isThere);

    }
        /*
     * sadly enough i still have no clue what is meant with this one nor whatshall i do
     * public String toString (){
     *  return null;
     * }
     * 
     */
}

很少的提示和建议对我非常有用，但是请在代码中演示您的建议，因为有时我很难理解给定建议的含义。 ;）

先感谢您。

（很抱歉出现语法和类型错误；英语不是我的母语）

Answer 1

如前所述，重要的是要学会自己解决这些问题。作业不是为了惩罚，而是要教您如何独自学习新知识，这是计算机科学家的重要特征。
但是，因为您似乎已经确实在努力解决该问题，所以这里是我的解决方案，然后进行一些解释。
一般概念
我觉得您不了解的第一件事是类和对象的概念。类就像对象的“蓝图”，而对象一旦实例化就可以了。
与诸如汽车之类的东西相比，该课程将描述如何制造汽车，而对象将是汽车。
用public class Car { ... }描述什么是类，并用Car myCar = new Car();实例化该对象。
一个类可以具有方法（=函数）和成员变量（=数据）。
我只是重复这些概念，因为您编写的代码看起来还没有完全理解该概念。请问其他了解它的学生来帮助您。
过滤器类

public class Filter{

    String letters;
    
    public Filter(String letters) {
        this.letters = letters;
    }
    
    public boolean contains (char character){
        for(int i = 0; i < letters.length(); i++) {
            if(letters.charAt(i) == character)
                return true;
        }
        return false;
    }

    public String toString (){
        return "Filter(" + letters + ")";
    }
}

好吧，让我们刹车一下。

public class Filter{
...
}

我想你已经明白了。这是您描述类结构的地方。

    String letters;

这是一个类成员变量。对于您创建的该类的每个对象，它都是唯一的。再次，有关详细信息，请问其他了解它的学生。

    public Filter(String letters) {
        this.letters = letters;
    }

这是构造函数。创建对象时，将调用该函数。
在这种情况下，它要做的只是获取参数 letters并将其存储在类变量 letters中。因为它们具有相同的名称，所以您需要明确地告诉java剩下的是类变量。您可以通过添加 this.来实现。

    public boolean contains (char character){
        for(int i = 0; i < letters.length(); i++) {
            if(letters.charAt(i) == character)
                return true;
        }
        return false;
    }

这需要一个字符，并查看它是否包含在 this.letters中。
因为这里没有名称冲突，所以可以省略 this.。
如果我理解正确，那么缺少 static就是您的问题之一。如果具有 static，则该函数是类绑定的，而不是对象绑定的，这意味着您可以在没有对象的情况下调用它。同样，了解两者之间的差异非常重要，如果您不同，请询问某人。 （准确地说，请问一下类，对象，静态和非静态之间的区别）。在这里详细解释这一过程将花费很长时间。
简而言之，如果函数不是静态的，则需要在对象上调用它才能起作用。在其他类中进一步查找详细信息。

    public String toString (){
        return "Filter(" + letters + ")";
    }

此功能也是非静态的。每当需要将对象转换为字符串（例如在 System.out.println()调用中）时，就使用它。同样，在这里重要的是要了解类和对象之间的区别。
QueryResolver类

public class QueryResolver {

    Filter filter;
    String query;
    
    public QueryResolver where(String queryStr) {
        this.query = queryStr;
        return this;        
    }

    public QueryResolver matches(String filterStr) {
        this.filter = new Filter(filterStr);
        return this;        
    }
        
    public int count() {
        int result = 0;
        for(int i = 0; i < query.length(); i++) {
            if(filter.contains(query.charAt(i))){
                result++;
            }
        }
        return result;
    }

}

再次，让我们分解一下。

public class QueryResolver {
...
}

我们班级的身体。
请注意，这里没有构造函数。最好有一个，但是在这种情况下，它将是一个空函数，不带任何参数，不执行任何操作，因此我们可以将其保留，编译器将自动生成它。

    public QueryResolver where(String queryStr) {
        this.query = queryStr;
        return this;        
    }

这是一个有趣的功能。它返回一个 this指针。因此，您可以使用函数的结果进行另一个调用，从而可以将多个函数调用“链接”在一起，例如 resolver.where(query).matches(filter).count()。
要了解其工作原理，您需要同时了解类对象差异和 this指针的作用。
简短的版本是 this指针是指向我们函数当前所在的对象的指针。

    public QueryResolver matches(String filterStr) {
        this.filter = new Filter(filterStr);
        return this;        
    }

这几乎与 where函数相同。
有趣的部分是 new Filter(...)。这将从类描述中创建先前讨论的 Filter对象，并将其放在 QueryResolver对象的 this.filter变量中。

    public int count() {
        int result = 0;
        for(int i = 0; i < query.length(); i++) {
            if(filter.contains(query.charAt(i))){
                result++;
            }
        }
        return result;
    }

遍历对象的 query变量，并检查每个字母是否包含在 filter中。它记录这种情况发生的次数并返回计数。
此功能要求设置 filter和 query。因此，重要的是在有人呼叫 count()之前，他们先呼叫 where(..)和 matches(..)。
在我们的例子中，所有这些都在一行 resolver.where(query).matches(filter).count()中发生。
主要功能
我编写了两个不同的 main函数。您希望在开发过程中尽可能地测试您的代码，因此，我编写的第一个代码是固定代码，您无需手动输入内容，只需单击运行即可运行：

    public static void main(String[] args) {

        String filter="kjasd";
        String query="kjg4t";
        
        
        QueryResolver resolver = new QueryResolver();
        int count = resolver.where(query).matches(filter).count();
        
        System.out.println(count);
    }

一旦了解了类对象差异，这应该很简单。
但要重复：

    QueryResolver resolver = new QueryResolver();

这将创建您的QueryResolver对象，并将其存储在变量 resolver中。

    int count = resolver.where(query).matches(filter).count();

然后，此行使用 resolver对象首先调用 where， matches，最后是 count。同样，此链接仅起作用，因为我们在 this和 where函数中返回了 matches。
现在，最后是您创建的交互式版本：

    public static void main(String[] args) {

        Scanner in =new Scanner(System.in);

        System.out.println("please enter the query string! ");

        String query= in.next();
        System.out.println("please enter the filter stirng!");

        String filter= in.next();
        System.out.println("the query string is : [" + query+ "]");
        System.out.println("the filter string is : [" + filter+ "]");

        QueryResolver resolver = new QueryResolver();
        int count = resolver.where(query).matches(filter).count();
        
        System.out.println("the characters of the String ["+filter+"] has been found in the forworded string ["+query+"] exactly "+count+" times!" );
        in.close();
    }