2、java语法之循环、数组与方法（找工作版）

写在前面：整个系列文章是自己学习慕课相关视频，进行的一个总结。文章只是为了记录学习课程的整个过程，方便以后查漏补缺，找到对应章节。

一、Java循环结构

while循环、do-while循环、for循环

1、while循环

• 循环输出26个英文字母，分两行输出

public class CharDemo {

	public static void main(String[] args) {
		// 循环输出26个英文字母，分两行输出
		char ch='a';
		int count=1;//控制换行
		while(ch<='z') {
			System.out.print(ch+" ");
			if(count%13==0) {
				System.out.println();
			}
			ch++;
			count++;
		}
	}
}
输出：
a b c d e f g h i j k l m 
n o p q r s t u v w x y z 

2、do-while循环

注意事项：
一、do-while循环至少执行一次
二、循环条件后的分号不能丢

• 猜字游戏。要求猜一个个于1到10之间的数字。然后将猜测的值与实际值进行比较，并给出提示，以便能更接近实际值，直到猜中为止。

import java.util.Scanner;

public class GuessDemo {

	public static void main(String[] args) {
		/*
		猜字游戏。要求猜一个个于1到10之间的数字。然后将猜测的
		值与实际值进行比较，并给出提示，以便能更接近实际值，直
		到猜中为止。
		*/
		//Math.random()[0,1)之间的随机数
		int number=(int)(Math.random()*10+1);//设置要猜的数
		System.out.println("number="+number);
		int guess;
		System.out.println("猜一个介于1~10之间的数");
		do {
			System.out.println("请输入您猜测的数：");
			Scanner sc=new Scanner(System.in);
			guess = sc.nextInt();
			if(guess>number) {
				System.out.println("太大！");
			}else if(guess<number){
				System.out.println("太小！");
			}
		}while(number!=guess);
		System.out.println("您猜中了！答案为"+number);

	}

}

3、for循环

• 编写一个程序，求出200到300之间的数，且满足条件: 它们三个数字之积为42，三个数字之和为12.

public class FlowDemo1 {

	public static void main(String[] args) {
		/*
		编写一个程序，求出200到300之间的数，且满足条
		件: 它们三个数字之积为42，三个数字之和为12.
		*/
		int ge,shi,bai;
		for(int i=200;i<=300;i++) {
			bai=i/100;
			shi=i/10%10;
			ge=i%10;
			
			if(ge*shi*bai==42&&ge+shi+bai==12) {
				System.out.println(i);
			}
		}
	}
}
输出：
237
273

4、嵌套循环

• 使用嵌套while循环输出10行10列的星号

public class StarDemo1 {

	public static void main(String[] args) {
		int m=1;//外重循环的循环变量
		int n=1;//内重循环的循环变量
		System.out.println("输出4行4列的星号：");
		//外重循环控制输出几行
		while(m<=4) {
			//内重循环控制每行输出几个星号
			n=1;
			while(n<=4) {
				System.out.print("*");
				n++;
			}
			System.out.println();
			m++;
		}
	}
}
输出：
输出4行4列的星号：
****
****
****
****

5、break语句

• break语句可以结束当前循环的执行
• 执行完break语句后，循环体中位于break语句后面的语句就不会被执行
• 在多重循环中，break语句只向外跳一层
  

6、continue语句

• continue语句只能用在循环里
• continue语句可以结束当前循环的执行，但是要继续下一次循环的执行
  

7、多种数据类型接收方法总结

Java并没有提供直接接收字符数据的方法，而是先接收字符串数据，然后进行转换。如下代码所示:先从键盘接收字符串类型数据，存储到字符串类型的变量str中，然后通过字符串的charAt()方法获得输入的第一个字符。

//从键盘接收char类型数据
System.out.println("请输入数据：");
Scanner sc=new Scanner(System.in);
String str=sc.next();
char ch=str.charAt(0);
System.out.println(ch);
输出：
请输入数据：
abcd
a

二、Java一维数组

1、数组的概念

• 数组在内存中的存储:数组会被分配连续的内存空间，对于整型数组默认值都为0，假设数组名为a，它指向数组的第一个元素，数组本身其实是对象。
  
  数组长度：arr.length

2、一些数组的案例

public class ArrayDemo {

