笔试强训day1~day5|选择&编程题模糊/易错知识点汇总

文章目录

    • 选择题
    • 编程题
      • 1.组队竞赛
      • 2.删除字符串公共字符【方法一&方法二重点理解掌握】
      • 3.排序子序列
      • 4.倒置字符串【重点理解掌握第二种】
      • 5.字符串中找出连续最长的数字串
      • 6.数组中出现超过一半的数字
      • 7.进制转换
      • 8.统计回文
      • 9.连续最大和

选择题

方法通常存储在进程中的哪一区(C)

A. 堆区 B. 栈区 C. 全局区 D. 方法区

相关知识:JVM内存模型

笔试强训day1~day5|选择&编程题模糊/易错知识点汇总_第1张图片

jvm内存模型

Math.round(11.5) 等于多少 (). Math.round(-11.5) 等于多少 ( C).

A. 11 ,-11 B 11 ,-12 C 12 ,-11 D 12 ,-12

相关知识:Math库round、floor、ceil以及取整运算

1.round:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oTxGisRQ-1669599460435)(F:\typora插图\image-20221127154325134.png)]

round 表示"四舍五入",算法为Math.floor(x+0.5) ,即将原来的数字加上 0.5 后再向下取整,所以 Math.round(11.5) 的结果为 12,Math.round(-11.5) 的结果为 -11,Math.round(-11.2)的结果为-12.0.

2.floor:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pKhNcKuI-1669599460436)(F:\typora插图\image-20221127154538923.png)]

floor() 方法可对一个数进行下舍入,返回给定参数最大的整数,该整数小于或等给定的参数。

3.ceil:

笔试强训day1~day5|选择&编程题模糊/易错知识点汇总_第2张图片

ceil() 方法可对一个数进行上舍入,返回值大于或等于给定的参数,类型为双精度浮点型

4.取整操作

直接舍去小数

====================================================

区别:

取整操作,无论操作数是正数还是负数,直接舍去小数

向上取整,即ceil方法,操作数是整数时是本身,否则是大于此数的最小整数,无论正负

向下取整:即floor方法,操作数为整数的时候是本身,否则就是不大于此数的最大整数,无论正负。

=====================================================

取整时,操作数为正数时,相当于向下取整,操作数为负数时,相当于向上取整。

round,当小数部分小于0.5,相当于向下取整,小数部分大于等于0.5,相当于向上取整

下列哪一种叙述是正确的(D)

A abstract修饰符可修饰字段、方法和类

B 抽象方法的body部分必须用一对大括号{ }包住

C 声明抽象方法,大括号可有可无

D 声明抽象方法不可写出大括号

相关知识:abstract关键字的使用|抽象类、抽象方法的定义

1.abstract关键字使用

是抽象修饰符。只能修饰类和方法,不能用来修饰属性/字段。

修饰类,表示当前类为抽象类;修饰方法,表示当前方法为抽象方法。

2.抽象类

抽象类不能实例化,但可以接收子类对象。它生来就是为了被继承。子类继承此类,重写父类抽象方法、写abstract关键字二选一。

访问权限:抽象类不能被private修饰,其他访问权限修饰限定符可以用,但是注意配套子类的访问权限修饰限定符。另外我们不写权限修饰符,默认是public,也就是说抽象类的访问权限最小就是protectd了。

抽象类中可以没有抽象方法

抽象类中也可以有非抽象方法,普通方法、构造方法,供子类在创建对象时,初始化父类的属性。

关于静态方法:抽象类中可以有静态方法,但是不能有静态抽象方法

3.抽象方法

抽象类中被abstract方法修饰的方法叫做抽象方法。

抽象方法不可以被final和static修饰,因为抽象方法需要被重写。

抽象类中的抽象方法只有声明,不能实现。

下面选项中,哪些是interface中合法方法定义?(ACD)

A public void main(String [] args);

B private int getSum();

C boolean setFlag(Boolean [] test);

D public float get(int x);

选项中哪一行代码可以替换 //add code here 而不产生编译错误(A)

public abstract class MyClass {
    public int constInt = 5;
    //add code here
    public void method() {
    }
}

A public abstract void method(int a);

B consInt=constInt+5;

C public int method();

D public abstract void anotherMethod(){}

相关知识:接口的定义|接口中方法的限制

1.接口的定义

与类定义相似,只是关键字从class变成了interface。

不能直接实例化,使用方法是类实现这个接口,使用implements关键字实现。

默认修饰限定符是public abstract,接口不能被private、private、final、static修饰。

接口中不能含有非抽象方法。但是从jdk1.8之后,接口中允许有静态具体方法和权限为default的具体方法。jdk1.9开始,允许将方法定义为private,使得某些复用的代码不会把方法暴露出去。

