------- android培训、java培训、期待与您交流！ ----------
此博仅仅贴一些练习的代码，会有少量注释说明，不定期添加。
1.打印螺旋数组。
/*
题目：打印螺旋数组。
Case：
1 2 3 4
12 13 14 5
11 16 15 6
10 9 8 7
思路：
1.判断循环次数，即：有几圈;
2.每次循环中都遵循相同的打印规律，即：上横(左到右)-->右竖(上到下)-->下横(右到左)-->左竖(下到上);
3.定义需要写入的值value，初始化为0，每赋值一次，自增1;
4.遍历二维数组，换行打印;
Ps：为了使代码更具普遍性，定义一个变量size，用于表示数阵的边长。
*/
class SpiralArray
{
public static void main(String[] args)
{
int size = 4;//定义一个size变量，用于接收数阵边长值
int[][] arr = ArrayTool.setArray(size);//调用数组工具类中的setArray(int size)方法，将得到的二维数组赋给arr
ArrayTool.printArr(arr);//调用数组工具类中的打印数组方法
}
}
//之前思路过于麻烦，代码就不写了。
class ArrayTool//定义数组工具类
{
public static int[][] setArray(int size)//传入数阵边长，返回符合规则的二维数组
{
int loopNum = loopNum(size);//得到圈数(循环最大次数)
int[][] arr = new int[size][size];//定义二维数组
int num = 1;//定义循环次数，初始化为1(最大值为loopNum)
int value = 1;//定义写入的值，从1开始
// int h = 0;//行指针
// int l = 0;//列指针
for (;num<=loopNum;num++ )//控制循环次数
{
for (int h=num-1,l=num-1;l<=size-num ;l++ )//每次循环的上横1
{
arr[h][l] = value++;
}
for (int h=num,l=size-num;h<=size-num ;h++ )//每次循环的右竖1
{
arr[h][l] = value++;
}
for (int h=size-num,l=h-1;l>=num-1 ;l-- )//每次循环的下横2
{
arr[h][l] = value++;
}
for (int h=size-num-1,l=num-1;h>=num ;h-- )//每次循环的左竖1
{
arr[h][l] = value++;
}
}
return arr;
}
public static int loopNum(int size)//根据数阵的大小(边长)判断几圈(即，循环次数)
{
return (size%2==0)?(size/2):((size/2)+1);//三元运算符，根据数阵边长的奇偶值，得到所需循环次数
}
private static void printArr(int[] arr)//定义打印一维数组方法
{
for (int x=0;x<arr.length ;x++ )
{
System.out.print(arr[x]+"\t");
}
}
public static void printArr(int[][] arr)//重载，定义打印二维数组方法
{
for (int x=0;x<arr.length ;x++ )
{
printArr(arr[x]);//函数间调用
System.out.println();
}
}
}
size=4时的运行结果为：
size=9时的运行结果为：
2.螺旋数阵(功能扩充)
/*
题目：打印螺旋数组。
Case：
1 2 3 4
12 13 14 5
11 16 15 6
10 9 8 7
思路：
1.判断循环次数，即：有几圈;
2.每次循环中都遵循相同的打印规律，即：上横(左到右)-->右竖(上到下)-->下横(右到左)-->左竖(下到上);
3.定义需要写入的值value，初始化为0，每赋值一次，自增1;
4.遍历二维数组，换行打印;
Ps：
1.为了使代码更具普遍性，定义一个变量size，用于表示数阵的边长。
2.为了增强代码的功能，将长宽相等的情况提取为任意row、column的情况。
想到可以将原size用row(行)和column(列)表示，扩充代码功能。
*/
class SpiralArray
{
public static void main(String[] args)
{
int row = 7;//定义非规则数阵的长和宽
int column = 5;
int size = 9;//定义规则数阵(长宽相等)的边长
int[][] arr1 = ArrayTool.setArray(size);//调用数组工具类中的setArray(int size)方法，将得到的二维数组赋给arr
int[][] arr2 = ArrayTool.setArray(row,column);//调用数组工具类中的setArray(int row,int column)方法，将得到的二维数组赋给arr
ArrayTool.printArr(arr1);//调用数组工具类中的打印数组方法
System.out.println("*****************************");
ArrayTool.printArr(arr2);
}
}
//之前思路过于麻烦，代码就不写了。
class ArrayTool//定义数组工具类
{
public static int[][] setArray(int size)//函数的重载。传入数阵边长，调用setArray(int row,int column)方法，返回符合规则的二维数组
{
int row = size;//定义行、列，分别赋值为size
int column = size;
int[][] arr = setArray(row,column);//函数间调用，重载
return arr;
}
public static int[][] setArray(int row,int column)//传入数阵的row(行)和列(column)，返回符合规则的二维数组
{
if (row<=0 || column<=0)//如果输入了不合理的数值，抛出异常
throw new RuntimeException("定义了非法的数值");
int loopNum = loopNum(row,column);//得到循环次数上限
int[][] arr = new int[row][column];//定义二维数组
int num = 1;//定义循环次数，初始化为1(最大值为loopNum)
int value = 1;//定义写入的值，从1开始
// int h = 0;//行指针
// int l = 0;//列指针
for (;num<=loopNum;num++ )//控制循环次数
{
for (int h=num-1,l=num-1;l<=column-num ;l++ )//每次循环的上横1
{
arr[h][l] = value++;
}
for (int h=num,l=column-num;h<=row-num ;h++ )//每次循环的右竖1
{
arr[h][l] = value++;
}
for (int h=row-num,l=column-num-1;l>=num-1 ;l-- )//每次循环的下横2
{
arr[h][l] = value++;
}
for (int h=row-num-1,l=num-1;h>=num ;h-- )//每次循环的左竖1
{
arr[h][l] = value++;
}
}
return arr;
}
public static int loopNum(int row,int column)//根据数阵的行列值，判断循环次数(规律：循环次数由row与column中的小值决定)
{
int base = row>=column?column:row;//获取行列中的较小值作为基数
return (base%2==0)?(base/2):((base/2)+1);//三元运算符，根据基数(row和column中的较小值)的奇偶，得到所需循环次数
}
private static void printArr(int[] arr)//定义打印一维数组方法
{
for (int x=0;x<arr.length ;x++ )
{
System.out.print(arr[x]+"\t");
}
}
public static void printArr(int[][] arr)//重载，定义打印二维数组方法
{
for (int x=0;x<arr.length ;x++ )
{
printArr(arr[x]);//函数间调用
System.out.println();
}
}
}
9行9列 与 7行5列 的结果：
3.猜数游戏：电脑随机生成一个1~100之间的随机数，我们在控制台中进行猜数，直到猜到为止。
/*
完成参数游戏
要求：
a.首先系统产生一个1~100之间的随机数字。用什么实现？
b.接着键盘录入一个数据，用什么实现？
c.判断该数据是否猜中：用什么实现？
|---如果猜大了，提示大了。
|---如果猜小了，提示小了。
|---如果猜中，提示"恭喜你猜中了"
d.如果第一次猜错了，可以继续猜，直到猜对为止，用什么实现？
*/
/*
思路：
1.使用Math类库中的random功能，完成产生随机数功能，并使用一个变量(targeNum)接收；
2.使用Scanner，完成键盘录入的功能，并使用变量(myNum)接收；
3.将targetNum与myNum比较，根据三种不同情况，进行输出，
4.为了保证找到targetNum后程序正常结束，使用break语句。
*/
/*
扩展：
a.统计猜的次数。
b.每次缩小提示范围。
思路：
1.定义计数器count初始化为0，在每次"猜数"过程的开始count++;
2.每次判断结束，头尾变化。
*/
import java.util.*;
class GuessNum
{
static//游戏简易开始界面提示
{
sop("******************************************************");
System.out.println("这是一个猜数字的游戏，请输入一个1~100之间的整数，谢谢! ");
sop("******************************************************");
}
public static void main(String[] args)
{
int targetNum = getTargetNum();//得到需要猜的目标随机数
isRight(targetNum);
}
public static int getTargetNum()//定义方法，产生1~100之间的随机整数
{
return (int)(100*Math.random()+1);
}
public static void isRight(int targetNum)//核心方法
{
int count = 0;//定义计数器，初始化为0
int begin = 1;//定义起始点
int end = 100;//定义末尾点
Scanner sc = new Scanner(System.in);//创建键盘录入对象
while (true)//如果没找到就继续键盘录入并比较，利用死循环实现
{
count++;
int myNum = sc.nextInt();//完成键盘录入功能
if (myNum==targetNum)
{
if (count==1)
sop("观今夜天象，知天下大事~~");
else
sop("Congratulations!~ 您共猜了"+count+"次！ ");
break;
}
else if (myNum>targetNum)
{
end = myNum;
sop("您猜的数"+myNum+"大了---当前已经猜了"+count+"次，请在"+begin+"~"+end+"之间继续猜");
}
else
{
begin = myNum;
sop("您猜的数"+myNum+"小了---当前已经猜了"+count+"次，请在"+begin+"~"+end+"之间继续猜");
}
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
运行结果：
4.求一个正整数的质因数分解公式。
/*
题目：将一个正整数分解质因数。
例如：输入90,打印出90=2*3*3*5。
*/
/*
思路：
a.判断数字是否为素数，如果是素数不必进行因数分解，直接打印：此数无法因式分解;
b.如果不是素数，求其约数的个数;
c.定义一个长度为约数个数的数组，将约数放入数组中;
d.遍历此数组，并按照格式打印出分解质因数公式。
*/
/*
扩展：
添加键盘录入，持续判定功能。
*/
import java.util.*;
class ApartNumTest//分解数字测试类
{
static//软件界面
{
System.out.println("****************************************************");
System.out.println("这是一个数学应用程序，可以求得一个数的质因数分解公式");
System.out.println("****************************************************");
System.out.println("请输入一个正整数，谢谢~");
}
public static void main(String[] args)
{
int num = PartibilityNum.aNum();//键盘录入一个数字
PartibilityNum.apartFormula(num);
}
}
class PartibilityNum//定义"可分解数"类
{
private PartibilityNum(){}//此类不对外提供创建对象方法
public static void apartFormula(int num)//定义方法，求num的约数计算公式
{
System.out.print(num+" = ");
int[] arr = getApartNums(num);//得到这个数的各个约数，并储存在数组中
for (int x=0;x<arr.length ;x++ )//遍历+按格式打印
{
if (x!=arr.length-1)
{
System.out.print(arr[x]+" * ");
}
else
System.out.println(arr[x]+";");
}
}
public static int apartCount(int num)//求出一个数的约数个数
{
int count = 0;//定义计数器，初始化为0
boolean flag = isPrime(num);//定义标记，判断num是否为素数
if (flag==true)//如果是素数返回-1
return -1;
else//不是素数的情况
{
int ap = 2;//定义除数
while (ap<=num)
{
if (isAP(ap,num))//是约数
{
num /= ap;//原数变为除以约数后的数
count++;//约数个数自增
}
else//不是约数
ap++;//除数自增
}
}
return count;//返回总个数
}
public static int[] getApartNums(int num)//求一个数的所有约数，并将他们存储在数组中
{
int count = apartCount(num);//判断数字有多少个约数
int[] arr = null;//定义一个数组引用，用来存放即将得到的约数
if (count==-1)//素数，没有约数
throw new RuntimeException("这是一个素数，没有约数，请重新输入一个数");
else//不是素数，存在约束时
{
arr = new int[count];//定义一个长度为约数个数的数组
int index = 0;//定义一个动态指针，用于遍历数组
int ap = 2;//定义除数
while (ap<=num && index<count)//索引不小于约数个数的时候，约数找尽，循环停止
{
if (isAP(ap,num))//是约数
{
arr[index++] = ap;//将ap放在数组中，之后，索引向后一位
num /= ap;//将原数除以约数，得到新数
}
else//不是约数
ap++;//ap改变
}
return arr;
}
}
public static boolean isAP(int ap,int num)//定义方法，判断ap是不是num的约数
{
return (num%ap==0)?true:false;
}
public static boolean isPrime(int num)//定义方法，判断一个数是不是素数
{
boolean flag = true;
if (num<2)
flag = false;
else
{
int ap = 2;
while (ap<num)//除数从2到num-1依次判断
{
if (isAP(ap,num))//pos是num的约数
{
flag = false;//num不是素数
break;//直接跳出循环不再判断
}
else
flag = true;
ap++;
}
}
return flag;
}
public static int aNum()//键盘录入一个数，并对这个数进行初步的判断，知道次数满足存在约数为止
{
Scanner sc = new Scanner(System.in);
int num;
while (true)
{
num = sc.nextInt();
if (isPrime(num))
System.out.println("您输入了一个不可分解的数(素数)，请重新输入。");
else if (num<=0)
System.out.println("您输入了一个非正数，请重新输入。");
else
break;
}
return num;
}
}
运行结果：