写在前面：整个系列文章是自己学习慕课相关视频，进行的一个总结。文章只是为了记录学习课程的整个过程，方便以后查漏补缺，找到对应章节。
文章目录
- 一、Java循环结构
- 1、while循环
- 2、do-while循环
- 3、for循环
- 4、嵌套循环
- 5、break语句
- 6、continue语句
- 7、多种数据类型接收方法总结
- 二、Java一维数组
- 1、数组的概念
- 2、一些数组的案例
- 3、增强型for循环
- 4、冒泡排序
- 三、Java二维数组
- 四、Java方法
- 1、方法简介
- 2、无参无返回值方法
- 3、无参有返回值方法
- 4、有参无返回值方法
- 5、有参有返回值的方法
- 6、方法重载
- 7、数据类型的传值
- 8、可变参数列表
- 五、综合案例：数组移位与统计
一、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
退出程序！
