一、题目集1
1.前言
知识点：基础的if，switch判断语句，循环语句，Java的输入和输出语句
题量：少
难度：简单
2.设计与分析
心得：题目简单，题量也不大，题目基本上没有需要太多需要自主设计的地方
3.踩坑心得
正如前文所提到的，题目基本上没有太多需要自主设计的地方，比较容易踩坑的地方不多
1）格式错误：比如漏掉一个空格，或打错字等
2）逻辑错误：当多个“||”并列时，有概率漏掉，导致答案不符等
4.主要困难以及改进建议
无
5.总结
这个时候刚刚开始学习Java，虽然题目简单，但难免需要多翻课本和上网搜索相关知识，说明基础知识的积累也是十分重要的，不然会大大降低写代码的效率。
二、题目集2
1.前言
知识点：foreach语句，类的创建、属性和方法，ArrayList集合，split函数，不同数据类型之间的转换
题量：一般
难度：较难（对于新手而言）
2.设计与分析
1）菜单计价程序-1
踩坑心得：我个人认为这一道题主要考的是类方面的知识，当时写这道题的时候，我对于类这一方面还是非常不足的，导致写这个题目，会不自觉有畏难心理，各方面都很容易出错。现在看来也不是很难，还是得勇于尝试，不能一开始就给自己消极的心理暗示。
主要困难以及解决措施：因为知识积累不足，一开始比较困惑于如何协调于各个类之间的关系，多翻翻课本和听一些网课会对这方面有较大帮助。
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Menu m=new Menu();
Scanner string=new Scanner(System.in);
/*输入菜单中所有菜品*/
Dish d=new Dish("西红柿炒蛋",15);
m.add(d);
d=new Dish("清炒土豆丝",12);
m.add(d);
d=new Dish("麻婆豆腐",12);
m.add(d);
d=new Dish("油淋生菜",9);
m.add(d);
Order o=new Order(m);
String name;
int portion;
name=string.next();
while(!name.equals("end"))
{
portion=string.nextInt();
o.addRecord(name,portion);
name=string.next();
}
if(o.getTotalPrice()!=0)
System.out.printf("%d\n",o.getTotalPrice());
}
}
/*菜品*/
class Dish{
String name; //菜名
int unit_price; //单价
Dish(String name,int price)
{
this.name=name;
this.unit_price=price;
}
int getPrice(int portion) //按分量计价
{
double[] m ={1,1.5,2};
return (int)(unit_price*m[portion-1]+0.5);
}
}
/*菜单*/
class Menu{
Dish[] dishes; //所有菜品
void add(Dish dish) //添加新菜品
{
int length=0;
if(dishes!=null)
length=dishes.length;
Dish[] d =new Dish[length+1];
if(length>0)
System.arraycopy(dishes,0,d,0,length);
d[length]=dish;
dishes=d;
}
Dish searchDish(String name) //搜索菜品
{
if (dishes != null)
{
for (Dish dish : dishes)
if (dish.name.equals(name))
return dish;
System.out.println(name + " does not exist"); //某菜品不存在
}
return null;
}
}
/*每份菜品点单信息*/
class Record{
Dish dish; //菜品
int portion; //分量
Record(Dish dish,int portion)
{
this.dish =dish;
this.portion=portion;
}
int getPrice()
{
return dish.getPrice(portion);
}
}
/*点单*/
class Order{
Menu menu; //菜单
Record[] records; //点单时的全部菜品记录
int getTotalPrice() //总价
{
int total=0;
if(records!=null)
return 0;
for (Record record : records) total += record.getPrice();
return total;
}
Order(Menu m)
{
this.menu=m;
}
void addRecord(String name, int portion) //添加记录
{
Dish dish=menu.searchDish(name);
Record record;
if(dish!=null)
{
int ln=0;
record=new Record(dish,portion);
if(records!=null)
ln=records.length;
Record[] tmp =new Record[ln+1];
if(ln>0)
System.arraycopy(records,0,tmp,0,ln);
tmp[ln]=record;
records=tmp;
}
}
}
关于类和方法的大致展示：
SourceMonitor图表分析：
从SourceMonitor的图表分析中不难看出，这份代码大部分是在良好范围内的，平均复杂度(Avg Complexity)，平均深度(Avg Depth)，最大深度(Max Depth)，最大复杂度(Max Complexity)，每个函数平均包含的语句个数(Methods/Class)，方法和类(Methods / Class)都在较为不错的范围内，唯一不足在于注释语句占总语句数的百分比(% Comments)太高，以后应当注意注释语言的简洁性
最终结果：虽然这道题难度不算高，但当时我还是没能拿到满分，有一个测试点一直没过去，后来时间也不够修改了
2）菜单计价程序-2
踩坑心得：这一题我也非常受消极心理暗示的影响，尤其是代码越写越长，还总是与测试样例不符的时候。
主要困难：这里主要困住我的是删除功能的添加，结合我个人过去经验，我觉得还是基础知识不牢，实践经验不足导致的。解决措施，我想只有多看课本，多听课，多上网查找资料。
修改部分：与菜单计价程序-1相比，修改部分主要为为菜单菜品的输入和点单菜品的删除
import java.util.*;
public class Main{
public static void main(String[] args){
Menu m = new Menu();
Order o = new Order(m);
Scanner s = new Scanner(System.in);
String string = s.nextLine();
while (!string.equals("end"))
{
String[] sArray = string.split(" ");
//点菜
if (sArray.length > 2)
{
int orderNum = Integer.parseInt(sArray[0]);
String name = sArray[1];
int portion = Integer.parseInt(sArray[2]);
int n = Integer.parseInt(sArray[3]);
o.addARecord(orderNum, name, portion, n);
}
//将某样菜从点菜名单中删除
else if ("delete".equals(sArray[1]))
o.deleteRecord(Integer.parseInt(sArray[0]));
else
m.add(sArray[0], Integer.parseInt(sArray[1]));
string = s.nextLine();
}
//输出订单总价
System.out.println(o.getTotalPrice());
}
}
/*菜单*/
class Menu {
private final List<Dish> dishes = new ArrayList<>(); //菜单中所有菜品
Dish searchDish(String name) //搜索菜品
{
for(Dish d : dishes)
if (d.getName().equals(name))
return d;
return null;
}
void add(String name, int price) //添加菜品
{
for (Dish d : dishes)
if (d.getName().equals(name))
{
d.setPrice(price);
return;
}
Dish d = new Dish(name, price);
dishes.add(d);
}
}
/*菜品*/
class Dish {
String name;
int price;
public String getName()
{
return name;
}
public void setPrice(int price) //设置价格
{
this.price = price;
}
public Dish(String name, int price) //设置名字和价格
{
this.name = name;
this.price = price;
}
public int getPrice(int portion) //获得每份菜品价格
{
double[] b = {1, 1.5, 2};
return (int)((price * b[portion - 1])+0.5);
}
}
/*点菜记录*/
class Record {
int number; //序号
Dish dish; //菜品
int portion; //分量
int n; //份数
boolean delete = false;
boolean isNot()
{
return notFound;
}
boolean notFound = false;
Record(int orderNum, Dish d, int portion, int n) {
this.number = orderNum;
this.dish = d;
this.portion = portion;
this.n = n;
}
int getNumber()
{
return number;
}
Dish getDish()
{
return dish;
}
int getPrice()
{
int m=this.n;
return dish.getPrice(portion) * m;
}
boolean isDeleted() //是否删除
{
return !delete;
}
void setDeleted()
{
delete = true;
}
}
/*点菜*/
class Order {
Menu menu;
static ArrayList<Record> records = new ArrayList<>();
Order(Menu m)
{
this.menu = m;
}
int getTotalPrice()
{
int total = 0;
for (Record r : records)
{
int price = r.getPrice();
if (r.isDeleted())
total += price;
}
return total;
}
//添加点单菜品
void addARecord(int number, String name, int p, int n)
{
Dish d = menu.searchDish(name);
//菜品不存在
if (d == null) {
System.out.println(name + " does not exist");
return;
}
//菜品存在
Record r = new Record(number, d, p, n);
records.add(r);
int price = r.getPrice();
System.out.println(r.getNumber() + " " + r.getDish().getName() + " " + price);
}
//删除某样菜品
void deleteRecord(int n)
{
for (Record r : records)
{
if (!r.isNot() && r.isDeleted())
if(r.getNumber() == n)
if(r.isDeleted())
if(r.getNumber() == n)
{
r.setDeleted();
return;
}
}
System.out.println("delete error;");
}
}
关于类和方法的大致展示：
SourceMonitor图表分析：
从SourceMonitor的图表分析中不难看出，这份代码大部分是在良好范围内的，平均复杂度(Avg Complexity)，平均深度(Avg Depth)，最大深度(Max Depth)，最大复杂度(Max Complexity)，注释语句占总语句数的百分比(% Comments)，方法和类(Methods / Class)等都在较为不错的范围内，与菜单计价程序-1相比，提高了语言简洁性（但我觉得是因为菜单计价程序-2的代码更多了，所以显得注释语句不那么多了）
最终结果：都对了，很奇怪，因为菜单计价程序-1反而有一个测试的过不了。
3）jmu-java-日期类的基本使用
踩坑心得：当时写的时候，我还是个新手，也没有很注意题目标题“日期类的基本使用”，导致一开始就走了很多弯路，这告诉我们要审题，并且后来也不太懂LocalDate函数和Date函数之类的方法，虽然也用了一点LocalDate，但是并没有最大程度（甚至是较大程度利用好），用了很笨的方法，现在看来很后悔，还是要多去网上搜索。使用浏览器搜索的时候最好能够简洁明了地表达自己的需求，不然很容易导致最终搜索结果与预期不符。此外，在网上搜索时，千万不要因为文字繁多而拒绝细看，很容易漏掉一些信息，导致错误或者错过简洁方法。
主要困难：因为当时选择了很笨的方法，所以主要困难在于计算和判断的方面，很容易有因为逻辑错误而导致的结果错误，不是什么很值得探讨的方面，这里就不多赘述了
关于代码：实在很烂，方法也不值得参考，就不放上来了
SourceMonitor图表分析：
这个代码是SourceMonitor都说差的程度，丢人。
4）小明走格子
踩坑心得：其实代码挺短的，就是觉得智商不太够用，这主要还是自己的逻辑思维能力不足导致的，一般来说，遇到这种题目如果能自己拿起纸笔多试验几次会有所帮助。不过好在CSDN上有类似题目，帮我捋清了逻辑，但是，这里也要强调一点，不要太相信过来人的答案，也是很可能暗藏bug的，还是要自己亲自试验，多动脑，不要一味跟着别人的思路走。
主要困难及解决措施：因为有CSDN上诸多大神的帮助，所以代码方面最终还是没有花太多时间，偏偏结果对了，卡在了运行超时这个问题上面。在这方面我找到了两种解决措施，如下，
（1）用字符流输入（BufferedReader）可以大大节省输入所耗的时间，从而很多时候这样可以在算法正当的情况下即便是Java也可以避免运行超时的问题，用Scanner就会超时
（2）StreamTokenizer，在读数组时，可以边读边存入，就不需要String[ ]了，可以解决大数组时产生的内存超限问题（恰好很适合这个题目）
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
public class Main {
public static void main(String[] args) throws IOException{
StreamTokenizer z = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
z.nextToken();
int T=(int)z.nval;
int[] m =new int[10010];
int[] n =new int[100];
int x = 0;
for(int i=0;i<T;i++)
{
z.nextToken();
m[i]=(int)z.nval;
if(x<m[i])x =m[i];
}
n[0]=1;n[1]=1;n[2]=2;n[3]=4;n[4]=8;
for(int i=5;i<=x;i++)
n[i]=2*n[i-1]-n[i-5];
for(int i=0;i<T;i++)
System.out.println(n[m[i]]);
}
}
SourceMonitor图表分析：
从SourceMonitor的结果来看，做得不太好，尤其在平均复杂度(Avg Complexity)和平均每个函数平均包含的语句个数(Avg Stmts/Method)两方面，但是不知道主要问题出在哪，毕竟代码很简短，我猜测可能是BufferedReader和StreamTokenizer的使用导致的
三、题目集3
1.前言
题量：一般
难度：菜单计价程序较难，其余均为简单
考察知识点：绝大部分与题目集2相同
2.设计与分析
1）菜单计价程序-3
当时没能写出来，被增加的table和时间相关的问题卡住了，其实现在看来并不难，主要原因还是当时自己的学习重心没有放在java上，导致时间不够自己去做更多的尝试，搞得白白失去了这些分数，学习还是要想清楚主次。但我现在还是在此进行一些关于我的table类的补充（不一定正确）
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
public class Table {
int number; //桌号
Customer customer; //客人
String date; //日期
String time; //时间
ArrayList<Dish> dishes = new ArrayList<>(); //点菜
boolean isOutOfRange = false; //是否超出营业时间
long totalPrice = 0; //总价public Table(int number, Customer customer, String date, String time) {
this.number = number;
this.customer = customer;
this.date = date;
this.time = time;
}
public void isOutOfRange(){
this.isOutOfRange = true;
}
public void totalPrice(Dish dish) {
this.totalPrice += dish.price;
}
public long discountPrice() throws ParseException {
return Math.round((discount()*totalPrice));
}
SimpleDateFormat df1 = new SimpleDateFormat("yyyy/MM/dd");
SimpleDateFormat df2 = new SimpleDateFormat("HH/mm/ss");
public boolean isBusinessHour() throws ParseException {
Date parseDate = df1.parse(date);
Date parseTime = df2.parse(time);
Calendar calendar = Calendar.getInstance();
calendar.setTime(parseDate);
int week = calendar.get(Calendar.DAY_OF_WEEK);
if(week == 1 || week == 7){
String start = "9/30/00";
String end = "21/30/00";
Date startTime = df2.parse(start);
Date endTime = df2.parse(end);
return !(parseTime.before(startTime) || parseTime.after(endTime));
}
else {
String noonStart = "10/30/00";
String noonEnd = "14/30/00";
String nightStart = "17/00/00";
String nightEnd = "20/30/00";
Date noonStartTime = df2.parse(noonStart);
Date noonEndTime = df2.parse(noonEnd);
Date nightStartTime = df2.parse(nightStart);
Date nightEndTime = df2.parse(nightEnd);
boolean judge1 = !(parseTime.before(noonStartTime) || parseTime.after(noonEndTime));
boolean judge2 = !(parseTime.before(nightStartTime) || parseTime.after(nightEndTime));
return judge1 || judge2;
}
}
public double discount() throws ParseException {
Date parseDate = df1.parse(date);
Date parseTime = df2.parse(time);
Calendar calendar = Calendar.getInstance();
calendar.setTime(parseDate);
String noonStart = "10/30/00";
String noonEnd = "14/30/00";
String nightStart = "17/00/00";
String nightEnd = "20/30/00";
Date noonStartTime = df2.parse(noonStart);
Date noonEndTime = df2.parse(noonEnd);
Date nightStartTime = df2.parse(nightStart);
Date nightEndTime = df2.parse(nightEnd);
boolean judge1 = !(parseTime.before(noonStartTime) || parseTime.after(noonEndTime));
boolean judge2 = !(parseTime.before(nightStartTime) || parseTime.after(nightEndTime));
if (judge1){
return 0.6;
}
else if (judge2){
return 0.8;
}
else
return 1;
}
2）其他题目
都比较简单，唯一有一点难度需要上网查一些信息的是最后一题所需的LocalTime函数，不过一但知道如何使用该函数进行比较后，就很轻松了
四、综合性总结
1.关于收获
作为一个新手，我觉得我比较好地掌握了Java的部分基础知识，对LocalTime函数有了一定的了解，此外，做题目的过程也对于我本人逻辑思维能力的提升有许多帮助。
2.关于建议
1）我个人认为之后如果有类似的blog作业，不应当距离题目集结束时间太久，否则记忆会模糊，对于blog作业的完成有一定困难。
2）对于一个java新手来说，可能题目集之间的难度跃迁有点大，让人有点猝不及防，我印象中当时对于菜单-1和菜单-2连在一起是觉得很困难的（虽然现在看来没那么难了）。
标签：总结,题目,String,int,PTA,return,Dish,new,name From： https://www.cnblogs.com/230523-abc/p/17426504.html