作业

ghslyr / 2023-05-03 / 原文

前言

在之后这三次pta作业中，我进一步理解类与类之间的关联，定义对象，输入输出，基本数据类型的使用，if-else判断，循环，数论，模拟，String类，boolean类，以及类内类外的数据和方法的使用，都可以熟练的掌握了。

二、设计与分析

7-2 有重复的数据

在处理寻找重复数据时我一开始运用了双for循环，结果在检验时出现

的问题，于是我想了一下，发现可以先在一个循环里给相同数字所占的数组位置一个标记，然后再在另一个循环里把标记的位置给i达到同样的效果。

7-3 去掉重复的数据

同理，7-3也是一样的方法。

7-4 单词统计与排序

这一次的单词判断长短，我运用了正则表达式，将逗号以及空格给分割开来，再给每个单词的长度排序，但由于相同的长度单词是通过判断每个字母的先后顺序依次排队，我确实没有找到更好的办法，所以就没有想出解决问题的思路，同寝室的舍友也没有给出好多方法，于是便空置了下来。

7-1 正则表达式训练-QQ号校验

这是我第一次学习并使用正则表达式来验证一串代码的正确性，前期做了一定的准备，运用起来时方便了很多。

7-2 字符串训练-字符排序

这道题我用了sort的函数，通过比较字符串中每一个字符的大小来进行排序。

7-5 日期问题面向对象设计（聚合一）

参考题目7-2的要求，设计如下几个类：DateUtil、Year、Month、Day，其中年、月、日的取值范围依然为：year∈[1900,2050] ,month∈[1,12] ,day∈[1,31] , 设计类图如下：

类图.jpg

应用程序共测试三个功能：

求下n天
求前n天
求两个日期相差的天数

import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
int year = 0;
int month = 0;
int day = 0;

int choice = input.nextInt();

if (choice == 1) { // test getNextNDays method
int m = 0;
year = Integer.parseInt(input.next());
month = Integer.parseInt(input.next());
day = Integer.parseInt(input.next());

DateUtil date = new DateUtil(year, month, day);

if (!date.checkInputValidity()) {
System.out.println("Wrong Format");
System.exit(0);
}

m = input.nextInt();

if (m < 0) {
System.out.println("Wrong Format");
System.exit(0);
}
System.out.println(date.getNextNDays(m).showDate());
} else if (choice == 2) { // test getPreviousNDays method
int n = 0;
year = Integer.parseInt(input.next());
month = Integer.parseInt(input.next());
day = Integer.parseInt(input.next());

DateUtil date = new DateUtil(year, month, day);

if (!date.checkInputValidity()) {
System.out.println("Wrong Format");
System.exit(0);
}

n = input.nextInt();

if (n < 0) {
System.out.println("Wrong Format");
System.exit(0);
}
System.out.println(date.getPreviousNDays(n).showDate());
} else if (choice == 3) { //test getDaysofDates method
year = Integer.parseInt(input.next());
month = Integer.parseInt(input.next());
day = Integer.parseInt(input.next());

int anotherYear = Integer.parseInt(input.next());
int anotherMonth = Integer.parseInt(input.next());
int anotherDay = Integer.parseInt(input.next());

DateUtil fromDate = new DateUtil(year, month, day);
DateUtil toDate = new DateUtil(anotherYear, anotherMonth, anotherDay);

if (fromDate.checkInputValidity() && toDate.checkInputValidity()) {
System.out.println(fromDate.getDaysofDates(toDate));
} else {
System.out.println("Wrong Format");
System.exit(0);
}
}
else{
System.out.println("Wrong Format");
System.exit(0);
}
}
}

