java经典50题详解

java经典50题详解

最近系统的做了一下java经典的50道题.
题目的难度不太大,而且不会用到什么生僻的类,
很适合接触java不太久的人来锻炼自己的逻辑思维,和加深对数组,逻辑控制,字符串等基础知识的理解…
本次做题,我尽量将代码变得灵活,使得代码可以通过参数的调整来适应更多的问题
而且对于每一个题的答案都进行过测试…
下面就将解题的代码分享给大家

更新说明: 已经将代码整理好上传到github上(PS:目录结构和类名有所优化,后续将陆续优化部分算法):
项目github链接
本编博客涉及代码的github链接

1. 1—10题

package fifties_practice;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;
import java.util.Set;

import javax.lang.model.util.SimpleAnnotationValueVisitor6;

/**
 * java编程50题1--10
 * 
 * @author xmr
 *
 */
public class One_To_Ten {
	public static void main(String[] args) {
		// first(-5);
		// second(2,2000);
		// third();
		// fourth(400000);
		// fifth(10);
		// sixth(10,15);
		// seventh("sadfsadf sdf sd dss34df re [] \\ \\]\\[ \\]\\ \\");
		// eighth(1);
		// nineth(1000);
		// tenth(100L,1);
	}

	/**
	 * 题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第四个月后每个月又生一对兔子，
	 * 假如兔子都不死，问每个月的兔子总数为多少？ 1,1,2,3,5,8 f(n)=f(n-1)+f(n-2)
	 * 
	 * @param month
	 */
	protected static void first(int month) {
		int sum = 0;
		if (month <= 0) {
			System.out.println("请输入正确的月份");
		} else if (month <= 2) {
			sum = 1;
		} else {
			int[] num = new int[month];
			num[0] = 1;
			num[1] = 1;
			for (int i = 2; i < month; i++) {
				num[i] = num[i - 1] + num[i - 2];
				sum = num[month - 1];
			}

		}
		System.out.println(sum);
	}

	/**
	 * 题目：判断两个数之间有多少个素数，并输出所有素数。
	 */
	protected static List<Integer> second(int startInt, int endInt) {
		List<Integer> list = new ArrayList<Integer>();
		int sum = 0;
		for (int i = startInt; i <= endInt; i++) {
			double num = i / 1;
			boolean flag = true;
			if (i < 2) {
				flag = false;
			}
			for (int j = 2; j <= Math.sqrt(num); j++) {
				if (num % j == 0) {
					flag = false;
					break;
				}

			}
			if (flag == true) {
				sum++;
				list.add(i);
			}

		}
		for (int i = 0; i < list.size(); i++) {
			System.out.print(list.get(i) + ",");
			if (i % 10 == 9) {
				System.out.println();
			}
		}
		System.out.println();
		System.out.println(startInt + "到" + endInt + "之间的素数个数为:" + sum);
		return list;
	}

	/**
	 * 题目：打印出所有的 水仙花数 ，
	 * 所谓 水仙花数 是指一个三位数，其各位数字立方和等于该数本身。
	 *  某三位数的百位 i / 100,十位 i % 100 / 10,个位 i % 10
	 */
	protected static void third() {
		int sum = 0;
		for (int i = 100; i <= 999; i++) {
			int hundred = i / 100;
			int ten = i % 100 / 10;
			int bits = i % 10;
			int cubicNum = hundred * hundred * hundred + ten * ten * ten + bits * bits * bits;
			if (cubicNum == i) {
				sum++;
				System.out.print(i + "    ");
			}
		}
		System.out.println();
		System.out.println("水仙花数的个数为:" + sum);
	}