	public static void main(String[] args) {
		// 声明一个整型数组
		int[] intArray;
		//声明一个字符串类型的数组
		String strArray[];
		//创建数组
		intArray = new int[5];
		strArray = new String[10];
		//声明数组的同时进行创建
		float[] floatArray=new float[4];
		
		//初始化数组
		char[] ch= {'a','b','c','d'};
		System.out.println("ch数组的长度为："+ch.length);
		System.out.println("intArray数组的第2个元素为："+intArray[1]);
		System.out.println("strArray数组的第5个元素为："+strArray[4]);
		System.out.println("floatArray数组的第最后一个元素为："+floatArray[floatArray.length-1]);
		
		//循环为整型数组赋值
		for(int i=0;i<5;i++) {
			intArray[i]=i+1;
		}
		//循环输出整型数组中的元素
		System.out.println("整型数组intArray的元素为：");
		for(int i=0;i<5;i++) {
			System.out.print(intArray[i]+"  ");
		}
	}
}
输出：
ch数组的长度为：4
intArray数组的第2个元素为：0
strArray数组的第5个元素为：null
floatArray数组的第最后一个元素为：0.0
整型数组intArray的元素为：
1  2  3  4  5  

• 求数组元素的累加和

import java.util.Scanner;

public class ArrayDemo1 {

	public static void main(String[] args) {
		// 求整型数组的累加和
		//定义整型数组
		int[] a=new int[5];
		Scanner sc=new Scanner(System.in);
		//从键盘接收数据，为数组赋值
		for(int i=0;i<a.length;i++) {
			System.out.println("请输入第"+(i+1)+"个元素：");
			a[i]=sc.nextInt();
		}
		System.out.println("数组元素内容为：");
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+"  ");
		}
		//求数组元素的累加和
		int sum=0;
		for(int i=0;i<a.length;i++) {
			sum +=a[i];
		}
		System.out.println();
		System.out.println("数组元素的累加和为："+sum);
	}
}
输出：
请输入第1个元素：
1
请输入第2个元素：
5
请输入第3个元素：
6
请输入第4个元素：
8
请输入第5个元素：
9
数组元素内容为：
1  5  6  8  9  
数组元素的累加和为：29

3、增强型for循环

• 增强型for循环与普通for循环的区别增强型for循环与普通for循环的区别:
  1、增强型for循环书写简洁，遍历数组时不需要下标，主要用于数组或集合的遍历，数组或集合遍历完毕时循环会结束执行。
  2、普通for循环需要三个条件，包括循环变量、循环结束条件和循环变量的变化。在进行数组遍历时，如果需要使用下标，可以使用普通for循环。比如:从键盘接收数组元索时，提示输入第几个元素。如果使用增强型for循环需要额外定义变量,

4、冒泡排序

public class SortDemo {

	public static void main(String[] args) {
		// 冒泡排序
		int[] a= {34,53,12,32,56,17};
		System.out.println("排序前的数组元素为：");
		for(int n:a) {
			System.out.print(n+"  ");
		}
		System.out.println();
		int temp;
		for(int i=0;i<a.length-1;i++) {
			//内循环控制每趟排序
			for(int j=0;j<a.length-i-1;j++) {
				if(a[j]>a[j+1]) {
					temp = a[j];
					a[j] = a[j+1];
					a[j+1] = temp;
				}
			}
		}
		System.out.println("从小到大排序后的数组元素为：");
		for(int n:a) {
			System.out.print(n+"  ");
		}
	}
}
输出：
排序前的数组元素为：
34  53  12  32  56  17  
从小到大排序后的数组元素为：
12  17  32  34  53  56  

三、Java二维数组

public class ArrayDemo5 {

	public static void main(String[] args) {
		// 二维数组的声明3种形式
		int[][] intArray;
		float floatArray[][];
		double[] doubleArray[];
		
		//创建一个3行3列int型二维数组
		intArray=new int[3][3];
		//为第2行第3个元素赋值
		intArray[1][2]=9;
		//声明数组的同时进行创建
		char[][] ch=new char[3][5];
		//float类型数组，只指定行数
		floatArray=new float[3][];
		//每行相当于一个一维数组，需要创建
		floatArray[0] =new float[3];
		floatArray[1] =new float[4];
		floatArray[2] =new float[5];
		
		// 二维数组的初始化
		int[][] num= {{1,2,3},{4,5,6},{7,8,9}};
		System.out.println("num数组的行数："+num.length);
		System.out.println("num数组的列数："+num[0].length);
		
		int[][] num1={{1,2,3,4},{6},{8,9}};
		//循环输出二维数组的内容
		for(int i=0;i<num1.length;i++) {
			for(int j=0;j<num1[i].length;j++) {
				System.out.print(num1[i][j]+"  ");
			}
			System.out.println();
		}
	}
}
输出：
num数组的行数：3
num数组的列数：3
1  2  3  4  
6  
8  9  

