每日一题 错选择 及 编程题 周总结（三）

Week3

Day1

选择题

下面有关JVM内存，说法错误的是？
A 程序计数器是一个比较小的内存区域，用于指示当前线程所执行的字节码执行到了第几行，是线程隔离的
B Java方法执行内存模型，用于存储局部变量，操作数栈，动态链接，方法出口等信息，是线程隔离的
C 方法区用于存储JVM加载的类信息、常量、静态变量、即时编译器编译后的代码等数据，是线程隔离的
D 原则上讲，所有的对象都在堆区上分配内存，是线程之间共享的

正确答案： C

方法区是线程共享的，C错

---

以下程序的输出结果是
public class Print{
static boolean out(char c){
System.out.println©;
return true;
}
public static void main(String[] argv){
int i = 0;
for(out(‘A’);out(‘B’) && (i<2);out(‘C’)){
i++;
out(‘D’);
}
}
A ABDCBDCB
B BCDABCD
C 编译错误
D 运行错误

正确答案： A
这里调用函数后都会有boolean返回值，不会发生编译错误
再就是考察for循环的过程

---

下面关于程序编译说法正确的是（）
A java语言是编译型语言，会把java程序编译成二进制机器指令直接运行
B java编译出来的目标文件与具体操作系统有关
C java在运行时才进行翻译指令
D java编译出来的目标文件，可以运行在任意jvm上

正确答案： C

A:.java编译成的是字节码，再被各系统的jvm翻译成本系统可以识别的机器码，这就是java一次编程多平台应用的跨平台性
B:java源文件生成的是class文件，与系统无关
C:注意字节码和机器码不是一回事 java程序在运行时字节码才会被jvm翻译成机 器码，所以说java是解释性语言
D:注意jvm的版本，好比人穿裤子，一条裤子能被任何人穿上吗

---

参数解析

方法一：分割字符串

import java.util.*;
public class Main{
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.nextLine();
        int l = 0;
        int r = 0;
        boolean symbol = false;
        List<String> list = new ArrayList<>();
        char[] arr = s.toCharArray();
        while (r < arr.length) {if(arr[r] == '/') {
            symbol = true;
            StringBuilder str = new StringBuilder();
            while (l < r) {
                str.append(arr[l]);
                l++;
            }
            if(!str.toString().trim().equals("")) {
                list.add(str.toString().trim());
            }
        }
            if(arr[r] == ':') {
                symbol = true;
                StringBuilder str = new StringBuilder();
                while (l < r-1) {
                    str.append(arr[l]);
                    l++;
                }
                if(!str.toString().trim().equals("")) {
                    list.add(str.toString().trim());
                }
            }
            if(arr[r] == '\"') {
                symbol = true;
                StringBuilder str = new StringBuilder();
                while (l < r) {
                    str.append(arr[l]);
                    l++;
                }
                l++;
                if(!str.toString().trim().equals("")) {
                    list.add(str.toString().trim());
                }
            }
            r++;
        }
        StringBuilder str = new StringBuilder();
        while (l < r) {
            str.append(arr[l]);
            l++;
        }
        if(!str.toString().trim().equals("")) {
            list.add(str.toString().trim());
        }
        if(symbol) {
            System.out.println(list.size());
            for (int i = 0; i < list.size(); i++) {
                System.out.println(list.get(i));
            }
        }else {
            String[] res = s.trim().split(" ");
            System.out.println(res.length);
            for(int i = 0; i < res.length; i++) {
                System.out.println(res[i]);
            }
        }
    }
}

方法二：条件顺序打印

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();
        int count = 0;
        for (int i = 0; i < str.length(); i++) {
            if(str.charAt(i) == '"') {
                do {
                    i++;
                }while (str.charAt(i) != '"');
            }
            if (str.charAt(i) == ' ') {
                count++;
            }
        }
        System.out.println(count+1);
        int font = 1;
        for (int i = 0; i < str.length(); i++) {
            if(str.charAt(i) == '"') {
                font = font^1;
            }
            if(str.charAt(i) != '"' && str.charAt(i) != ' ') {
                System.out.print(str.charAt(i));
            }
            if(font == 1 && str.charAt(i) == ' ') {
                System.out.println();
            }
            if(font == 0 && str.charAt(i) == ' ') {
                System.out.print(' ');
            }
        }
    }
}