	/**
	 * 题目四:将一个数分解质因数
	 * 
	 * @param n
	 */
	protected static void fourth(int n) {
		// 首先获取到小于这个数的全部素数
		List<Integer> list = second(2, n);
		List<Integer> resultList = new ArrayList<Integer>();
		result(list, resultList, n);
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < resultList.size(); i++) {
			sb.append(resultList.get(i)).append("*");
		}
		sb.delete(sb.length() - 1, sb.length());
		System.out.println(n + "=" + sb.toString());
	}

	protected static List<Integer> result(List<Integer> list, List<Integer> resultList, int n) {

		if (n < 2) {
			return resultList;
		}
		for (int i = 0; i < list.size(); i++) {
			if (n % list.get(i) == 0) {
				n = n / list.get(i);
				resultList.add(list.get(i));
			}
		}
		result(list, resultList, n);
		return resultList;
	}

	/**
	 * 利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。
	 */
	protected static void fifth(int grade) {
		if (grade >= 90 && grade <= 100) {
			System.out.println("A");
			return;
		}
		if (grade >= 60 && grade < 90) {
			System.out.println("B");
			return;
		}
		if (grade >= 0 && grade < 60) {
			System.out.println("C");
			return;
		}
		System.out.println("grade is error");
	}

	/**
	 * 题目：输入两个正整数m和n，求其最大公约数和最小公倍数。 辗转相除余数为0时，除数就是最大公约数
	 */
	protected static void sixth(int m, int n) {
		int biggestConvention;
		int leastMultiple = m * n;
		int temp;
		if (n < m) {
			temp = n;
			n = m;
			m = temp;
		}
		int smallInt = m;
		int bigInt = n;
		while (n % m != 0) {
			temp = n % m;
			n = m;
			m = temp;
		}
		biggestConvention = m;
		leastMultiple = leastMultiple / m;
		System.out.println(smallInt + "," + bigInt + "的最大公约数为" + biggestConvention);
		System.out.println(smallInt + "," + bigInt + "的最小公倍数为" + leastMultiple);
	}

	/**
	 * 题目：输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。 String的toCharArray方法，可以把字符串转换为数组
	 */
	protected static void seventh(String str) {
		int number = 0;
		int english = 0;
		int space = 0;
		int others = 0;
		char[] strCharArray = str.toCharArray();
		for (char chars : strCharArray) {
			if (chars >= '0' && chars <= '9') {
				number++;
			} else if ((chars >= 'a' && chars <= 'z') || (chars >= 'A' && chars <= 'Z')) {
				english++;
			} else if (chars == ' ') {
				space++;
			} else {
				others++;
			}
		}
		System.out.println(str + "含有数字" + number + "  含有字母" + english + "  含有空格" + space + "  其他" + others);
	}

	/**
	 * 题目：求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。
	 * 例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加有键盘控制。
	 */
	protected static void eighth(int a) {
		Scanner sc = new Scanner(System.in);
		System.out.println("你希望几个数相加呢？");
		int number = sc.nextInt();
		int sum = 0;
		int addition = 0;
		for (int i = 0; i < number; i++) {
			addition += (int) (a * Math.pow(10, i));
			sum = sum + addition;
		}
		System.out.println(number + "个数相加的和为：" + sum);
	}

	/**
	 * 题目：一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1＋2＋3.编程找出1000以内的所有完数。
	 */
	protected static void nineth(int number) {
		List<ArrayList<Integer>> outerList = new ArrayList<ArrayList<Integer>>();
		ArrayList<Integer> innerList = null;
		for (int i = 1; i <= number; i++) {
			innerList = new ArrayList<Integer>();
			for (int j = 1; j <= i; j++) {
				if (i % j == 0) {
					innerList.add(j);
				}

			}
			outerList.add(innerList);

		}
		System.out.println(number + "以内的完数有：");
		for (int i = 1; i <= outerList.size(); i++) {
			int sum = 0;
			for (int j = 1; j <= outerList.get(i - 1).size(); j++) {
				sum += outerList.get(i - 1).get(j - 1);
				if (sum == i) {
					System.out.print(i + ",");
				}
			}
		}
	}

	/**
	 * 题目：一球从100米高度自由落下，每次落地后反跳回原高度的一半； 再落下，求它在 第10次落地时，共经过多少米？第10次反弹多高？
	 */
	protected static void tenth(Long highth, int bounceNumber) {
		Long distance = 0L;
		Long bounceHigh = highth;
		for (int i = 0; i < bounceNumber; i++) {
			distance = bounceHigh + distance;
			bounceHigh = bounceHigh / 2;
		}
		System.out.println("第" + bounceNumber + "次落地，球共经过" + distance + "米");
		System.out.println("第" + bounceNumber + "次反弹的高度为：" + bounceHigh);
	}
}

2. 11–20题
   18题做的时候遇到了一些阻碍,就先跳过了
   最后会将18题的解题代码单独分享出来

package fifties_practice;

import java.util.ArrayList;
import java.util.Scanner;

/**
 * java基础50题 11--20
 * 
 * @author xmr
 *
 */
public class Eleven_To_Twenty {
	public static void main(String[] args) {
		// eleven(6);
		// twelve();
		// thirteen();
		// fourteen(2022, 2, 20);
		// fifteen(16, 19, 13);
		// sixteen();
		// seventeen(1,10);
		//  Eighteen
		// nineteen(10);
		// twenty(10);
	}

	/**
	 * 题目：有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？ 全排列减去不符合条件的
	 */
	protected static void eleven(int number) {
		int sum = 0;
		for (int i = 1; i <= number; i++) {
			for (int j = 1; j <= number; j++) {
				if (i == j) {
					continue;
				}
				for (int k = 1; k <= number; k++) {
					if (k == i || k == j) {
						continue;
					}
					sum++;
					int threeDigits = i * 100 + k * 10 + j;
					System.out.print(" " + threeDigits);
					if (sum % 5 == 0) {
						System.out.println();
					}
				}
			}
		}
		System.out.println("互不相同且无重复数字的三位数共有" + sum + "个");
	}