注意
1、数组是引用数据类型
2、创建数组时，会开辟连续的内存空间
3、数组长度使用length属性获取
4、数组元素的下标从0开始
5、数组下标越界问题

• 在一个二维数组中存放了三名学生的语文和数学的成绩，从键盘输入三名学生的成绩存储到二维数组中，分别求语文和数学的总成绩及平均分并输出。

import java.util.Scanner;

public class ArrayDemo4 {

	public static void main(String[] args) {
		// 定义一个三行两列的整型二维数组intArray
		int[][] intArray=new int[3][2];
		//从键盘输入学生成绩
		Scanner sc=new Scanner(System.in);
		for(int i=0;i<intArray.length;i++) {
			for(int j=0;j<intArray[i].length;j++) {
				if(j==0) {
					System.out.println("请输入第"+(i+1)+"个学生的语文成绩：");
					intArray[i][j]=sc.nextInt();
				}else {
					System.out.println("请输入第"+(i+1)+"个学生的数学成绩：");
					intArray[i][j]=sc.nextInt();
				}
			}
		}
		//求语文的总成绩和平均分
		int sum1=0;
		float avg1;
		for(int i=0;i<intArray.length;i++) {
			sum1 += intArray[i][0];
		}
		avg1=sum1/intArray.length;
		
		//求数学的总成绩和平均分
		int sum2=0;
		float avg2;
		for(int i=0;i<intArray.length;i++) {
			sum2 += intArray[i][1];
		}
		avg2=sum2/intArray.length;
		
		System.out.println("语文的总成绩为："+sum1);
		System.out.println("语文的平均分为："+avg1);
		System.out.println("数学的总成绩为："+sum2);
		System.out.println("数学的平均分为："+avg2);
	}

}
输出：
请输入第1个学生的语文成绩：
78
请输入第1个学生的数学成绩：
98
请输入第2个学生的语文成绩：
95
请输入第2个学生的数学成绩：
100
请输入第3个学生的语文成绩：
75
请输入第3个学生的数学成绩：
80
语文的总成绩为：248
语文的平均分为：82.0
数学的总成绩为：278
数学的平均分为：92.0

四、Java方法

1、方法简介

2、无参无返回值方法

注意：方法在类的内部定义

public class MethodDemo {
	//打印输出星号的方法
	public void printStar() {
		System.out.println("*******************************");
	}

	public static void main(String[] args) {
		// 创建一个类对象
		MethodDemo myMethodDemo=new MethodDemo();
		//使用对象名.方法名()去调用方法
		myMethodDemo.printStar();
		System.out.println("欢迎来到Java的世界！");
		myMethodDemo.printStar();
	}
}
输出：
*******************************
欢迎来到Java的世界！
*******************************

3、无参有返回值方法

public class Rectangle {
	//求长方形面积的方法
	public int area(){
		int length=10;
		int width=5;
		int getArea=length*width;
		return getArea;//返回语句
		
	}
	public static void main(String[] args) {
		Rectangle rc=new Rectangle();
		System.out.print("长方形的面积为："+rc.area());
	}
}
输出：
长方形的面积为：50

4、有参无返回值方法

public class MaxDemo {
	// 求最大值的方法
	public void max(float a,float b) {
		float max;
		if(a>b) {
			max=a;
		}else {
			max=b;
		}
		System.out.println("两个数"+a+"和"+b+"的最大值为："+max);
	}
	public static void main(String[] args) {
		MaxDemo mDemo = new MaxDemo();
		int a=5,b=3;
		mDemo.max(a,b);
		float m=5.6f,n=8.9f;
		mDemo.max(m, n);
		mDemo.max(9.8f, 12.8f);
	}

}
输出：
两个数5.0和3.0的最大值为：5.0
两个数5.6和8.9的最大值为：8.9
两个数9.8和12.8的最大值为：12.8

5、有参有返回值的方法

• 定义一个求n!的方法，然后再求1!+2!+3!+4!+5!
  public int fac(int n)

public class FacDemo {
	// 方法不能嵌套定义
	//求阶乘的方法
	public int fac(int n) {
		int s=1;
		for(int i=1;i<=n;i++) {
			s*=i;
		}
		return s;
	}
	public static void main(String[] args) {
		FacDemo facDemo=new FacDemo();
		int fac=facDemo.fac(3);
		System.out.println("3!="+fac);
		int sum=0;
		for(int i=1;i<=5;i++) {
			fac=facDemo.fac(i);
			sum+=fac;
		}
		System.out.println("1!+2!+3!+4!+5!="+sum);
	}
}
输出：
3!=6
1!+2!+3!+4!+5!=153

