JAVA练习——选择+编程（1）

最新推荐文章于 2024-12-05 23:36:31 发布

原创最新推荐文章于 2024-12-05 23:36:31 发布 · 779 阅读

6 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#java #面试

JAVA 专栏收录该内容

12 篇文章

订阅专栏

本文是一篇关于JAVA编程的基础练习，包括选择题和编程题两部分。选择题涉及多线程、序列化、面向对象设计等概念，详细解析了每个问题并给出答案。编程题则提出字符串操作和选手组队优化问题，要求最大化队伍的水平值总和。

1. 选择题

1）1、执行如下程序，输出结果是（ C）

class Test {
	private int data;
	int result = 0;
	public void m() {
		result += 2;
		data += 2;
	System.out.print(result + " " + data);
	}
}
class ThreadExample extends Thread {
	private Test mv;
	public ThreadExample(Test mv)  {
	this.mv = mv;
	}
	public void run() {
		synchronized(mv){
			mv.m();
		}
	}
}
class ThreadTest {
	public static void main(String args[]) {
		Test mv = new Test();	// 声明并初始化对data赋默认值 
		Thread t1 = new ThreadExample(mv);
		Thread t2 = new ThreadExample(mv);
		Thread t3 = new ThreadExample(mv);
		t1.start();
		t2.start();
		t3.start();
	}
}

A、0 22 44 6
B 、2 42 42 4
C、2 24 46 6
D、4 44 46 6
解答：
① 使用synchronized关键字加同步锁，使三个线程依次顺序操作m() 方法
② t1.start(); 使得result=2,data=2,输出即为2 2
t2.start(); 使得result=4,data=4,输出即为4 4
t3.start(); 使得result=6,data=6,输出即为6 6
③ System.out.print(result +" "+ data)；
是print()方法，不会自动换行，所以输出结果为2 24 46 6

2）要使对象具有序列化能力，则其类应该实现如下哪个接口（A）
A、java.io.Serializable
B 、java.lang.Cloneable
C、java.lang.CharSequence
D、java.lang.Comparable
解答：
A：专门提供给类实现序列化的
B：实现克隆方法的；Object.clone() 方法可以合法地对该类实例进行按字段复制
C： CharBuffer、String、StringBuffer、StringBuilder四个类都实现此接口，
这样当处理String或者StringBuffer的类时就不用重载
D：用于对实现它的每个类的对象进行整体排序
序列化的作用？

**序列化是干什么的？
　　简单说就是为了保存在内存中的各种对象的状态，并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保存Object States，但是Java给你提供一种应该比你自己好的保存对象状态的机制,那就是序列化。
　　
*什么情况下需要序列化？
　　a）当你想把的内存中的对象保存到一个文件中或者数据库中时候；
　　b）当你想用套接字在网络上传送对象的时候；
　　c）当你想通过RMI传输对象的时候；

*在序列化时，有几点要注意的：
　　１：当一个对象被序列化时，只保存对象的非静态成员变量（包括声明为private的变量），不能保存任何的成员方法和静态的成员变量。
　　２：如果一个对象的成员变量是一个对象，那么这个对象的数据成员也会被序列化。
　　３：如果一个可序列化的对象包含对某个不可序列化的对象的引用，那么整个序列化操作将会失败，并且会抛出一个NotSerializableException。我们可以将这个引用标记为transient，那么对象仍然可以序列化。
　　
3)下列选项中属于面向对象设计方法主要特征的是（A）

A 、继承
B 、自顶向下
C 、模块化
D 、逐步求精
解答：
A : 面向对象设计的三大特征为：封装、继承、多态，
如果问到四大特征，那就是：封装、继承、多态、抽象
B : 算法中：分治法是自底向上的策略；动态规划是自顶向下的策略。
面向过程的系统两种都采用，也就是“先局部再整体”和“先整体再局部”。
C : 模块化就是：把程序划分成独立运行且可以独立访问的模块，每个模块完成一个子功能，
把这些模块集成起来构成一个整体，可以完成指定的功能满足用户的需求。
前端使用模块化可以：降低耦合度，减少重复代码，提高代码重用性，并且更清晰。
D: 结构设计是一种应用最广泛的系统设计方法，是以“数据流”为基础，自顶向下、逐步求精和模块化的过程。

4）关于下列程序段的输出结果，说法正确的是：（B）