	/**
	 * 题目：企业发放的奖金根据利润提成。利润(I)低于或等于10万元时，奖金可提10%；
	 * 利润高于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可可提成7.5%；
	 * 20万到40万之间时，高于20万元的部分，可提成5%；40万到60万之间时高于40万元的部分，可提成3%；
	 * 60万到100万之间时，高于60万元的部分，可提成1.5%， 高于100万元时，超过100万元的部分按1%提成
	 * 从键盘输入当月利润I，求应发放奖金总数？
	 */
	protected static void twelve() {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入企业当月的利润");
		Double profit = sc.nextDouble();
		double bonus = 0;
		if (profit <= 100000 && profit >= 0) {
			bonus = profit * 0.1;
		} else if (profit <= 200000) {
			bonus = 100000 * 0.1 + (profit - 100000) * 0.075;
		} else if (profit <= 400000) {
			bonus = 100000 * 0.1 + (200000 - 10) * 0.75 + (profit - 200000) * 0.05;
		} else if (profit <= 600000) {
			bonus = 100000 * 0.1 + (200000 - 10) * 0.75 + (400000 - 200000) * 0.05 + (profit - 400000) * 0.03;
		} else if (profit <= 1000000) {
			bonus = 100000 * 0.1 + (200000 - 10) * 0.75 + (400000 - 200000) * 0.05 + (600000 - 400000) * 0.03
					+ (profit - 600000) * 0.015;
		} else if (profit >= 1000000) {
			bonus = 100000 * 0.1 + (200000 - 10) * 0.75 + (400000 - 200000) * 0.05 + (600000 - 400000) * 0.03
					+ (1000000 - 600000) * 0.015 + (profit - 1000000) * 0.001;
		} else {
			System.out.println("利润不正确");
		}
		System.out.println("应发放的奖金总额为:" + bonus);
	}

	/**
	 * 题目：一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？ 完全平方数:开根号所得的值为整数
	 */
	protected static void thirteen() {
		for (int i = 0; i <= 100000; i++) {
			if (isCompletelysquare(i + 100) && isCompletelysquare(i + 268)) {
				System.out.println("该数为" + i);
			}
		}
	}

	protected static boolean isCompletelysquare(int x) {
		boolean flag = false;

		for (int j = 1; j <= x; j++) {
			if (j * j == x) {
				flag = true;
			}
		}

		return flag;
	}

	/**
	 * 题目：输入某年某月某日，判断这一天是这一年的第几天？ 注意: 闰年的二月多一天
	 */
	protected static void fourteen(int year, int month, int day) {
		int daysOfYear = 0;
		if (month == 1) {
			daysOfYear = day;
		} else {
			if (isLeapYear(year)) {
				switch (month) {
				case 2:
					daysOfYear = 31 + day;
					break;
				case 3:
					daysOfYear = 31 + 29 + day;
					break;
				case 4:
					daysOfYear = 31 + 29 + 31 + day;
					break;
				case 5:
					daysOfYear = 31 + 29 + 31 + 30 + day;
					break;
				case 6:
					daysOfYear = 31 + 29 + 31 + 30 + 31 + day;
					break;
				case 7:
					daysOfYear = 31 + 29 + 31 + 30 + 31 + 30 + day;
					break;
				case 8:
					daysOfYear = 31 + 29 + 31 + 30 + 31 + 30 + 31 + day;
					break;
				case 9:
					daysOfYear = 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + day;
					break;
				case 10:
					daysOfYear = 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + day;
					break;
				case 11:
					daysOfYear = 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + day;
					break;
				case 12:
					daysOfYear = 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + day;
					break;
				default:
					;
				}

			}
			if (!isLeapYear(year)) {
				switch (month) {
				case 2:
					daysOfYear = 31 + day;
					break;
				case 3:
					daysOfYear = 31 + 28 + day;
					break;
				case 4:
					daysOfYear = 31 + 28 + 31 + day;
					break;
				case 5:
					daysOfYear = 31 + 28 + 31 + 30 + day;
					break;
				case 6:
					daysOfYear = 31 + 28 + 31 + 30 + 31 + day;
					break;
				case 7:
					daysOfYear = 31 + 28 + 31 + 30 + 31 + 30 + day;
					break;
				case 8:
					daysOfYear = 31 + 28 + 31 + 30 + 31 + 30 + 31 + day;
					break;
				case 9:
					daysOfYear = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + day;
					break;
				case 10:
					daysOfYear = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + day;
					break;
				case 11:
					daysOfYear = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + day;
					break;
				case 12:
					daysOfYear = 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + day;
					break;
				default:
					;
				}
			}
		}
		System.out.println("这是一年的第" + daysOfYear + "天");
	}

	protected static boolean isLeapYear(int year) {
		boolean flag = false;
		if (year % 400 == 0) {
			flag = true;
		} else if (year % 100 == 0) {
			flag = false;
		} else if (year % 4 == 0) {
			flag = true;
		} else {
			flag = false;
		}
		return flag;
	}

	/**
	 * 题目：输入三个整数x,y,z，请把这三个数由小到大输出。 令x,y,z依次递增
	 */
	protected static void fifteen(int x, int y, int z) {
		int temp = 0;
		if (x >= y) {
			temp = x;
			x = y;
			y = temp;
		}
		if (x >= z) {
			temp = x;
			x = z;
			z = temp;
		}
		if (y >= z) {
			temp = y;
			y = z;
			z = temp;
		}
		System.out.println("from small to large:" + x + "," + y + "," + z);
	}

	/**
	 * 题目：输出9*9口诀。
	 */
	protected static void sixteen() {
		for (int i = 1; i <= 9; i++) {
			for (int j = 1; j <= i; j++) {
				System.out.print(i + "*" + j + "=" + i * j + "  ");
			}
			System.out.println();
		}
	}