• 例:查找数组元素的值
  public boolean search(int n,int[] arr){}

import java.util.Scanner;

public class ArraySearch {
	//查找数组元素值的方法
	public boolean search(int n,int[] arr) {
		boolean flag=false;//默认是没找到
		for(int i=0;i<arr.length;i++) {
			if(arr[i]==n) {
				flag=true;//找到了
				break;
			}
		}
		return flag;
	}

	public static void main(String[] args) {
		int[] arr1= {10,20,30,40,50,60};
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入要查找的数据：");
		int n1=sc.nextInt();
		ArraySearch as = new ArraySearch();
		boolean flag=as.search(n1, arr1);
		if(flag) {
			System.out.println("找到了");
		}else {
			System.out.println("没找到");
		}
	}
}
输出：
请输入要查找的数据：
35
没找到

6、方法重载

方法名相同，参数列表不同

public class MathDemo {
	//求两个int类型数的和
	public int plus(int m,int n) {
		return m+n;
	}
	//求两个double类型数的和
	public double plus(double m,double n) {
		return m+n;
	}
	//求数组元素的累加和
	public int plus(int[] arr) {
		int sum=0;
		for(int i=0;i<arr.length;i++) {
			sum=sum+arr[i];
		}
		return sum;
	}

	public static void main(String[] args) {
		int m=5,n=10;
		int[] arr= {1,2,3,4,5,6};
		MathDemo mathDemo=new MathDemo();
		System.out.println("int类型的和："+mathDemo.plus(m, n));
		System.out.println("double类型的和："+mathDemo.plus(5.6,7.8));
		System.out.println("数组元素的和："+mathDemo.plus(arr));
	}
}
输出：
int类型的和：15
double类型的和：13.399999999999999
数组元素的和：21

Java方法重载的总结:
方法名相同，参数列表不同。
参数列表不同包括，参数的个数和类型不同。如果只有参数名不同，不能算作方法重载。如下三个方法是重载方法，它们的参数列表都是不同的。
public void display(){}
public void display(int n){}
public void display(float n){}
如下两个方法不是重载方法，两个方法只是参数名不同，不满足方法重载条件。
public void display(int n){}
public void display(int d){}

7、数据类型的传值

基本数据类型传值时，不会影响主方法中的值；引用数据类型传值时，会影响主方法中的值。

• 方法传值，只传值，不传地址。因此调用方法后m和n的值不变。

public class ExchangeDemo {
	//交换方法
	public void swap(int a,int b) {
		int temp;
		System.out.println("交换前：a="+a+",b="+b);
		temp=a;a=b;b=temp;
		System.out.println("交换后：a="+a+",b="+b);
	}
	public void swapTest() {
		int m=4,n=5;
		System.out.println("交换前：m="+m+",n="+n);
		swap(m, n);
		System.out.println("交换后：m="+m+",n="+n);
	}
	public static void main(String[] args) {
		ExchangeDemo ed = new ExchangeDemo();
		ed.swapTest();
	}
}
输出：
交换前：m=4,n=5
交换前：a=4,b=5
交换后：a=5,b=4
交换后：m=4,n=5

• 数组传值时，主方法外和主方法内指向的是同一片内存空间。

public class ArrayDemo {
	//定义一个用于修改某个数组元素值的方法
	public void updateArray(int[] a) {
		a[3]=15;
		System.out.println("数组a的元素为：");
		for(int n:a) {
			System.out.print(n+"  ");
		}
		System.out.println();
	}

	public static void main(String[] args) {
		ArrayDemo ad=new ArrayDemo();
		int[] a1= {1,2,3,4,5};
		System.out.println("方法调用前数组a1的元素为：");
		for(int n:a1) {
			System.out.print(n+"  ");
		}
		System.out.println();
		ad.updateArray(a1);
		System.out.println("方法调用后数组a1的元素为：");
		for(int n:a1) {
			System.out.print(n+"  ");
		}
		System.out.println();
	}
}
输出：
方法调用前数组a1的元素为：
1  2  3  4  5  
数组a的元素为：
1  2  3  15  5  
方法调用后数组a1的元素为：
1  2  3  15  5  

8、可变参数列表

