java基础

发布于 2021-11-02  424 次阅读


笔记字体颜色说明

黑色:日期,表格

蓝色:大标题

红色:说明,例子,细节标题

粉色:细节,需要注意的地方

紫色:代码和运算之类的

注意:此说明为一般情况下都是这样,但可能会出现特殊情况那就是我懒不想改༼ •̀ ₒ •́ ༽

10.31

基本数据类型转换

数据类型按精度(大小)排序

char-int-long-float-double

byte-short-int-long-float-double

例子

int a='a';

double d=80;

细节

  • 有多种类型的数据混合运算时,系统首先自动将所有的数据转换成容量最大的那种数据类型,然后再进行计算。
  • 当我们把精度(容量)大的数据类型赋值给精度小的数据类型时,就会报错,反之就会进行自动类型的转换。
  • (byte,short)和char之间不会互相自动转换
  • byte,short,char 他们三者可以计算,在计算时首先转换为int类型。
  • boolean不参与转换
  • 自动提升原则:表达式结果的类型自动提升为 操作数中最大的类型

11.2

强行类型转换

例子

int i=(int)1.9;

System.out.println(i);//输出1

int j=100;

byte bl=(byte)j;

System.out.println(b1);//输出100

细节

  • 当进行数据的大小从大——>小,就需要使用到强制转换
  • 强转符号只针对于最近的操作数有效,往往会使用到小括号提升优先级

int x=(int)10*3.5+6*1.5;//错的(int只对10有效果)

int y=(int)(10*3.5+6*1.5);//为对

System.out.println(x);

  • char类型可以保存int的常量值,但不能保存int的变量值,需要强转

char c1=100;

int m=100;

char c2=m;//会报错

char c3=(char)m;//可以运行

Syseem.out.println(c3); //输出为d

  • byte和short类型在进行运算时,当做int类型处理。

基本数据类型转String类型的转换

例子

  • 基本数据转String类型,语法将基本数据类型的值+”“

int n1=100;

float n2=1.1f;

double b1=3.4;

String str1=n1+”“;

String str2=n2+”“;

String str3=n3+”“;

String str4=b1+”“;

System.out.println(str1+" "+str2.......)

  • String类型转基本数据类型,语法:通过基本类型的包装类调用parseXX方法

int nim1=Integer.paarseInt(”123“);

Double.parseDouble("123.1");;

Float.parseFloat("123.45");

Short.parseShort("12");

Long.parseLong("12345");

Boolean.parseBoolean("true");

Byte.parseByte("12");

11.3

算数运算符

运算符运算范例结果
+正号+11
-负号b=11,-b-11
+9+918
-9-81
*7*856
/9/91
%取余(取模)20%84
++
++
自增(前):先运算后取值
自增(后):先取值后运算
a=2;b=++a;
a=2;b=a++
a=3,b=3
a=3,b=2
--
--
自减(前):先运算后取值
自减(后):先取值后运算
a=2;b=--a;
a=2;b=a--;
a=1,b=1
a=1,b=2
+字符串相加"w"+"h""wh"
用于数据的运算、赋值和比较等

例子

System.out.println(10/4);//输出为2,因为10和4都为整数

System.out.println(10.0/4); //输出为2.5,10.0为小数

double d=10/4;//输出为2.0,2——>2.0

%公式a%b=a-a/b*b

System.out.println(10%3);//输出1

System.out.println(-10%3); //输出-1

System.out.println(10%-3); //输出1

System.out.println(-10%-3); //输出-1

int i=10;

i++;输出 11

++i输出 12

System.out.println(i);

int j=20;

int k=++j;输出 21

int k=j++;