	/**
	 * 题目：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个 第二天早上又将剩下的桃子吃掉一半，又多吃了一个。
	 * 以后每天早上都吃了前一天剩下的一半零一个。 到第10天早上想再吃时，见只剩下一个桃子了。 求第一天共摘了多少。
	 */
	protected static void seventeen(int remaining, int days) {
		for (int i = 1; i < days; i++) {
			remaining = (remaining + 1) * 2;
		}
		System.out.println("第一天摘了" + remaining + "个");
	}

	/**
	 * 题目：两个乒乓球队进行比赛，各出三人。甲队为a,b,c三人，乙队为x,y,z三人。 以抽签决定比赛名单。有人向队员打听比赛的名单。
	 * a说他不和x比，c说他不和x,z比，请编程序找出三队赛手的名单。
	 */
	protected static void  eighteen() {
		// ========c-->y
		// ========a-->z
		// ========b-->x
		// 看起来非常简单的题,转换成程序语言却没那么简单,只能换一种解决思路
	

	}

	/**
	 * 题目：打印出如下图案（菱形）              
	 *
	 */
	protected static void nineteen(int rows) {
		// ---------------打印菱形的上半部分-----------------
		for (int i = 0; i < rows; i++) {
			for (int j = 0; j < rows * 2; j++) {
				if (j < rows - i) {
					System.out.print(" ");
				}
				if ((j >= rows - i) && (j <= rows + i)) {
					System.out.print("*");
				}
			}
			System.out.println();
		}
		// ---------------打印菱形的下半部分------------------
		for (int i = 0; i < rows; i++) {
			System.out.print(" ");
			for (int j = 0; j < 2 * rows - i - 1; j++) {
				if (j < i)
					System.out.print(" ");
				if (j >= i && j < 2 * rows - i - 2)
					System.out.print("*");
			}
			System.out.println();
		}
	}

	/**
	 * 题目：有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13... 求出这个数列的前20项之和。
	 * 注意分析分子分母的规律(分子的值是前一项的分母...后一项的分子分母是前两项的和)
	 */
	protected static void twenty(int n) {
		int[] molecular = new int[n];
		int[] denominator = new int[n];
		double sum = 0;
		if (n == 1) {
			molecular[0] = 1;
			denominator[0] = 2;
			sum = denominator[0] / molecular[0];
			System.out.println("前" + n + "项的结果为" + sum);
			return;
		}

		molecular[0] = 1;
		denominator[0] = 2;
		molecular[1] = denominator[0];
		denominator[1] = 3;
		sum = ((double) denominator[0] / (double) molecular[0]) + ((double) denominator[1] / (double) molecular[1]);
		for (int i = 2; i < n; i++) {
			molecular[i] = molecular[i - 1] + molecular[i - 2];
			denominator[i] = denominator[i - 1] + denominator[i - 2];
			sum = sum + ((double) denominator[i] / (double) molecular[i]);
		}
		System.out.println("前" + n + "项的结果为" + sum);
		System.out.println((double) 3 / (double) 2);
	}

}

3. 21-30题

package fifties_practice;

import java.util.Arrays;

import scala.util.Random;

public class TwentyOne_To_Thirty {
	public static void main(String[] args) {
		// twentyOne(20);
		// twentyTwo(5);
		// twentyThree(10,5);
		// twentyFour(1234);
		// twentyFive(12321);
		// twentySix("sunday");
		// twentySeven();
		// twentyEight(39);
		// twentyNine(1);
		// thrity(30,5);
	}

