Java 题目汇总

Java 题目汇总

xiaohu

2024 年 05 月 27 日

264 次浏览

暂无评论

2567字数

1.编写一个方法实现：2/1, 3/2, 5/3, 8/5, 13/8, 21/13……求这个数列的前20项之和

2.编写一个方法实现：输入某年某月某日，判断这一天式这一年的第几天

3.编写一个方法实现：求方程a*x*x+b*x+c=0的根 （a,b,c要求从键盘输入）

4.编写一个方法实现：计算数组的平均值（数组自己定义，自己手动录入数据）

6.编写一个方法实现：鸡兔一共35只，笼子里共有94只脚，请问分别有多少只鸡多少只兔

7.编写一个方法实现：数组a:{1,7,9,11,13,15,17,19}
                               数组b:{2,4,6,8,10}
                   两个数组合并微数组c，按升序排序输出

8.编写一个方法实现：从键盘输入一个数字，反转输出，如：输入123，输出321

9.编写一个方法实现：求1！+2！+3！+……+n!的和，n的值又键盘输入

10.我们可以通过父母的身高大致推出子女身高，假设父母的身高与子女身高遗传关系如下：
  儿子身高(cm)=(父亲身高+母亲身高)*1.08/2
  女儿身高(cm)=(父亲身高*0.923+母亲身高)/2