System.out.println((k);输出21

System.out.println(j);输出22

关系运算符

运算符运算范例结果
!=不等于8!=7true
<小于8<7false
>大于8>7true
<=小于等于8<=7false
>=大于等于8>=7true
==相等于8==7false
instanceof检查是否是类的对象“hsp” instanceof Stringtrue
关系运算符的结果都是boolean型,也就是要么是true,要么是false/关系运算符经常用于if结构或循环结构中

例子

int a=9;

int b=8;

System.out.println(a>b);//输出true

System.out.println(a>=b); //输出true

System.out.println(a<b); //输出false

System.out.println(a<=b); //输出false

System.out.println(a==b); //输出false

System.out.println(a!=b); //输出true

boolean flag=a>b; //输出true

逻辑运算符

aba&ba&&ba|ba||b!aa^b
truetruetruetruetruetruefalsefalse
truefalsefalsefalsetruetruefalsetrue
falsetruefalsefalsetruetruetruetrue
falsefalsefalsefalsefalsefalsetruefalse

例子

int x=5;

int y=5;

if(x++==5&++y=6){

x=11;

}

System.out.println("x="+x+",y="+y);//输出x=6,y=6

int x=5;

int y=5;

if(x++==5&&++y=6){

x=11;

}

System.out.println("x="+x+",y="+y);//输出x=6,y=5

int x=5;

int y=5;

if(x++==5|++y=5{

x=11;

}

System.out.println("x="+x+",y="+y);//输出x=11,y=6

int x=5;

int y=5;

if(x++==5||++y=5){

x=11;

}

System.out.println("x="+x+",y="+y);//输出x=11,y=5

赋值运算符

  • 基本赋值运算符:=
  • 复合赋值运算符:+=,-=,*=,/=,%=

例子

a+=b;//(等于a=a+b;)

细节

  • 运算顺序从右往左 int num=【a+b+c】;//先计算(a+b+c)再赋给num;
  • 赋值运算符的左边 只能是变量,右边可以是变量、表达式、常量值

int num=20; //常量值 int nmu2=7*8-8;//表达式 int num3=a;//变量

  • 复合赋值运算符等价于下面的效果

a+=3等于a=a+3;

  • 复合赋值运算符会进行类型转换(包括强制转换)

byte b=2; b+=3;//等价于b=(byte)(b+2); b++;//b=(byte)(b+1);

三元运算符

基本语法

  • 条件表达式?表达式1:表达式2;
  • 1.如果条件表达式为ture,运算后的结果是表达式1;
  • 2.如果条件表达式为false,运算后的结果是表达式2;

例子

int a=10;

int b=99;

int result=a>b?a++:b--;

细节

  • 1.表达式1和表达式2要为赋给接收变量的类型(或可以自动转换)
  • 2.三元运算符可以转成if--else

int res=a>b? a++:b--;

if(a>b)res=a++;

else res=b--;

运算符的优先级

. () {} ; ,
R——>L++ -- ~  !(data type)
L——R*     /    %
L——R +    -
L——R <<    >>   >>>   位移
L——R <  >  <=  >=    instanceof 
L——R == !=
L——R &
L——R ^
L——R |
L——R &&
L——R ||
L——R ? :
R——L= *= /= %=
+= -= <<= >>=
>>>= &= ^= |=

键盘输入

使用说明

  1. 导入该类的所在包,java.util.*
  2. 创建该类的对象(声明变量)
  3. 调用里面的功能

例子

import java.util.Scanner;//引入包使用Scanner类为文本扫码器

scanner input =new Scanner(System.in);//创建Scanner对象

System.out.println("请输入姓名:");

String name= input.next();

System.out.println("请输入年龄:");

int age=input.nextInt();

System.out.println("请输入成绩:");

double score= input.nextDouble();

System.out.println("name:"+name);

System.out.println("age:"+age);

System.out.println("score:"+score);

进制

  • 二进制:0,1 满2进1,以0b或0B开头
  • 十进制:0-9,满10进1
  • 八进制:0-7,满8进1.以数字0开头表示
  • 十六进制:0-9以及A(10)-F(15),满16进1.以0x或0X开头表示。此处的A-F不区分大小写

例子

int n1=ob1010;//二进制

int n2=1010;//十进制

int n3=01010;//八进制

int n4=0x10101//十六进制

  • 二转十(八转十,十六转十同理,把二换成八或十六)

0b1010=10//运算过程1*2^3+0*2^2+1*2^1+0*2^0

  • 十转二(十转八,十转十六同理,把二换成八或十六)
  • 10=0b(1010)(以下为过程,结果:下面的高位到上面的低位,鼠标好难画qaq)
  • 二转八(二转十六为4位一组)

0b1010=(012);=001010分开算(001)=1,(010)=2;=12//3位一组转八进制数

  • 八转二(十六转二同理)

(012)=0b1010;12=1=(001)2=(010)=001010=1010

位运算

源码 反码 补码

  1. 二进制的最高位是符号位:0代表正数,1代表负数
  2. 正数的源码 反码 补码都是一样的
  3. 负数的反码=它的源码符号位不变,其他位取反
  4. 负数的补码=它的反码+1负数的反码=负数的补码-1
  5. 0的反码 补码都是0
  6. java没有无符号数,换言之,java中的数都是有符号的
  7. 当计算机运算的时候,都是以补码的方式运算的
  8. 当我们看运算结果的时候,要看他的源码

位运算符

  • java中有7个运算符(&、|、^、~、>>、<<、>>>)
  • 分别是按位与&、按位或|、按位异或^、按位取反~,它们的运算规则是:
  • 按位与& :两位全为1,结果为1,否则为0
  • 按位或| :两位有一个为1,结果为1,否则为0
  • 按位异或 ^ :两位一个为0,一个为1,结果为1,否则为0
  • 按位取反~: 0->1 1->
  • 算数右移>>:低位溢出,符号位不变,并用符号位补溢出的高位
  • 算数左移<<:符号位不变,低位补0
  • >>>逻辑右移/无符号右移,低位溢出,高位补0

例子

2&3=?//输出为2

2=(00000000 00000000 00000000 00000010)//最高位0为正,所以源码等于补码

3=(00000000 00000000 00000000 00000011)//同理

?= ( 00000000 00000000 00000000 00000010 )=2

~-2=?//输出为1

~-2(10000000 00000000 00000000 00000010)//1为负数,下一步源码转反码

-2反码=11111111 11111111 11111111 11111101//下一步反码转补码

-2补码 =11111111 11111111 11111111 11111110//下一步开始运算

取反=00000000 00000000 00000000 000000001=1

int a=1>>2;//1=>00000000 00000000 00000000 00000001=》00000000 00000000 00000000 00000000本质1/2/2=0

int c=1<<2;//1=>00000000 00000000 00000000 00000001=》00000000 00000000 00000000 00000100本质1*2*2=4

11.4

分支控制(if,else,switch)

基本语法

if(条件表达式){

执行代码块;(可以有多条语句)//结果为ture

} else if{

执行代码2;

}.......

else{

执行代码块n;

}

嵌套分支

介绍

在一个分支中又完整的嵌套了另一个完整的分支结构,里面的分支结构称为内层分支外面的分支结构称为外层分支。规范包括第一个if不要超过4层,(可读性不好)

基本语法

if(){

if-else....

}else{

if-else

}

}

switch分支结构

基本语法

switch(表达式){

case常量:

语句块1;

break;

case常量2:

语句块2;

break;

.....

case常量n:

语句块n:

break;

说明

  1. switch 关键字,表达swtich分支
  2. 表达式 对应一个值
  3. case常量1:当表达式的值等于常量1,就执行 语句块1
  4. break:表示退出swtich
  5. 如果和case常量1匹配,就执行语句块1,如果没有匹配,就继续匹配case常量2
  6. 如果一个都没有匹配上,就执行default

细节

  1. 表达式数据类型,应和case后的常量类型一致,或者可以自动转换成可以相互比较的类型,比如输入的是字符。而且常量是int
  2. switch(表达式)中表达式的返回值必须是(byte,short,int,char,enum,String)
  3. case字句中的值必须是常量,而不能是变量
  4. default字句是可选的,当没有匹配的case时,执行default
  5. break语句用来在执行完一个case分支后使程序跳出switch语句块;如果没有写break,程序会顺序执行到switch结尾

for循环

基本语法

  • for(循环变量初始化;循环条件;循环变量迭代){
  • 循环操作(可以多个语句);
  • }
  • 循环变量初始化;
  • for(循环条件;){
  • 循环操作(可以多个语句);
  • 循环变量迭代
  • }

细节

  1. 循环条件是返回一个布尔值的表达式
  2. for(;循环判断条件;)中的初始化和变量迭代可以写到其他地方,但是两边的分号不能省略。
  3. 循环初始值可以是多条初始化语句,但要求类型一样,并且逗号隔开,循环变量迭代也可以有多条变量迭代语句,中间用逗号隔开。

例子

for(i=0;i<=10;i++){

System.out.println(“输出语句”);

11.5

while循环控制

基本语法

循环变量初始化;

while(循环条件){

循环体(语句);

循环变量迭代;

}

说明

  • while循环也有四要素
  • 只是四要素放置的位置,不一样

例子

int i=1;

while(i<=10){

System.out.prinltn(“输出”);

i++;

do...while循环控制

基本语法

循环变量初始化;

do{

循环体(语句);

循环控制迭代;

}while(循环条件);

说明

  • do while是关键字
  • 也是循环四要素,只是位置不一样
  • 先执行,后判断,也就是说,一定会执行一次
  • 最后 有一个分号;
  • while和do.....while区别为do。。while先直接执行一次语句

多重循环控制

基本语法例子

for(int i=0;i<2;i++){

for(int j=0; j<3;j++){

System.out.println("i="+i+"j="+j);

}

}

循环题目在java题目文章里

跳转控制语句-break

基本语法

{ .......

break;

.........

}

例子

for(int i=0;i<10;i++){
   if(i==3){break;}
   System.out.println("ok"+i);
}

细节

break语句现在在多层循环的语句块中时,可以通过标签指明要终止的是哪一层语句块

标签的基本使用

label1:{.............

label2 : {.......

label3: {..........

break label2;

..................

}

}

}

  1. break语句可以指定退出哪层
  2. label1是标签,由程序员指定。(名字可以自己定)
  3. break后指定到哪个label就退出到哪里
  4. 在实际开发中,尽量不要使用标签。(可读性会变差)
  5. 如果没有指定break,默认退出最近的循环体

控制跳转语句—continue

基本介绍

continue语句用于结束本次循环,继续执行下一次循环。

continue语句出现在多层嵌套的循环语句体中,可以通过标签指名要跳过的是哪一层循环,这个可以和前面的标签的使用的规则一样。

基本语法

{........

continue;

.........

}

例子

int i=1;
while(i<=4){
i++;
if(i==2){
   continue;
  }
System.out.println("i="+i);
}

跳转控制语句-return

介绍

return写在mian方法,退出程序.....

例子

for(int =1;i<=5;i++){
     if(i==3){
System.out.println("祈曦"+i);
return;
}
System.out.println("Hello World");
}
rintln("go on..");

11.9

数组

数组介绍

数组可以存放多个同一类型的数据,数组也是一种数据类型,是引用类型。

既:数据就是一组数据

数组的使用

使用方法1-动态初始化1

数组的定义

数据类型 数组名[]=new 数据类型[大小]

int a[]=new int[5];//创建了一个数组,名字a,存放5个int

例子

int w[]=new int[];

使用方法2-动态初始化2

先声明数组

语法:数据类型 数组名[];也可以 数据类型[] 数组名;

int a[];或者 int []a;

创建数组

语法:数组名=new 数据类型[大小];

a=new int[];

例子

int a[];

a=new int[];

使用方法3-静态初始化

语法:数据类型 数组名[]={元素值,元素值....}

int a[]={5,6,2,5,6,8,5,50}

细节

  1. 数组是多个相同类型的组合,实现对这些数据的统一管理
  2. 数组中的元素可以是任何数据类型,包括基本类型和引用类型,但是不能混用。
  3. 数组创建后,如果没有赋值,有默认值int 0,short 0,long 0,float 0.0,double 0.0, char \u0000,boolean false, String null
  4. 使用数组的步骤 1.声明数组并开辟空间 2.给数组各个元素赋值3使用数组
  5. 数组的下标是从0开始的。
  6. 数组下标必须在指定范围内使用,否则报:下标越界异常,比如int[]arr=new int[5];则有效下标为0-4
  7. 数组属引用类型,数组型数据是对象(object)

数组赋值机制

  • 基本数据类型赋值,这个值就是具体的数据,而且互相不影响。int n1=2;int n2=n1;
  • 数组在默认情况下引用传递,赋的值是地址。如

int[] i1={1,2,3};

int[] i2=i1;

  • 这样的话改变i2 i1也会被改变

数组拷贝

将int[] arr1={10,20,30};拷贝到arr2数组

例子

package steam;
		import java.util.Scanner;
		public class steam {
			public static void main(String[] args){
			Scanner ow=new Scanner(System.in);
			int[] arr1={10,20,30};
			int [] arr2=new int[arr1.length];//定义一个新的数组  大小和arr1一样
			for(int i=0;i<arr1.length;i++){
				arr2[i]=arr1[i];//把arr1的值拷贝给arr2
			}
			arr1[2]=50;//把50赋值给arr2[2]
		for(int w=0;w<arr1.length;w++){
			System.out.print(arr1[w]);
			}//输出为10 20 50
		System.out.println("");
		for(int h=0;h<arr2.length;h++){
			System.out.print(arr2[h]);
			}	//输出为 10 20 30
		}
	}

数组反转

方法1

package steam;
		import java.util.Scanner;
		public class steam {
			public static void main(String[] args){
			int[]  w={10,20,30,40,50,60};
			/*w[0]和w[5]转换   
			 * w[1]-w[4]
			 * w[2]-w[3]
			 * 一共三次所以w.length/2
			 * w[i]=012  w[arr.length-1-i]
			 */
			int e=0;
			for(int i=0;i<w.length/2;i++){
				e=w[i];
				w[i]=w[w.length-1-i];
				w[w.length-1-i]=e;
			}
			for(int o=0;o<w.length;o++){
				System.out.println(w[o]);
			}
		}
	}

方法2

package steam;
		import java.util.Scanner;
		public class steam {
			public static void main(String[] args){
			int[]  w={10,20,30,40,50,60};
			int[] w2=new int[w.length];
			for(int p=w.length-1,u=0;p>=0;p--,u++){
				w2[u]=w[p];
				
			}
			
			for(int r=0;r<w2.length;r++){
			System.out.print(w2[r]+" ");
			}w=w2;//把w2地址给w
			for(int t=0;t<w.length;t++){
				System.out.print(w[t]+" ");}//输出结果60 50 40 30 20 10
		}
	}

数组扩容

package steam;
		import java.util.Scanner;
		public class steam {
			public static void main(String[] args){
			Scanner ow=new Scanner(System.in);
		int[] hw={1,2,3,4};//定义数组的元素
		
		abc:do{
			int[] ww=new int[hw.length+1];//定义ww数组让他比hw数组大一个元素的空间
			
		for(int i=0;i<hw.length;i++){
			ww[i]=hw[i];//把hw的元素拷贝给ww
		}
		System.out.println("请输入你想添加的数");
		int hu=ow.nextInt();//定义一个键盘让用户可以自己添加想添加的数
		ww[ww.length-1]=hu;
		hw=ww;//把ww的数组地址给hw这样hw就成功扩容
		System.out.println("以下为现在hw数组的元素");
		
		for(int j=0;j<hw.length;j++){//查看 现有元素
		System.out.print(hw[j]+" ");
			}
		
		System.out.println(" ");
		System.out.println("是否继续添加 y/n");//询问是否要继续扩容
		char lp=ow.next().charAt(0);
		
	if(lp=='n'){
			break;//退出循环
		
			}
		}while(true);//继续信号
		System.out.println("添加结束");	
	}
}

数组删减

package steam;
		import java.util.Scanner;
		public class steam {
			public static void main(String[] args){
			Scanner ow=new Scanner(System.in);
		int[] hw={1,2,3,4};//定义数组的元素
		int l=0;
		abc:do{
			int[] ww=new int[hw.length-1];
			
		for(int i=0;i<hw.length-1;i++){
			ww[i]=hw[i];
		}		
		hw=ww;
		l++;
		System.out.println("以下为现在hw数组的元素");
		
		for(int j=0;j<hw.length;j++){//查看 现有元素
		System.out.print(hw[j]+" ");
			}
		if(l==4-1){
		System.out.println("只剩下一个元素了,你不能再继续删减了");
		break abc;
		}
		System.out.println(" ");
		System.out.println("是否继续删减 y/n");//询问是否要继续扩容
		char lp=ow.next().charAt(0);
		
	if(lp=='n'){
			break;//退出循环
		
			}
		}while(true);
		System.out.println("删除结束");	
	}
}
		

				
			

排序的介绍

排序是将一群数据,依指定的顺序进行排序的过程。

排序的分类:

1.内部排序:

指将需要处理的所有数据都加载到内部存储器中进行排序。包括(交换式排序法、选择式排序法和插入式排序法);

2.外部排序法:

数据量过大,无法全部加载到内存中。需要借助外部储存进行排序。包括(合并排序法和直接合并排序法)。

冒泡排序法

package steam;
		import java.util.Scanner;
		public class steam {
			public static void main(String[] args){
			Scanner ow=new Scanner(System.in);
			int o=0;//用于储存元素
			int[] w={60,20,50,30,90};//定义一个静态数组
		for(int k=0;k<w.length;k++){	//换w.length次才能全部排序完
			for(int i=0;i<w.length-1-k;i++){//比较几次才能比较完
				if(w[i]>w[i+1]){//如果第一个元素比第二个元素大,那么让两个元素互换位置
					o=w[i];
					w[i]=w[i+1];
					w[i+1]=o;
					}
			}

		}
			for(int l=0;l<w.length;l++){//看效果
				System.out.println(w[l]);	//输出为	20  30  550  60  90		
		
				}		
	
	}
}

查找

package steam;
		import java.util.Scanner;
		public class steam {
			public static void main(String[] args){
			Scanner ow=new Scanner(System.in);
			String[] name={"英梨梨","和泉纱雾","香风智乃","四糸乃"};
			System.out.println("请输入老婆名字");
			String name1=ow.next();//键盘输入
			int p=-1;
			for(int i=0;i<name.length;i++){
				if(name1.equals(name[i])){//equals为 判断字符串
					System.out.println("名字正确");
					p=i;//查找到了p保存i的值
					break;
				}
			}
			if(p==-1){//p==-1说明没有查找到
				System.out.println("没有找到");
			}
	}
}

二维数组

package steam;
		import java.util.Scanner;
		public class steam {
			public static void main(String[] args){
			Scanner ow=new Scanner(System.in);
			int[][] op={{1,2,3,4},
					    {5,6,7,8}};
			for(int p=0;p<op.length;p++){//访问一维数组
				for(int u=0;u<op[p].length;u++){//访问一维数组的各个元素
						System.out.print(op[p][u]+" ");
				}
				System.out.println("");//换行
			}
	}	
}

二维数组的使用

使用方法1:动态初始化

语法:类型[][] 数组名=new 类型[大小][大小]

比如int a[][]=new int[2][3]

使用方法2:动态初始化

先声明:类型 数组名[][];

再定义(开辟空间) 数组名=new 类型[][]

赋值(有默认值,比如int 类型就是0)

比如int a[][];

a=new int[][];

使用方法3:数列不确定

package steam;
		import java.util.Scanner;
		public class steam {
			public static void main(String[] args){
			Scanner ow=new Scanner(System.in);
			int[][] a=new int[3][];
			for(int i=0;i<a.length;i++){
				a[i]=new int[i+1];//new给一维数组开辟空间
				for(int j=0;j<a[i].length;j++){
					a[i][j]=i+1;//给一维数组赋值
				}
				
			}
			for(int i=0;i<a.length;i++){//看结果
				for(int j=0;j<a[i].length;j++){
					System.out.print(a[i][j]+" ");//输出为1     22    333		 
				}
			System.out.println("");//换行
			}
		}	
}

使用方法4:静态初始化

定义 类型 数组名[][]={{值1,值2},{值1,值2},{值1,值2}}

杨辉三角形

package steam;
		import java.util.Scanner;
		public class steam {
			public static void main(String[] args){
			Scanner ow=new Scanner(System.in);
			int[][] a=new int[10][];
			for(int i=0;i<a.length;i++){
				a[i]=new int[i+1];//new给一维数组开辟空间
				for(int j=0;j<a[i].length;j++){
					if(j==0||j==a[i].length-1){
						a[i][j]=1;//最左边和最右边都为1;
					}else{
						a[i][j]=a[i-1][j]+a[i-1][j-1];
						/*中间为上面的数加上面左边的一个数
						 * 比如
						 * 1
						 * 11
						 * 121
						 * 1331
						 * 14641
						 * 
						 * 2=1+1; 3=2+1  4=3+1  6=3+3
						 */
					}
					
				}
				
			}
			for(int i=0;i<a.length;i++){//看结果
				for(int j=0;j<a[i].length;j++){
					System.out.print(a[i][j]+" ");//输出为1     22    333		 
				}
			System.out.println("");//换行
			}
		}	
}

二维数组的细节

1.一维数组的声明方式有:

int[] x或者int x[]

2.二维数组的声明方式有:

int[][] y或者 int[] y[] 或者 int y[][]

3.二维数组实际上是由多个一维数组组成的,他的各个一维数组的长度可以相同。也可以不同。比如:mao[][] 是一个二维数组

mao[][]= {{1,2},{3,4,5}}

由mao[0]是一个含有2个元素的一维数组,mao[1]是一含有三个元素的一维数组构成的,我们也称为列数不等的二维数组。