【Java】常见习题练习

小灰灰@123

已于 2022-07-11 19:41:53 修改

阅读量654

点赞数

分类专栏： Java编程入门文章标签： java 开发语言

于 2022-07-11 19:23:46 首次发布

本文链接：https://blog.csdn.net/weixin_46437504/article/details/125714150

版权

Java编程入门专栏收录该内容

27 篇文章 0 订阅

订阅专栏

Java 基础题目

1、Java语言特点

简单易学（Java语言和C语言和C++语言很接近）
面向对象（封装继承多态）
平台无关性（Java虚拟机实现了平台无关性）
支持网络编程（Java语言诞生就是为了简化网络编程设计的）
支持多线程
解释与编译共存的语言

2、JVM、 JDK 和 JRE

JVM是运行java字节码的虚拟机。不同的平台有自己的虚拟机，因此java语言可以实现跨平台。
JDK即Java Development Kit，是供Java开发人员使用的，其中有Java的开发工具，比如编译工具javac.exe，打包工具jar.exe，同时包含了jre
JRE即Java Runtime Enviroment，是java的运行时环境，包括了jvm、java类库、java命令和其他的一些基础构件。

3、JAVA和C++的区别？

都是面向对象语言，支持封装继承多态。

java提供指针来直接访问内存，程序内存更加安全。
java的类是单继承的，c++放支持多继承，但java的接口可以多继承
java它有自动内存管理垃圾回收机制GC。
c语言中，字符串和数组最后都会有一个额外的字符’\0’来表示结束。

4、java语言编译与解释并存

java程序要先经过编译，后解释两个步骤，有java编写的程序需要先经过编译步骤，生成字节码文件，这种字节码必须由java解释器来执行。
编译型语言指编译器将源代码一次性的翻译成可被特定平台执行的机器码。
解释型语言指解释器将源代码逐行解释成可被特定平台执行的机器码并立即执行。

5、continue、break 和return的区别

在循环结构中，当发生了某种条件后提前终止循环。这时候就要用到这几个关键字：

continue：跳出当前的这一次循环，继续下一次循环。
break:跳出整体的循环体，继续执行循环下面的语句。
return：结束方法的运行。

6、java有哪些基本数据类型

基本数据类型：

数值型：byte(1个字节，默认值0) ，short(2个字节，默认值0) ， int(4个字节，默认值0) ， long(8个字节，默认值0L) ，float(4个字节，默认值0.0F) ，double(8个字节，默认值0.0D)
字符型：char（2个字节，默认值’\u0000’）
布尔型：boolean(1个字节，默认值false)
引用数据类型：
类class
接口interface
数组[]

7、方法的返回值以及返回值在类的方法里的作用

方法的返回值就是获取到的某个方法体中代码执行后产生的结果。
返回值的作用就是接收结果，使得它可以用于其他的操作。

8、面向对象和面向过程

面向对象主要是把事务给对象化，包括它的属性和行为。面向对象编程更贴近实际生活的思想。总体来说面向对象的底层还是面向过程，面向过程抽象成类，然后封装，方便使用就是面向对象。
面向过程就是分析出解决问题的步骤，然后用函数把这些步骤一步一步实现，使用时候一次调用即可。

9、面向过程和面向对象的区别

面向过程：面向过程的性能比面向对象高。因为类调用时需要实例化，开销较大消耗资源，所以以性能为主要考虑因素时一般采用面向过程开发，比如单片机，嵌入式开发，Linux等。
面向对象：面向对象易于维护，易复用，易扩展。因为面向对象有封装继承多态的特性，所以可以设计出低耦合的系统。

10、 &和&& 的区别

相同点：&和&&都可以用作逻辑与的运算符（and）
不同点：
&& 具有短路与的功能。当 & 运算符两边的表达式都为true时，整个运算结果才为true。而 && 运算符，第一个表达式为false时，结果直接为false，不再进行第二个表达式。
& 还可以做按位与运算符。

11、标识符和关键字的区别

标识符就是我们在写程序的时候为类，变量和方法取的名字。
但有一些标识符，被赋予了特殊的含义，只能用于特定的地方，这种特殊的标识符就是关键字。
常见的关键字有：
关键字和保留字

12、数学库类中的常见算法

ceil的英文意义是天花板，该方法就表示向上取整，Math.ceil（11.3）的结果为12，Math.ceil(-11.6)的结果为-11；
floor的英文是地板，该方法就表示向下取整，Math.floor(11.6)的结果是11，Math.floor(-11.4)的结果-12；
round方法表示四舍五入，算法为Math.floor(x+0.5),即将原来的数字加上0.5后再向下取整，所以
Math.round(11.5)的结果是12，Math.round(-11.5)的结果为-11.