public class MyClass{
	static int i;
	public static void main(String argv[]{
	System.out.println(i);
	}

A 、有错误，变量i没有初始化
B 、0
C 、1
D 、null
解答：
int 型变量的默认初始值为0；
八大基本数据类型的默认值如下~
boolean（false） short（0） byte（0） float（0.0F或0.0f）
double（0.0） long（0L） char（‘\u0000’）

5）下列代码的执行结果是（1 和 1.0）

public class Test3{
	public static void main(String args[]){
		System.out.println(100%3);
		System.out.println(100%3.0);
	}
}

6）在基本 JAVA 类型中，如果不明确指定，整数型的默认是（int）类型，带小数的默认是 (double) 类型。

7）方法通常存储在进程中的哪一区？（D）

A 、堆区
B 、栈区
C 、全局区
D 、方法区
解答：
堆区放真正的数据，对象的属性信息；
栈区存放局部变量；
全局区放全局变量；
属性在对象上➡对象在堆上➡属性在堆上
静态属性在类中➡类在方法区➡静态属性在方法中
局部变量在栈中➡栈帧在栈上➡局部变量在栈上

8）不考虑反射，关于私有访问控制符 private 修饰的成员变量，以下说法正确的是（C）
A、可以三种类所引用：该类自身、与它在同一包中的其他类，在其他包中的该类的子类
B、可以被两种类访问和引用：该类本身、该类的所有子类
C、只能被该类自身所访问和修改
D、只能被同一个包中的类访问
解答：
private 修饰的变量，是私有变量。私有变量只能被本类自己所使用。 “私有变量被子类继承后，不能使用，不可修改。”
A ~ public权限
B ~ protected权限
D ~ 默认

9） Math.round(11.5) 等于多少 (). Math.round(-11.5) 等于多少？（12和-11）
解答：
简单来说：
floor ：意为地板，指向下取整，返回不大于它的最大整数
ceil ：意为天花板，指向上取整，返回不小于它的最小整数
round ：意为大约，表示“四舍五入”，而四舍五入是往大数方向入。

10）假设 A 类有如下定义，设 a 是 A 类的一个实例，下列语句调用哪个是错误的？（C）

public class A{
	public int i;
	static String s;
	void method1(){}
	static void method2(){}
}

A、System.out.println(a.i);
B、a.method1();
C、A.method1();
D、A.method2();

解答：
static修饰的变量为静态成员变量；
static修饰的方法为静态方法；
静态成员变量，静态方法可以直接通过类名或对象名去调用；
而非静态方法，应该是通过对象的实例化去调用。
即：C项应该是 a.method1();

2. 编程题

1）输入两个字符串，从第一字符串中删除第二个字符串中所有的字符
思路：使用Split()将第一个字符串分割为每一个字符，之后使用contains()方法判断字符串中是否有子字符串。

public class Main {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        String s1=scanner.nextLine();
        String s2=scanner.nextLine();
        String[] arr1=s1.split("");
        StringBuffer string=new StringBuffer();
        for (int i=0;i<arr1.length;i++){
            if (!s2.contains(arr1[i])){
                string.append(arr1[i]);
            }
        }
        System.out.println(string.toString());
    }
}

2）题目描述：牛牛举办了一次编程比赛,参加比赛的有3*n个选手,每个选手都有一个水平值a_i.

现在要将这些选手进行组队,一共组成n个队伍,即每个队伍3人.牛牛发现队伍的水平值等于该队伍队员中第二高水平值。
例如: 一个队伍三个队员的水平值分别是3,3,3.那么队伍的水平值是3 一个队伍三个队员的水平值分别是3,2,3.那么队伍的水平值是3
一个队伍三个队员的水平值分别是1,5,2.那么队伍的水平值是2 为了让比赛更有看点,牛牛想安排队伍使所有队伍的水平值总和最大。
如样例所示: 如果牛牛把6个队员划分到两个队伍如果方案为: team1:{1,2,5}, team2:{5,5,8}, 这时候水平值总和为7. 而如果方案为:
team1:{2,5,8}, team2:{1,5,5}, 这时候水平值总和为10. 没有比总和为10更大的方案,所以输出10.
输入描述: 输入的第一行为一个正整数n(1 ≤ n ≤ 10^5)
第二行包括3*n个整数a_i(1 ≤ a_i ≤ 10^9),表示每个参赛选手的水平值.
输出描述: 输出一个整数表示所有队伍的水平值总和最大值.
输入例子: 2 5 2 8 5 1 5
输出例子: 10
————————————————
思路：交替获取相隔2的值,就是说将3n-2,3n-4,3*n-6,作为每一组的中间值

public class Main{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            int n = scanner.nextInt();
            int[] arr = new int[3*n];
            for(int i = 0; i < 3*n;i++){
                arr[i] = scanner.nextInt();
            }
            Arrays.sort(arr);
            long sum = 0;  //必须要用long型，1 ≤ a_i ≤ 10^9，若为int型则会越界
            for(int i = 3*n-2; i>=n;i = i - 2){  //这里必须≥n，而不是≥1.若为三组，当≥1则会提出四个值，故只能≥n
                sum += arr[i];
            }
            System.out.println(sum);
        }
    }
}