我的基础测试题及答案

最新推荐文章于 2023-01-04 09:38:12 发布

jwd8713765

最新推荐文章于 2023-01-04 09:38:12 发布

阅读量1.1k

点赞数

本文链接：https://blog.csdn.net/jwd8713765/article/details/46581411

版权

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

1、以下代码哪个是正确的？为什么？

a. byte b = 1 + 1;
b. byte b = 1; b = b + 1;
c. byte b = 1; b = b += 1;
d. byte b = 1; b = ++b;
a，c，d正确；
选项b中，b+1的结果默认转换为int型，int型不能直接转换为byte型，需强制转换。应改为：byte b=1;b=(byte)(b+1);
选项c中，b+=1包含了一个隐藏的类型转换，相当于 b=(byte)(b+1);
选项d中，b=++b也包含了一个隐藏的类型转换

2、编程计算3乘8等于几，什么方法效率更高？

package com.jwd.black.test;

/**
 * 编程计算3乘8等于几，什么方法效率更高
 *
 * @author:Jwd
 *
 */
public class Test2 {
    public static void main(String args[]) {
        // 采用移位运算输出结果
        System.out.println(3 << 3);// 左移相当于乘. 左移n位相当于乘2的n次方,左移三位相当于乘8
    }
}

3、编写一个延迟加载的单例设计模式。

/**
 * 延迟加载的单例设计模式
 * @author jwd
 *
 */
public class LazySingleton {

    private static LazySingleton  instance;      
    private LazySingleton()
    {
        
    }
    
    public   static  LazySingleton  getSingleInstance()
    {
        if (instance == null)
        {
                    instance = new LazySingleton();
        }        
        return instance;
    }    
}

4、从键盘接受一个数字，列出该数字的中文表示格式，例如：键盘输入123，打印出一二三；键盘输入3103，打印出三一零三。

package com.jwd.black.test;

import java.util.Scanner;

/**
 * 从键盘接受一个数字，列出该数字的中文表示格式，例如：键盘输入123，打印出一二三；键盘输入3103，打印出三一零三。
 *
 * @author Jwd
 *
 */
public class Test4 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        String a[] = { "零", "一", "二", "三", "四", "五", "六", "七", "八", "九" };
        for (int i = 0; i < s.length(); i++) {
            int x = s.charAt(i);

            System.out.print(a[x - 48]);
        }

    }
}

5、编写程序，打印1到100之内的整数，但数字中包含7的要跳过，例如：17、27、71、72

package com.jwd.black.test;

/**
 * 编写程序，打印1到100之内的整数，但数字中包含7的要跳过，例如：17、27、71、72
 *
 * @author jwd
 *
 */
public class Test5 {
    public static void main(String[] args) {
        int i;
        for (i = 0; i < 100; i++) {
            if (i % 10 != 7 && i / 10 != 7)
                System.out.println(i);
        }
    }
}

6、写一个正则表达式，可以匹配尾号5连的手机号。规则: 第1位是1，第二位可以是数字3458其中之一，后面4位任意数字，最后5位为任意相同的数字。
例如：18601088888、13912366666
[1][3458][0-9]{4}(\\d)\\1{4}

7、 throw和throws有什么区别？ try、catch、finally分别在什么情况下使用？
throw语句用来明确地抛出一个“异常”。throws用来标明一个成员函数可能抛出的各种“异常”。
try用来指定一块预防所有“异常”的程序。
紧跟在try程序后面，应包含一个catch子句来指定你想要捕捉的“异常”的类型
Finally为确保一段代码不管发生什么“异常”都被执行一段代码。

8、编写一个可以获取文件扩展名的函数，形参接收一个文件名字符串，返回一个扩展名字符串。

package com.jwd.black.test;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * 编写一个可以获取文件扩展名的函数，形参接收一个文件名字符串，返回一个扩展名字符串。
 *
 * @author jwd
 *
 */
public class Test8 {

    public static void main(String[] args) throws IOException {
        System.out.println("请从键盘上随便输入一个带扩展名的文件");
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s = br.readLine();
        System.out.println(getPath(s));
    }

    public static String getPath(String path) {

        return path == null || path.lastIndexOf(".") == -1 ? null : path
                .substring(path.lastIndexOf(".") + 1);
    }
}

9、编写程序，该程序启动后用户可以按“yyyy-MM-dd”的格式输入一个日期，程序计算这一天是星期几，并且计算出是一年中的第几天。

1、 以下代码哪个是正确的？为什么？