class DateUtil{
Day d = new Day();

public DateUtil() {

}

public DateUtil(int year,int month,int day) {
d.day = day;
d.month.month = month;
d.month.year.year = year;
}

public Day getDay() {
return d;
}

public void setDay(Day day) {
d = day;
}

public boolean checkInputValidity() {
boolean a;
if(d.validat()&&d.month.validat()&&d.month.year.validat()) {
a = true;
}
else {
a = false;
}
return a;
}

public DateUtil getPreviousNDays(int n) {
int[] m = new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
int day1 = d.day;
int month1 = d.month.month;
int year1 = d.month.year.year;
int k;
if(d.month.year.isLeapYear()) {
k = 366;
m[2] = 29;
}
else {
k = 365;
}
int a = 0;
for(int i=1;i<d.month.month;i++) {
a = a + m[i];
}
a = a + d.day;
if(n>a) {
n = n-a;
year1 = year1-1;
month1 = 12;
day1 = 31;
d.month.year.yearReduction();
if(d.month.year.isLeapYear()) {
k = 366;
m[2] = 29;
}
else {
k = 365;
}
while(n-k>0) {
n = n-k;
year1 = year1-1;
d.month.year.yearReduction();
if(d.month.year.isLeapYear()) {
k = 366;
m[2] = 29;
}
else {
k = 365;
}
}
while(n>m[month1]) {
n -=m[month1];
month1 = month1-1;
}
day1 =m[month1]-n;
}
else {
if(d.month.year.isLeapYear()) {
k = 366;
m[2] = 29;
}
else {
k = 365;
}
if(n>day1) {
n = n-day1;
month1 = month1-1;
while(n>m[month1]) {
n = n-m[month1];
month1 = month1-1;
}
day1 =m[month1]-n;
}
else {
day1 = day1 - n;
}
}
DateUtil beforedate = new DateUtil(year1, month1, day1);
return beforedate;
}

public DateUtil getNextNDays(int n) {
int[] m = new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
int day1 = d.day;
int month1 = d.month.month;
int year1 = d.month.year.year;
int k;
int a = 0;
if(d.month.year.isLeapYear()) {
k = 366;
m[2] = 29;
}
else {
k = 365;
}
for(int i=1;i<d.month.month;i++) {
a = a + m[i];
}
a = a + d.day;
if(n>k-a) {
n = n-(k-a);
year1++;
d.month.year.yearIncrement();
month1 = 1;
day1 = 1;
if(d.month.year.isLeapYear()) {
k = 366;
m[2] = 29;
}
else {
k = 365;
m[2] = 28;
}
while(n-k>0) {
n = n-k;
year1 ++;
d.month.year.yearIncrement();
if(d.month.year.isLeapYear()) {
k = 366;
m[2] = 29;
}
else {
k = 365;
m[2] = 28;
}
}
while(n>m[month1]) {
n -= m[month1];
month1++;
}
day1 = n;
}
else {
if(d.month.year.isLeapYear()) {
k = 366;
m[2] = 29;
}
else {
m[2] = 28;
k = 365;
}
if(n>m[month1]-day1) {
n = n-(m[month1]-day1);
month1 ++;
while(n>m[month1]) {
n = n-m[month1];
month1++;
}
day1 = n;
}
else {
day1 = day1 + n;
}
}
DateUtil nextdate = new DateUtil(year1, month1, day1);
return nextdate;
}

public int getDaysofDates(DateUtil toDate) {
boolean b = equalTwoDates(toDate);
boolean a = compareDates(toDate);
int[] m = new int[]{0,31,28,31,30,31,30,31,31,30,31,30,31};
int duringday = 0;
int k1;
if(b) {
duringday = 0;
}
else {
if(a) {
if(d.month.year.year<toDate.d.month.year.year) {
if(d.month.year.isLeapYear()) {
k1 = 366;
m[2] = 29;
}
else {
k1 = 365;
}
for(int i=1;i<d.month.month;i++) {
duringday +=m[i];
}
duringday += d.day;
duringday = k1-duringday;
while(toDate.d.month.year.year-d.month.year.year>1) {
d.month.year.yearIncrement();
if(d.month.year.isLeapYear()) {
k1 = 366;
}
else {
k1 = 365;
}
duringday +=k1;
}
if(toDate.d.month.year.isLeapYear()) {
m[2] = 29;
}
else {
m[2] = 28;
}
for(int i=1;i<toDate.d.month.month;i++) {
duringday = duringday + m[i];
}
duringday +=toDate.d.day ;
}
else {
if(d.month.year.isLeapYear()) {
m[2] = 29;
}
else {
m[2] = 28;
}
if(d.month.month<toDate.d.month.month) {
duringday = m[d.month.month]-d.day;
while(toDate.d.month.month-d.month.month>1) {
d.month.monthIncrement();
duringday +=m[d.month.month];
}
duringday +=toDate.d.day;
}
else {
duringday = toDate.d.day-d.day;
}
}
}
else {
if(d.month.year.year>toDate.d.month.year.year) {
if(toDate.d.month.year.isLeapYear()) {
k1 = 366;
m[2] = 29;
}
else {
k1 = 365;
}
for(int i=1;i<toDate.d.month.month;i++) {
duringday = duringday + m[i];
}
duringday = duringday + toDate.d.day;
duringday = k1-duringday;
while(d.month.year.year-toDate.d.month.year.year>1) {
toDate.d.month.year.yearIncrement();
if(toDate.d.month.year.isLeapYear()) {
k1 = 366;
}
else {
k1 = 365;
}
duringday +=k1;
}
if(d.month.year.isLeapYear()) {
m[2] = 29;
}
else {
m[2] = 28;
}
for(int i=1;i<d.month.month;i++) {
duringday = duringday + m[i];
}
duringday +=d.day ;
}
else {
if(d.month.year.isLeapYear()) {
m[2] = 29;
}
else {
m[2] = 28;
}
if(d.month.month>toDate.d.month.month) {
duringday = m[toDate.d.month.month]-toDate.d.day;
while(d.month.month-toDate.d.month.month>1) {
toDate.d.month.monthIncrement();
duringday +=m[toDate.d.month.month];
}
duringday +=d.day;
}
else {
duringday =d.day-toDate.d.day;
}
}
}
}
return duringday;
}

public String showDate() {
String str1 = ""+d.month.year.year+"-"+d.month.month+"-"+d.day;
return str1;
}

public boolean equalTwoDates(DateUtil date) {
if(date.d.month.year.year==d.month.year.year&&date.d.day==d.day&&date.d.month.month==d.month.month) {
return true;
}
else {
return false;
}
}

public boolean compareDates(DateUtil date) {
if(d.month.year.year>date.d.month.year.year) {
return false;
}
else if(d.month.year.year<date.d.month.year.year){
return true;
}
else {
if(d.month.month>date.d.month.month) {
return false;
}
else if(d.month.month<date.d.month.month) {
return true;
}
else {
if(d.day>date.d.day) {
return false;
}
else {
return true;
}
}
}
}
}

