Java代码的基本格式
java中的程序代码都必须放在一个类中。类需要使用class定义，在class前面可以有一些修饰符，格式如下：
修饰符 class 类名{
程序代码
}
在编写Java代码时，需要特别注意下列几个关键点：
（1）java中的程序代码可分为结构定义语句和功能执行语句，其中，结构定义语句用于声明一个类或方法，功能执行语句用于实现具体的功能。每条功能执行语句的最后都必须用分号（;)结束。
System.out.println("这是第一个java程序");
(2)java语言严格区分大小写。例如，定义一个类时，Computer和computer是两个完全不同的符号，在使用时务必注意。
（3）虽然java没有严格要求用什么格式编写代码，但是出于可读性的考虑，应该让自己编写的程序代码整齐美观、层次清晰。
（4）java程序中一句连续的字符串不可以分开书写，例如，下面这条语句在编译时将会出错：
System.out.println("这是第一个
Java程序"）;
如果为了便于阅读，想将一个太长的字符串分在两行中书写，可以先将这个字符串分成两个字符串，然后用加号（+）将这两个字符串连起来，在加号（+）处断行，上面的语句可以修改成如下形式：
System.out.println("这是第一个"+
"Java程序"）;
java中的注释：
注释是对程序的某个功能或者某行代码的解释说明，它只在java源文件有效，在编译程序时编译器会忽略这些注释信息不会将其编译到class字节码文件中去。
注释是程序员在编写代码时很好的一个习惯。
java中的注释有三种类型，具体如下：
单行注释：通常用于对程序中的某一行代码进行解释，用符号“//”表示，“//”后面为被注释的内容，具体示例如下：
int c=10;//定义一个整型变量
多行注释：顾名思义就是在注释中的内容可以为多行，它以符号“/*”开头，以符号“*/”结尾，多行注释具体实例如下：
/*int c=10;
int x=5;*/
文档注释：以“/**”开头，并在注释内容末尾以“*/”结束。
Java中的标识符：
在编程过程中，经常需要在程序中定义一些符号来标记一些名称：如，包名，类名，方法名，参数名，变量名等，这些符号被称为标识符。
标识符可以由任意顺序的大小写字母、数字、下划线（_）和美元符号（$）组成，但不能以数字开头，不能是Java中的关键字。
最好还应该遵循以下规则：
1、包名所有字母一律小写，例如，cn.itcase.test。
2、类名和接口名每个单词的首字母都要大写。如，ArrayList、Lterator。
3、常量名所有字母都大写，单词之间用下划线连接。例如：DAY_OF_MONTH。
4、变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写。例如：lineNumber、getLineNumber。
5、在程序中，应该尽量使用有意义的英文单词来定义标识符，使得程序便于阅读。例如使用userName表示用户名，password表示密码。
Java中的关键字
关键字是编程语言里事先定义好并赋予了特殊含义的单词，也称作保留字，和其它语言一样，Java中保留了许多关键字，例如，class、public等，下面列举Java中所有的关键字：
| abstract | boolean | break | byte | case | catch | char |
| const | class | continue | default | do | double | else |
| extends | false | final | finally | float | for | goto |
| if | implement | import | instanceof | int | interface | long |
| native | new | null | package | private | protected | public |
| return | short | static | strictfp | super | switch | this |
| throw | throws | transient | true | try | void | volatile |
| while | synchronized |
Java中的常量：
常量就是在程序中固定不变的值，是不能改变的数据。
在Java中，常量包括整型常量、浮点数常量、布尔常量、字符常量等。
1、整型常量
整型常量是整数类型的数据，他的表现形式有四种，具体如下：
二进制：由数字0和1组成的数字序列，如：00110101.
八进制：以0开头并且其后由0~7范围（包括0和7）内的整数组成的数字序列，如0342
十进制：由数字0~9（包括0和9）内的整数组成的数字序列。如：198.整数以十进制表示时，第一位不能是0，0本身除外
十六进制：以0x或则0x开头并且其后由0~9、A~F（包括0和9、A和F）组成的数字序列，如0x25AF。
2、浮点数常量
浮点数常量就是在数学中用到的小数，分为float单精度浮点数和double双精度浮点数两种类型。其中，单精度浮点数后面以F或f结尾，而双精度则以D或d结尾。当然，在使用浮点数常量还可以通过指数形式来表示。具体示例如下：
2e3f 3.6d 0f 3.84d 5.022e+23f
上述列出的浮点数常量中用到的e和f，初学者可能会感到困惑，在后面的2.2.2小节中将会详细介绍。
3、字符常量
字符常量用于表示一个字符，一个字符常量要用一对英文半角格式的单引号（' ')引起来，它可以使英文字母、数字、标点符号、以及由转义序列来表示的特殊字符。具体示例如下：
'a' '1' '&' '\r' '\u0000'
上面的示例中，'\u0000'表示一个空白字符，即在单引号之间没有任何字符。之所以能这样表示是因为，Java采用的是Unicode字符集，Unicode字符以\u开头，空白字符在Unicode码表中对应的值为'\u0000'。
4、字符串常量
字符串常量用于表示一串连续的字符，一个字符串常量要用一对英文半角格式的双引号（" "）引起来，具体示例如下：
"HelloWorld" "123" "Welcome \nm XXX" " "
一个字符串可以包含一个字符或多个字符，也可以不包含任何字符，即长度为零。
5、布尔常量
布尔常量即布尔型的两个值true和false，该常量用于区分一个事务的真与假。
6、null常量
null常量只有一个值null，表示对象的引用为空。
变量的定义
在程序运行期间，随时可能产生一些临时数据，应用程序会将这些数据保存在一些内存单元中，每个内存单元都用一个标识符来标识。这些内存单元我们称之为变量，定义的标识符就是变量名，内存单元中存储的数据就是变量的值。
下方的代码中，第一行代码的作用就是定义了两个变量x和y，也就是相当于分配了两块内存单元，在定义变量的同时变量x分配了一个初始值0，而变量y没有分配初始值。
int x=0，y;
y=x+3;
变量的数据类型
Java是一门强类型的编程语言，他对变量的数据类型有严格的限定。在定义变量时必须声明变量的类型，在为变量赋值时必须赋予和变量同一种类型的值，否则程序会报错。
1、整型类型变量
用来存储整数数值，即没有小数部分的值。
整数类型分为四种不同的类型：字节型(byte)、短整型（short）、整型（int)\和长整型（long)
| 类型名 | 占用空间 | 取值范围 |
|---|---|---|
| byte | 8位（1个字节） | -2^7~2^7-1 |
| short | 16位（2个字节） | -2^15~2^15-1 |
| int | 32位（4个字节） | -2^31~2^31-1 |
| long | 64位（8个字节） | -2^63~2^63-1 |
占用空间指的是不同类型的变量分别占用的内存大小
取值范围是变量存储的值不能超出的范围
2、浮点类型变量
浮点数类型用来存储小数数值。
浮点数类型分为两种：单精度浮点数（float）、双精度浮点数（double），double型所表示的浮点数比float型更精确。
| 类型名 | 占用空间 | 取值范围 |
| float | 32位（4个字节） | 1.4E-45~3.4E+38~-1.4E-45 |
| double | 64位（8个字节） | 4.9E-324~1.7E+308~-4.9E-324 |
在取值范围中，E表示以10为底的指数，E后面的”+“号和”-“号代表正指数和副指数，例如1.4E-45表示1.4*10^-45。
在为一个float类型的变量赋值时需要注意一点，所赋值的后面一定要加上字母“F”（或“f”），而为double类型的变量赋值时，可以在所赋值的后面加上字符“D”或“d”，也可以不加。
在程序中也可以为一个浮点数类型变量赋予一个整数数值。
3、字符类型变量
用于存储一个单一字符，在Java中用char表示
每个char类型的字符变量都会占用2个字节。
赋值时，要用英文半角格式的单引号（'')把字符括起来，例如’a',
也可以赋值为0~55535范围的整数，计算机会自动即将整数转化为所对应的字符，如数值97对应的字符为‘a’。
4、布尔类型变量
布尔类型变量用来存储布尔值，在Java中用boolean表示，该类型的变量只有两个值，即true和false。具体示例如下：
boolean flag=false //声明一个boolean类型的变量，初始值false
flag=true//改变fla变量的值为true
变量的类型转换
当把一种数据类型的值赋给另一种数据类型的变量时，需要进行数据类型转换。根据转换方式的不同，数据类型转换可分为两种：自动类型转换和强制类型转换。（布尔类型不参为强制类型转换）
1、自动类型转换
也叫隐式类型转换，指的是两种数据类型在转换的过程中不需要显示地进行声明。
要实现自动类型转换，必须同时满足两个条件：
第一个是两种数据类型彼此兼容
第二个是目标类型的取值范围大于原类型的取值范围。
例：
byte b=3;
int x=b;//程序把byte类型的变量b转换成了int类型，无需特殊声明
（1）整数类型之间可以实现转换，如byte类型的数据可以赋值给short、int、long类型的变量，short、char类型的数据可以赋值给int 、long类型的变量，int类型的数据可以赋值给long类型的变量
（2）整数类型转换为float类型，如byte、char、short、int类型的数据可以赋值给float类型的变量。
（3）其他类型转换为double类型，如byte、char、short、int类型的数据可以赋值给float类型的数据可以赋值给double类型的变量。
2、强制类型转换
强制类型转换也叫显示类型转换，指的是两种数据类型之间的转换需要进行显示地声明。
当两种类型彼此不兼容，或者目标类型取值范围小于原类型时，自动类型转换无法进行，这时就需要进行强制类型转换
强制类型转换的格式如下所示：
目标类型 变量 =（目标类型）值
变量的作用域
变量需要在他的作用范围内才可以被使用这个作用范围称为变量的作用域。
在程序中，变量一定会被定义在某一对大括号中，该大括号所包含的代码区域便是这个变量的作用域
算术运算符
算术运算符就是用来处理四则运算的符号，这是最简单、最常用。
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| + | 正号 | +3 | 3 |
| - | 负号 | b=4；b； | -4 |
| + | 加 | 5+5 | 10 |
| - | 减 | 6-4 | 2 |
| * | 乘 | 3*4 | 12 |
| / | 除 | 5/5 | 1 |
| % | 取余（即算数中的求余数） | 7%5 | 2 |
| ++ | 自增（前） | a=2;b=++a; | a=3;b=3 |
| ++ | 自增（后） | a=2；b=a++; | a=3;b=2; |
| -- | 自减（前） | a=2;b=--a; | a=1;b=1; |
| -- | 自减（后） | a=2;b=a--; | a=1;b=2; |
算术运算符在实际使用时的注意事项：
（1）在进行自增（++）和自减（--）的运算时，如果运算符放在操作数前面则是先进性自增或自减运算，在进行其他运算。反之，如果运算符放在操作数的后面则是先进进行其他运算再进行自增或自减运算。
（2）在进行除法运算时，当除数和被除数都为整数时，得到的结果也是一个整数。如果除法运算有小数参与，得到的结果会是一个小数。
（3）在进行取余（%）运算时，运算结果的正负取决于被模数（%左边的数）的符号，与模数（%右边的数无关）。
赋值运算符
赋值运算符的作用就是将常量、变量、或表达式的值赋给某一个变量，表中列出了Java中的赋值运算符及用法。
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| = | 赋值 | a=3;b=2; | a=3;b=2; |
| += | 加等于 | a=3;b=2;a+=b; | a=5;b=2; |
| -= | 减等于 | a=3;b=2;a-=b; | a=1；b=2; |
| *= | 乘等于 | a=3;b=2;a*=b; | a=6；b=2; |
| /= | 除等于 | a=3;b=2;a/=b; | a=1;b=2; |
| %= | 模等于 | a=3;b=2;a%=b; | a=1;b=2; |
再赋值运算符的使用中，需要注意以下几个问题：
（1）再java中可以通过一条赋值语句对多个变量进行赋值
int x,y,z;
x=y=z=5;//为三个变量同时赋值
int x=y=z=5;//这样写是错误的
（2）除了“=”，其他的都是特殊的赋值运算符，以“+=”为例，x+=3就相当于x=x+3,首先会进行加法运算x+3，再将运算结果赋值给变量x，-=、*=、/=、%=赋值运算符都可以依此类推。
注意：在位变量赋值时，当两种类型彼此不兼容，或者目标类型取值范围小于源类型，需要进行强制类型转换。
然而在使用+=、-=、*=、/=、%=运算符进行赋值时，强制类型转换会自动完成，程序不需要做任何地显式声明。
比较运算符
比较运算符用于对两个数值或变量进行比较，其结果是一个布尔值，即true或false。
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| == | 相等于 | 4==3 | false |
| ！= | 不等于 | 4！=3 | true |
| < | 小于 | 4<3 | false |
| > | 大于 | 4>3 | true |
| <= | 小于等于 | 4<=3 | false |
| >= | 大于等于 | 4>=3 | true |
比较运算符在使用时需要注意一个问题，不能将比较运算符“==”误写成赋值运算符“=”。
逻辑运算符
逻辑运算符用于对布尔型的数据进行操作，其结果仍是一个布尔型
| 运算符 | 运算 | 范例 | 结果 | |
|---|---|---|---|---|
| & | 与 | true&true | true | |
| true&false | false | |||
| false&false | false | |||
| false&true | false | |||
| | | 或 | true|true | true | |
| true|false | true | |||
| false|false | false | |||
| false|true | true | |||
| ~ | 异或 | true^true | false | |
| true^false | true | |||
| false^false | false | |||
| false^true | true | |||
| ! | 非 | !true | false | |
| !false | true | |||
| && | 短路与 | true&&true | true | |
| true&&flase | false | |||
| false&&false | false | |||
| false&&true | false | |||
| || | 短路与 | true||true | true | |
| true||false | true | |||
| false||true | true | |||
| false||false | false | |||
在使用逻辑运算符的过程中，需要注意以下几个细节：
（1）逻辑运算符可以针对结果为布尔值的表达式进行运算。如：x>3&&y!=0。
（2）运算符“&”和“&&”都表示与操作，当且仅当运算符两边的操作数都为true时，其结果才为true，否则结果为false。当运算符“&”和“&&”的右边为表达式时，两者在使用上还有一定的区别。在使用“&”进行运算时，不论左边为true或者false，右边的表达式都会进行运算。如果使用“&&”进行运算，当左边为false，右边的表达式不会进行运算，因此“&&”被称作短路与。
运算符的优先级
在对一些比较复杂的表达式进行运算时，要明确表达式中的所有运算符参与运算的先后顺序，把这种顺序称作运算符的优先级。
| 优先级 | 运算符 |
|---|---|
| 1 | [] () . |
| 2 | ++ -- ~ !(数据类型） |
| 3 | * / % |
| 4 | + - |
| 5 | << >> >>> |
| 6 | < > <= >= |
| 7 | == != |
| 8 | & |
| 9 | ^ |
| 10 | | |
| 11 | && |
| 12 | || |
| 13 | ?: |
| 14 | = *= /= %= += -= < <= > >= >>>= ^= |
商城的库存清单案例
package heima;
/*
* 商城库存清单案例
* 变量的形式对商品的数据保存
* 品牌，尺寸大小，价格，配置，库存数量
* 三个商品苹果，thinkpad，华硕
*
* 计算出总的库存数，和商品的总金额
*/
public class SroreList {
public static void main(String[] args) {
//苹果笔记本电脑
String macBrand="MacBookAir";
double macSize=13.3;
double macPrice=6988.88;
String macConfig="i5处理器4GB内存128GB固体硬盘";
int macCount=5;
//联想Thinkpad笔记本电脑
String thinkpadBrand="ThinkpadT450";
double thinkpadSize=14.0;
double thinkpadPrice=5999.99;
String thinkpadConfig="i5处理器4GB500G硬盘";
int thinkpadCount=10;
//华硕ASUS笔记本电脑
String ASUSBrand="ASUS-FL5800";
double ASUSSize=15.6;
double ASUSPrice=4999.50;
String ASUSConfig="i7处理器4G内存128固态硬盘";
int ASUSCount=18;
//列表的顶部
System.out.println("--------------------商城库存清单--------------------");
System.out.println("品牌型号 尺寸 价格 配置 库存数");
//列表的中部
System.out.println(macBrand+" "+macSize+" "+macPrice+" "+macConfig+" "+macCount);
System.out.println(thinkpadBrand+" "+thinkpadSize+" "+thinkpadPrice+" "+thinkpadConfig+" "+thinkpadCount);
System.out.println(ASUSBrand+" "+ASUSSize+" "+ASUSPrice+" "+ASUSConfig+" "+ASUSCount);
//统计总库存数 总库存金额
int totalCount=macCount+thinkpadCount+ASUSCount;
double totalMoney=(macPrice*macCount)+(thinkpadPrice*thinkpadCount)+(ASUSPrice*ASUSCount);
//列表的底部
System.out.println("------------------------------------------------");
System.out.println("总库存是："+totalCount);
System.out.println("库存商品总金额："+totalMoney);
}
}
输出：
选择结构语句
if语句
if条件语句分为三种语法格式，具体如下:
(1)if语句
(2) if...else语句
(3) if...else if...else语句
1、if语句:
>if语句是指如果满足某种条件，就进行某种处理，其语法格式如下所示:
if(条件语句）{
语句块}
>上述语法格式中，判断条件是一个布尔值，当值为true时，才会执行{}中的语句。
执行代码如图：
2、if...else语句
>if...else语句是指如果满足某种条件，就进行某种处理，否则就进行另一种处理，其语法格式如下所示:
if(判断条件）{
执行语句1}
else{
执行语句2}流程图如下：
在Java中有一种特殊的运算叫做三元运算，它和if-else语句类似，语法如下:
判断条件 ?表达式1 :表达式 2
>三元运算通常用于对某个变量进行赋值，当判断条件成立时，运算结果为表达式1的值，否则结果为表达式2的值。
int x=0;
int y=1;
int max;
if(x>y){
max=x;}
else{
max=y}等价于
int max =x>y?x:y;3、if...else if...else语句
if...else if ...else语句用于对多个条件进行判断，进行多种不同的处理，其语法格式如下所示:
if(判断条件1）{
执行语句1}
else if(判断条件2）{
执行语句2}
……
else if（判断条件n）{
执行语句n}
else{
执行语句n+1}
switch条件语句
>switch语句也是一种很常见的选择语句。和if条件语句不同，它只能针对某个表达式的值做出判断，从而决定执行哪一段代码。
在switch语句中，使用switch关键字来描述一个表达式，使用case关键字来描述和表达式结果比较的目标值，当表达式的值和某个目标值匹配时，会执行对应case下的语句，switch语句的基本语法结果如图所示。
switch(表达式）{
case 目标值1：
执行语句1
break；
case 目标值2：
执行语句2
break；
……
case 目标值n：
执行语句n
break；
default:
执行语句n+1
break;
}需要注意的是，在switch语句中的表达式只能是byte、short、char、int、枚举(JDK1.5引入的)、String类型 (JDK1.7引入的的值，如果传入其他值，程序会报错.
在使用switch语句的过程中，如果多个case条件后面的执行语句是一样的，则该执行语句只需书写一次即可。Ce>例如，要判断一周中的某一天是否为工作日，同样使用数字1~7来表示星期一到星期天，当输入的数字为1、2、3、4、5时就视为工作日，否则就视为休息日.
while循环语句
while语句和if条件语句有点类似，都是根据条件判断来决定是否执行后面的代码，区别在于，while循环语句会反复地进行条件判断，只要条件成立，0内的执行语句就会执行，直到条件不成立，while循环结束。
>while循环语句的语法结构如下所示:
while(循环条件）{
语句块}while循环语句的执行流程图如下图所示：
do…while循环语句
do...while循环语句和while循环语句功能类似，其语法结构如下所示：
do{
执行语句块
}while（循环条件）do……while流程图：
for循环语句
for循环语句是最常用的循环语句，一般用在循环次数已知的情况下，其语法格式如下所示:
for(初始化表达式;循环条件;操作表达式）{
执行语句
……}
在上述语法格式中，for后面的 () 中包括三部分内容，初始化表达式、循环条件和操作表达式，它们之间用“;"分隔，{}中的执行语句为循环体
如果用1表示初始化表达式、2表示循环条件、3表示操作表达式、4表示循环体，则for循环的执行流程如下所示:
for(1;2;3){
4}
第一步，执行1
第二步，执行2，如果判断结果为 true，执行第三步，如果判断结果为 false，执行第五步
第三步，执行4
第四步，执行3，然后重复执行第二步
第五步，退出循环。
循环嵌套
嵌套循环是指在一个循环语句的循环体中再定义一个循环语句的语法结构。while、do...while、for循环语句都可以进行嵌套，并且它们之间也可以互相嵌套，如最常见的在for循环中嵌套for循环格式如下:
for(初始化表达式;循环条件；操作表达式）{
……
for（初始化表达式；循环条件；操作表达式）{
……
}
……
}跳转语句 (break、continue)
跳转语句用于实现循环执行过程中程序流程的跳转，在Java中的跳转语句有break语句和continue语句
1、break语句:用在switch条件语句和循环语句中，它的作用是终止某个case并跳出switch结构。
2、continue语句:用在循环语句中，它的作用是终止本次循环，执行下一次循环
猜数字游戏
public static void main(String[] args) {
// TODO Auto-generated method stub
//1.通过Random类中的nextInt (n)方法，生成一个0-9之间的随机数
int randomNumber = new Random().nextInt(10);
System.out.println("随机数已生成!");
//2.输入猜的数字
System.out.println("----请输入您猜的数字----");
Scanner sc = new Scanner(System.in);
int enterNumber = sc.nextInt ();
//3.通过while循环，进行猜数字对错判断
while(enterNumber!=randomNumber){
//猜错了，根据结果,给出提示,接着猜数字,游戏继续
if(enterNumber > randomNumber) {
//如果猜大了,打印sorry，您猜大了!继续下一次循环
System.out.println("sorry,您猜大了!");}
else {
//如果猜小了,打印sorry,您猜小了!继续下一次循环
System.out.println("sorry,您猜小了!");}
//输入猜的数字
System.out.println("----请输入您的数字:----");
enterNumber = sc.nextInt ();
}
}方法的定义及使用
在Java中，声明一个方法的具体语法格式如下所示:
修饰符 返回值类型 方法名（[参数类型 参数名1，参数类型 参数名2，……]）{
执行语句
……
return 返回值；
}修饰符:是对访问权限的限定，例如，public、static都是修修饰符
返回值类型:用于限定方法返回值的数据类型
参数类型:用于限定调用方法时传入参数的数据类型。
参数名:是一个交量，用于接收调用方法时传入的数据。
retum关键宇:用于结束方法以及返回方法指定类型的值
返回值:retum语句返回的值，该值会返回调用者
方法的重载
Java允许一个程序定义多个名称相同的方法，但是参数的类型或个数必须不同，这就是方法的重载。
数组
数组是指一组数据的集合，数组中的每个元素被称为元素，在数组中可以存放任意类型的元素，但同一个数组中存放的元素类型必须一致。
>在Java中，可以使用下列格式定义一个数组，具体示例如下:
int[] x=new int[100];上述语句就相当于在内存中定义了100个int类型的变量，第一个变量的名称为x[0]，第二个变量的名称为x[1]，以此类推，第100个变量的名称为x[99]，这些变量的初始值都是0。
为了更好地理解数组的定义方式，可以把上述代码定义为两行来
写，具体如下:
int []x;//定义一个int[]类型的变量
x=new int [100]//创建一个长度为100的数组接下来，通过两张内存图来说明数组在创建过程中的内存分配情况，具体如下所示:
在Java中，为了方便我们获得数组的长度，提供了一个length属性在程序中可以通过“数组名.length”的方式来获得数组的长度，即元素的个数。
当数组被成功创建后，数组中元素会被自动赋予一个默认值，根据元素类型的不同，默认初始化的值也是不一样的。
| 数据类型 | 默认初始化 |
|---|---|
| byte、short、int、long | 0 |
| float、double | 0.0 |
| char | 一个空字符 |
| boolean | false |
| 引用数据类型 | null，表示变量不引用任何对象 |
静态初始化
在初始化数组时还有一种方式叫做静态初始化，就是在定义数组的同时就为数组的每个元素赋值。数组的静态初始化有两种方式:
1.类型[]数组名=new类型[]{元素，元素……}；
2类型[]数组名={元素，元素……}；数组的常见操作
1、数组的遍历
在操作数组时，经常需要依次访问数组中的每个元素，这种操作叫做数组的遍历。
(int[]arr=({,2,3,4,5};// 定义数组使用for循环遍历数组的元素
//使用for循环遍历数组的元素
for(int i=0 :i<arr.length;i++){
System.out.printn(arr[i]);// 通过索引访问元素}2、数组最值
在操作数组时，经常需要获取数组中元素的最值。
3、数组排序
数组排序的过程如下:
(1)从第一个元素开始，将相邻的两个元素依次比较，直到最后两个元素完成比较，如果第一个元素比后一个大，则交换位置。整个过程完成后，数组中最后一个元素就是最大值
(2)除最后一个元素，将剩余的元素继续进行两两比较，过程与第一步类似，这样数组中第二大的元素放在了倒数第二个位置
(3)以此类推，持续对越来越少的元素重复上面的步骤，直到没有任何一个元素需要比较为止。在操作数组时，经常需要对数组中的元素进行排序，其中冒泡排序是比较常见的一种算法。冒泡过程中，不断比较数组中相邻的两个元素，较小者向上浮，较大者往下沉，整个过程和水中气泡上升的原理相似。
多维数组
多维数组
多维数组可以简单地理解为在数组中嵌套数组。在程序中比较常见的就是二维数组。
二维数组的定义有很多方式,具体如下:
。方式一:
int[]arr=new int[3][4];
上面的代码定义了一个3行4列的二维数组，它的结构如下图所示：
方式二：
int[]arr=new int[3][];上述方式与第一种方式类似，只是数组中每个元素的长度不确定，采用第二种方式常见的数组结构如下图所示。
方式三:
int[][]arr={{1,2},{3,4,5,6},{7,8,9}}采用上述方式定义的二维数组有三个元素，这三个元素都是数组分别是{1,2}、{3,4,5,6}、7,8,9Jo
接下来，通过一张图来描述方式三定义的数组结构：
>多维数组对元素的访问也是通过角标的方式，例如，访问二维数组中第一个元素数组的第二个元素的方式如下所示:
arr[0][1];数组的定义
数组是指一组数据的集合，数组中的每个元素被称为元素，在数组中可以存放任意类型的元素，但同一个数组中存放的元素类型必须一致。
>在Java中，可以使用下列格式定义一个数组，具体示例如下:
int[] x =new int[100];.
>上述语句就相当于在内存中定义了100个int类型的变量，第一个变量的名称为x[0]，第二个变量的名称为x[1]，以此类推，第100个变量的名称为x[99]，这些变量的初始值都是0。
package heima;
import java.util.Scanner;
public class CallName {
public static void addStudentName(String[] students) {
Scanner sc = new Scanner(System.in);
for(int i =0 ;i < students.length ; i++) {System.out.println("存储第"+(i+1)+"个名");
students[i]=sc.next();
}
}
//总揽全班同学姓名
public static void printStudentName(String[] students){
//遍历数组，得到每个同学姓名
for(int i=0;i<students.length;i++) {
String name= students[i];
System.out.println("第"+(i+1)+"个学生姓名:"+name);
}
}
//随机
public static void main(String[] args) {
// TODO Auto-generated method stub
// 创建一个可以存储多个同学姓名的容器(数组
String[] students = new String[3];
//存储全班同学姓名
addStudentName(students);
//2.总揽全班同学姓名
printStudentName(students);
//随机点出其中一人
String randomName = randomStudentName(students);
System.out.println("被点到名字的同学是:"+ randomName);
}
}
扫一扫
702
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