public void sum(int… n){}

public class ArgsDemo {
	//求和
	public void sum(int... n) {
		int sum=0;
		for(int i:n) {
			sum+=i;
		}
		System.out.println("sum="+sum);
	}

	public static void main(String[] args) {
		ArgsDemo ad=new ArgsDemo();
		ad.sum(1);
		ad.sum(1,2);
		ad.sum(1,2,3);
	}
}
输出：
sum=1
sum=3
sum=6

• 参数列表中如果有两个以上参数，可变参数一定是在最后的。

import javax.print.attribute.IntegerSyntax;

public class ArgsDemo1 {
	//查找
	public void search(int n,int... a) {
		boolean flag=false;
		for(int a1:a) {
			if(a1==n) {
				flag=true;break;
			}
		}
		if(flag) {
			System.out.println("找到了！"+n);
		}else {
			System.out.println("没找到！"+n);
		}
	}

	public static void main(String[] args) {
		ArgsDemo1 ad1=new ArgsDemo1();
		ad1.search(3,1,2,3,4,5);
		//可以将数组传递给可变参数列表 
		int[] a= {1,2,3,4,5};
		ad1.search(3, a);
		/*
		 注意：如果数组作为参数时，是不能将多个值传递给数组的
		 public void search(int n,int[] a) {}
		 ad1.search(3,1,2,3,4,5);会报错
		 */
	}
}
输出：
找到了！3
找到了！3

• 可变参数列表所在的方法是最后被访问的。

/**
 * 文档注释：
 * 关于可变参数列表和重载的问题
 * @author 86156 
 */
public class ArgsDemo2 {
	//可变参数列表所在的方法是最后被访问的。
	public int plus(int a,int b) {
		System.out.println("不带可变参数的方法被调用！");
		return a+b;
	}
	public int plus(int... a) {
		int sum=0;
		for(int n:a) {
			sum+=n;
		}
		System.out.println("带可变参数的方法被调用！");
		return sum;
	}

	public static void main(String[] args) {
		ArgsDemo2 ad2=new ArgsDemo2();
		System.out.println("和为："+ad2.plus(1,2));
	}
}
输出：
不带可变参数的方法被调用！
和为：3

可变参数列表总结：
1、可变参数列表作为方法参数时，如果有多个参数，可变参数列表只能放到最后一个位置。
2、不能有多个可变参数列表作为方法参数。而数组没有这个限制。
3、数组可以传递给可变参数的方法，反之不行。
4、在重载中，含有可变参数的方法是最后被选中的。
关于可变参数作为方法参数，下面的方法定义形式都是错误的:
public void method(int… m,int… n){} //不能有多个可变参数作为方法参数
public void method(int… m,int n){} //可变参数应该放到参数列表的最后
5、可变参数的底层实现就是数组。
6、当传入方法的参数数量不确定的时候，可以考虑使用可变参数列表。

五、综合案例：数组移位与统计

package com.imooc.datamanage;

import java.util.InputMismatchException;
import java.util.Scanner;

/**
 * 从键盘接收整型数据存放到数组中，并对数组中的数据进行管理
 * @author 86156
 */
