笔试强训day1~day5|选择&编程题模糊/易错知识点汇总
文章目录
-
- 选择题
- 编程题
-
- 1.组队竞赛
- 2.删除字符串公共字符【方法一&方法二重点理解掌握】
- 3.排序子序列
- 4.倒置字符串【重点理解掌握第二种】
- 5.字符串中找出连续最长的数字串
- 6.数组中出现超过一半的数字
- 7.进制转换
- 8.统计回文
- 9.连续最大和
选择题
方法通常存储在进程中的哪一区（C）
A. 堆区 B. 栈区 C. 全局区 D. 方法区
相关知识：JVM内存模型
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)]](http://img.e-com-net.com/image/info8/fb9aa4b52e2446c98e2ee4679edc1d4f.jpg)
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)]](http://img.e-com-net.com/image/info8/16b826e8dec54093bb80960564961440.jpg)
floor() 方法可对一个数进行下舍入，返回给定参数最大的整数，该整数小于或等给定的参数。
3.ceil：
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)]](http://img.e-com-net.com/image/info8/dbeaa870385d4180aebb11d93d1120e6.jpg)
以下说法错误的是（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;
}
}