---

跳石板

方法一：动态规划

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        int[] arr = new int[m+1];
        //初始化n-m的数据为最大值
        for (int i = n; i < arr.length; i++) {
            arr[i] = Integer.MAX_VALUE;
        }
        arr[n] = 0; //初始状态
        for (int i = n; i < m; i++) {
            //如果没有到达过这个位置，则下一轮循环
            if (arr[i] == Integer.MAX_VALUE) {
                continue;
            }
            //list来记录当前石板能跳的所有距离
            List<Integer> list = piv(i);
            //遍历当前石板所有能跳的距离
            for (int j : list) {
                //大前提，跳到的石板下标不能超过m，否则数组越界
                if(i+j <= m) {
                    //如果跳到的石板之前没有跳到过，则直接+1
                    if(arr[i] == Integer.MAX_VALUE) {
                        arr[i+j] = arr[i] + 1;
                    }else { //否则就取跳到石板步数最小值
                        arr[i+j] = Math.min(arr[i+j],arr[i]+1);
                    }
                }
            }
        }
        //最后判断下标为m的石板的最小步数
        if(arr[m] == Integer.MAX_VALUE) {
            System.out.println(-1);
        }else {
            System.out.println(arr[m]);
        }
    }

    //用来记录石板下标的所有约数
    public static List<Integer> piv(int num) {
        List<Integer> list = new ArrayList<>();
        //这里只需要遍历到i*i <= num即可，因为两数相乘才得到num，小的乘数找到了，对应的大的乘数则为num/i
        for (int i = 2; i*i <= num; i++) {
            if(num % i == 0) {
                list.add(i);
                //这里有可能有i == num/i 的情况，所以只取一次i
                if(i != num/i) {
                    list.add(num/i);
                }
            }
        }
        return list;
    }
}

方法二：广度优先遍历

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        Queue<Integer> queue = new LinkedList<>();
        Map<Integer,Integer> map = new HashMap<>();
        map.put(n,0);
        queue.add(n);
        while (!queue.isEmpty()) {
            int head = queue.poll();
            if(head == m) {
                System.out.println(map.get(head));
                return;
            }
            List<Integer> list = yueNum(head);
            for(int i = 0; i < list.size(); i++) {
                int sum = head + list.get(i);
                if(!map.containsKey(sum) && sum <= m) {
                    queue.add(sum);
                    map.put(sum,map.get(head)+1);
                }
            }
        }
        System.out.println(-1);
    }
    public static ArrayList<Integer> yueNum(int n) {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 2; i <= Math.sqrt(n); i++) {
            if (n % i == 0) {
                list.add(i);
                if (n / i != i) {
                    list.add(n / i);
                }
            }
        }
        return list;
    }
}

Day2

选择题

____技术是一种可以使音频，视频和其他多媒体信息在 Internet 及 Intranet 上以实时的，无需下载等待的方式进行播放的技术。
A 流媒体
B 多媒体
C 复合媒体
D 音视媒体

正确答案：A
流媒体技术是一种可以使音频，视频和其他多媒体信息在 Internet 及 Intranet 上以实时的，无需下载等待的方式进行播放的技术。

---

下列语句正确的是：
A 形式参数可被字段修饰符修饰
B 形式参数不可以是对象
C 形式参数为方法被调用时真正被传递的参数
D 形式参数可被视为local variable

正确答案：D
A：形式参数只能被final修饰
B：形式参数可以是对象
C：形式参数被调用时被传递的是实际参数的拷贝
D：local variable：局部变量

---

给定代码：