实现此接口的类必须重写接口中(抽象)方法。
JAVA所有的除定义或声明语句之外的任何语句都必须在方法内部,不存在游离在方法外的非声明/定义语句。

2.接口中方法的限制

默认都是public abstract。写成abstract/public abstrct/public都等价于public abstrct。

1.8开始允许有静态方法和默认方法这两种具体实现的方法;1.9开始允许有私有方法声明。

在创建派生类对象,构造函数的执行顺序(A )

A 基类构造函数,派生类对象成员构造函数,派生类本身的构造函数

B 派生类本身的构造函数,基类构造函数,对象成员构造函数

C 基类构造函数,派生类本身的构造函数,派生类对象成员构造函数

D 对象成员构造函数,基类构造函数,派生类本身的构造函数

名词区分:与C/C++知识点有重合,略…

下面属于软件定义阶段任务的是(A)

A 需求分析

B 软件测试

C 详细设计

D 系统维护

这里是属于、是属于、是属于!!!!不是不属于

相关知识点:软件测试基础

软件生命周期分为 3 个阶段:

软件定义阶段,任务是确定软件开发工作必须完成的目标,确定工程的可行性;

软件开发阶段,任务是具体完成设计和实现定义阶 段所定义的软件,通常包括总体设计、详细设计、编码和测试;

软件维护阶段,任务是使软件在运行中持久地满足用户的需要。

以下代码结果是什么?(C)

public class foo {
    public static void main(String sgf[]) {
        StringBuffer a=new StringBuffer("A");
        StringBuffer b=new StringBuffer("B");
        operate(a,b);
        System.out.println(a+"."+b);
    }
    static void operate(StringBuffer x,StringBuffer y) {
        x.append(y);
        y=x;
    }
}

A 代码可以编译运行,输出“AB.AB”。

B 代码可以编译运行,输出“A.A”。

C 代码可以编译运行,输出“AB.B”。

D 代码可以编译运行,输出“A.B”。

相关知识:值传递、引用传递

值传递:是指在调用函数时将实际参数复制一份传递到函数中,这样在函数中如果对参数进行修改,将不会影响到实际参数。

引用传递:是指在调用函数时将实际参数的地址直接传递到函数中,那么在函数中对参数所进行的修改,将影响到实际参数。

java中没有指针的概念,因此没有引用传递的概念。

这道题中a、b(是引用的副本,Java中没有引用传递)传入operate()函数中,但最后a指向的对象的值发生了变化,而b指向的对象的值没有发生变化,这是因 为x.append(y);改变了a指向的对象的值,而y=x;并没有改变b指向对象的值,指向将y指向了x所指向的对象(之前y和b指向同一个对象)。

下列哪个说法是正确的(D)

A .ConcurrentHashMap使用synchronized关键字保证线程安全

B. HashMap实现了Collction接口

C .Array.asList方法返回java.util.ArrayList对象

D. SimpleDateFormat是线程不安全的

相关知识:ArrayList源码|线程安全的类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eRlwRYD9-1669599460438)(F:\typora插图\image-20221127172354582.png)]

以下说法错误的是(D)

A 虚拟机中没有泛型,只有普通类和普通方法

B 所有泛型类的类型参数在编译时都会被擦除

C 创建泛型对象时请指明类型,让编译器尽早的做参数检查

D 泛型的类型擦除机制意味着不能在运行时动态获取List中T的实际类型

相关知识:泛型的擦除机制

编程题

1.组队竞赛

题目链接

解法一:排序,控制取的条件

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[] arr=new int[3*n];
            for(int i=0;i<3*n;i++){
                arr[i]=in.nextInt();
            }
            Arrays.sort(arr);
            long ret=0;
            for(int i=n;i<3*n;i+=2){
                ret+=arr[i];
            }
            System.out.println(ret);
        }
    }
}

解法二:优先级队列

本质上还是排序,跳着取数据

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        while(in.hasNextInt()){
            PriorityQueue<Integer> q=new PriorityQueue<>(new Comparator<Integer>(){
                public int compare(Integer o1,Integer o2){
                    return o2.compareTo(o1);
                }
            });
            int n=in.nextInt();
            for(int i=0;i<3*n;i++){
                int tmp=in.nextInt();
                q.offer(tmp);
            }
            long ret=0;
            for(int i=0;i<n;i++){
                q.poll();
                ret+=q.poll();
            }
            System.out.println(ret);
        }
    }
}

2.删除字符串公共字符【方法一&方法二重点理解掌握】

题目链接

