Java高编机试题

Java高编机试题

本文通过几道java高编机试题来加深对java高编的理解

一．题目

（一）计时器 （20分）：

1 编写，只负责计时，不处理具体事务。并做测试。

（二）数据库操作（20分）：

1 创建学生信息表 -- 。

2 提供添加学生信息（id name phone）， 查询学生信息功能。

//将SQL语句写在代码中即可

（三）IO流（20分）：

1 创建一个文件user.txt.

2 向文件写入json数据

key:,value:danny

key:,value:

key:age,value:26

key:high,value:172.5

3 从文件user.txt中读出数据 name，age，high

（四）集合框架（20分）：

完成下面的要求

1.创建一个List，在List 中增加三个工人，基本信息如下：

1. 姓名 年龄 工资

2. 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集合
ArrayListlist=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就它删除
Iteratorit = 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盘传过来的图片。

以上就是高编的题目的参考答案，参考答案是本人编写，只代表个人意见，有些题目方法还是多样的。