public class SwitchTest{//1
	public static void main(String[] args) {//2
	System.out.println("value="+switchit(4));//3
}//4
public static int switchit(int x) {
	int j=1;
	switch (x) {
		case 1:j++;
		case 2:j++;
		case 3:j++;
		case 4:j++;
		case 5:j++;
		default:j++;
	}
	return j+x;
}

第三行将输出什么？
A value=6
B value=8
C value=3
D value=5
E value=4

正确答案：B
不加break的话，switch会从第一次进入case语句的地方，一直向下执行完。

---

计算日期到天数转换

import java.util.*;
public class Main{
    public static int iConverDateToDay(int year,int month,int day) {
        int[] monthDay = {31,28,31,30,31,30,31,31,30,31,30,31};
        int sum = 0;
        if(year < 0 || month < 0 || month > 12) {
            return -1;
        }
        if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
            monthDay[1] = 29;
        }
        if(day > monthDay[month-1]) {
            return -1;
        }
        for(int i = 0; i < month-1; i++) {
            sum += monthDay[i];
        }
        sum += day;
        return sum;
    }
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);while (in.hasNext()) {
            int year = in.nextInt();
            int month = in.nextInt();
            int day = in.nextInt();
            System.out.println(iConverDateToDay(year, month, day));
        }
    }
}

---

幸运的袋子

import java.util.*;
 
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] num = new int[n];
        for (int i = 0; i < n; i++) {
            num[i] = scanner.nextInt();
        }
        //排序为了简化流程
        Arrays.sort(num);
        System.out.println(dfs(num,0,1,0));
    }

    public static int dfs(int[] num,int sum,int product,int index) {
        int count = 0;  //幸运袋子个数
        //从index位置开始遍历数组
        for (int i = index; i < num.length; i++) {
            sum += num[i];
            product *= num[i];
            if (sum > product) {    //如果和比积大，则个数加一，并向下递归
                count = count + 1 + dfs(num,sum,product,i+1);
            }else if(num[i] == 1) { //1特例，因为数字1能提高总和值但不会提高总积值，1的个数越多，和更有可能大于积，所以给它一次机会向下递归，但不+1
                count = count + dfs(num,sum,product,i+1);
            }else { //如果遇到了大于的情况，则不用向后遍历，因为数组有序，往后肯定越大，不可能再比sum小了
                break;
            }
            //回溯需要把sum和product回溯到上一递归的值。
            sum = sum-num[i];
            product = product/num[i];
            //注意：因为题目说了，拥有相同号码的球是无区别的，所以遇到相同的，往后遍历即可
            while (i+1 < num.length && num[i] == num[i+1]) {
                i++;
            }
        }
        return count;
    }
}

Day3

选择题

用命令方式运行以下代码的运行结果是（）

public class f{
	public static void main(String[] args){
		String foo1 = args[1];
		String foo2 = args[2];
		String foo3 = args[3];
	}
}

命令: java f a b c
A 程序编译错误
B a b c
C 程序运行错误
D f

正确答案：C
执行的是运行命令java
编译的命令是javac
而且 java f 是运行 f 文件，
真正的参数就是a，b，c，下标对应0，1，2
而题目是arg[1],arg[2],arg[3],显然数组越界

---

可将语句块或方法设为同步使用的语句是（）
A synchronized
B static
C abstract
D final

正确选项：A
加锁设置同步

---

以下哪项不属于java类加载过程？
A 生成java.lang.Class对象
B int类型对象成员变量赋予默认值
C 执行static块代码
D 类方法解析

正确选项：B
类加载包括5个阶段：加载，验证，准备，解析，初始化。
A. 生成java.lang.Class对象： 加载阶段
B. int类型对象成员变量赋予默认值：使用阶段（不属于类加载阶段）
C. 执行static块代码：初始化阶段（执行类构造器()方法）
D. 类方法解析：解析阶段

---

查找输入整数二进制中1的个数

import java.util.*;
public class Main {
    public static int findNumberof1(int num) {
        int count = 0;
        while(num > 0) {
            if(num%2 == 1) {
                count++;
            }
            num = num/2;
        }
        return count;
    }
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNext()) {int num = in.nextInt();
            System.out.println(findNumberof1(num));
        }
    }
}

---

手套

import java.util.*;