	/**
	 * 题目：求1+2!+3!+...+20!的和
	 */
	protected static void twentyOne(int n) {
		int sum = 0;
		int factorial = 1;
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= i; j++) {
				factorial = factorial * j;
			}
			sum += factorial;
			factorial = 1;
		}
		System.out.println("1+2!+..." + n + "!" + "的和为" + sum);
	}

	/**
	 * 题目：利用递归方法求5!
	 */
	protected static void twentyTwo(int n) {
		int factorial = 1;
		for (int i = 1; i <= 5; i++) {
			factorial = factorial * i;
		}
		System.out.println(n + "的阶乘是:" + factorial);
	}

	/**
	 * 题目：有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。 问第4个人岁数，他说比第3个人大2岁。 问第三个人，又说比第2人大两岁。
	 * 问第2个人，说比第一个人大两岁。 最后问第一个人，他说是10岁。请问第五个人多大？
	 */
	protected static void twentyThree(int firstAge, int numbersOfPeople) {
		int lastAge = firstAge;
		for (int i = 1; i < numbersOfPeople; i++) {
			lastAge += 2;
		}
		System.out.println("最后一个人的年纪是:" + lastAge);
	}

	/**
	 * 题目：给一个不多于5位的正整数， 要求：一、求它是几位数，二、逆序打印出各位数字。
	 */
	protected static void twentyFour(Integer positiveInteger) {
		char[] integerCharArray = positiveInteger.toString().toCharArray();
		System.out.println("正整数" + positiveInteger + "的位数是:" + integerCharArray.length);
		for (int i = integerCharArray.length - 1; i >= 0; i--) {
			System.out.print(integerCharArray[i] + " ");
		}
	}

	/**
	 * 题目：一个5位数，判断它是不是回文数。 即12321是回文数，个位与万位相同，十位与千位相同。
	 */
	protected static void twentyFive(int numbers) {
		boolean flag = false;
		if ((numbers / 10000 == numbers % 10) && (numbers % 10000 / 1000 == numbers % 100 / 10)) {
			System.out.println(numbers + "是一个回文数");
			return;
		}
		System.out.println(numbers + "不是一个回文数");
	}

	/**
	 * 题目：请输入星期几的第一个字母来判断一下是星期几， 如果第一个字母一样，则继续 判断第二个字母。 星期一:monday 星期二:tuesday
	 * 星期三:wednesday 星期四:thursday 星期五:firday 星期六:saturday 星期日:sunday
	 * 我觉得按照题目给定的方式并不能判断出是星期几...除非输入的参数是正确的.不过不管它,就这么算好了
	 */
	protected static void twentySix(String week) {
		char[] weekCharArray = week.toCharArray();
		if(weekCharArray.length < 6) {
			System.out.println("输入的参数有误!");
			return;
		}
		if (weekCharArray[0] == 'm') {
			System.out.println(week + "是星期一");
			return;
		}
		if (weekCharArray[0] == 'w') {
			System.out.println(week + "是星期三");
			return;
		}
		if (weekCharArray[0] == 'f') {
			System.out.println(week + "是星期五");
			return;
		}
		if (weekCharArray[0] == 't') {
			if (weekCharArray [1] == 'u') {
				System.out.println(week + "是星期二");
				return;
			}
			System.out.println(week + "是星期五");
			return;
		}
		if (weekCharArray[0] == 's') {
			if (weekCharArray [1] == 'u') {
				System.out.println(week + "是星期日");
				return;
			}
			System.out.println(week + "是星期六");
			return;
		}

	}
    
	/**
	 * 题目：求100之内的素数
	 * 直接调用之前写的方法就好了(第二题的方法)
	 */
	protected static void twentySeven() {
		One_To_Ten.second(0,100);
	}
	
    /**
     * 题目：对10个数进行排序
     * 为了增加程序可扩展性,我实现的功能是对输入参数个随机数进行排序
     */
	protected static void twentyEight(int number) {
        int [] array = new int [ number ];
        for (int i = 0; i < array.length; i++) {
    	    array [i] =new Random().nextInt(500);
        }
        Arrays.sort(array);
        System.out.println("排序之后的结果为:");
        for (int i = 0; i<array.length; i++) {
        	System.out.print(array[i] + " ");
        	if ((i+1) % 5 == 0) {
        		System.out.println();
        	}
        }
        
	}
    
	/**
	 * 题目：求一个3*3矩阵对角线元素之和
	 * 我写的程序是求n*n阶矩阵对角线元素之和
	 */
	protected static void twentyNine(int number) {
		int [] [] array = new int [number] [number];
		
		//---------------对矩阵里的元素赋值----------------
		for (int i = 0; i < array.length; i++) {
			for (int j = 0; j < array[i].length; j++) {
				array [i] [j] = new Random().nextInt(500);
			}
		}
		
		//---------遍历矩阵元素,求对角线元素之和-------------
		int sum = 0;
        for (int i = 0; i < number; i++) {
        	for (int j = 0;j < number; j++) {
        		if ( i == j) {
        		  sum += array [i] [j];  
        		}
        	}
        }
        System.out.println(number + "*" + number + "阶矩阵的对角线元素之和为" +sum);
	}
    
	/**
	 * 题目：有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。
	 */
	protected static void thrity(int number,int insertNumber) {
		int [] array = new int [number];
		//---------首先对长度为number的数组赋值并排序---------------
		for (int i = 0; i < array.length; i++) {
			array [i] = new Random().nextInt(500);
		}
		Arrays.sort(array);
		
		//---------重新定义一个数组,长度为当前数组加1,值为当前数组值,和新插入的值------------
		int [] newArray =new int [number + 1];
		for (int i = 0; i<array.length;i++) {
			newArray [i] =array [i];
		}
		newArray [newArray.length - 1] = insertNumber;
		Arrays.sort(newArray);
		
		//--------遍历排序好的数组,检验结果是否正确---------------
		for (int i = 0; i < newArray.length; i++) {
			System.out.print(newArray [i] + " ");
			if ((i + 1) % 5 == 0) {
				System.out.println();
			}
		}

	}
}

4. **31---40**
package fifties_practice;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;

public class ThirtyOne_To_Forty {
	public static void main(String[] args) {
		// thirtyOne("你是我的眼带我阅读浩瀚的书海");
		// thirtyTwo(432544553);
		// thirtyThree(100);
		// thirtyFour();
		// thirtyFive(new int [] {6,2,76,43,54,34,5,8,14,15,16});
		// thirtySix(20,4);
		// thirtySeven(100);
		// thirtyEight("多么无聊的一道题");
		// thirtyNine(1000000000);
		// forty(new String [] {"sdf","sas","sfds","23r","dsffg"});
	}