class Day {
int day;
Month month = new Month();
int[] m = new int[]{31,28,31,30,31,30,31,31,30,31,30,31};

public Day(){

}

public Day(int year,int month,int day) {
this.day = day;
this.month.month = month;
this.month.year.year = year;
}

public void setMonth(Month value) {
month = value;
}

public void setvalue(int value) {
day = value;
}

public void dayIncrement() {
day++;
}

public void dayReduction() {
day--;
}

public int getValue() {
return day;
}

public Month getMonth() {
return month;
}

public void resetMin() {
day = 1;
}

public void resetMax() {
if(month.year.isLeapYear()) {
m[1] = 29;
}
day = m[month.month-1];
}

public boolean validat()
{
if(month.year.isLeapYear()) {
m[1] = 29;
}
if(day>0&&day<=m[month.month-1])
return true;
else return false;
}

}

class Month{
int month;
Year year = new Year();

public Month() {

}

public Month(int yearValue,int monthValue) {
month = monthValue;
year.year = yearValue;
}

public int getValue() {
return month;
}

public void setValue(int monthValue) {
month = monthValue;
}

public Year getYear() {
return year;
}

public void setYear(Year year) {
this.year = year;
}

public void monthIncrement() {
month++;
}

public void monthReduction() {
month--;
}

public void resetMin() {
month = 1;
}

public void resetMax() {
month = 12;
}

public boolean validat()
{
if(month>0&&month<=12) {
return true;
}
else{
return false;
}
}
}

class Year{
int year;

public Year() {

}

public Year(int year) {
this.year = year;
}

public int getValue() {
return year;
}

public void setValue(int value) {
this.year = value;
}

public void yearIncrement() {
year++;
}

public void yearReduction() {
year--;
}

public boolean isLeapYear() //判断year是否为闰年，返回boolean类型；
{

if((year%4 == 0&&year%100 != 0)||(year%400 == 0))
return true;
else return false;
}

public boolean validat()
{

if(year>=1900&&year<=2050)
return true;
else return false;
}
}

这一题禁止使用关于时间的函数时，说实话我刚开始确实抽了一下，因为之前有几题是叫我们运用时间函数来解决两个日期之间的先后以及这两个日期的间隔，但过了一段时间后发现我其实已经进入了固定思维，被刚刚所学的知识给困住了，我完全可以用之前写的代码，所以我设置了年月日三个类，来解决是否为平年闰年，二月份有几天等问题，再通过计算天数来判断谁前谁后。但依旧出了问题，在判断月份时，month类里面对一个月的天数限制范围出现了问题