public class Gloves {
    public int minCount(int[] left,int[] right) {
        //对应数就是 左数组和右数组下标相同的值 不为0 的数
        List<Integer> l = new ArrayList<>();    //用来存放左数组的对应数
        int sumL = 0;   //左数组的总和
        int sumR = 0;   //右数组的总和
        int sumDuiR = 0;    //左对应数和
        //遍历数组得到上述所有的值
        for(int i = 0; i < left.length; i++) {
            if(left[i] != 0 && right[i] != 0) {
                l.add(left[i]);
                sumDuiR += right[i];
            }
            sumL += left[i];
            sumR += right[i];
        }
        l.sort(Integer::compareTo);
        //左数组总结公式：左数组和 - 对应值最小的数 + 1
        int resL = sumL - l.get(0) + 1;
        //右数组总结公式：右数组和 - 右对应数和 + 1
        int resR = sumR - sumDuiR + 1;
        return resL + resR;
    }

    public int findMinimum(int n, int[] left, int[] right) {
        int res1 = minCount(left,right);
        int res2 = minCount(right,left);
        //交换左右数组进行比较，返回最小的
        if(res1 > res2) {
            return res2;
        }
        return res1;
    }
}

Day4

选择题

jre 判断程序是否执行结束的标准是（）
A 所有的前台线程执行完毕
B 所有的后台线程执行完毕
C 所有的线程执行完毕
D 和以上都无关

正确选项：A
其实这个题，就是在说守护线程和非守护（用户）线程的问题。后台线程就是守护线程，前台线程就是用户线程。

守护线程：是指在程序运行时在后台提供一种通用服务的线程，这种线程并不是必须的。同时守护线程的线程优先级都很低的。JVM中的GC线程就是一个守护线程，只要JVM启动，GC线程就启动了。

用户线程和守护线程几乎没有什么区别，唯一的区别就在于，如果用户线程都已经退出了，只剩下了守护线程，那么JVM直接就退出了。

---

如下语句通过算术运算和逻辑运算之后i和 j的结果是（ ）

int i=0;
int j=0;
if((++i>0)||(++j>0)){
	//打印出i和j的值。
}

A i=0;j=0
B i=1;j=1
C i=0;j=1
D i=1;j=0

正确答案：B
++i先自增再运算，i++先运算在自增，所以i=1。||短路前一部分不正确就不会继续执行，所以j=0.

---

instanceof运算符能够用来判断一个对象是否为:
A 一个类的实例
B 一个实现指定接口的类的实例
C 全部正确
D 一个子类的实例

正确答案：C
instance是java的二元运算符，用来判断他左边的对象是否为右面类（接口，抽象类，父类）的实例

---

完全数计算

import java.util.*;
public class Main {
    public static int count(int n) {
        int count = 0;
        for (int i = 2; i <= n; i++) {
            if(i == sum(i)) {
                count++;
            }
        }
        return count;
    }
    public static int sum(int num) {
        int sum = 1;
        int i;
        for (i = 2; i <= Math.sqrt(num); i++) {
            if(num%i == 0) {
                sum += i;
                if(num/i != i) {
                    sum += num / i;
                }
            }
        }
        return sum;
    }
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNext()) {
            int n = in.nextInt();
            System.out.println(count(n));
        }
    }
}

---

扑克牌大小

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.nextLine();
        String[] both = s.split("-");
        String[] left = both[0].split(" ");
        String[] right = both[1].split(" ");
//判断比较性
        if(left.length != right.length) {
            if(left.length != 4 && right.length != 4) {
                if(!both[0].equals("joker JOKER") && !both[1].equals("joker JOKER")) {
                    System.out.println("ERROR");
                    return;
                }
                if(both[0].equals("JOKER") && right.length != 1 || both[1].equals("JOKER") && left.length != 1) {
                    System.out.println("ERROR");
                    return;
                }
                if(both[0].equals("joker") && right.length != 1 || both[1].equals("joker") && left.length != 1) {
                    System.out.println("ERROR");
                    return;
                }
            }
        }