	/**
	 * 题目：将一个数组逆序输出。 倒序遍历即可,为了方便起见，参数输入一个String， 在程序里将其转换为数组，对该数组进行逆序输出
	 */
	protected static void thirtyOne(String args) {
		char[] argsCharArray = args.toCharArray();
		for (int i = argsCharArray.length - 1; i >= 0; i--) {
			System.out.print(argsCharArray[i] + " ");

		}
	}

	/**
	 * 题目：取一个整数a从右端开始的4～7位。
	 */
	protected static void thirtyTwo(int number) {
		if (number < 1000000) {
			System.out.println("输入的数字不符合要求");
			return;
		}
		char[] numberCharArray = new Integer(number).toString().toCharArray();
		System.out.println("整数" + number + "从右端开始的4—7位分别是：");
		for (int i = numberCharArray.length - 1 - 3; i >= numberCharArray.length - 7; i--) {
			System.out.print(numberCharArray[i] + "  ");
		}
	}

	/**
	 * 题目：打印出杨辉三角形 1 1 1 1 2 1 1 3 3 1 1 4 4 6 1
	 * 分析：两边的数字都为1，中间的数字等于上一行相对应位置和前一个数之和
	 */
	protected static void thirtyThree(int rows) {
		int[][] yangHui = new int[rows][rows];
		// -----------对杨辉三角形赋值------------------
		for (int i = 0; i < rows; i++) {
			yangHui[i][0] = yangHui[i][i] = 1;
		}
		for (int i = 2; i < rows; i++) {
			for (int j = 1; j < i; j++) {
				yangHui[i][j] = yangHui[i - 1][j - 1] + yangHui[i - 1][j];
			}
		}
		// -----------输出杨辉三角形-------------------
		for (int i = 0; i < rows; i++) {
			for (int j = 0; j <= i; j++) {
				System.out.print(yangHui[i][j] + " ");
			}
			System.out.println();
		}
	}

	/**
	 * 题目：输入3个数a,b,c，按大小顺序输出。 题目同第15题,直接调用15题的方法即可
	 */
	protected static void thirtyFour() {
		Eleven_To_Twenty.fifteen(34, 3, 2);
	}

	/**
	 * 题目：输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。
	 */
	protected static void thirtyFive(int[] array) {
		int[] arrayCopy = new int[array.length];

		for (int i = 0; i < array.length; i++) {
			arrayCopy[i] = array[i];
		}
		Arrays.sort(array);
		// ---------最大的与第一个元素交换,最小的与最后一个元素交换----------
		int temp = 0;
		for (int i = 0; i < arrayCopy.length; i++) {
			if (arrayCopy[i] == array[array.length - 1]) {
				temp = arrayCopy[0];
				arrayCopy[0] = arrayCopy[i];
				arrayCopy[i] = temp;
			}
			if (arrayCopy[i] == array[0]) {
				temp = arrayCopy[arrayCopy.length - 1];
				arrayCopy[arrayCopy.length - 1] = arrayCopy[i];
				arrayCopy[i] = temp;
			}
		}

		// -----------------输出数组----------------------
		for (int i = 0; i < arrayCopy.length; i++) {
			System.out.print(arrayCopy[i] + " ");
			if ((i + 1) % 5 == 0) {
				System.out.println();
			}
		}
	}

	/**
	 * 题目：有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数
	 */
	protected static void thirtySix(int n, int m) {
		if (n < 2 * m) {
			System.out.println("输入参数有误!!!");
			return;
		}

		// --------------定义数组并赋值--------------
		int[] array = new int[n];
		for (int i = 0; i < array.length; i++) {
			array[i] = new Random().nextInt(500);
		}
		int[] arrayTailM = new int[m];
		for (int i = n - 1; i > n - 1 - m; i--) {
			arrayTailM[n - 1 - i] = array[i];
		}
		// ----------前面的向后移,后面的向前面补位--------
		for (int i = 0; i < n - m; i++) {
			array[i + m] = array[i];
		}
		for (int i = n - 1; i > n - 1 - m; i--) {
			array[i] = arrayTailM[n - i - 1];
		}
		// --------输出最终的数组-------------
		for (int i = 1; i <= array.length; i++) {
			System.out.print(array[i - 1] + "  ");
			if (i % 5 == 0) {
				System.out.println();
			}
		}
	}

	/**
	 * 题目：有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数）， 凡报到3的人退出圈子，问最后留下的是原来第几号的那位。
	 */
	protected static void thirtySeven(int n) {
		// ---------定义数组变量标识某人是否还在圈内------------
		boolean[] isIn = new boolean[n];
		for (int i = 0; i < isIn.length; i++)
			isIn[i] = true;
		int inCount = n;
		int countNum = 0;
		int index = 0;
		while (inCount > 1) {
			if (isIn[index]) {
				countNum++;
				if (countNum == 3) {
					countNum = 0;
					isIn[index] = false;
					inCount--;
				}
			}
			index++;
			if (index == n)
				index = 0;
		}
		for (int i = 0; i < n; i++)
			if (isIn[i])
				System.out.println("留下的是：" + (i + 1));
	}
	

