Java高编机试题
本文通过几道java高编机试题来加深对java高编的理解
一．题目
（一） 计时器 （20分）：
1 编写TimeThread，只负责计时，不处理具体事务。并做测试。
（二）数据库操作（20分）：
1 创建学生信息表 -- studentInfo。
2 提供添加学生信息（id name phone）， 查询学生信息功能。
//将SQL语句写在代码中即可
（三）IO流（20分）：
1 创建一个文件user.txt.
2 向文件写入json数据
key:account,value:danny
key:password,value:123456
key:age,value:26
key:high,value:172.5
3 从文件user.txt中读出数据 name，age，high
（四）集合框架（20分）：
完成下面的要求
1.创建一个List，在List 中增加三个工人，基本信息如下：
1. 姓名 年龄 工资
2. zhang3 18 3000
3. li4 25 3500
4. wang5 22 3200
2.在li4 之前插入一个工人，信息为：
1. 姓名：zhao6，年龄：24，工资3300
3.遍历并删除其中姓名为 wang5 的信息
（五） 多线程（20分）：
1 创建线程数量为5的线程池。
2 同时运行5个卖票窗口。
3 总票数为100，每隔一秒钟卖一张票
（六） UDP传输图片（20分）：
1 UDP服务端，等待客户端请求。
2 服务端接收客户端请求，开始向客户端发送图片
3 客户端开始接收图片并写入文件
二．参考答案
（一）第一题
package com.java.test1;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* 编写TimeThread，负责计时，并打出当前的时间,输出小时分钟秒钟，
时间格式要求为： 12:35:28。并做测试。
*
* 程序分析：
* 1.计时功能要使用线程来实现
* 2.显示时间的格式用SimpleDateFormat类
* */
public class TimeThread extends Thread{
public static void main(String[] args) {
//一进来就开始计时
new TimeThread().start();
}
@Override
public void run() {
super.run();
//让线程一直在跑
while (true) {
// 需要显示出来的时间的格式,SimpleDateFormat类的使用
SimpleDateFormat s = new SimpleDateFormat("HH:mm:ss");// 参数代表的是时间的显示格式
System.out.println("当前的时间是：" + s.format(new Date()));// new Date()是当前时间的对象
//显示时间后睡眠1秒
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
运行后可以看到：
每秒自动变化的计时器！
（二）第二题
package com.java.test2;
/**
* 数据库操作：
* 1.创建学生信息表 -- studentInfo。
* 2.提供添加学生信息（id name phone）， 查询学生信息功能。
* 3.将SQL语句写在代码中即可
*
* 程序分析：
* 1.创建表格使用的是create table---
* 2.添加表格信息使用的是insert into----
* 3.查询信息使用的是select * from ---
* */
public class MainClass {
//1.创建学生信息表 的语句
String sql1="create table studentInfo("
+ "id Integer primary key , "
+ "name varchar(10), "
+ "phone varchar(11),"
+ "); ";
//2.添加学生信息。
String sql2="insert into studentInfo values(1,'李文志','18777009999');";
String sql3="insert into studentInfo values(2,'李嘉诚','18877009999');";
//3.查询学生信息功能
String sql4="select * from studentInfo ;";//查询所有用户的信息
String sql5="select * from studentInfo where name='李文志'; " ;//查询姓名为李文志的用户的信息
}
数据库语句的简单使用，没什么好说的。
（三）第三题
1.序列化对象的实现类
package com.java.test3.copy;
import java.io.Serializable;
public class User implements Serializable {// 实现序列化
String account = "";
String password = "";
int age = 0;
double height = 0;
// 重写构造方法，方便数的传入
public User(String account, String password, int age, double height) {
super();
this.account = account;
this.password = password;
this.age = age;
this.height = height;
}
// 重写toString方法，方便显示
@Override
public String toString() {
return "account=" + account + ", age=" + age + ", height=" + height;
}
}
2.主方法调用类
package com.java.test3.copy;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import javax.swing.text.html.HTMLDocument.HTMLReader.IsindexAction;
/**
* IO流：
* 1.创建一个文件user.txt.
* 2.向文件写入序列化对象User
* 属性:account,值:danny 属性:password,值:123456 属性:age,值:26 属性:high,值:172.5
* 3.从文件user.txt中读出User对象的数据 name，age，high
*
* 程序分析：
* 1.创建文件使用file.createNewFile();
* 2.使用ObjectOutputStream和它的方法writeObject来进行写入对象。
* 3.使用ObjectInputStream和它的readObject来进行对象的读取。
* */
public class IOTest {
public static void main(String[] args) {
// 在D盘创建一个文件user.txt，使用File的方法
File file = new File("D:", "user.txt");//指定文件路径
try {
file.createNewFile();// 创建文件
} catch (IOException e1) {
}
if (file.exists()) {
//文件的写入
ForWrite(file);
//文件的读取
ForRead(file);
} else {
System.out.println("文件不存在！");
}
}
private static void ForRead(File file) {
// 文件的读取
ObjectInputStream ois = null;
try {
ois = new ObjectInputStream(new FileInputStream(file));
//在输入流中读取对象
User temp=(User) ois.readObject();
System.out.println("读取的文件内容为：");
System.out.println(temp);
} catch (Exception e) {
System.out.println(e.getMessage() + "错误!");
}finally{
try {
ois.close();// 关闭输入流
} catch (IOException e) {
}
}
}
private static void ForWrite(File file) {
ObjectOutputStream oos =null;
try {
// 把对象写入到文件中，使用ObjectOutputStream
oos = new ObjectOutputStream(
new FileOutputStream(file));
// 创建对象
User user = new User("danny", "123465", 26, 172.5);
// 把对象写入到文件中
oos.writeObject(user);
System.out.println("写入文件完毕！");
} catch (IOException e) {
System.out.println(e.getMessage() + "错误！");
}finally{
try {
oos.close();//关闭输出流
} catch (IOException e) {
}
}
}
}
运行后可以看到：
（四）第四题
package com.java.test4;
import java.util.ArrayList;
import java.util.Iterator;
import com.java.test3.User;
/**
* 集合框架：
* 完成下面的要求
* 1.创建一个List，在List 中增加三个工人，基本信息如下：
* 姓名 年龄 工资
* zhang3 18 3000
* li4 25 3500
* wang5 22 3200
* 2.在li4 之前插入一个工人，信息为：
* 姓名：zhao6，年龄：24，工资3300
* 3.遍历并删除其中姓名为 wang5 的信息
*
* 程序分析：
* 1.ArrayList的使用，add添加信息
* 2.在某一个位置后面添加信息用add(int index, E element)方法
* 3.最后删除使用的是迭代器的知识
* */
public class ListTest {
public static void main(String[] args) {
//1.创建ArrayList集合
ArrayList
list=new ArrayList<>();
//实例化4对象
People p1=new People("zhangsan",18, 3000);
People p2=new People("li4", 25, 3500);
People p3=new People("wang5", 22, 3200);
People p4=new People("zhao6", 24, 3300);
//先添加3个对象
list.add(p1);
list.add(p2);
list.add(p3);
//在li4 之前插入zhao6
list.add(1,p4);
// 遍历到数据就打印出来，如果发现是 wang5就它删除
Iterator
it = list.iterator();// 获取迭代器对象
while (it.hasNext()) {// 如果有数据
People temp = it.next();// 获取遍历到的People对象
System.out.println(temp);// 把遍历到的数据显示出来
// 发现是 wang5就它删除
if (temp.name.equals("wang5")) {
it.remove();// 把wang5删除
}
}
}
//创建一个静态的内部类
static class People{
//定义基本信息
String name="";
int age=0;
double salary=0;
//重写构造方法，方便数据的写入
public People(String name, int age, double salary) {
super();
this.name = name;
this.age = age;
this.salary = salary;
}
//重写toString方法，方法数据的显示
@Override
public String toString() {
return "name=" + name + ", age=" + age + ", salary="+ salary ;
}
}
}
（五）第五题
package com.java.test5;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 多线程 ： 1 创建线程数量为5的线程池。 2 同时运行5个卖票窗口。 3 总票数为100，每隔一秒钟卖一张票
*
* 程序分析：
* 1.线程池类的使用，限制线程的个数
* 2.静态变量的定义
* 3.代码块锁的使用
* */
public class ThreadTest {
public static void main(String[] args) {
// 1.调用Executors类的静态方法来创建一个ExecutorService对象，该对象代表一个线程池。
ExecutorService pool=Executors.newFixedThreadPool(6);//创建5或5以上都可以
// 2.调用Runnable实现类的示例，作为线程执行任务。
//实例化站台对象，并为每一个站台取名字
Station station1=new Station("窗口1");
Station station2=new Station("窗口2");
Station station3=new Station("窗口3");
Station station4=new Station("窗口4");
Station station5=new Station("窗口5");
// 3.调用ExecutorService对象的submit方法来提交Runnable示例。
// 让每一个站台对象各自开始工作
pool.submit(station1);
pool.submit(station2);
pool.submit(station3);
pool.submit(station4);
pool.submit(station5);
// 4.当不想提交任务时，调用ExecutorService对象的shutdown方法来关闭线程。
pool.shutdown();
/*
*如果没有线程池，直接启动线程也能实现效果，但是效率低一点
*station1.start();
station2.start();
station3.start();
station4.start();
station5.start();
*/
}
static class Station extends Thread {
// 通过构造方法给线程名字赋值
public Station(String name) {
super(name);// 给线程名字赋值
}
// 为了保持票数的一致，票数要静态
static int tick = 100;
// 创建一个静态钥匙
static Object ob = " aa";
// 重写run方法
@Override
public void run() {
while (tick > 0) {
synchronized (ob) {// 这个很重要，必须使用一个锁，
// 进去的人会把钥匙拿在手上，出来后才把钥匙拿出来
if (tick > 0) {
System.out.println(getName() + "卖出了第" + tick + "张票");
tick--;
} else {
System.out.println("票卖完了");
}
}
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
（六）第六题
1.服务器端的设置
package com.java.test6;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
* TCP服务端
* 文件传输功能！能够给客户端发送一个图片
* */
public class TCPServer extends Thread {
// 定义服务器接口ServerSocket
ServerSocket server = null;
// 定义一个服务器，定义端口
public TCPServer(int port) {
try {
server = new ServerSocket(port);
} catch (Exception e) {
e.printStackTrace();
}
}
// 接收信息的线程
@Override
public void run() {
super.run();
try {
while (true) {
// 建立socket接口，accept方法是一个阻塞进程,等到有用户连接才往下走
// 定义Socket类
Socket socket = server.accept();
// 在服务器显示连接的上的电脑、
String hostMessage = socket.getInetAddress().getHostAddress().toString();
System.out.println(hostMessage+"连接上了");
// 向用户发送图片
SendPictureToUser(socket);
}
} catch (Exception e) {
e.printStackTrace();
}
}
// 把发送给用户一个图片，涉及到写的操作OutStream
private void SendPictureToUser(Socket socket) {
// 拿到用户的socket对象，对其进行写入数据
OutputStream os = null;
FileInputStream fis = null;
try {
os = socket.getOutputStream();
// 把D盘的一个图片发给用户
File file = new File("D:", "mm.jpg");
fis = new FileInputStream(file);
byte[] buf = new byte[1024];
int len = 0;
// 边读边写
while ((len = fis.read(buf)) != -1) {
os.write(buf, 0, len);
}
os.flush();// 刷新一下写入的数据，很有必要
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
//关闭打开的流
fis.close();
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
2.客户端的设置
package com.java.test6;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;
import java.net.UnknownHostException;
/*
* 客户端
* 接收文件功能，
* 接收服务器发送过的文件
* */
public class TCPClient extends Thread {
Socket socket = null;
public TCPClient(String host, int port) {
try {
socket = new Socket(host, port);
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void run() {
InputStream s =null;
FileOutputStream fos=null;
try {
// 读Sock里面的数据，把读取到的文件写到某个位置
s = socket.getInputStream();
byte[] buf = new byte[1024];
int len = 0;
fos=new FileOutputStream(new File("C:","server.jpg"));//文件存放的位置
//边读边写
while ((len = s.read(buf)) != -1) {
fos.write(buf, 0, len);
}
fos.flush();//刷新一下流
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
//关闭打开的流
s.close();
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
3.主方法的调用类
package com.java.test6;
/**
* TCP传输图片
*1.创建TCP服务端，TCP客户端。
*2.服务端等待客户端连接，客户端连接后，服务端向客户端写入图片。
*3.客户端收到后进行文件保存。
*
*程序分析：
*1.服务器和客户端的创建,ServerSocket和Socket类的使用
*2.过OutputStream和InputStream的对对象方法进行数据的写入和读取。
* */
public class TCPTest {
public static void main(String[] args) {
// 开启服务器 ,设定端口号
TCPServer server = new TCPServer(6508);
server.start();
// 开启客户端
// 需要服务端的正确的IP地址和端口号
TCPClient client = new TCPClient("192.168.18.34", 6508);
client.start();
}
}
这里主方法的调用类一般是把服务器和客户端的启动分开的，这里只是为了方便显示。
运行后，可以发现，在C盘接收到一张D盘传过来的图片。
以上就是高编的题目的参考答案，参考答案是本人编写，只代表个人意见，有些题目方法还是多样的。
扫一扫
1051
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