a. byte b = 1 + 1;     
b. byte b = 1; b = b + 1; 
c. byte b = 1; b = b += 1;    
d. byte b = 1; b = ++b;  
a，c，d正确；
选项b中，b+1的结果默认转换为int型，int型不能直接转换为byte型，需强制转换。应改为：byte b=1;b=(byte)(b+1);
选项c中，b+=1包含了一个隐藏的类型转换，相当于 b=(byte)(b+1);
选项d中，b=++b也包含了一个隐藏的类型转换

2、 编程计算3乘8等于几，什么方法效率更高？
package com.jwd.black.test;

/**
 * 编程计算3乘8等于几，什么方法效率更高
 * 
 * @author:Jwd
 *
 */
public class Test2 {
	public static void main(String args[]) {
		// 采用移位运算输出结果
		System.out.println(3 << 3);// 左移相当于乘. 左移n位相当于乘2的n次方,左移三位相当于乘8
	}
}

3、 编写一个延迟加载的单例设计模式。
/**
 * 延迟加载的单例设计模式
 * @author jwd
 *
 */
public class LazySingleton {

	private static LazySingleton  instance;	  
	private LazySingleton()
	{
		
	}
	
	public   static  LazySingleton  getSingleInstance()
	{
		if (instance == null) 
		{
				    instance = new LazySingleton();
	    }		
		return instance;
	}	
}


4、 从键盘接受一个数字，列出该数字的中文表示格式，例如：键盘输入123，打印出一二三；键盘输入3103，打印出三一零三。

package com.jwd.black.test;

import java.util.Scanner;

/**
 * 从键盘接受一个数字，列出该数字的中文表示格式，例如：键盘输入123，打印出一二三；键盘输入3103，打印出三一零三。
 * 
 * @author Jwd
 *
 */
public class Test4 {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String s = sc.next();
		String a[] = { "零", "一", "二", "三", "四", "五", "六", "七", "八", "九" };
		for (int i = 0; i < s.length(); i++) {
			int x = s.charAt(i);

			System.out.print(a[x - 48]);
		}

	}
}


5、 编写程序，打印1到100之内的整数，但数字中包含7的要跳过，例如：17、27、71、72
package com.jwd.black.test;

/**
 * 编写程序，打印1到100之内的整数，但数字中包含7的要跳过，例如：17、27、71、72
 * 
 * @author jwd
 *
 */
public class Test5 {
	public static void main(String[] args) {
		int i;
		for (i = 0; i < 100; i++) {
			if (i % 10 != 7 && i / 10 != 7)
				System.out.println(i);
		}
	}
}


6、 写一个正则表达式，可以匹配尾号5连的手机号。规则: 第1位是1，第二位可以是数字3458其中之一，后面4位任意数字，最后5位为任意相同的数字。
例如：18601088888、13912366666
[1][3458][0-9]{4}(\\d)\\1{4}

7、 throw和throws有什么区别？ try、catch、finally分别在什么情况下使用？
throw语句用来明确地抛出一个“异常”。throws用来标明一个成员函数可能抛出的各种“异常”。 
try用来指定一块预防所有“异常”的程序。
紧跟在try程序后面，应包含一个catch子句来指定你想要捕捉的“异常”的类型
Finally为确保一段代码不管发生什么“异常”都被执行一段代码。

8、 编写一个可以获取文件扩展名的函数，形参接收一个文件名字符串，返回一个扩展名字符串。
package com.jwd.black.test;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * 编写一个可以获取文件扩展名的函数，形参接收一个文件名字符串，返回一个扩展名字符串。
 * 
 * @author jwd
 *
 */
public class Test8 {

	public static void main(String[] args) throws IOException {
		System.out.println("请从键盘上随便输入一个带扩展名的文件");
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String s = br.readLine();
		System.out.println(getPath(s));
	}

	public static String getPath(String path) {

		return path == null || path.lastIndexOf(".") == -1 ? null : path
				.substring(path.lastIndexOf(".") + 1);
	}
}


9、 编写程序，该程序启动后用户可以按“yyyy-MM-dd”的格式输入一个日期，程序计算这一天是星期几，并且计算出是一年中的第几天。
package com.jwd.black.test;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;