//个子、对子、顺子、三个、
        if(both[0].equals("joker JOKER") || both[1].equals("joker JOKER")) {
            System.out.println("joker JOKER");
            return;
        }
        if(left.length == 4 && right.length != 4 || right.length == 4 && left.length != 4) {
            if(left.length == 4) {
                System.out.println(both[0]);
                return;
            }else {
                System.out.println(both[1]);
                return;
            }
        }
        if(both[0].equals("joker") || both[1].equals("joker")) {
            System.out.println("joker");
            return;
        }if(both[0].equals("JOKER") || both[1].equals("JOKER")) {
            System.out.println("JOKER");
            return;
        }
        int l = change(left[0]);
        int r = change(right[0]);
        if(l > r) {
            System.out.println(both[0]);
            return;
        }else {
            System.out.println(both[1]);
            return;
        }
    }
    public static int change(String num) {
        int l = 0;
        switch (num) {
            case "3":
                l = 3;
                break;
            case "4":
                l = 4;
                break;
            case "5":
                l = 5;
                break;
            case "6":
                l = 6;
                break;
            case "7":
                l = 7;
                break;
            case "8":
                l = 8;
                break;
            case "9":
                l = 9;
                break;
            case "10":
                l = 10;
                break;
            case "J":
                l = 11;
                break;
            case "Q":
                l = 12;
                break;
            case "K":
                l = 13;
                break;
            case "A":
                l = 14;
                break;
            case "2":
                l = 15;
                break;
        }
        return l;
    }
}

简化

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        String[] pp = str.split("-");
        String[] p1 = pp[0].split(" ");
        String[] p2 = pp[1].split(" ");
        String p = "34567891JQKA2";
        if (pp[0].equals("joker JOKER") || pp[1].equals("joker JOKER")) {
            System.out.println("joker JOKER");
        }else if (p1.length == p2.length) {
            if (p.indexOf(p1[0].substring(0,1)) > p.indexOf(p2[0].substring(0,1))) {
                System.out.println(pp[0]);
            }else {
                System.out.println(pp[1]);
            }
        }else if (p1.length == 4) {
            System.out.println(pp[0]);
        }else if (p2.length == 4) {
            System.out.println(pp[1]);
        }else {
            System.out.println("ERROR");
        }
    }
}

Day5

选择题

Java 语言用以下哪个类来把基本类型数据封装为对象（）
A 包装类
B Class
C Math
D Object

正确答案：A
java的数据类型分为两大类：基本类型和引用类型；
基本类型只能保存一些常量数据，引用类型除了可以保存数据，还能提供操作这些数据的功能；

为了操作基本类型的数据，java也对它们进行了封装， 得到八个类，就是java中的基本类型的封装类；他们分别是：
八种基本类型： byte short int long float double char boolean

对应的包装类 ： Byte Short Integer Long Float Double Character Boolean

---

杨辉三角形变形

import java.util.*;
public class Main {
    public static void main(String[] args) {Scanner in = new Scanner(System.in);
        while (in.hasNextInt()) {
            int n = in.nextInt();
            int count = 2*n-1 + 2;
            int[] tmp = new int[count];
            int[] res = new int[count];
            int i = count/2;
            res[i] = 1;
            int j = 1;
            while (j <= n) {
                tmp = res.clone();
                res[i] = tmp[i] + tmp[i-1] + tmp[i+1];
                for(int k = 1; k < j; k++) {
                    res[i-k] = tmp[i-k] + tmp[i-k-1] + tmp[i-k+1];
                    res[i+k] = tmp[i+k] + tmp[i+k-1] + tmp[i+k+1];
                }
                j++;
            }
            int q;
            for(q = 1; q < res.length-1; q++) {
                if(res[q]%2 == 0) {
                    System.out.println(q);
                    break;
                }
            }
            if (q >= res.length-1){
                System.out.println(-1);
            }
        }
    }
}

---