编程练习

首先复习一下语法基础，再进行编程练习
统计位数为偶数的数字
给你一个整数数组 nums，请你返回其中位数为偶数的数字的个数。
示例 1：

输入：nums = [12,345,2,6,7896]
输出：2
解释：
12 是 2 位数字（位数为偶数）
345 是 3 位数字（位数为奇数）
2 是 1 位数字（位数为奇数）
6 是 1 位数字 位数为奇数）
7896 是 4 位数字（位数为偶数）
因此只有 12 和 7896 是位数为偶数的数字

示例 2：

输入：nums = [555,901,482,1771]
输出：1
解释：
只有 1771 是位数为偶数的数字。

提示：

1 <= nums.length <= 500
1 <= nums[i] <= 10^5

两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返
回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
示例:

给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9，所以返回 [0, 1]

寻找两个正序数组的中位数

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。请你找出这两个有序数组的中位数，并且要求
算法的时间复杂度为 O(log(m + n))。你可以假设 nums1 和 nums2 不会同时为空。
示例 1:

nums1 = [1, 3]
nums2 = [2]
则中位数是 2.0

nums1 = [1, 2]
nums2 = [3, 4]
则中位数是 (2 + 3)/2 = 2.5

原地删除重复元素

给你一个有序数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组
的新长度。不要使用额外的数组空间，你必须在原地修改输入数组，并在使用 O(1) 额外空间的条件下完
成。
示例 1：

输入：nums = [1,1,2]
输出：2, nums = [1,2]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组
中超出新长度后面的元素。

示例 2：

输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不
需要考虑数组中超出新长度后面的元素。

移除元素

给定一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，返回移除后数组的新长
度。不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。元素
的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例 1:

给定 nums = [3,2,2,3], val = 3,
函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。
你不需要考虑数组中超出新长度后面的元素。

示例 2:

给定 nums = [0,1,2,2,3,0,4,2], val = 2,
函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。
注意这五个元素可为任意顺序。
你不需要考虑数组中超出新长度后面的元素。

搜索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，
返回它将会被按顺序插入的位置。你可以假设数组中无重复元素。
示例 1:

输入: [1,3,5,6], 5
输出: 2

示例 2:

输入: [1,3,5,6], 2
输出: 1

示例 3:

输入: [1,3,5,6], 7
输出: 4

示例 4:

输入: [1,3,5,6], 0
输出: 0

寻找重复数

给定一个包含 n + 1 个整数的数组 nums，其数字都在 1 到 n 之间（包括 1 和 n），可知至少存在一个
重复的整数。假设只有一个重复的整数，找出这个重复的数。
示例 1:

输入: [1,3,4,2,2]
输出: 2

输入: [3,1,3,4,2]
输出: 3

说明：

不能更改原数组（假设数组是只读的）。
只能使用额外的 O(1) 的空间。
时间复杂度小于 O(n2) 。
数组中只有一个重复的数字，但它可能不止重复出现一次。

颜色分类

给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。
注意：不能使用代码库中的排序函数来解决这道题。
示例:

输入: [2,0,2,1,1,0]
输出: [0,0,1,1,2,2]

进阶：

一个直观的解决方案是使用计数排序的两趟扫描算法。
首先，迭代计算出0、1 和 2 元素的个数，然后按照0、1、2的排序，重写当前数组。

买卖股票的最佳时机

给定一个数组 prices ，其中 prices[i] 是一支给定股票第 i 天的价格。设计一个算法来计算你所能获取的
最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。注意：你不能同时参与多笔交易
（你必须在再次购买前出售掉之前的股票）。
示例 1:

输入: prices = [7,1,5,3,6,4]
输出: 7
解释: 在第2天（股票价格 = 1）的时候买入，在第3天（股票价格 = 5）的时候卖出, 这笔交易所能获
得利润 = 5-1 = 4 。随后在第4天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时
候卖出, 这笔交易所能获得利润 = 6-3 = 3 。

示例 2:

输入: prices = [1,2,3,4,5]
输出: 4
解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易
所能获得利润 = 5-1 = 4 。注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。因为
这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。

示例 3:

输入: prices = [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

寻找所有数组中消失的数字

给定一个范围在 1 ≤ a[i] ≤ n ( n = 数组大小 ) 的整型数组，数组中的元素一些出现了两次，另一些只出
现一次。
找到所有在 [1, n] 范围之间没有出现在数组中的数字。
您能在不使用额外空间且时间复杂度为O(n)的情况下完成这个任务吗? 你可以假定返回的数组不算在额
外空间内。
示例:

输入:
[4,3,2,7,8,2,3,1]
输出:
[5,6]

最短无序连续子数组

给定一个整数数组，你需要寻找一个连续的子数组，如果对这个子数组进行升序排序，那么整个数组都
会变为升序排序。你找到的子数组应是最短的，请输出它的长度。
示例 1:

输入: [2, 6, 4, 8, 10, 9, 15]
输出: 5
解释: 你只需要对 [6, 4, 8, 10, 9] 进行升序排序，那么整个表都会变为升序排序。

说明 :

输入的数组长度范围在 [1, 10,000]。
输入的数组可能包含重复元素，所以升序的意思是<=。

旋转数组

给你一个数组，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。
示例 1:

输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右轮转 1 步: [7,1,2,3,4,5,6]
向右轮转 2 步: [6,7,1,2,3,4,5]
向右轮转 3 步: [5,6,7,1,2,3,4]

示例2：

输入：nums = [-1,-100,3,99], k = 2
输出：[3,99,-1,-100]
解释:
向右轮转 1 步: [99,-1,-100,3]
向右轮转 2 步: [3,99,-1,-100]

旋转图像

给定一个 n × n 的二维矩阵表示一个图像。将图像顺时针旋转 90 度。
说明：你必须在原地旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要使用另一个矩阵来旋
转图像。
示例 1:

给定 matrix =
[
[1,2,3],
[4,5,6],
[7,8,9]
],
原地旋转输入矩阵，使其变为:
[
[7,4,1],
[8,5,2],
[9,6,3]
]

示例2：

给定 matrix =
[
[ 5, 1, 9,11],
[ 2, 4, 8,10],
[13, 3, 6, 7],
[15,14,12,16]
],
原地旋转输入矩阵，使其变为:
[
[15,13, 2, 5],
[14, 3, 4, 1],
[12, 6, 8, 9],
[16, 7,10,11]
]

除自身以外数组的乘积

给你一个长度为 n 的整数数组 nums，其中 n > 1，返回输出数组 output ，其中output[i]等于nums中
除 nums[i] 之外其余各元素的乘积。
示例:

输入: [1,2,3,4]
输出: [24,12,8,6]

提示：题目数据保证数组之中任意元素的全部前缀元素和后缀（甚至是整个数组）的乘积都在 32 位整数范围内说明: 请不要使用除法，且在 O(n) 时间复杂度内完成此题。

判断能否形成等差数列

给你一个数字数组 arr。如果一个数列中，任意相邻两项的差总等于同一个常数，那么这个数列就称为
等差数列。如果可以重新排列数组形成等差数列，请返回 true ；否则，返回 false 。
示例 1：

输入：arr = [3,5,1]
输出：true
解释：对数组重新排序得到 [1,3,5] 或者 [5,3,1] ，任意相邻两项的差分别为 2 或 -2 ，可以形
成等差数列。

示例 2：

输入：arr = [1,2,4]
输出：false
解释：无法通过重新排序得到等差数列。

提示：

2 <= arr.length <= 1000
-10^6 <= arr[i] <= 10^6

合并区间

给出一个区间的集合，请合并所有重叠的区间。
示例 1:

输入: intervals = [[1,3],[2,6],[8,10],[15,18]]
输出: [[1,6],[8,10],[15,18]]
解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

输入: intervals = [[1,4],[4,5]]
输出: [[1,5]]
解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。

提示： intervals[i][0] <= intervals[i][1]

进阶

100 ~ 50000之间有多少整数，其各位数字之和为5，分别是哪些数（例如整数1324的各位数字之和为 1+3+2+4 等于10（不为5）），并统计满足条件的整数有多少个

public class Test1 {
	//100 ~ 50000之间有多少整数，其各位数字之和为5，分别是哪些数（例如整数1324的各位数字之和为 1+3+2+4 等于10（不为5）），并统计满足条件的整数有多少个
	public static void main(String[] args) {
		int cc=0;
		for(int i=100;i<=50000;i++) {
			//处理3位数
			if(i>=100 && i<1000) {
				int l1=i/100;
				int l2=i%10;
				int l3=i/10%10;
				if(l1+l2+l3==5) {
					cc++;
					System.out.println(i);
				}
			}
			if(i>=1000 && i<=10000) {
				int l1=i/1000;
				int l2=i%10;
				//1234   1  4
				int l3=i/100%10;
				int l4=i/10%10;
				if(l1+l2+l3+l4==5) {
					cc++;
					System.out.println(i);
				}
			}
			if(i>=10000) {
				int l1=i/10000;
			}
		}
		System.out.println("滿足條件的數據個數為"+cc);
	}
//未尽事宜：1、是否有办法将相同的代码抽离出来，2、是否可以直接求数据，而不使用遍历所有数据的方法
}

练习题

1、计算输入数据的阶乘值

System.out.println("请输入整数:");
Scanner sc=new Scanner(System.in);
int kk=sc.nextInt();
int res=1;
for(int k=1;k<=kk;k++){
res*=k;//res=res*k
}
System.out.println(kk+"!="+res);

2、互换两个数的值（不允许使用中间变量）

建立临时变量
加减运算交换
位运算方法

		System.out.println("请输入第一个整数:");
		int num1 = sc.nextInt();
		System.out.println("请输入第二个整数:");
		int num2 = sc.nextInt();
		
		num1=num1+num2;
		num2=num1-num2;
		num1=num1-num2;
		
		System.out.println("交换后的第一个数是"+num1);
		System.out.println("交换后的第二个数是"+num2);

3、输出三个数中的最大值和最小值

System.out.println("请输入第一个整数:");
		int number1= sc.nextInt();
		System.out.println("请输入第二个整数:");
		int number2 = sc.nextInt();
		System.out.println("请输入第三个整数:");
		int number3 = sc.nextInt();
		if(number1>number2) {
			if(number2>number3) {
				System.out.println("最大值："+number1);
				System.out.println("最小值："+number3);
			    }else{	
				System.out.println("最大值："+number1);
				System.out.println("最小值："+number2);
			    }
	        }else if(number1>number3){
			System.out.println("最大值："+number2);
			System.out.println("最小值："+number3);			
		    }else if(number2>number3){
			System.out.println("最大值："+number2);
			System.out.println("最小值："+number1);
			}else{
			System.out.println("最大值："+number3);
			System.out.println("最小值："+number1);
			}

4、输出1-100的奇数(每行输出6个)

 int  j =  0 ;
         for ( int  i= 1 ; i<= 100 ; i++){
             if  (i% 2  !=  0 ) {
                 j++;
                 System.out.print(i+ "  " );
                 if  (j% 6  ==  0 ) {
                 System.out.print( "\n" ); 
                 }
             }
         }
        System.out.print( "\n" );

5、1-100求和(for while以及do/while的写法)

int sum = 0;
		//定义变量，来承接
		for (int i = 1; i <= 100; i++) {
		   sum += i;
		 } System.out.println("和为：" + sum);
	 
		//while循环

		 int sum1 = 0;
		 int i = 1;
		 while (i<=100){
		      sum1+=i;
		      i++;
		    }
		System.out.println("1~100的和为："+sum1);
		
		//do while循环
		int ii = 1;
        int sum2 = 0;
        do {
            sum2 += ii;
            ii++;
        } while (i <= 100);
        System.out.println("1~100的和：" + sum2);

6、1-100奇数求和

 int  n =  0 ;
        for ( int  m= 1 ; m<= 100 ; m++){
            if  (m% 2  !=  0 ) {
                n++;
           System.out.print(m+ "  " );
            }                
        }

7、1~100可以被3整除的数

public class Test1 {
	public static void main(String[] args) {
		// 输出1-100之间能够被3整除的数,每行输出6个
		int cc = 0;
		for (int i = 1; i < 101; i++) {
			if (i % 3 == 0) {
				System.out.print(i + "\t");
				cc++;
				if(cc%6==0)
					System.out.println();
			}
		}
	}
}

8、求100 以内所有能被3 整除但不能被5 整除的个数

public class Test3 {
	public static void main(String[] args) {
		// 求100 以内所有能被3 整除但不能被5 整除的个数
		int cc = 0;
		int k = 1;
		do {
			if (k % 3 == 0 && k % 5 != 0) {
				System.out.print(k+"\t");
				cc++;
				if(cc%6==0)
					System.out.println();
			}
		} while (k++ < 100);
		System.out.println("\n1到100之间能够被3整除但是不能被5整除的整数个数为" + cc);
	}
}

9、打印出所有的水仙花数

public class Test4 {
	public static void main(String[] args) {
		// 打印出所有的水仙花数
		// 水仙花数是指一个 3 位数，它的每个位上的数字的 3次幂之和等于它本身（例如：1^3 + 5^3+ 3^3 = 153
		for (int i = 100; i < 1000; i++) {
			int gewei = i % 10;// 个位数
			int baiwei = i / 100;// 百位数
			int shiwei = i / 10 % 10;// 十位数
			if (gewei * gewei * gewei + baiwei * baiwei * baiwei + shiwei * shiwei * shiwei == i) {
				System.out.println(i);
			}
		}

	}
}

10、判断一个数是否质数

public class Test5 {
public static void main(String[] args) {
	//判断一个数是否质数
	//质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。
	
	//键盘录入一个整数[自然数]
	int input=0;
	Scanner sc=new Scanner(System.in);
	System.out.println("请输入一个大于1的自然数");
	while(true) {
		input=sc.nextInt();
		if(input<=1)
			System.out.println("输入的数据不合法!");
		else
			break;
	}
	//判断是否有>=2并且<自身的因数
	boolean ziShu=true;
	for(int k=2;k<input;k++) {
		if(input%k==0) {
			ziShu=false;
			break;
		}
	}
	//根据判断结果输出提示信息
	if(ziShu)
		System.out.println(input+"是质数");
	else
		System.out.println(input+"不是质数");
}
}

11、编程求出自然数101-205中的所有质数

public class Test6 {
//编程求出自然数101-205中的所有质数
	public static void main(String[] args) {
		int cc=0;
		for (int i = 101; i <= 205; i++) {
			boolean bb=true;
			for(int k=2;k<i;k++) {
				if(i%k==0) {
					bb=false;
					break;
				}
			}
			if(bb) {
				System.out.print(i+"\t");
				cc++;
				if(cc%6==0)
					System.out.println();
			}
		}
	}
}

12、输入两个正整数m和n，求其最大公约数和最小公倍数

 public static void main(String[] args) {
    //输入两个正整数m和n，求其最大公约数和最小公倍数
    int k1=12,k2=18;
    int begin=Math.min(k1, k2);
    for(int i=begin;i>1;i--) {
      if(k1%i==0 && k2%i==0) {
        System.out.println("最大公约数为"+i);
        break;
      }
    }
    
    begin=Math.max(k1, k2);
    for(int i=begin;i<=k1*k2;i++) {
      if(i%k1==0 && i%k2==0) {
        System.out.println("最小公倍数为"+i);
        break;
      }
    }
  }

13、100 ~ 50000之间有多少整数，其各位数字之和为5，分别是哪些数（例如整数1324的各位数字之
和为 1+3+2+4 等于10（不为5）），并统计满足条件的整数有多少个

public class Test1 {
	//100 ~ 50000之间有多少整数，其各位数字之和为5，分别是哪些数（例如整数1324的各位数字之和为 1+3+2+4 等于10（不为5）），并统计满足条件的整数有多少个
	public static void main(String[] args) {
		int cc=0;
		for(int i=100;i<=50000;i++) {
			//处理3位数
			if(i>=100 && i<1000) {
				int l1=i/100;
				int l2=i%10;
				int l3=i/10%10;
				if(l1+l2+l3==5) {
					cc++;
					System.out.println(i);
				}
			}
			if(i>=1000 && i<=10000) {
				int l1=i/1000;
				int l2=i%10;
				//1234   1  4
				int l3=i/100%10;
				int l4=i/10%10;
				if(l1+l2+l3+l4==5) {
					cc++;
					System.out.println(i);
				}
			}
			if(i>=10000) {
				int l1=i/10000;
			}
		}
		System.out.println("滿足條件的數據個數為"+cc);
	}
//未尽事宜：1、是否有办法将相同的代码抽离出来，2、是否可以直接求数据，而不使用遍历所有数据的方法
}

14、鸡兔同笼共80个头，208只脚，鸡和兔各有几只

public class Test3 {
//鸡兔同笼共80个头，208只脚，鸡和兔各有几只
	public static void main(String[] args) {
//		for(int i=0;i<=80;i++) {  //鸡的数量
//			for(int k=0;k<=80-i;k++) {
//				if(2*i+k*4==208 && i+k==80) {
//					System.out.println("鸡有"+i+"只，兔子有"+k+"只");
//				}
//			}
//		}
//	}
		//=======================
		for(int i=0;i<=52;i++) {//兔子
			int k=80-i;//鸡
				if(4*i+k*2==208) {
					System.out.println("鸡有"+k+"只，兔子有"+i+"只");
				}
			}
		}
	//理解时间复杂度的概念，使用一定的方法减少循环次数，则可以提高代码的执行效率
	}

15、鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何

public class Test4 {
public static void main(String[] args) {
	for(int i=0;i<=20;i++) {
		for(int k=0;k<34;k++) {
			for(int m=0;m<301;m=m+3) {
				if(i+k+m==100 && 5*i+3*k+m/3==100) {
					System.out.println("公鸡"+i+"只，母鸡"+k+"只,小鸡"+m+"只");
				}
			}
		}
	}
	//未尽事宜：参照Test3考虑如何减少循环计算次数
}
}