从键盘输入父亲和母亲的身高，求子女的身高。编写一个方法实现。
```java
package com.xiaohu.test;

import java.util.Scanner;

public class Test1 {
	public static void main(String[] args) {
		Test1 t = new Test1();
//		数列的前20项之和
		float res1=t.add(20);
		System.out.println("数列的前20项之和:"+res1);
		
//		判断这一天式这一年的第几天
		System.out.println("判断这一天式这一年的第几天:"+t.judge(2024,5,30));
		
//		计算数组的平均值
		double[] array= {1,2,3,4,5,33.1,55.5};
		System.out.println("数组平均值:"+t.average(array));
		
//		请问分别有多少只鸡多少只兔
		t.judgeChicken(35,94);
		
//		从键盘输入一个数字，反转输出
		System.out.println("反转:"+t.reverse("123"));
		
//		 两个数组合并为数组c，按升序排序输出
		int[] arr1={1,7,9,11,13,15,17,19};
		int[] arr2={2,4,6,8,10};
		int[] arr3= t.combine(arr1, arr2);
		System.out.print("两个数组合并为数组c，按升序排序输出:");
		for(int i=0;i<arr3.length;i++) {
			System.out.print(arr3[i]+" ");
		}
		
//		求1！+2！+3！+……+n!的和，n的值又键盘输入
		System.out.println("\nn的阶乘和"+t.addSum(10));
		
//		父亲和母亲的身高，求子女的身高。编写一个方法实现。
		
		System.out.println("Daughter:"+t.computeDaughterHeight(178, 190.5)+"cm");
		System.out.println("Son:"+t.computeSonHeight(178, 190.5)+"cm");

//		求方程a*x*x+b*x+c=0的根 （a,b,c要求从键盘输入）
		Scanner sa = new Scanner(System.in);
		System.out.println("请输入a");
		float a = sa.nextFloat();
		System.out.println("请输入b");
		float b = sa.nextFloat();
		System.out.println("请输入c");
		float c = sa.nextFloat();
		float delta=b*b-4*a*c;
		
		if(t.isSecondBinary(a,b,c)) {
			System.out.println("一元一次");

}else if(t.isHaveRoot(a,b,c)) {
			System.out.println("有实根");
			if(t.isSameRoot(delta)) {
				System.out.println("跟相同");
				System.out.println(t.computeRes1(a, b, c));
				
			}else {
				System.out.println("跟不相同");
				System.out.println(t.computeRes1(a, b, c));
				System.out.println(t.computeRes2(a, b, c));
			}
			
		}else {
			System.out.println("无实根");
		}
		sa.close();
	}

//	数列的前n项之和
	public float add(int n) {
//		初始化前两个分子分母
//		2/1
		float preNumZi=2,preNumMu=1;
//		2/3
		float currNumZi=3,currNumMu=2;
//		2/1 + 2/3
		float sum=preNumZi/preNumMu+currNumZi/currNumMu;
//		除了前两个之外的  下一个的
		for(int i=2;i<n;i++) {
//			分子= 当前和前一个的分母相加
			float nextNumZi=currNumMu+preNumMu;
//			分母 = 当前的分母+前一个数的分母
			float nextNumMu=currNumMu+preNumMu;
//			对当前结果累加
			sum+=nextNumZi/nextNumMu;
			
//			移动到下一个对象 为之后计算做准备
//			前一个子=当前子  前一个母=当前母
			preNumZi = currNumZi;
			preNumMu = currNumMu;
//			当前子=下一个的母   当前母=下一个的母
			currNumZi= nextNumZi;
			currNumMu = nextNumMu;
		}
		return sum;
	}
	
	public int judge(int year,int month,int day) {
//		闰年366 平年365
		if(month>12 || day>31) {
			System.out.println("输入错误");
		}else {
			boolean isRunYear=false;
//			平年2月 28  闰年29
			
			int[] monthDays = {31,28,31,30,31,30,31,30,31,30,31};
			//		如果一个年份可以被4整除但不能被100整除，则该年份是闰年；
			if(year%4==0 && year%100!=0) {
				isRunYear=true;
			}else if(year%4==0 && year%100==0 && year%400==0) {
				//		如果一个年份既可以被4整除又可以被100整除，但能被400整除，则该年份是闰年；
				isRunYear=true;
			}
			
//			是闰年就改变数组里2月的天数
			if(isRunYear) {
				monthDays[1]=29;
			}
			int totalDay=0;
//			累加到指定的月份
			for(int i=0;i<month-1;i++) {
				totalDay+=monthDays[i];
			}
			
//			月份+天数
			totalDay+=day;
			return totalDay;
		}
		return 0;
	}
	
	
	public boolean isSecondBinary(float a,float b,float c) {
		if(a==0) {
			return true;
		}
		return false;
	}
//	判断是否有根
	public boolean isHaveRoot(float a,float b,float c) {
		float delta=b*b-4*a*c;
		if(delta>0 || delta==0) {
			return true;
		}else {
			return false;
		}
	}
//	判断跟是否相同 
	public boolean isSameRoot(float delta) {
		if(delta>0) {
			return false;
		}else if(delta==0) {
			return true;
		}
		return false;
	}
//	算第跟1
	public float computeRes1(float a,float b,float c) {
		float delta=(float) Math.sqrt(b*b-4*a*c);
		
		float res1=0.0f;
		res1=(-b+delta)/(2*a);
		return res1;
	
		
//		-b+delta/2*a
//		-b-delta/2*a
	}
//	算第跟2
	public float computeRes2(float a,float b,float c) {
		float delta=(float) Math.sqrt(b*b-4*a*c);
		float res2=0.0f;
		res2=(-b-delta)/(2*a);

return res2;
	}
//	计算数值平均值
	public double average(double[] array) {
		float sum=0.0f,avg=0.0f;
		for(int i=0;i<array.length;i++) {
			sum+=array[i];
		}
		avg=sum/array.length;
		return avg;
	}
	public void judgeChicken(int total,int feetTotal) {
//		鸡兔一共35只，笼子里共有94只脚
		
		for(int chicken=0;chicken<=total;chicken++) {
			int rabbit =total-chicken;
			if(2*chicken+4*rabbit==feetTotal) {
				System.out.println("chicken:"+chicken+"\t"+"rabbit:"+rabbit);
				return;
			}
		}
	}
//	数组结合
	public int[] combine(int[] arr1,int[] arr2) {
		int arrCLength=arr1.length+arr2.length;
		int[] arrC =new int[arrCLength];
		for(int i=0;i<arrCLength;i++) {
			if(i<arr1.length) {
				arrC[i]=arr1[i];
			}else {
				arrC[i]=arr2[i-arr1.length];
			}
		}
		
		sortArray(arrC);
		return arrC;
	}
	
//	冒泡排序
	public int[] sortArray(int[] arr) {
		int len=arr.length;
		for(int i=0;i<len-1;i++) {
			for(int j=0;j<len-i-1;j++) {
				if(arr[j]>arr[j+1]) {
					int temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}
		}
		return arr;
	}
//	字符串翻转
	public String reverse(String str) {
		String reverseStr="";
		for(int i=str.length()-1;i>=0;i--) {
			reverseStr+=str.charAt(i);
		}
		return reverseStr;
	}
//	阶乘
	public int addSum(int n) {
		int nowNum=1,sum=0;
		for(int i=1;i<=n;i++) {
			nowNum*=i;
			sum+=nowNum;
		}
		return sum;
	}
	
//	  儿子身高(cm)=(父亲身高+母亲身高)*1.08/2
//	  女儿身高(cm)=(父亲身高*0.923+母亲身高)/2
	public double computeDaughterHeight(double mom,double dad) {
		double daughter=(dad*0.923+mom)/2;
		return daughter;
	}
	public double computeSonHeight(double mom,double dad) {
		double son=(dad+mom)*1.08/2;
		return son;
	}
	
	
		
}

```

Java 题目汇总