public class Test9 {
	public static void main(String[] args) throws ParseException {
		// 创建键盘输入对象
		Scanner sca = new Scanner(System.in);
		System.out.println("请按照yyyy-MM-dd的格式输入要制定的日期");
		String str = sca.next();// 使用一个字符串接收输入的日期
		SimpleDateFormat simp = new SimpleDateFormat("yyyy-MM-dd");// 创建对象，指定日期格式
		Date dat = simp.parse(str); // 将字符串转换成日期对象
		Calendar cal = Calendar.getInstance();// 创建calendar对象
		cal.setTime(dat);// 设置时间
		int year = cal.get(Calendar.YEAR);// 提取年
		System.out.println("这是" + year + "年");
		int dayofWeek = cal.get(Calendar.DAY_OF_WEEK);
		int dayofyear = cal.get(Calendar.DAY_OF_YEAR);
		String d = null;
		switch (dayofWeek) {
		case 1:
			d = "日";
			break;
		case 2:
			d = "一";
			break;
		case 3:
			d = "二";
			break;
		case 4:
			d = "三";
			break;
		case 5:
			d = "四";
			break;
		case 6:
			d = "五";
			break;
		case 7:
			d = "六";
		}
		System.out.println("这是一年中的第" + dayofyear + "天");
		System.out.println("这一天星期" + d);
	}
}

10、 一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，则不会发生这种问题。编程解决猫狗鱼过河问题。

package com.jwd.black.test;

import java.util.LinkedList;

public class Test10 {

	int[] route = new int[16];

	int farmer(int location) {
		if ((location & 0x08) != 0)
			return 1;
		else
			return 0;
	}

	int dog(int location) {
		if ((location & 0x04) != 0)
			return 1;
		else
			return 0;
	}

	int cat(int location) {
		if ((location & 0x02) != 0)
			return 1;
		else
			return 0;
	}

	int fish(int location) {
		if ((location & 0x01) != 0)
			return 1;
		else
			return 0;
	}

	boolean isSafe(int location) {
		if ((farmer(location) != cat(location))
				&& (cat(location) == fish(location)))// 如果农夫不在场且猫和鱼在一起则不安全
			return false;
		if ((farmer(location) != dog(location))
				&& (dog(location) == fish(location)))// 如果农夫不在上且狗和猫在一起则不安全
			return false;
		return true;// 其余情况安全
	}

	public static void main(String[] args) {
		Test10 fcr = new Test10();
		int location = 0x00;
		int newlocation;
		int route[] = new int[16];//从0000-1111总共有16种状态
		for (int i = 0; i < route.length; i++)
			route[i] = -1;//-1在二进制里的表达就是全1
		route[0] = 0;// 首先考虑0000状态
		LinkedList<Integer> ll = new LinkedList<Integer>();
		LinkedList<Integer> route_list = new LinkedList<Integer>();// 存储route[]非零的路线图
		ll.addFirst(location);//将给定元素插入列表开头.
		while (!ll.isEmpty() && route[15] == -1) {
			location = (Integer) ll.removeFirst();//移除并返回此列表的第一个元素
			for (int movers = 1; movers <= 8; movers <<= 1) {
				if ((0 != (location & 0x08)) == (0 != (location & movers))) {
					newlocation = location ^ (0x08 | movers);
					if (fcr.isSafe(newlocation) && (route[newlocation] == -1)) {
						route[newlocation] = location;
						ll.addFirst(newlocation);
					}
				}
			}
		}
		if (route[15] != -1)
		// 到达最终状态
		{
			for (location = 15; location >= 0; location = route[location]) {
				if (location != 0)
					route_list.addFirst(location);				
				else {
					route_list.addFirst(location);
					break;
				}
			}
		} else
			System.out.println("No solution.\n");
		// 问题无解
		int length = route_list.size();
		for (int i = 0; i < length; i++) {
			int lo = (Integer) route_list.removeLast();//移除并返回此列表的最后一个元素
			System.out.print("第" + i + "步,河的这边还有： ");
			if (fcr.farmer(lo) == 1)
				System.out.print("农夫 ");
			if (fcr.dog(lo) == 1)
				System.out.print("狗 ");
			if (fcr.cat(lo) == 1)
				System.out.print("猫 ");
			if (fcr.fish(lo) == 1)
				System.out.print("鱼");
			System.out.println();
			System.out.print("河的对岸有： ");
			if (fcr.farmer(lo) == 0)
				System.out.print("农夫 ");
			if (fcr.dog(lo) == 0)
				System.out.print("狗 ");
			if (fcr.cat(lo) == 0)
				System.out.print("猫 ");
			if (fcr.fish(lo) == 0)
				System.out.print("鱼");
			System.out.println();
			System.out.println();
		}
	}
}

10、一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，则不会发生这种问题。编程解决猫狗鱼过河问题。

