每日刷题练习Day4~Day7

果绿森裙@

已于 2022-03-30 22:14:50 修改

阅读量965

点赞数

分类专栏：习题详解文章标签： java

于 2022-03-29 23:47:04 首次发布

本文链接：https://blog.csdn.net/qq_57603004/article/details/123829887

版权

习题详解专栏收录该内容

14 篇文章 0 订阅

订阅专栏

每日刷题练习Day4

队列特点：先进先出

A、

B、接口里的方法是为了被重写，被private修饰的不行，私有的是不能被重写的

C、默认是public

void不能修饰接口，但能在接口里面使用

final不能修饰接口，修饰接口接口就不能被重写了，但是接口出现的意义就是被重写，所以接口不能被final修饰

程序是算法，但算法不一定是程序

B、final类是不能被继承的（final不能有子类），里面的方法不能用abstruct （abstruct需要被继承之后重写方法）

C、抽象类是不能被实例化的

D、如果抽象类的子类也是抽象的，可以不实现

结构化程序的三种基本结构是：顺序、选择、循环

被abstruct修饰的类不可以实例化，可以被继承

C、子类是不是抽象的都可以

D、

E、

题目：计算糖果

思路：要求的数可能为0，正数，负数

String Builder有reverse()
import java.util.*;
public class Main{
    public static void main(String []args){
        Scanner scan=new Scanner(System.in);
        int a=scan.nextInt();
        int b=scan.nextInt();
        int c=scan.nextInt();
        int d=scan.nextInt();
        int A=(a+c)/2;
        int B1=(c-a)/2;
        int B2=(b+d)/2;
        int C=(d-b)/2;
        if(B1==B2){
            System.out.println(A+" "+B1+" "+C);
        }else{
            System.out.println("No");
        }
    }
}
题目：进制转换
import java.util.*;
public class Main {
    public static void main(String[] args) { 
        Scanner in = new Scanner(System.in); 
        int m = in.nextInt();
        int n = in.nextInt();
        boolean flg = false;//标志位，防止为负数 
        String table = "0123456789ABCDEF"; //因为余数为10以后都要用字母表示，假设余数为15的话，直接根据15这个下标上table里找，将找出来的F拼接就可以了
        StringBuilder ret = new StringBuilder();//因为在循环里如果用String拼接回浪费很多空间，所以改用StringBuilder
        if(m==0){//m值为正数时
            System.out.println("0");
            return;
        }
        if(m < 0) {//如果m值为负数时
            m = -m;//先将其变为正数
            flg = true; 
        }
        while(m != 0) { 
            ret.append(table.charAt(m%n)); //m转n进制就是求余数，之后将除数求余数，把所有的余数拼接就是n进制数
            m = m/n;
        }
            if(flg) {
                ret.append("-");//如果之前是负数，将其拼接一个符号到后面，最后再逆置到前面就可以求出负数的进制数了
            }
        ret.reverse(); //因为求余数后得到的进制数是反的，需要将其倒回来
        System.out.println(ret);
    }
}

每日刷题练习Day5

传引用修改原来对象的值，才会修改原来的对象

x.append(y);修改了值，是将a的值修改为了AB

y=x；没有修改值，对原来的b的对象的值没有变化，相当于什么都没做，b的值还是B

局部变量要初始化，否则编译会失败

float double long boolean 都不能作为switch的参数

A、可以包含很多类，只有public类的类名要和文件名相同，并且只能有一个public类

B、还可以包含其他的类

D、public类不可以包含多个，只能有一个

若没有finally，try中若有return直接返回

若有finally，finally一定会被执行，因为finally是最后被执行的，所以会return false

Java中的标识符：数字、字母、下划线、$

void是关键字，不能做标识符

final修饰方法，表示方法不可重写

final修饰属性，表示属性不可变

throws是用来声明一个成员方法可能抛出的各种非运行异常情况

throw是用来明确地抛出一个异常情况

也是传引用，把ex.str传给str，把ex.ch传给了ch[]

传引用只有修改值才会对原来的引用做出改变

str=“test ok” 只是将形参str指向了“test ok”，并没有改变原来引用的值

ch[0]='g' 修改了值，对原来的引用有影响

题目：统计回文

思路：在str1的合适的位置插入str2,每次插入之后判断是否为回文串（看逆置之后和逆置之前是否相同）

知识点：

StringBuilder,有reverse方法,insert方法,可以在指定位置插入字符串,但没有equals方法；

String没有reverse方法，但是又equals方法