方法一:哈希set取差集,set里边放置的是“被减数”,然后用stringbuilder

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        while(in.hasNextLine()){
            String s1=in.nextLine();
            String s2=in.nextLine();
            Set<Character> set=new HashSet<>();
            for(int i=0;i<s2.length();i++){
                set.add(s2.charAt(i));
            }
            StringBuilder str=new StringBuilder();
            for(int i=0;i<s1.length();i++){
                char ch=s1.charAt(i);
                if(set.contains(ch)){
                    continue;
                }
                str.append(ch);
            }
            System.out.println(str.toString());
        }
    }
}

方法二:哈希数组映射

加加==》加入所有的,减减==》去除s2出现的,遍历如果不为0(没有被删除),就打印输出

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        while(in.hasNextLine()){
            String s1=in.nextLine();
            String s2=in.nextLine();
            int[] hash=new int[256];
            for(char ch:s1.toCharArray()){
                hash[ch]++;
            }
            for(char ch:s2.toCharArray()){
                hash[ch]=0;
            }
            for(char ch:s1.toCharArray()){
                if(hash[ch]!=0){
                    System.out.print(ch);
                }
            }
            System.out.println();
        }
    }
}

方法三:其他容器的利用

public class Main {
    /**
     * 双list解法
     * @param args
     */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) {// 注意,如果输入是多个测试用例,请通过while循环处理多个测试用例
            String a=in.nextLine();
            String b=in.nextLine();
            List<Character> list=new ArrayList<>();
            List<Character> list2=new ArrayList<>();
            char[] str=a.toCharArray();
            char[] str2=b.toCharArray();
            for(int i=0;i<str.length;i++){
                list.add(str[i]);
            }
            for(int i=0;i<str2.length;i++){
                list2.add(str2[i]);
            }
            list.removeAll(list2);
            StringBuilder sb=new StringBuilder();
            for(int i=0;i<list.size();i++){
                sb.append(list.get(i));
            }
            System.out.println(sb);
        }
    }
}

3.排序子序列

题目链接

方法一:遍历分三种情况处理

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[] array=new int[n+1];
            for(int i=0;i<n;i++){
                array[i]=in.nextInt();
            }
            int ret=0;
            int j=0;
            while(j<n){
                if(array[j]<array[j+1]){
                    while(j<n&&array[j]<array[j+1]){
                        j++;
                    }
                    ret++;
                }else if(array[j]>array[j+1]){
                    while(j<n&&array[j]>array[j+1]){
                        j++;
                    }
                    ret++;
                }else{
                     ;   
                }
                j++;
            }
            System.out.println(ret);
        }        
    }
}

方法二:滑动窗口

4.倒置字符串【重点理解掌握第二种】

题目链接

方法一:split+倒序拼接+toString

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        while(in.hasNextLine()){
            String str=in.nextLine();
            String[] s=str.split(" ");
            StringBuilder ret=new StringBuilder();
            for(int i=s.length-1;i>=0;i--){
                ret.append(s[i]);
                if(i>0){
                    ret.append(" ");
                }
            }
            System.out.println(ret.toString());
        }
    }
}

方法二:

整体翻转+每个单词反转===》双指针+指定区间反转

import java.util.*;
public class Main{
    private static void reverse(char[] s,int left,int right){
        while(left<right){
            char tmp=s[left];
            s[left]=s[right];
            s[right]=tmp;
            left++;
            right--;
        }
    }
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        while(in.hasNextLine()){
            String str=in.nextLine();
            char[] s=str.toCharArray();
            reverse(s,0,s.length-1);
            int i=0;
            while(i<s.length){
                int j=i;
                while(j<s.length&&s[j]!=' '){
                    j++;
                }
                if(j<s.length){
                    reverse(s,i,j-1);
                    i=j+1;
                }else{
                    reverse(s,i,j-1);
                    i=j;
                }
            }
            str=new String(s);//利用String的构造方法将字符数组转成字符串
            System.out.println(str);
        }
    }
}

5.字符串中找出连续最长的数字串

题目链接

方法一:借助中间变量cur

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        while(in.hasNextLine()){
            String s=in.nextLine();
            String cur="";
            String ret="";
            int i=0;
            for(;i<s.length();i++){
                char ch=s.charAt(i);
                if(ch>='0'&&ch<='9'){
                    cur+=ch+"";//只能拼接字符串,不能拼接字符
                }else{
                    if(cur.length()>ret.length()){
                        ret=cur;
                    }else{
                        cur="";
                    }
                }
            }
            if(i==s.length()&&cur.length()>ret.length()){
                ret=cur;
            }
            System.out.println(ret);
        }
    }
}