1、 以下代码哪个是正确的？为什么？

a. byte b = 1 + 1;     
b. byte b = 1; b = b + 1; 
c. byte b = 1; b = b += 1;    
d. byte b = 1; b = ++b;  
a，c，d正确；
选项b中，b+1的结果默认转换为int型，int型不能直接转换为byte型，需强制转换。应改为：byte b=1;b=(byte)(b+1);
选项c中，b+=1包含了一个隐藏的类型转换，相当于 b=(byte)(b+1);
选项d中，b=++b也包含了一个隐藏的类型转换

2、 编程计算3乘8等于几，什么方法效率更高？
package com.jwd.black.test;

/**
 * 编程计算3乘8等于几，什么方法效率更高
 * 
 * @author:Jwd
 *
 */
public class Test2 {
	public static void main(String args[]) {
		// 采用移位运算输出结果
		System.out.println(3 << 3);// 左移相当于乘. 左移n位相当于乘2的n次方,左移三位相当于乘8
	}
}

3、 编写一个延迟加载的单例设计模式。
/**
 * 延迟加载的单例设计模式
 * @author jwd
 *
 */
public class LazySingleton {

	private static LazySingleton  instance;	  
	private LazySingleton()
	{
		
	}
	
	public   static  LazySingleton  getSingleInstance()
	{
		if (instance == null) 
		{
				    instance = new LazySingleton();
	    }		
		return instance;
	}	
}


4、 从键盘接受一个数字，列出该数字的中文表示格式，例如：键盘输入123，打印出一二三；键盘输入3103，打印出三一零三。

package com.jwd.black.test;

import java.util.Scanner;

/**
 * 从键盘接受一个数字，列出该数字的中文表示格式，例如：键盘输入123，打印出一二三；键盘输入3103，打印出三一零三。
 * 
 * @author Jwd
 *
 */
public class Test4 {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String s = sc.next();
		String a[] = { "零", "一", "二", "三", "四", "五", "六", "七", "八", "九" };
		for (int i = 0; i < s.length(); i++) {
			int x = s.charAt(i);

			System.out.print(a[x - 48]);
		}

	}
}


5、 编写程序，打印1到100之内的整数，但数字中包含7的要跳过，例如：17、27、71、72
package com.jwd.black.test;

/**
 * 编写程序，打印1到100之内的整数，但数字中包含7的要跳过，例如：17、27、71、72
 * 
 * @author jwd
 *
 */
public class Test5 {
	public static void main(String[] args) {
		int i;
		for (i = 0; i < 100; i++) {
			if (i % 10 != 7 && i / 10 != 7)
				System.out.println(i);
		}
	}
}


6、 写一个正则表达式，可以匹配尾号5连的手机号。规则: 第1位是1，第二位可以是数字3458其中之一，后面4位任意数字，最后5位为任意相同的数字。
例如：18601088888、13912366666
[1][3458][0-9]{4}(\\d)\\1{4}

7、 throw和throws有什么区别？ try、catch、finally分别在什么情况下使用？
throw语句用来明确地抛出一个“异常”。throws用来标明一个成员函数可能抛出的各种“异常”。 
try用来指定一块预防所有“异常”的程序。
紧跟在try程序后面，应包含一个catch子句来指定你想要捕捉的“异常”的类型
Finally为确保一段代码不管发生什么“异常”都被执行一段代码。

8、 编写一个可以获取文件扩展名的函数，形参接收一个文件名字符串，返回一个扩展名字符串。
package com.jwd.black.test;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * 编写一个可以获取文件扩展名的函数，形参接收一个文件名字符串，返回一个扩展名字符串。
 * 
 * @author jwd
 *
 */
public class Test8 {

	public static void main(String[] args) throws IOException {
		System.out.println("请从键盘上随便输入一个带扩展名的文件");
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String s = br.readLine();
		System.out.println(getPath(s));
	}

	public static String getPath(String path) {

		return path == null || path.lastIndexOf(".") == -1 ? null : path
				.substring(path.lastIndexOf(".") + 1);
	}
}


9、 编写程序，该程序启动后用户可以按“yyyy-MM-dd”的格式输入一个日期，程序计算这一天是星期几，并且计算出是一年中的第几天。
package com.jwd.black.test;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;