	/**
	 * 题目：写一个函数，求一个字符串的长度，在main函数中输入字符串，并输出其长度。 极其愚蠢的一个题....
	 */
	protected static void thirtyEight(String str) {
		// System.out.println("输入的字符串的 长度为:" + str.length());
		System.out.println("输入的字符串的长度为:" + str.toCharArray().length);
	}

	/**
	 * 编写一个函数，输入n为偶数时，调用函数求1/2+1/4+...+1/n, 当输入n为奇数时，调用函数1/1+1/3+...+1/n
	 */
	protected static void thirtyNine(int n) {
		double sum = 0D;
		if (n % 2 == 0) {
			for (int i = 2; i <= n; i += 2) {
				sum = sum + ((double) 1 / (double) i);
			}
			System.out.println(n + "是一个偶数,和为" + sum);
			return;
		}
		if (n % 2 != 0) {
			for (int i = 1; i <= n; i += 2) {
				sum = sum + ((double) 1 / (double) i);
			}
			System.out.println(n + "是一个奇数,和为" + sum);
		}
	}

	/**
	 * 题目：字符串排序。
	 */
	protected static void forty(String[] args) {
		Set<String> set = new HashSet<String>();
		for (int i = 0; i < args.length; i++) {
			set.add(args[i]);
		}
		System.out.println("字符串数组排序过后的顺序是:");
		for (String str : set) {
			System.out.print(str + "  ");
		}
	}
}

5.** 41–50题**

package fifties_practice;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.Scanner;

public class FortyOne_To_Fifty {
	public static void main(String[] args) throws IOException {
		// fortyOne(5);
		// fortyTwo();
		// fortyThree();
		// fortyFour(100);
		// fortyFive(23);
		// fortySix("I love you","money");
		// fortySeven(20);
		// fortyEight(1000);
		// fortyNine("I am a pig");
		// fifty(1);

	}

	/**
	 * 题目：海滩上有一堆桃子，五只猴子来分。 第一只猴子把这堆桃子凭据分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。
	 * 第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份，
	 * 第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？
	 */
	protected static void fortyOne(int monkeys) {
		int sum = 1;
		for (int i = 1; i <= monkeys; i++) {
			sum = sum * 5 + 1;
		}
		System.out.println("海滩上原来桃子的个数是:" + sum);
	}

	/**
	 * 题目：809*??=800*??+9*??+1 其中??代表的两位数,8*??的结果为两位数，9*??的结果为3位数。
	 * 求??代表的两位数，及809*??后的结果。 出这道题的人怕是个弱智吧???
	 */
	protected static void fortyTwo() {
		int number = 0;
		for (int i = 10; i <= 99; i++) {
			if (8 * i > 99) {
				continue;
			}
			if (9 * i < 100) {
				continue;
			}
			if ((809 * i == 800 * i + 9 * i + 1)) {
				number = i;
				int result = 809 * number;
				System.out.println("??代表的两位数是:" + number + "    809*??的结果是:" + result);
			}
		}
		if (number == 0) {
			System.out.println("没有符合要求的数!!!");
		}

	}

	/**
	 * 题目：求0—7所能组成的奇数个数。 奇数,末位为1,3,5,7
	 */
	protected static void fortyThree() {
		int n = 8;
		int sum = 0;
		sum += n / 2;
		sum += (n - 1) * n / 2;
		sum += (n - 1) * n * n / 2;
		sum += (n - 1) * n * n * n / 2;
		sum += (n - 1) * n * n * n * n / 2;
		sum += (n - 1) * n * n * n * n * n / 2;
		sum += (n - 1) * n * n * n * n * n * n / 2;
		System.out.println("0--7所能组成的奇数个数为:" + sum);
	}

	/**
	 * 题目：一个偶数总能表示为两个素数之和。 这个题同样是一道弱智题....我他娘的能证明出这个东西还敲代码干嘛, 早成了世界最顶尖的数学大师了...
	 * 因此,我只能尝试证明小于我输入的偶数范围内的全部偶数都能表示成两个素数的和 或者是任何一个输入的整数都能表示成两个素数的和
	 */
	protected static void fortyFour(int even) {
		// ----证明我输入偶数能表示成为两个素数的和,素数通过第二题写的方法得到
		List<Integer> list = One_To_Ten.second(0, even);
		boolean flag = false;
		int mark = 0;
		for (int j = 0; j < list.size(); j++) {
			int outer = list.get(mark);
			for (int k = 0; k < list.size(); k++) {
				int inner = list.get(k);
				if (outer + inner == even) {
					flag = true;
					System.out.println("输入的偶数" + even + "能够表示为两个素数之和!");
					return ;
				}
			}
			mark++;
		}
		System.out.println("输入的偶数" + even + "不能够表示为两个素数之和!");
	}

	/**
	 * 题目：判断一个素数能被几个9整除
	 */
	protected static void fortyFive(int primeNumber) {
		// 因为前面已经有好几个筛选素数的方法,所以就不加以筛选,默认输入进来的数是素数
		int result = primeNumber / 9;
		System.out.println("该素数" + primeNumber + "能被" + result + "个9整除");
	}

