1-1java的介绍和前景
使用Java语言写的程是跨平台的，从PC 机到手电话都有Java开发的程和游戏，Java程可任计算机操作系统和支持Java的硬件设备上运行。
Java是于1995年由Sun公司推出的一种极富创造力的面向对象的程序设计语言，它是由有java之父之称的Sun研究院院士詹姆斯·戈士林博士亲手设计而成的，并完成了 Java技术的原始编译器和虚拟机。Java最初的名字是OAK，在1995年被重命名为 Java，正式发布。
Java是一种通过解释方式来执行的语言，其语法规则和C++类似。同时，Java也是一种跨平台的程序设计语言。用Java语言编写的程序，可以运行在任何平台和设备上，如跨越IBM 个人电脑、 MAC 苹果计算机、各种微处理器硬件平台，以及Windows、UNIX、OS/2MACOS等系统平台，真正实现了“一次编写，到处运行”。Java 非常适于企业网络和Internet 环境，并且已成为Internet中最具有影响力、最受欢迎的编程语言之一。
与目前常用的C++相比，Java语言不仅简洁，而且提高了可靠性，除去了最大的程序错误根源，此外它还有较高的安全性，可以说它是有史以来最为卓越的编程语言。
Java语言编写的程序既是编译型的，又是解释型的。程序代码经过编译之后转换为一种称为Java字节码的中间语言，Java虚拟机(JVM)将对字节码进行解释和运行。编译只进行一次，而解释在每次运行程序时都会进行。编译后的字节码采用一种针对JVM优化过的机器码的形式保存，虚拟机将字节码解释为机器码，然后在计算机上运行。
1-2Java的特征性与版本
自从Sun公司推出Java以来，就力图使之无所不能。java发展至今，按应用范围分为3个版本，即 Java SE、Java EE 和 Java ME，也就是Sun ONE (Open Net Environment)体系。
Java的版本区别
J2SE:标准版,提供了Java语言最核心的功能，是其他版本的基础
J2EE:企业版,针对企业级应用开发提供了更多高级功能
J2ME:嵌入式版，可为智能设备开发应用程序，目前已极少使用
1-3我与java第一次接触
在线网编辑器
public class hellojava { //创建一个 hellojava 的类
public static void main(String[] args) { //主函数
System.out.println(" Hello java"); //输出 Hello java
}
}
第二章 java语言基础
注释
1.单行注释 //为单行注释标记，从符号“//"开始直到换行为止的所有内容均作为注释释而被编译器忽略。语法如下:
//注释内容
例如，以下代码为声明的int型变量添加注释:
int age;
//声明int型变量用于保存年龄信息
2.多行注释 /**/为多行注释标记，符号“/*”与“*/”之间的所有内容均为注释内容。注释中的内容可
2.1 关键词
2.2 认识Java标识符
使用标识符时，需要遵守几条规则：
1. 标识符可以由字母、数字、下划线（_）、美元符（$）组成，但不能包含 @、%、空格等其它特殊字符，不能以数字开头。譬如：123name 就是不合法滴
2. 标识符不能是 Java 关键字和保留字（ Java 预留的关键字，以后的升级版本中有可能作为关键字），但可以包含关键字和保留字。如：不可以使用 void 作为标识符，但是 Myvoid 可以
3. 标识符是严格区分大小写的。 所以涅，一定要分清楚 imooc 和 IMooc 是两个不同的标识符哦！
4. 标识符的命名最好能反映出其作用，做到见名知意。
如果我们把变量比作是酒店的房间，要存储的数据就好比要住宿的客人，我们可以根据客人的要求安排其入住“标准间”或者是“总统套房”，并且可以根据房间名字快速查找到入住客人的信息。同理，在 Java 程序中，我们也可以根据所需要保存的数据的格式，将其保存在指定类型的变量空间中，并且通过变量名快速定位！
public class HelloWorld{
public static void main(String[] args){
System.out.println("helloword!");
}
}
2.3变量是什么（练习题）
变量
（1）变量名必须是一个有效标识符。
（2）变量名不可以使用java 中的关键字。
（3）变量名不能重复。
（4）应选择有意义的单词作为变量名。
2.4如何命名Java变量
如同酒店会给每个房间起个性化的名字一样，程序中的变量也需要用合理的名字进行管理---变量名！
2.5Java中的数据类型
通常情况下，为了方便物品的存储，我们会规定每个盒子可以存放的物品种类，就好比在“放臭袜子的盒子”里我们是不会放“面包”的！同理，变量的存储也讲究“分门别类”！
Java 语言是一种强类型语言。通俗点说就是，在 Java 中存储的数据都是有类型的，而且必须在编译时就确定其类型。 Java 中有两类数据类型：
类型转换
是将一个值从 一种类型更改为另种类型的过程。 例如，不仅可以将String类型数据“457”转换为一个数值型，而且可以将任意类型的数据转换为String类型。
如果从低精度数据类型向高精度数据类型转换，则永远不会溢出，并且总是成功的:而把高精度数据类型向低精度数据类型转换则必然会有信息丢失，有可能失败。
数据类型转换有两种方式，即隐式转换与显式转换。
目标类型大于源类型，如 double 类型长度为 8 字节， int 类型为 4 字节，因此 double 类型的变量里直接可以存放 int 类型的数据，但反过来就不可以了
任务
请在编辑器中，main 方法内的空白处编写代码，定义两个变量，分别保存“我爱慕课网”以及“www.imooc.com”这两个字符串，并实现打印输出
public class HelloWorld{
public static void main(String[] args) {
String s1 = "我爱慕课网";
String s2 = "www.imooc.com";
System.out.println(s1 + "\n" +s2);
}
}2.6Java中的数据类型
通常情况下，为了方便物品的存储，我们会规定每个盒子可以存放的物品种类，就好比在“放臭袜子的盒子”里我们是不会放“面包”的！同理，变量的存储也讲究“分门别类”！
Java 语言是一种强类型语言。通俗点说就是，在 Java 中存储的数据都是有类型的，而且必须在编译时就确定其类型。 Java 中有两类数据类型：
在 Java 的领域里，基本数据类型变量存的是数据本身，而引用类型变量存的是保存数据的空间地址。说白了，基本数据类型变量里存储的是直接放在抽屉里的东西，而引用数据类型变量里存储的是这个抽屉的钥匙，钥匙和抽屉一一对应。
常用的基本数据类型有：
你可能已经注意到了：
注：关于 float 型和 double 型的区别，以及 char 型和 String 型的不同，在 wiki 中有相关的总结，小伙伴们可以去查看哦~~
String 是一种常见的引用数据类型，用来表示字符串。在程序开发中，很多操作都要使用字符串来完成，例如系统中的用户名、密码、电子邮箱等。
PS：关于引用类型的其他小伙伴们，在后面课程中会详细讲到滴。
任务
试试手气吧~！
下面的数据该使用哪种类型的变量进行保存呢？
public class HelloWorld{
public static void main(String[] args) {
String name="爱慕课";
char sex='男';
int num=18;
double price=120.5;
boolean isOK=true;
System.out.println(name);
System.out.println(sex);
System.out.println(num);
System.out.println(price);
System.out.println(isOK);
}
}
2.7Java中的自动类型转换
在 Java 程序中，不同的基本数据类型的数据之间经常需要进行相互转换。例如：
代码中 int 型变量 score1 可以直接为 double 型变量 score2 完成赋值操作，运行结果为： 82.0
这种转换称为自动类型转换。
当然自动类型转换是需要满足特定的条件的：
1. 目标类型能与源类型兼容，如 double 型兼容 int 型，但是 char 型不能兼容 int 型
2. 目标类型大于源类型，如 double 类型长度为 8 字节， int 类型为 4 字节，因此 double 类型的变量里直接可以存放 int 类型的数据，但反过来就不可以了
自增和自减运算符
是单目运算符，可以放在变量之前，也可以放在变量之后。自增和自减运算符的作用是使变量的值增1或减1。
public class HelloWorld{ //创建类
public static void main(String[] args) { //主方法
String city="南宁"; //输出我的家乡在南宁
System.out.println("我的家乡在："+city); //输出我家乡所在的城市
}
}
2-8练习题
2.9Java中的强制类型转
在 Java 程序中，不同的基本数据类型的数据之间经常需要进行相互转换。例如：
，
代码中 int 型变量 score1 可以直接为 double 型变量 score2 完成赋值操作，运行结果为： 82.0
这种转换称为自动类型转换。
当然自动类型转换是需要满足特定的条件的：
1. 目标类型能与源类型兼容，如 double 型兼容 int 型，但是 char 型不能兼容 int 型
2. 目标类型大于源类型，如 double 类型长度为 8 字节， int 类型为 4 字节，因此 double 类型的变量里直接可以存放 int 类型的数据，但反过来就不可以了
8.1隐式转换
从低级类型向高级类型的转换，系统将自动打执行，程序员无须进行任何操作。这种类型的转换称为隐式转换，也可以称为自动转换。下列基本类数据类型会涉及数据转换，不包括逻辑类型。这些类型按精度从“低”到“高”排列的顺序为 byte<short<int<long<float<double。
8.2显式转换
当把高精度的变量值赋给低精度的变量时 必须使用显式类型转换运算(又称强制类型转换)，
当执行显式类型转换时可能会导致精度损失。
语法如下:
(类型名)要转换的值
9、运算符
运算符是一些特殊的符号，主要用于数学函数、一些类型的赋值语句和逻辑比较方面。Java中提供了丰富的运算符，如赋值运算符、算术运算符和比较运算符等。
9.1赋值运算符
赋值运算符以符号“=”表示，它是一个双目运算符(又对两个操作数做处理)，其功能是将右边操作数所含的值赋给左边的操作数。例如:
inta=100; //该表达式是将100赋值给变量a
左边的操作数必须是一个量，而右边的操作数则可以是变量(如 a、number)、常量(如 123、'book)、有效的表达式(如45*12)。
9.2算术运算符
Java中的算术运算符主要有+(加号)、-(减号)、*(乘号)、/(除号)、%(求余)，它们都是双目运算符。
9.3自增和自减运算符
自增和自减运算符是单目运算符，可以放在变量之前，也可以放在变量之后。自增和自减运算符的作用是使变量的值增1或减1.
a++; ++a a--; --a
符合在前 ++i --i 先计算后使用
符合在后 i++ i-- 先使用后计算
9.4关系运算符
关系运算符属于双目运算符，用来判断一个操作数与另外一个操作数之间的关系。关系运算符的计算结果都是布尔类型的。
9.5 逻辑运算符
假定某面包店，在每周二的下午7点至8点和每周六的下午5点至6点，对生日蛋糕商品进行折扣让利活动，那么想参加折扣活动的顾客，就要在日时间上满足这样的条件，周二并且7:00 PM~8:00PM或者周六并且5:00PM~6:00PM，这里就用到了逻辑关系。
逻辑运算符是对真和假这两种逻辑值进行运算，运算算后的结果仍是一个逻辑值。逻辑运算符包括&&(逻辑与)、(逻辑或)、!(逻辑非)。逻辑运算符计算的值必须是 boolean 型数据。在逻辑运算符中，除了“!”是单目运算符之外，其他都是双目运算符。
9.6 位运算符
位运算的操作数类型是整形，可以有符号的，也可以是无符号的，位运算符可以分为两大类，位逻辑运算符和位移运算符。
1、位逻辑运算符
位逻辑运算符包括&、、^和~，前三个是双目运算符，第四个是单目运算符。
2、移位运算符
移位运算有三个，分别是左移<<、右移>>和无符号右移>>>，这三个运算符都是双目的。
9.7复合赋值运算符
和其他主流编程语言一样，Java 中也有复合赋值运算符。所谓的复合赋值运算符，就是将赋值运算符与其他运算符合并成一个运算符来使用，从而同同时实现两种运算符的效果。
9.8三元运算符
三元运算符的使用格式为:条件式?值1:值2
三元运算符的运算规则为:若条件式的值为truc，则整个表达式取值1，否则取值 2
9.9 圆括号
圆括号可以提升公式中计算过程的优先级，在编程中常用，使用圆括号更改运算的优先级，可以得到不同的结果
9.10运算符优先级
和其他主流编程语言一样，Java 中也有复合赋值运算符。所谓的复合赋值运算符，就是将赋值运算符与其他运算符合并成一个运算符来使用，从而同同时实现两种运算符的效果。
技巧:
在编写程序时尽量使用括号“()”运算符来限定运算次序，以免产生错误的运算顺序。
10、 程序结构
顺序结构、选择结构和循环结构是结构化程序设计的3种基基本结构，是各种复杂程序的基本构造单元。图31展示了这3种程序结构的基本理念，其中，第一幅高图是顺序结构的流程图，它就是按照书写顺序执行的语句构成的程序段;第二幅图是选择结构的流程程图，它主要根据输入数据和中间结果的不同选择执行不同的语句，选择结构主要由条件语句(也叫判断语句或者分支语句)组成;而第三幅图是循环结构的流程图，它是在一定条件下反复执行某段程序的流程结构，其中，一组被重复执行的语句称为循环体，而决定循环是否终止的判断条件是循环条件，循环结构主要由循环语句组成。
我们之前编写的程序都是顺序结构，比如定义一个int类型的变量并输出，代码如下: int a = 15;
System.out.println(a);
程序3种基本结构流程图
10.1条件语句
在生活中，用户选择的情况非常多，比如，当一个人走到岔路口时，摆在面前的有两条路，那么应该如何根据需要选择要走的路呢?或者，在一个公司面临重大的战略转型时，领导人和投资人该如何做出正确的选择，这些都需要进行选择。那么在程序中，如果遇到选择的情况怎么办呢?这时条件语句就可以派上用场了。条件适句根据不同的条件来执行不同的语句，在Java中，条件语句主要包括if语句和switch语句两种。
10.1.1 if条件语句
if件语句主要用于告诉程序在某个条件成立的情况下执行某段语句，而在另一种情况下执行另外的语句。
使用if条件语句，可选择是否要执行紧跟在条件之后的那个语句。关键字if之后是作为条件的
“布尔表达式”，如果该表达式返回的结果为 true， 则执行其后的语句;若为 false，则不执行 if 条
件之后的语句。if条件语句可分为简单的 if条件语句、if...else 语句和 if….else if 多分支语句。
1.简单的if 条件语句语法如下:
if(布尔表达式){ 语句; } 布尔表达式:必要参数，它最后返回的结果必须是一个布尔值。它可以是一个单纯的布尔变量或常量，也可以是关系表达式。
语句:可以是一条或多条语句，当布尔表达式的值为 true 时执行这些语句。若语句序列中仅有一条语句，则可以省略条件语句中的“{}”。
10.1.2. if...else语句
else 语句是条件语句中最常用的一种形式，它会针对某种条件有选择地做出处理。通常表现为“如果满足某种条件，就进行某种处理，否则就进行另一种处理”。
语法如下:
if(布尔表达式){
语句1;}else {
语句 2;
如果表达式的值为true，则执行紧跟if语句的复合语句;如果表达式的值为false，则执行else后面的语句。
这种形式的判断语句相当于汉语里的“如果……那么……否则……”，用流程图表示第二种判断语句，
3.if..elseif多分支语句
if..elseif多分支语句用于针对某一事件的多种情况进行处理。通常表现为“如果满足某种条件，就进行某种处理;如果满足另一种条件，则进行另一种处理理”。语法如下: if(表达式1){ 语句1 } else if(表达式 2){ 语句2 } else if(表达式n){ 语句n }
表达式1~表达式n:必要参数。可以由多个表达式组成，但最后返回的结果一定要为 boolean类型。
语句 1~语句 n:可以是一条或多条语句，当表达式1的值为true时，执行语句1;当表达式2的值为 true 时，执行语句 2，依此类推。
if..else if多分支语句的执行流程如下图 ：
4.if 语句的嵌套
前面讲过三种形式的条件语句，这三种形式的条件语句都可以嵌套条件语句。例如，在第一种形式的条件语句中嵌套第二种形式的条件语句。形式如下:
if(表达式1)
{
if(表达式 2)
语句1;
else
语句 2;
}
在第二种形式的条件语句中嵌套第二种形式的条件语句。形式如下:
if(表达式1){
if(表达式2)
语句1;
else
语句2;
}
else
{
if(表达式2)
语句1;
else
语句2;
}
条件语句可以有多种，嵌套方式可以根据具体需要进行设计，但一定要注意逻辑关系的正确处理。使用if语句嵌套时要注意 else关键字字要和if关键字成对出现，并且遵守临近原则，else 关键字和自己最近的if语句构成一对。
10.2 switch 多分支语句
2008 年北会时候，全个国家齐聚北京，每个国家的参赛队都有指定的休息区，
如“美国代表队请到A4-14休息区等候”“法国代表队请到F9-03息区等候”等。本次奥运会共有204个国家参与，如果用计算机来分配休息区，难道要写204个if语句?
这是编程中一个常见的问题，就是检测一个变量是否符合某个条件，如果不符合，再用另一个值来检测，依此类推。比如我们给各个国家一个编号，然后我们判断某个代表队的国家编号是不是美国的?如果不是美国的，那是不是法国的?是不是德国的?是不是新加坡的?当然，这种问题可以使用if条件语句完成。
例如，使用if语句检测变量是否符合某个条件。关键代码如下:
country=001;
if (country=-001)(
System.out.printin("美国代表队请到A4-14休息区等候");
if (country -- 026) 1
System.out.printIn("法国代表队请到F9-03休息区等候");
if (country--103){
System.out.printIn("新加坡代表队请到 S2-08休息区等候");
...... /*此处省略其他201个国家的代表队*/这个程序显得比较笨重，程序员需要测试不同的值来给出输出语句。在 Java 中，可以用switch语句将动作组织起来，以一个较简单明了的方式来实现“多选一”的选择。
语法如下:
switch(用于判断的参数)(
case 常量表达式1 :语句1;[break;] case.常量表达式2 :语句2;[break;]
..。。
case 常量表达式n:语句n;[break;1 default :语句n+1; [break;] switch 语句中参数必须是整型、字符型、枚举类型或字符串类型，常量值I~n必须是与参数兼容的数据类型。 switch语句首先计算参数的值,如果参数的值和某个 case 后面的常量表达式相同,则执行该case语句后的若干个语句，直到遇到 break 语句为止。此时如果该cas se 语句中没有 break 语句，将继续执行后面 case 中的若干个语句，直到遇到 break 语句为止。若没有任何一个常量表达式与参数的值相同，则执行default后面的语句。
break的作用是跳出整个 switch语句。
default语句是可以不写的，如果它不存在，而且switch语句中表达式的值不与任何case的常量值相同，switch 则不做任何处理。
如果 switch 语句中没有 break关键字，即使执行完对应的 case的处理语句，switch语句也不会立即停止，而是会继续执行下面所有的case，直至遇见break关键字或者完成执行完所有代码才会停止。这就是 switch的“贯穿”特性。我们可以利用这个“贯穿”的特性，让多个 case 共享同一段处理代码。
注意:
(1)同一个switch语句，case的常量值必须互不相同。
(2)在switch语句中，case语句后常量表达式的值可以为整数(除long外)，但绝不可以是实数。例如，下面的代码就是不合法的: case 1.1；
10.3 循环语句
循环语句就是在满足一定条件的情况下反复执行某一个操作。在Java中提供了4种常用的循环语句，分别是while语句、do...while 语句、for 语句和 foreach 语句，其中，foreach 语句是 for 语句的特殊简化版本。
10.3.1 while 循环语句
While语句的循环方式为利用一个条件来控制是否要继续反复执行这个语句，语法如下:
while(条件表达式){
执行语句 }
当条件表达式的返回值为真时，则执行“{}”中的语句，当把执行完“{}”中的语句后，重新判断条件表达式的返回值，直到表达式返回的结果为假时，退出循环。while 循环语句的执行流程如图：
10.3.2 do...while 循环语句
do...while 循环语句与 while 循环语句类似，它们之间的区别是 while 语句为先判断条件是否成立再执行循环体，而 do...while 循环语句则先执行一次循环后，再判断条件是否成立。也就是说 do...while 循环语句中“{}”中的程序段至少要被执行一次。语法如下： do{
执行语句 }
while(条件表达式);
do...while 语句与 while 语句的一个明显区别是 do...while语句在结尾处多了一个分号(;)。根据 do...while 循环语句的语法特点总结出的 do...while 循环语句的执行流程。
10.3.3 while 与 do...while 比较
可以通过设置起始循环条件不成立的循环语句来观察 while 和 do...while 的不同。将变量i初值设置为0，然后循环表达式设置为i>1，显然循环条件不成立。循环体执行的是对变量j的加1这算，通过输出变量j在循环前的值和循环后的值进行比较。
10.3.4 for 循环语句
for循环是Java设计中最有用的循环语句之一，一个for循环可以用来重复执行某条语句，直到某个条件得到满足。for语句语法如下:
for(表达式1;表达式2;表达式3) {
语句 }
*表达式 1:该表达式通常是一个赋值表达式，负责设置循环的起
始值，也就是给控制循环的变量赋初值。
*表达式 2:该表达式通常是一个关系表达式,用控制循环的变量和循环变量允许的范围值进行比较。
*表达式 3:该表达式通常是一个赋值表达式，对控制循环的变量
进行增大或减小。
*语句:语句仍然是复合语句。
for 循环语句的执行流程如下
(1)先执行表达式1.
(2)判断表达式 2，若其值为真，则执行for 语句中指定的内嵌语句，然后执行
(3)若表达式2值为假，则结束循环，转到(5)。
(3)执行表达式3。
(4)返回(2)继续执行。
(5)循环结束，执行 for 语句下面的一个语句。
10.3.5 foreach 语句
foreach 语句是 for 语句的特殊简化版本，但是 foreach 语句并不能完全取代 for 语句，然而任何
foreach 语句都可以改写为 for 语句版本。foreach 并不是一个关键字，习惯上将这种特殊的 for 语句格式称之为foreach语句。foreach 语句在遍历数组等方面为程序员提供了很大的方便。 语法如下:
for(循环变量x :遍历对象 obj){
引用了x的java 语句;}
遍历对象 obj:依次去读 obj 中元素的值。 循环变量 x:将 obj 遍历读取出的值赋给x。
说明:
遍历，在数据结构中是指沿着某条路线，依次对树中每个节点均做一次且且仅做一次访问。我们可以简单地理解为，对数组或集合中的所有元素，逐一访问，依次读取一遍。数组，就是的集合。
是相同数据类型的元素按一定顺序排列 的集合 foreach 语句中的元素变量x，不必对其进行初始化。下面通过简单的例子来介绍foreach语句是如何遍历一维数组的。
10.3.6循环语句的嵌套
循环有for、while、do...while3 种方式，这3种循环可以相互嵌套。 在 while 循环中套用 for 循环：
for (...)
{
for (..){
...
}
}
在 while 循环中套用 while 循环：
while (...)
{
while (...){
{
...
}
}
在 while 循环中套用 for 循环：
while(..)
{
for (...)
{
...
}
}
10.4 跳转语句
跳转语句包含两方面的内容，一方面是控制循环变量的变化方式，也就是让循环判断中的逻辑关系表达式变成false，从而达到终止循环的效果;一方面是控制循环的跳转。控制循环的跳转需要用到 break 和 continue 两个关键字，这两条跳转语句的跳转效果不同，break 是中断循环，continue是直接执行下一次循环。
10.4.1 break 语句
使用break 语句可以跳出 switch 结构。在循环结构中，同样也可用 break 语句跳出当前循环体从而中断当前循环。
从这个运行结果我们可以看出:
（1)循环中的 if语句判断:如果j等于4时，执行 break 语句，则中断了内层的循环，输出的 j值最大到3为止。
(2)但是外层的循环没有受任何影响，输出的i值最大到 2，正是 for 循环设定的最大值。如果想要让 break 跳出外层循环，Java 提供了“标签”的功能，语法如下:标签名:循环体{
break 标签名;
标签名:任意标识符。循环体:任意循环语句。
break 标签名:break跳出指定的循环体，此循环体的标签名必须与break的标签名一致。带有标签的 break 可以制定跳出的循环，这个循环可以是内层循环，也可以是外层循环。
10.4.2 continue 语句
continue 语句是针对 break 语句的补充。continue 不是立即跳出循环体，而是跳过本次循环结束前的语句，回到循环的条件测试部分，重新开始执行循环。在 for 循环语句中遇到 continue 语句后，首先执行循环的增量部分，然后进行条件测试。在 while 和 do...while 循环中，continue 语句使控制直接回到条件测试部分。
与break语句一样，continue语句也支持标签签功能，语法如下: 标签名 : 循环体{
continue 标签名;
标签名:任意标识符。 循环体:任意循环语句。
continue标签名:continue语句跳出指定的循环体，此循环体的标签名必须与 continue 的标
签名一致。
11.数组的概述
数组是具有相同数据类型的一组数据的集合，例如，球类的集合--足球、篮球、羽毛球等;器集合--电视机、洗衣机、电风扇等。在程序设计中，可以将这些集合称为数组。数组中的每个元素具有相同的数据类型。在 Java 中同样将数看作是一个对象，虽然基本数据类型不是对象由基本数据类型组成的数组则是对象。在程序设计中引入数组可以更有效地管理和处理数据。我们经常使用的数组包括一维数组和二维数组等。
12.一维数组
一维数组时至上是一组相同类型数据的线性集合，例如学校中学生们排列的一字长队就是一个数组，每一位学生都是数组中的一个元素。再比如快捷酒店，就相当于一个一维数组，每一个房间
都是这个数组中的元素。当在程序中需要处理一组数据， 或者传递一组数据时，就可以使用数组实现。本节将介绍一维数组的创建及使用。
12.1创建一维数组
数组元素类型决定了数组的数据类型，它可以是Java中任意的数据类型，包括基本数据类型和其他引用类型。数组名字为一个合法的标识符，符号“[ ]”指明该变量是一个数组类型变量。单“[ ]”表示要创建的数组是一个一维数组。
声明一维数组有两种方式: 数组元素类型 数组名字[]; 数组元素类型[] 数组名字; 声明一维数组，语法如下:
int arr[]; //声明int型数组，数组中的每个元素都是int型数值
double[] dou; //声明 double 型数组，数组中的每个元素都是 double 型数值
声明数组后，还不能访问它的任何元素，因为声明数组只是给出了数组名字和元素的数据类型要想真正使用数组，还要为它分配内存空间。在为数组分配内存空间时必须指明数组的长度。为数组分配内存空间的语法格式如下:
数组名字=new数组元素类型[数组元素的个数]; 数组名字:被连接到数组变量的名称。
数组元素个数:指定数组中变量的个数，即数组的长度。为数组分配内存，语法如下:
arr=new int[5]; //数组长度为 5
以上代码表示要创建一个有5个元素的整型数组，并且将创建的数组对象赋给引用变量anr，即引用变量arr引用这个数组，
上面代码中arr为数组名称，括号“[ ]”中的值为数组的下标，也叫索引。数组通过下标来区分不同的元素，也就是说，数组中的元素都可以通过下标来访问。这就相当于刚才比喻的快捷酒店，我们想要找到某个房间里的人，只需要知道这个人所在房间号。这个房间号就相当于数组的下标。
数组的下标是从0开始的。由于创建的数组arr中有5个元素，因此数组中元素的下标为 0~4在声明数组的同时也可以为数组分配内存空间，这种创建数组的方法是将数组的声明和内存的分配合在一起执行，语法如下:
数组元素类型数组名=new数组元素类型[数组元素的个数]; 声明并为数组分配内存，语法如下: int month[] = new int[12];
上面的代码创建数组month，并指定了数组长度为12。这种创建数组的方法也是Java程序编写过程中普遍的做法。
12.2初始化一维数组
数组可以与基本数据类型一样进行初始化操作，也就是赋初值。数组的初始化可分别初始化组中的每个元素。数组的初始化有以下3种方式:
1、int[] a = new int[]{1,2,3,4,5},
2、int[] a;
a = {1,2,3,4,5};
3、int[] a = new int[5];
a[0] = 1;
a[1] = 2;
a[2] = 3;
a[3] = 4;
a[4]= 5;
从中可以看出，数组的初始化就是包括在大括号之内用逗号分开的表达式列表。用逗号“”分隔数组中的各个元素，系统自动为数组分配一定的空间。第一种初始化方式，将创建3个元素的数组，依次为 1、2、3:第二种初始化方式，创建3个元素的数组，依次为 4、5、6:第三种初始化方式先给数组创建了内存空间，再给数组元素逐一赋值。
12.3获取数组长度
我们初始化一维数组的时候都会在内存中分配内存空间，内存空间的大小决定了一维数组能够储存多少个元素，也就是数组长度该如何获取数组长度呢?我们可以使用数组对象自带的 length属性。语法如下:
arr.length
an :数组名。
length :数组长度属性，返回 int 值。
13.二维数组
比如快捷酒店，每一个楼层都有很多房间，这些房间都可以构成一维数组，如果这个酒店有500
个房间，并且所有房间都在同一个楼层里，那么拿到499号房钥匙的旅客可能就不高兴了，从1号
房走到499号房要花好长时间，因此每个酒店都不只有一个楼层，而是很多楼层，每一个楼层都会有很多房间，形成一个立体的结构，把大量的房间均摊了下来，这种结构就是二维表结构，如图4.7所示，在计算机中，这种二维表结构可以使用二维数组来表示。如图 4.7所示，每一个楼层都是一个一维数组，楼层数本身又构成了一个数组，这样一家酒店就构成了一个二维数组。 二维数组常用于表示表，表中的信息以行和列的形式表示，第一个下标代表元素所在的行，第二个下标代表元素所在的列。
13.1创建二维数组
二维数组可以看作是特殊的一维数组，因此，二维数组有两种声明方式:
数组元素类型数组名字[][]; 数组元素类型[][]数组名字; 声明二维数组，代码如下: int tdarrl[][]; char[][] tdarr2;
同一维数组一样,二维数组在声明时也没有分配内存空间，同样要使用关键字new 来分配内存，然后才可以访问每个元素。
为二维数组分配内存有两种方式: int a[][];
a = newint[2][4]; //直接分配行列
int b[][];
b=newint[2][]; //先分配行，不分配列
1、int[] a = new int[][]{{1,2,3,4,5},{},{},{}},
2、int[][] a;
a = {{1,2,3,4,5},{},{},{}};
3、int[] a = new int[4][5];
a[0] = {1,2,3,4,5};
a[1] = {1,2,3,4,5};
a[2] = {1,2,3,4,5};
a[3] = {1,2,3,4,5};
a[4]= {1,2,3,4,5};
13.2初始化二维数组
二维数组的初始化方法和一维数组类似也有三种方式，但不同的是二维数组有两个索引。二维数组在实际应用中非常广泛。
/*第一种方式*/
int tdarr1[][] = { { 1, 3, 5 },{ 5, 9, 10 } };// 创建二维数组
/*二种方式*/
int tdarr2[][] = { { 65, 55, 12 },{ 92, 7, 22 } };// 创建二维数组
/*第三种方式*/
int tdarr3[][] = new int[2][3]; // 先给数组分配内存空间
tdarr3[0] = new int [] {6, 54, 71};//给第一行分配一个一维数组
tdarr3[1][0] = 63; //给第二行第一列赋值为63
tdarr3[1][1] = 10;//给第二行第二列赋值为10
tdarr3[1][2] = 17;//给第二行第三列赋值为714. 数组的基本操作
1.shift() 方法：把数组的第一个元素删除，并返回第一个元素的值 2.concat() 方法：用于连接两个或多个数组,并返回一个新数组，新数组是将参数添加到原数组中构成的。 3. join() 方法：用于把数组中的所有元素放入一个字符串。元素是通过指定的分隔符进行分隔的。4. pop() 方法：用于删除并返回数组的最后一个(删除元素)元素,如果数组为空则返回undefined ,把数组长度减 1。 5.push() 方法：可向数组的末尾添加一个或多个元素，并返回新的长度，（用来改变数组长度）。6.reverse() ：方法用于颠倒数组中元素的顺序。 7.slice() 方法：可从已有的数组中返回选定的元素。slice(开始截取位置，结束截取位置)。
14.1遍历数组
遍历数组就是获取数组中的每个元素，通常遍历数组都是使用for循环来实现的，遍历一维数组很简单，也很好理解，遍历二维数组需使用双层for循环，通过数组的Length属性可获得数组的长度。
14.2填充和批量替换数组元素
数组中的元素定义完成后，可通过 Arrays类的静态方法 fill0来对数组中的元素进行分配，可以起到填充和替换的效果。fill()方法有两种参数类型，下面以 int型数组为例介绍 fill()方法的使用。
1. fill(intl a , int value)
该方法可将指定的int值分配给int型数组的每个元素。语法如下:
Arrays.fill(int[] a, int value) a:要进行元素分配的数组。
value:要存储数组中所有元素的值
2. fill(int]a, int fromindex, int tolndex, int value)
该方法将指定的 int 值分配给int型数组指定范围中的每个元素。填充的范围从索引 fromIndex(包括)一直到索引toIndex(不包括)。如果fromIndex==toIndex，则填充范围为空。语法如下:
Arrays.fill(int!] a,int fromIndex, int toIndex, int value ya:要进行分配的数组。
yfromIndex:要使用指定值填充的第一个元素的索引(包括)。 toIndex:要使用指定值填充的最后一个元素的索引(不包括)。 value:要存储在数组所有元素中的值。 注意:如果指定的索引位置大于或等于要进行分配的数组的长度，则会报出 ArrayIndexOutOf-BoundsException(越界异常)异常。
14.3复制数组
Arrarys 类的copyOf0方法与copyOfRange方法可实现对数组的复制。copyOf方法是复制数组
至指定长度，copyOfRangeO方法则将指定数组的指定长度复制到一个新数组中。
1. copyOf()方法
该方法提供了多种使用方式，用于满足不同类型数组的复制。语法如下: Arrays.copyof(arr,int newlength) y an:要进行复制的数组。
ynewlength:int型常量，指复制后的新数组的长度。如果新数组的长度大于数组ar的长度，
则用0填充(根据复制数组的类型来决定填充的值，整型数组用0填充，char 型数组则使用null);果数长小数组arr，会从arr第一个元素开始截取至满足新数组长度为止
2、copyofRange（）方法 该方法提供了多种使用方式，其常用语法如下:，
Arrays.copyofRange(arr,inf formIndexint toIndex
arr:要进行复制的数组对象。 formIndex:指定开始复制数组的索引位置。formIndex必须在0至整个数组的长度之间。新
数组包括索引是formIndex的元素。
toIndex:要复制范围的最后索引位置。可大于数组arr的长度。新数组不包括索引是toIndex的元素。
15.数组的排序
在程序设计中，经常需要将一组数据进行排序，这样更加方便统计与查询。程序常用的排序方法有冒泡排序、选择排序等。本节将对常用的数据排序方法进行详细讲解。
.1算法：冒泡排序
冒泡排序是最常用的数组排序算法之一，它以简洁的思想与实现方法备受青睐，是初学者最先
接触的一个排序算法。使用冒泡排序时，排序数组元素的过程总是小数往前放，大数往后放，类似水中气泡往上升的动作，所以称作冒泡排序。
1.基本思想
冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把较大的元素移动到数组后面(也就是交换两个元素的位置)，这样较小的元素就像气泡一样从底部上升到顶部。
2.计算过程
冒泡算法由双层循环实现，其中外层循环用于控制排序轮数，一般是要排序的数组长度减1次，因为最后一次循环只剩下一个数组元素，不需要对比，同时数组已经完成排序了。而内层循环主要用于对比数组中每个临近元素的大小，以确定是否交换位置，对比和交换次数以排序轮数而减少。例如，一个拥有6个元素的数组，在排序过程中每一次循环的排序过程和结果如图 4.18所示。
第一轮外层循环时把最大的元素值63移动到了最后面(相应的比63小的元素向前移动，类似气泡上升)，第二轮外层循环不再对比最后一个元素值63，因为它已经确认为最大(不需要上升)，应该放在最后，需要对比和移动的是其他剩余元素，这次将元素24移动到了63的前一个位置。其他循环将依此类推，继续完成排序任务。
15.1算法：选择排序
直接选择排序方法属于选择排序的一种，它的排序速度要比冒泡排序快一些，也是常用的排序算法，是初学者应该掌握的。
1.基本思想
直接选择排序的基本思想是将指定排序位置与其他数组元素分别对比，如果满足条件就交换元素值，注意这里区别冒泡排序，不是交换相邻元素，而是把满足条件的元素与指定的排序位置交换(如从最后一个元素开始排序)，这样排序好的位置逐渐扩大，最后整个数组都成为已排序好的格式。
这就好比有一个小学生，从包含数字1~10的乱序的数字堆中分别选择合适的数字，组成一个从1~10的排序，而这个学生首先从数字堆中选出1，放在第一位，然后选出2(注意这时数字堆中已经没有1了)，放在第二位，依此类推，直到找到数字 9，放到8的后面，最后剩下 10，就不用选择了，直接放到最后就可以了。
与冒泡排序相比，直接选择排序的交换次数要少很多，所以速度会快些。
2. 计算过程
每一趟从待排序的数据元素中选出最小(或最大)的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
15.2Arrays.Sort()方法
通过Arrays类的静态sort（）方法可实现对数组的排序。sort（)方法提供了多种使用方式，可对任意类型数组进行升序排序。语法如下：Arrays.sort(object);
例题
import java.util.Arrays;//导入输出函数需要用到的包
public class Tran {//创建类
public static void main(String[] args) {//主函数
int arr[] = new int[] { 23, 42, 12, 8 }; // 声明数组
Arrays.sort(arr); // 将数组进行排序
System.out.println("排序后的结果为");//输出排序后的结果为
for (int i = 0; i < arr.length; i++) { // 循环遍历排序后的数组
System.out.print(arr[i]+" "); // 将排序后数组中的各个元素输出
}
}
}