超长正整数相加

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            String a = in.nextLine();
            String b = in.nextLine();
            if(a.length() > b.length()) {
                StringBuilder s = new StringBuilder();
                for(int i = 0; i < a.length()-b.length(); i++) {
                    s.append('0');
                }
                b = s.toString() + b;
            }else {
                StringBuilder s = new StringBuilder();
                for(int i = 0; i < b.length()-a.length(); i++) {
                    s.append('0');
                }
                a = s.toString() + a;
            }
            int i = a.length()-1;
            int upOne = 0;
            char[] res = new char[i+1];
            while (i >= 0) {
                int c = (int)a.charAt(i)-(int)'0';
                int d = (int)b.charAt(i)-(int)'0';
                int sum = c+d+upOne;
                if(sum >= 10) {
                    upOne = 1;
                }else {
                    upOne = 0;
                }
                res[i] = (char) (sum%10+'0');
                i--;
            }
            String s = String.valueOf(res);
            if(upOne == 1) {
                s = "1" + s;
            }
            System.out.println(s);
        }
    }
}

Day6

选择题

考虑下面这个简单的例子，让我们看看reflection是如何工作的。

import java.lang.reflect.*;
public class DumpMethods{
    public static void main(String[] args) {
        try {
            Class c=Class.forName(args[0]);
            Method m[]=c.getDeclaredMethods();
            for (int i = 0; i < m.length; i++) {
                System.out.println(m[i].toString());
            }
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}

其中"c.getDeclaredMethods"的作用是:
A 取得类的公有方法对象
B 取得类的所有公有方法名称
C 取得类的所有方法对象
D 以上选项都不正确

正确选项：D
getDeclaredMethods是以数组的方式获得该类所有方法，而不是对象

---

java 的字符类型采用的是 Unicode 编码方案，每个 Unicode 码占用（）个比特位。
A 8
B 16
C 32
D 64

正确答案：B
占用两个字节，一个字节8个比特位，两个也就是16位

---

对于一个已经不被任何变量引用的对象，当垃圾回收器准备回收该对象所占用的内存时，将自动调用该对象的哪个方法（）
A finalize
B notify
C notifyAll
D hashCode

正确选项：A
finalize()是Object中的方法，当垃圾回收器将要回收对象所占内存之前被调用，即当一个对象被虚拟机宣告死亡时会先调用它finalize()方法，让此对象处理它生前的最后事情

---

以下代码输出的是：

public class SendValue{
	public String str="6";
	public static void main(String[] args) {
		SendValue sv=new SendValue();
		sv.change(sv.str);
		System.out.println(sv.str);
	}
	public void change(String str) {
		str="10";
	}
}

A 6
B 10
C 都不对
D 16

• Java 中的基本类型，属于值传递。
• Java 中的引用类型，属于引用传递。
• Java 中的 String及包装类，属于特殊群体，作为形参时，由于每次赋值都相当于重新创建了对象，因此看起来像值传递，但是其特性已经破坏了，值传递、引用传递的定义。因此他们属于引用传递的定义，却表现为值传递。

---

统计每个兔子的总数

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNext()) {
            int n = in.nextInt();
            int a = 1;
            int b = 1;
            int count = 2;
            while(count < n) {
                int c = a+b;
                a = b;b = c;
                count++;
            }
            System.out.println(b);
        }
    }
}

---

字符串通配符

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            String str1 = scanner.nextLine();
            String str2 = scanner.nextLine();
            //进入递归函数
            System.out.println(match(str1,str2,0,0));
        }
    }

    //i为str1指向的位置，j为str2指向的位置
    public static boolean match(String str1,String str2,int i,int j) {
        //如果i，j刚好都到字符串最后，则true
        if(i == str1.length() && j == str2.length()) {
            return true;
        }
        //如果只有一个到达，另一个没到达，则false
        if(i == str1.length() || j == str2.length()) {
            return false;
        }
        if(str1.charAt(i) == '?') { //遇到？，则两个指针都往前走一步
            return match(str1,str2,i+1,j+1);
        }else if (str1.charAt(i) == '*') {  //遇到*，可能*代表0个，代表1个，代表多个，依次递归
            return match(str1,str2,i+1,j) || match(str1,str2,i+1,j+1) || match(str1,str2,i,j+1);
        }else if (str1.charAt(i) == str2.charAt(j)) {   //如果i，j下标的字符相同，则继续往后递归
            return match(str1,str2,i+1,j+1);
        }else { //上面条件都不满足，说明i，j下标字符不相同，则false
            return false;
        }
    }
}