	/**
	 * 题目：两个字符串连接程序
	 */
	protected static void fortySix(String str1, String str2) {
		StringBuffer sb = new StringBuffer();
		String str = sb.append(str1).append(str2).toString();
		System.out.println("两个字符串拼接的结果为:" + str);
	}

	/**
	 * 题目：读取7个数（1—50）的整数值，每读取一个值，程序打印出该值个数的*。
	 */
	protected static void fortySeven(int n) {
		for (int i = 0; i < n; i++) {
			int number = new Random().nextInt(49) + 1;
			for (int j = 0; j <= number; j++) {
				System.out.print("*");
			}
			System.out.println();
		}
	}

	/**
	 * 题目：某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，
	 * 加密规则如下：每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。
	 */
	protected static void fortyEight(Integer number) {
        int encryption = 0;
        int temp = 0;
        int bit = number % 10;
        int ten = number % 100 / 10;
        int hundreds = number % 1000 /100;
        int thousands = number / 1000;
        bit = (bit + 5) % 10;
        ten = (ten + 5) % 10;
        hundreds = (hundreds + 5) % 10;
        thousands =(thousands +5) % 10;
        temp = bit ;
        bit = thousands;
        thousands =temp;
        temp = ten;
        ten = hundreds;
        hundreds = temp;
        encryption = thousands * 1000 + hundreds * 100 +ten * 10 +bit;
        System.out.println(number + "加密之后的结果为:" +encryption);
	}

	/**
	 * 题目：计算字符串中子串的个数
	 */
	protected static void fortyNine(String fatherStr) {
		char[] strCharArray = fatherStr.toCharArray();
		int count = 1;
		for (char c : strCharArray) {
			if (c == ' ') {
				count++;
			}
		}
		System.out.println("字符串" + fatherStr + "的子串个数为:" + count);
	}

	/**
	 * 题目：有五个学生，每个学生有3门课的成绩，从键盘输入以上数据（包括学生号，姓名，三门课成绩），计算出平均成绩，
	 * 将原有的数据和计算出的平均分数存放在磁盘文件"stud"中。
	 * @throws IOException 
	 */
	protected static void fifty(int studentNumber) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String [] sutdentID = new String [studentNumber];
		String [] name = new String [studentNumber];
		String [] chinese = new String [studentNumber];
		String [] math = new String [studentNumber];
		String [] english = new String [studentNumber];
		int [] average = new int [studentNumber];
		for (int i = 0; i < studentNumber; i++) {
			System.out.println("请输入第" + i + 1 + "个同学的学号");
			sutdentID[i] =br.readLine();
			System.out.println("请输入第" + i + 1 + "个同学的姓名");
		    name[i] = br.readLine();
			System.out.println("请输入第" + i + 1 + "个同学的成绩");
		    chinese [i]= br.readLine();
		    math [i] = br.readLine();
			english [i] = br.readLine();
		    average [i]= Integer.valueOf(chinese [i] + math [i] + english [i]) / 3;
		}
		try {
			FileWriter fw = new FileWriter("d://stud");
			BufferedWriter bw =new BufferedWriter(fw);
			for(int i = 0 ;i < studentNumber ; i ++) {
				bw.write(sutdentID[i]+" ");
				bw.write(name [i] + " ");
				bw.write(chinese [i] + " ");
				bw.write(math [i]+" ");
				bw.write(english [i] +" ");
				bw.write(average [i] + " ");
				bw.flush();
			}
			bw.close();
		} catch (IOException e) {
			e.printStackTrace();
		}

	}
}

6.第 18 题

package fifties_practice;

import java.util.ArrayList;



/**
 * 题目：两个乒乓球队进行比赛，各出三人。甲队为a,b,c三人，乙队为x,y,z三人。 以抽签决定比赛名单。有人向队员打听比赛的名单。
 * a说他不和x比，c说他不和x,z比，请编程序找出三队赛手的名单。
 */
public class Eighteen {
	// ========c-->y
	// ========a-->z
	// ========b-->x
	// 看起来非常简单的题,转换成程序语言却没那么简单,只能换一种解决思路
	String a;
	String b;
	String c;

	public static void main(String [] args) {
		String[] teamB = { "x", "y", "z" };
		ArrayList<Eighteen> list = new ArrayList<Eighteen>();
		for (int i = 0; i < 3; i++)
			for (int j = 0; j < 3; j++)
				for (int k = 0; k < 3; k++) {
					Eighteen eighteen = new Eighteen(teamB[i], teamB[j], teamB[k]);
					if (!eighteen.a.equals(eighteen.b) && !eighteen.a.equals(eighteen.c)
							&& !eighteen.b.equals(eighteen.c) && !eighteen.a.equals("x") && !eighteen.c.equals("x")
							&& !eighteen.c.equals("z"))
						list.add(eighteen);
				}
		for (Object obj : list)
			System.out.println(obj);
	}

	private Eighteen(String a, String b, String c) {
		this.a = a;
		this.b = b;
		this.c = c;
	}
	public String toString(){
		return "a的对手是"+a+"  "+"b的对手是"+b+"  "+"c的对手是"+c;
	}

}

编写时,我尽量使用规范的命名
和规范的代码格式
可能一些问题的解决方法并不是太好
欢迎交流.