reverse方法逆置是在原来字符串上逆置
import java.util.*;
public class Main{
    public static void main(String[]args){
        Scanner scan=new Scanner(System.in);
        String str1=scan.nextLine();
        String str2=scan.nextLine();
        int count=0;
        for(int i=0;i<=str1.length();i++){//因为有可能插入到尾部，所以边界是0-总长度
            StringBuilder str=new StringBuilder(str1);//因为不能直接在str1上修改，创建一个str代替str1
            str.insert(i,str2);//把字符串str2,依次插入对应位置
            StringBuilder tmp=new StringBuilder(str);//因为reverse（）会在原来的字符串上修改，所以先创建个临时的，让这个临时的逆置
            StringBuilder str3=tmp.reverse();
            if(str3.toString().equals(str.toString())){//因为String Builder没有equals方法，String有equals方法，所以要先转为字符串再equals
                count++;
            }
        } 
        System.out.println(count);
    }
}
题目：连续最大和
每日刷题练习Day6

最终类也叫密封类，就是被final修饰的类

最终类不能被继承，最终类只能被实例化

abstruct和final是不能同时出现的

C、abstruct方法是不能被具体实现的，不能有{}

数组求长度的length是没有()的

default是包访问权限

静态代码块一定优先执行，所以会先执行父类发静态代码块，再执行子类的静态代码块

然后再执行构造方法，先执行父类的构造方法，在执行子类的构造方法

构造方法的调用不仅仅是通过new调用，还可以通过子类使用super来调用父类的构造方法

boolean类型不是数值类型，不能强转

byte类型的取值范围-128~127

A、以0开头是8进制，转换为10进制是10

D、以0X开头的是16进制

题目：把字符串转换成整数

知识点：字符串不能修改，数组可以修改下标的值

字符.和字符0相减就可以得到相应数字

字符串转换为数字，只需要将每个字符拿出来减去字符0，然后将所得数字乘10
public class Solution {
    public int StrToInt(String str) {
        char[]chs=str.toCharArray();//如果不转换为数组的话，不能修改元素的值，因为字符串底层是个final类型的数组，不能修改
        if(chs==null||chs.length==0){//如果是字符串判断空的话用str.isEmpty()
            return 0;
        }
        int flg=1;//标志位，如果为负号，最后返回个负数直接乘以flg就是负的了
        if(chs[0]=='+'){
            flg=1;
            chs[0]='0';//为了防止遍历数组时，第一个为+-号直接被误判为不能转为数字的字符串直接返回0，事先把符号位给改为字符0
        }
        if(chs[0]=='-'){
            flg=-1;
            chs[0]='0';
        }
        int result=0;//所要求的结果
        for(int i=0;i<chs.length;i++){//遍历数组，有不是数值的就不能转为数字，直接返回0
            if(chs[i]<'0'||chs[i]>'9'){
                return 0;
            }
            result=result*10+chs[i]-'0';//关键：将字符串转换为数字，只需要将每个字符取出来减去字符0，就可以得到相应的数字，再每次乘10，因为数字每个位数是成10倍增长的
        }
        return flg*result;//乘以flg是做符号上的调整
    }
}
题目：不要二

思路：

每日刷题练习Day7

public是一个公有的权限访问控制符

final修饰类的话则这个类是不能被继承的，修饰方法，则这个方法是不能被重写的，修饰引用，则这个引用指向的实例是不能被改变的，但是实例的属性是可以变的

class是定义类的一个关键字

Math.round()是四舍五入的方法

一个子类只能继承一个父类，一个类可以实现多个接口

一个类可以派生出多个子类，可以实现多个接口

因为被static修饰的变量只有一个，无论创建多少个对象，都是在同一个变量上修改的

hasNext()是迭代器Iterator接口里的方法

this只是类的实例，写类的构造函数中会用到

java语言使用的字符码集是Unicode

ASCII 针对特殊字符、0~9、大小写字母

BCD 针对数字

题目：Fibonacci数列
import java.util.*;
public class Main{
    public static void main(String[]args){
        Scanner scan=new Scanner(System.in);
        int n=scan.nextInt();
        int F1=0;
        int F2=1;
        while(n>F2){//此时还没找到位置
            int F3=F1+F2;
            F1=F2;
            F2=F3;
        }
        int min=Math.min(n-F1,F2-n);//找到位置此时n在F1的右边，在F2的左边
        System.out.println(min);
    }
}
题目：合法括号序列判断

思路：栈
import java.util.*;

public class Parenthesis {
    public boolean chkParenthesis(String A, int n) {
        if(n%2!=0){//不是2的倍数证明肯定不匹配
            return false;
        }
        Stack<Character> stack=new Stack<>();
        for(char ch:A.toCharArray()){
            if(ch=='('){
                stack.push('(');
            }else if(ch==')'){
                if(stack.isEmpty()){//如果栈为空了，证明没有小括号可以与右括号匹配了
                    return false;
                }else{
                    stack.pop();
                }
            }else{
                return false;//若字符串里有其他符号直接返回false
            }
        }
        return stack.isEmpty();//最后若栈为空，证明栈里面的左括号都弹出去与右括号匹配了
        }
}