public class DataManage {
	// 插入数据
	public int[] insertData() {
		int[] a=new int[10];
		Scanner sc=new Scanner(System.in);
		//少接收一个数据，为在指定位置处插入数据做准备
		for(int i=0;i<a.length-1;i++) {
			System.out.println("请输入第"+(i+1)+"个数据：");
			try {
				a[i]=sc.nextInt();
			}catch (InputMismatchException e) {
				System.out.println("输入数据的格式有误，不能有非数字！");
				sc.next();
				i--;//重新输入刚才的数据
			}
		}
		return a;
	}
	/**
	 * 显示数组中元素的内容
	 * @param a 数组
	 * @param length  要显示的数组元素个数
	 */
	public void showData(int[] a,int length) {
		for(int i=0;i<length;i++) {
			System.out.print(a[i]+"   ");
		}
		System.out.println();
	}
	/**
	 * 从键盘接收一个数据，插入到数组的指定位置处
	 * @param a 要插入数据的数组
	 * @param n 要插入的数据
	 * @param k 要插入的位置，从0开始
	 * 在数组中插入数据，相当于对数组的元素进行赋值，会对当前数据进行覆盖
	 */
	public void insertAtArray(int[] a,int n,int k) {
		//注意从最后一个数据开始移动，避免数据覆盖
		for(int i=a.length-1;i>k;i--) {
			a[i]=a[i-1];
		}
		a[k]=n;
	}
	/**
	 * 输出数组中能被3整除的元素
	 * @param a
	 */
	public void divThree(int[] a) {
		String str="";
		int count=0;
		for(int n:a) {
			if(n%3==0) {
				str=str+n+" ";
				count++;
			}
		}
		if(count==0) {
			System.out.println("数组中没有能被3整除的元素！");
		}else {
			System.out.println("数组中能被3整除的元素为："+str);
		}
	}
	/**
	 * 提示信息
	 */
	public void notice() {
		System.out.println("************************************");
		System.out.println("                   1--插入数据");
		System.out.println("                   2--显示所有数据");
		System.out.println("                   3--在指定位置处插入数据");
		System.out.println("                   4--查询能被3整除的数据");
		System.out.println("                   0--退出");
		System.out.println("************************************");
	}
	public static void main(String[] args) {
		DataManage dm=new DataManage();
		Scanner sc=new Scanner(System.in);
		//在主方法中定义的变量都是局部变量，需要赋初值
		int input=0;
		int[] a = null;
		int n=0,k=0;//n表示要插入的数据，k表示要插入的位置
		while(true) {
			dm.notice();
			System.out.println("请输入对应的数字进行操作：");
			try {
				input = sc.nextInt();
			} catch (InputMismatchException e) {
				System.out.println("输入的数据格式有误，不能有非数字！");
				sc.next();
				continue;
			}
			
			if(input==0) {
				System.out.println("退出程序！");
				break;
			}
			switch(input) {
			case 1:
				//插入数据
				a=dm.insertData();
				//显示数据
				System.out.println("数组元素为：");
				dm.showData(a, a.length-1);
				break;
			case 2:
				if(a!=null) {
					System.out.println("数组元素为：");
					if(a[a.length-1]==0) {
						//如果数组的最后一个元素为0，说明还没有插入数据，因此不显示最后一个元素
						dm.showData(a, a.length-1);
					}else {
						dm.showData(a, a.length);
					}
				}else {
					System.out.println("还未在数组中插入数据，请重新选择操作！");
				}
				break;
			case 3:
				//在指定位置插入数据
				if(a!=null) {
					System.out.println("请输入要插入的数据：");
					try {
						n=sc.nextInt();
						System.out.println("请输入要插入的位置：");
						k=sc.nextInt();
					} catch (InputMismatchException e) {
						System.out.println("输入的数据格式有误，不能有非数字！");
						sc.next();
						break;
					}
					dm.insertAtArray(a, n, k);
					dm.showData(a, a.length);
				}else {
					System.out.println("还未在数组中插入数据，请重新选择操作！");
				}
				break;
			case 4:
				if(a!=null) {
					dm.divThree(a);
				}else {
					System.out.println("还未在数组中插入数据，请重新选择操作！");
				}	
				break;
			}
		}
	}
}

输出：
************************************
                   1--插入数据
                   2--显示所有数据
                   3--在指定位置处插入数据
                   4--查询能被3整除的数据
                   0--退出
************************************
请输入对应的数字进行操作：
1
请输入第1个数据：
1
请输入第2个数据：
2
请输入第3个数据：
3
请输入第4个数据：
4
请输入第5个数据：
5
请输入第6个数据：
6
请输入第7个数据：
7
请输入第8个数据：
8
请输入第9个数据：
9
数组元素为：
1   2   3   4   5   6   7   8   9   
************************************
                   1--插入数据
                   2--显示所有数据
                   3--在指定位置处插入数据
                   4--查询能被3整除的数据
                   0--退出
************************************
请输入对应的数字进行操作：
2
数组元素为：
1   2   3   4   5   6   7   8   9   
************************************
                   1--插入数据
                   2--显示所有数据
                   3--在指定位置处插入数据
                   4--查询能被3整除的数据
                   0--退出
************************************
请输入对应的数字进行操作：
3
请输入要插入的数据：
12
请输入要插入的位置：
6
1   2   3   4   5   6   12   7   8   9   
************************************
                   1--插入数据
                   2--显示所有数据
                   3--在指定位置处插入数据
                   4--查询能被3整除的数据
                   0--退出
************************************
请输入对应的数字进行操作：
4
数组中能被3整除的元素为：3 6 12 9 
************************************
                   1--插入数据
                   2--显示所有数据
                   3--在指定位置处插入数据
                   4--查询能被3整除的数据
                   0--退出
************************************
请输入对应的数字进行操作：
0
退出程序！