方法二:借助计数器

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        while(in.hasNextLine()){
            String str=in.nextLine();
            String ret=func(str);
            System.out.println(ret);
        }
    }
    public static String func(String str){
        int count=0;
        int max=0;
        int right=0;
        for(int left=0;left<str.length();left++){
            if(str.charAt(left)>='0'&&str.charAt(left)<='9'){
                count++;
                if(max<count){
                    max=count;
                    right=left;
                }
            }else{
                count=0;
            }
        }
        return str.substring(right-max+1,right+1);//选定位置截取为子串,不需要加入到集合中,跟滑动窗口有点像
    }
}

6.数组中出现超过一半的数字

题目链接

假设一定存在这样的数字

如果不一定存在【需要拿到之后再遍历,看count是不是大于数组长度的一半】

方法一:排序取中法

import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
*
*
* @param numbers int整型一维数组
* @return int整型
*/
    public int MoreThanHalfNum_Solution (int[] numbers) {
        // write code here
        Arrays.sort(numbers);
        return numbers[numbers.length/2];
    }
}

方法二:打擂台法找众数

count就是血条

import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
*
*
* @param numbers int整型一维数组
* @return int整型
*/
    public int MoreThanHalfNum_Solution(int[] array) {
            int ret = array[0];
            int count = 1;

            for (int i = 1; i < array.length; i++) {
                if (count == 0) {
                    ret = array[i];
                    count++;
                } else{
                    if(ret==array[i]){
                        count++;
                    }else{
                        count--;
                    }
                }
            }
            return ret;
        }
    }
}

7.进制转换

题目链接

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
     *
     * 进制转换
     * @param M int整型 给定整数
     * @param N int整型 转换到的进制
     * @return string字符串
     */
    public String solve (int m, int n) {
        // write code here
        StringBuilder s=new StringBuilder();
        String table="0123456789ABCDEF";
        boolean tag=false;
        if(m<0){
            m=-m;
            tag=true;
        }
        while(m!=0){
            s.append(table.charAt(m%n));
            m=m/n;
        }
        if(tag){
            s.append("-");
        }
        s.reverse();
        return s.toString();
    }
}

8.统计回文

题目链接

20/25

import java.util.*;
    public class Main{
        public static void main(String[] args){
            Scanner in=new Scanner(System.in);
            while(in.hasNextLine()){
                String a=in.nextLine();
                String b=in.nextLine();
                int index=0;
                int ret=0;
                while(index<a.length()){
                String tmp = a.substring(0,index)+b+a.substring(index);
                if(func(tmp)){
                	ret++;
                }
                	index++;
                }
                System.out.println(ret);
        }
    }
    private static boolean func(String a){
        char[] s=a.toCharArray();
        if(s.length<=1){
        	return true;
        }
        int left=0;
        int right=s.length-1;
        while(left<right){
            if(s[left]!=s[right]){
            	return false;
            }
            left++;
            right--;
        }
        return true;
    }
}

AC代码

import java.util.*;
    public class Main{
        public static void main(String[] args){
            Scanner in=new Scanner(System.in);
            while(in.hasNextLine()){
                String a=in.nextLine();
                String b=in.nextLine();
                int ret=0;
                for(int i=0;i<=a.length();i++){
                    StringBuilder tmp=new StringBuilder(a);
                    tmp.insert(i,b);
                    if(func(tmp.toString())){
                        ret++;
                    }
                }
                System.out.println(ret);
        }
    }
    private static boolean func(String a){
        char[] s=a.toCharArray();
        if(s.length<=1){
        	return true;
        }
        int left=0;
        int right=s.length-1;
        while(left<right){
            if(s[left]!=s[right]){
            	return false;
            }
            left++;
            right--;
        }
        return true;
    }
}

9.连续最大和

22.5/25

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[] nums=new int[n];
            int sum=0;
            for(int i=0;i<n;i++){
                nums[i]=in.nextInt();
                sum+=nums[i];
            }
            int ret=subArrayMaxSum(nums,sum);
            System.out.println(ret);
        }
    }
    private static int subArrayMaxSum(int[] nums,int sum){
        for(int i=0;i<nums.length;i++){
            int subSum=0;
            int j=i;
            for(;j<nums.length;j++){
                subSum+=nums[j];
                sum=Math.max(sum,subSum);
            }
        }
        return sum;
    }
}

AC代码

题目链接

import java.util.*;
public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
     *
     * 
     * @param array int整型一维数组 
     * @return int整型
     */
    public int FindGreatestSumOfSubArray (int[] nums) {
        // write code here
        int ret=nums[0];
        int sum=nums[0];
        for(int i=1;i<nums.length;i++){
            if(sum<0){
                sum=nums[i];
            }else{
                sum+=nums[i];
            }
            ret=Math.max(ret,sum);
        }
        return ret;
    }
}

你可能感兴趣的:(笔试强训,jvm,java,算法)