public class Test9 {
	public static void main(String[] args) throws ParseException {
		// 创建键盘输入对象
		Scanner sca = new Scanner(System.in);
		System.out.println("请按照yyyy-MM-dd的格式输入要制定的日期");
		String str = sca.next();// 使用一个字符串接收输入的日期
		SimpleDateFormat simp = new SimpleDateFormat("yyyy-MM-dd");// 创建对象，指定日期格式
		Date dat = simp.parse(str); // 将字符串转换成日期对象
		Calendar cal = Calendar.getInstance();// 创建calendar对象
		cal.setTime(dat);// 设置时间
		int year = cal.get(Calendar.YEAR);// 提取年
		System.out.println("这是" + year + "年");
		int dayofWeek = cal.get(Calendar.DAY_OF_WEEK);
		int dayofyear = cal.get(Calendar.DAY_OF_YEAR);
		String d = null;
		switch (dayofWeek) {
		case 1:
			d = "日";
			break;
		case 2:
			d = "一";
			break;
		case 3:
			d = "二";
			break;
		case 4:
			d = "三";
			break;
		case 5:
			d = "四";
			break;
		case 6:
			d = "五";
			break;
		case 7:
			d = "六";
		}
		System.out.println("这是一年中的第" + dayofyear + "天");
		System.out.println("这一天星期" + d);
	}
}

10、 一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，则不会发生这种问题。编程解决猫狗鱼过河问题。

package com.jwd.black.test;

import java.util.LinkedList;

public class Test10 {

	int[] route = new int[16];

	int farmer(int location) {
		if ((location & 0x08) != 0)
			return 1;
		else
			return 0;
	}

	int dog(int location) {
		if ((location & 0x04) != 0)
			return 1;
		else
			return 0;
	}

	int cat(int location) {
		if ((location & 0x02) != 0)
			return 1;
		else
			return 0;
	}

	int fish(int location) {
		if ((location & 0x01) != 0)
			return 1;
		else
			return 0;
	}

	boolean isSafe(int location) {
		if ((farmer(location) != cat(location))
				&& (cat(location) == fish(location)))// 如果农夫不在场且猫和鱼在一起则不安全
			return false;
		if ((farmer(location) != dog(location))
				&& (dog(location) == fish(location)))// 如果农夫不在上且狗和猫在一起则不安全
			return false;
		return true;// 其余情况安全
	}

	public static void main(String[] args) {
		Test10 fcr = new Test10();
		int location = 0x00;
		int newlocation;
		int route[] = new int[16];//从0000-1111总共有16种状态
		for (int i = 0; i < route.length; i++)
			route[i] = -1;//-1在二进制里的表达就是全1
		route[0] = 0;// 首先考虑0000状态
		LinkedList<Integer> ll = new LinkedList<Integer>();
		LinkedList<Integer> route_list = new LinkedList<Integer>();// 存储route[]非零的路线图
		ll.addFirst(location);//将给定元素插入列表开头.
		while (!ll.isEmpty() && route[15] == -1) {
			location = (Integer) ll.removeFirst();//移除并返回此列表的第一个元素
			for (int movers = 1; movers <= 8; movers <<= 1) {
				if ((0 != (location & 0x08)) == (0 != (location & movers))) {
					newlocation = location ^ (0x08 | movers);
					if (fcr.isSafe(newlocation) && (route[newlocation] == -1)) {
						route[newlocation] = location;
						ll.addFirst(newlocation);
					}
				}
			}
		}
		if (route[15] != -1)
		// 到达最终状态
		{
			for (location = 15; location >= 0; location = route[location]) {
				if (location != 0)
					route_list.addFirst(location);				
				else {
					route_list.addFirst(location);
					break;
				}
			}
		} else
			System.out.println("No solution.\n");
		// 问题无解
		int length = route_list.size();
		for (int i = 0; i < length; i++) {
			int lo = (Integer) route_list.removeLast();//移除并返回此列表的最后一个元素
			System.out.print("第" + i + "步,河的这边还有： ");
			if (fcr.farmer(lo) == 1)
				System.out.print("农夫 ");
			if (fcr.dog(lo) == 1)
				System.out.print("狗 ");
			if (fcr.cat(lo) == 1)
				System.out.print("猫 ");
			if (fcr.fish(lo) == 1)
				System.out.print("鱼");
			System.out.println();
			System.out.print("河的对岸有： ");
			if (fcr.farmer(lo) == 0)
				System.out.print("农夫 ");
			if (fcr.dog(lo) == 0)
				System.out.print("狗 ");
			if (fcr.cat(lo) == 0)
				System.out.print("猫 ");
			if (fcr.fish(lo) == 0)
				System.out.print("鱼");
			System.out.println();
			System.out.println();
		}
	}
}