第一题
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
/**
* <p>功能: 编写程序,在C盘根目录下创建文件myFile.txt，文件内容如下，请注意缩进和换行：
* Java
* C/C++
* Python
* JavaScripts
*/
public class Question1 {
public void answer() throws IOException {
String fileData = "Java\n" +
"C/C++\n" +
"Python\n" +
"JavaScripts";
Files.write(Paths.get("C:\\myFile.txt"), fileData.getBytes());
}
public static void main(String[] args) throws IOException {
new Question1().answer();
}
}
第二题 单例模式的程序
/**
*
* <p>功能: 编写单例模式的程序
*/
public class Question2 {
static class Singleton{
private static Singleton instance = new Singleton();
private Singleton(){}
public static Singleton newInstance(){
return instance;
}
}
public void answer() {
Singleton.newInstance();
}
}
第三题 触发StackOverflow
/**
*
* <p>
* 功能: 编写一个程序,在运行时触发StackOverflow
*
*/
public class Question3 {
public void answer() {
answer();
}
public static void main(String[] args) {
new Question3().answer();
}
}
第四题 反射实现
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.List;
/**
* <p>功能: 使用反射实现如下功能，并运行出正确的结果
* <pre>
* List<Integer> myList = new ArrayList<Integer>(10);
* myList.add(1);
* myList.add(3);
* myList.add(5);
* myList.add(7);
* myList.add(9);
* myList.add(8);
* myList.add(6);
* myList.add(4);
* myList.add(2);
* myList.add(10);
* Collections.sort(myList);
* System.out.println(myList);
* </pre>
*/
public class Question4 {
public void answer() throws Exception {
Class clazz = Class.forName("java.util.ArrayList");
Constructor constructor = clazz.getConstructor(int.class);
List<Integer> myList = (List<Integer>) constructor.newInstance(10);
Method add = clazz.getMethod("add", Object.class);
add.invoke(myList, 3);
add.invoke(myList, 5);
add.invoke(myList, 7);
add.invoke(myList, 9);
add.invoke(myList, 8);
add.invoke(myList, 6);
add.invoke(myList, 4);
add.invoke(myList, 2);
add.invoke(myList, 10);
Collections.sort(myList);
System.out.println(myList);
}
public static void main(String[] args) throws Exception {
new Question4().answer();
}
}
第五题 打印分组信息
/**
* <p>功能: 有一个列表含有N个学生，学生可以获取姓名和班级编号，其中姓名为字符串，班级编号为int。
* <p>现在对这些学生按班级分组和排序，班级之间按编号递增排序，班级内学生按照姓名字母序排序，然后顺序打印分组信息
*/
public class Question5 {
List<Student> list = new ArrayList<>();
public Question5() {
list.add(new Student("ZhangDa", 2));
list.add(new Student("ZhangEr", 1));
list.add(new Student("ZhangSan", 3));
list.add(new Student("LiDa", 4));
list.add(new Student("LiEr", 1));
list.add(new Student("LiSan", 2));
list.add(new Student("LiSi", 3));
list.add(new Student("ZhaoLiu", 1));
list.add(new Student("WangDa", 2));
list.add(new Student("WangEr", 2));
list.add(new Student("MutouLiu", 1));
list.add(new Student("NiuDa", 4));
list.add(new Student("XiongDa", 2));
list.add(new Student("XiongEr", 4));
}
public void answer() {
list.stream().sorted((a, b) -> {
if (a.classIndex != b.classIndex) {
return Integer.compare(a.classIndex, b.classIndex);
}
return String.CASE_INSENSITIVE_ORDER.compare(a.name,b.name);
}).forEach(System.out::println);
}
public static void main(String[] args) {
new Question5().answer();
}
}
/**
* 学生类型供参考
*/
class Student {
public Student(String name, int classIndex) {
super();
this.name = name;
this.classIndex = classIndex;
}
String name;
int classIndex;
@Override
public String toString() {
return new StringJoiner(", ", Student.class.getSimpleName() + "[", "]")
.add("name='" + name + "'")
.add("classIndex=" + classIndex)
.toString();
}
}
第六题 16个线程分别打印A~P，编程实现调度这16个线程,屏幕循环打印10次A-P
import java.util.concurrent.locks.LockSupport;
/**
* <p>
* 功能: 实现16个线程分别打印A~P，编程实现调度这16个线程,屏幕循环打印10次A~P
*/
public class Question6 {
public void answer() {
int charNum = 16;//x个线程
int p = 10;//打印x次
Thread[] threads = new Thread[charNum];
for (int i = 0; i < charNum; i++) {
final char c = (char) ('A' + i);
int finalI = i;
threads[i] = new Thread(() -> {
for (int j = 0; j < p; j++) {
LockSupport.park();
System.out.print(c);
LockSupport.unpark(threads[(finalI + 1) % charNum]);
}
}, String.valueOf(c));
}
for (int i = 0; i < charNum; i++) {
threads[i].start();
}
LockSupport.unpark(threads[0]);
}
public static void main(String[] args) {
new Question6().answer();
}
第七题 圈复杂度计算
控制流图（Control Flow Graph）是以有向图表示程序逻辑结构的一种形式，能够直观展示程序的分支、跳转、复杂度等特性，是编译优化、程序分析、软件测试等领域的一种基本程序中间表示。
圈复杂度是用于评价函数复杂度的一种指标，一般认为圈复杂度越高，说明函数越复杂、越难以维护或测试。圈复杂度的一种计算方法是：
圈复杂度 = 控制流图中分支节点个数+1
分支节点是指含 if，else if，for，while，switch 语句的节点，即在控制流图中有多个后
继节点的节点。
下图所示为一个 C 语言函数 func 和其对应的控制流图。
/**
* <p>
* 功能: 计算程序的圈复杂度
* <p>
* 控制流图（CFG,Control Flow Graph）是以有向图表示程序逻辑结构的一种形式，
* 能够直观展示程序的分支、跳转、复杂度等特性，是编译优化、程序分析、软件测试等 领域的一种基本程序中间表示。
* <p>
* 圈复杂度是用于评价函数复杂度的一种指标，一般认为圈复杂度越高，说明函数越 复杂、越难以维护或测试。圈复杂度的一种计算方法是：
*
* <pre>
* 圈复杂度 = 控制流图中分支节点个数 + 1
* </pre>
* <p>
* 分支节点是指含if，else if，for，while语句的节点，即在控制流图中有多个后继节点的节点。
* <p>
* 理解上述概念，编写一个函数int calculateMcCabe(GraphNode
* entry)，输入控制流图的入口节点entry，输出其对应的圈复杂度。 当参数为非法情况时返回0。
*/
public class Question7 {
public Question7() {
}
/**
* 题目提供的CFG构造方法，不要修改,返回CFG的入口节点
*/
static CFGNode buildCFG() {
CFGNode entry = new CFGNode("entry");
CFGNode exit = new CFGNode("exit");
CFGNode count__0 = new CFGNode("int count = 0; int i =0");
CFGNode for_a_lt_0 = new CFGNode("for(.. ;i < 100; ..");
CFGNode i_inc = new CFGNode("for(..;.. ; i++");
CFGNode if_a_lt_0 = new CFGNode("if (i < 0)");
CFGNode return0 = new CFGNode("return 0");
CFGNode if_i_mod_7_eq_0 = new CFGNode("if (i % 7 == 0) ");
CFGNode count_inc_i = new CFGNode("count += i");
CFGNode if_count_mod_2_eq_0 = new CFGNode("if (count % 2 == 0)");
CFGNode return1 = new CFGNode("return 1");
CFGNode return2 = new CFGNode("return 2");
entry.addNext(count__0);
count__0.addNext(for_a_lt_0);
for_a_lt_0.addNext(if_a_lt_0);
for_a_lt_0.addNext(if_count_mod_2_eq_0);
if_a_lt_0.addNext(return0);
if_a_lt_0.addNext(if_i_mod_7_eq_0);
if_count_mod_2_eq_0.addNext(return1);
if_count_mod_2_eq_0.addNext(return2);
if_i_mod_7_eq_0.addNext(count_inc_i);
if_i_mod_7_eq_0.addNext(i_inc);
count_inc_i.addNext(i_inc);
i_inc.addNext(for_a_lt_0);
return0.addNext(exit);
return1.addNext(exit);
return2.addNext(exit);
return entry;
}
/**
* 完成下面的方法，返回正确的圈复杂度
*/
public static int calculateMcCabe(CFGNode entry) {
Set<String> set = Arrays.stream(new String[]{"if", "else", "for", "while"}).collect(Collectors.toSet());
Queue<CFGNode> queue = new LinkedList<>();
queue.add(entry);
int ans = 0;
Set<CFGNode> visited = new HashSet<>();
visited.add(entry);
while (!queue.isEmpty()) {
int size = queue.size();
for (int i = 0; i < size; i++) {
CFGNode poll = queue.poll();
for (String s : set) {
if (poll.data.contains(s)) {
ans++;
break;
}
}
for (CFGNode e : poll.nextList) {
if (!visited.contains(e)) {
visited.add(e);
queue.add(e);
}
}
}
}
return ans+1;
}
public static void main(String[] args) {
CFGNode entry = buildCFG();
System.out.println("该程序的圈复杂度为：" + calculateMcCabe(entry) + "\n");
}
}
/**
* CFG节点类，表示该节点上的数据和后继节点， 可根据需要补充方法和成员
*/
class CFGNode {
String data; // 节点数据
Collection<CFGNode> nextList; // 后继节点列表
public CFGNode(String data) {
super();
this.data = data;
this.nextList = new ArrayList<>();
}
public void addNext(CFGNode next) {
this.nextList.add(next);
}
}
扫一扫
1086
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
