2.Java语言基础
Java语言基础组成：关键字、标识符、注释、常量与变量、运算符、语句、函数、数组。
2.1 关键字
什么是关键字：就是被赋予了Java特殊含义的单词。（都是小写）
如：class、public、synchronized、static等等，比较多，不一一列举，不需要刻意去记忆关键字。
2.2 标识符
什么是标识符：就是程序中自定义的一些名称。如：类名、方法名都是标识符。
标识符的组成：26个英文字母大小写（Java中严格区分大小写）、0-9数字、以及$符号、_下划线。
注意：1、标识符不能以数字开头。2、不能使用关键字作为标识符。
合法标识符：method、demo、Abc_123、$abc。
非法标识符：123ABC、My Demo、@Abc。
Java语言有其自己的一些规范：
如：程序中的类名每个单词首字母都要大写
class Demo{}、class DemoTest{}。
程序中的方法名第一个单词小写，后面每个单词首字母都要大写。
public void method(){}
public int getMax(){}。
2.3注释
什么是注释：就是用于注解说明的文字。
注意：注释除了注解说明程序的作用，还有一个作用就是可以调试程序，缩小程序的问题范围。
Java中的注释分为：单行注释 符号：“ \\注释内容”
多行注释 符号：“ /*…….注释内容………*/”
文档注释 符号：“/**…….注释内容………/*”（文档注释，可以通过javadoc命令，将文档注释信息转成html页面。）
/**
需求：编写一个程序，在控制台输出：Hello World！
思路：1，java程序的编写是以类的形式体现的，类是存储代码的地方。
2，有了类，还要有程序的入口，那就是主函数。
3，要在控制台输出信息，就需要写输出语句。
步骤：1，定义一个类，类名为Demo
2，写主函数，这是JVM所能识别的固定格式。
3，写输出语句，输出Hello World信息，到控制台。
*/
public class Demo //定义一个类名为Demo 的类。
{
public static void main(String[] args) //编写主函数。
{
System.out.println("Hello World!"); //写输出语句，输出Hello world信息。
}
}2.4 常量与变量
常量:表示不能改变的数值.
Java中常量的分类：
1， 整数常量：所有整数。
2， 小数常量：所有小数。
3， 布尔常量：true、false。
4， 字符常量：将一个字母、数字或符号用单引号‘’标识。
5， 字符串常量：将一个或多个字符用双引号“”标识。
6， null常量：null
整数的四种表现形式：
1， 二进制：0、1。
2， 八进制：0-7,0开头。
3， 十进制：0-9。
4， 十六进制：0-9，A-F，0x开头。
进制的互转：
1，十进制转二进制（就是用十进制数去除以2，再用商除以二，直到不能整除。记录每次得到的余数，就是二进制位。）
如：十进制数10，转二进制
10转成二进制为：1010.
Java中整数类型默认为int型，占4个字节，32位。
整数10 的二进制位就是：0000-0000 0000-0000 0000-0000 0000-1010
由此得出结论：10进制数转八进制数就是除以8，取余数。10进制转16进制就除以16，取余数。但要注意为了让8进制数和16进制数区分开，8进制数开头加0,16进制数开头加0x。
如：八进制：056 、067.
十六进制：0xAE、0x89.
1， 二进制转十进制、八进制、十六进制。
如：十进制数：345
可以写成：5*10（0）+4*10（1）+3*10（2）
那么，二进制位：0000-0000 0000-0000 0000-0000 0000-1110可以写成：
0*2（0）+1*2（1）+1*2（2）+1*2（3）+0*2（4）+…….+0*(31)=14.
（这里我只计算有效位1，其他为0的就不计算）。
我们知道：八进制的中每一位的最大值是7，十六进制的每一位最大值是15也就是（F）。因为二进制中3个二进制位能表示的最大数是7，4个二进制位能表示的最大数是15.
由此得出结论：八进制数实际上就是二进制位中3个二进制位，为一个八进制位。
十六进制实际上就是二进制位中4个二进制位，为一个十六进制位。
如： 110 010 010转八进制数（按每3位进行计算）：0622
1100 0110 转十六进制数（按4位进行计算）：0xC6
变量：内存中的一个存储区域。
该区域有自己的名称（变量名）和类型（数据类型）该区域的数据可以在同一类型范围内不断变化。
为什么要定义变量？
因为变量的值是不固定的，同一区域中可以用来不断存放同一类型的常量。
什么时候定义变量？
当数据不确定时。
使用变量要注意：变量的作用范围（一对{}之间）和变量的初始化值。
格 式：数据类型 变量名=初始化值。
Java中变量的类型：
byte占一个字节、short占两个字节、int占四个字节、long占八个字节、float占四个字节、double占八个字节、char占两个字节、boolean占一个二进制位。
为了区分long和int，float和double，定义的long型变量后面加l，定义的float型后加f。
整数默认为int型。
小数默认为double型。
2.4.1自动类型提升和强制类型转换。
自动类型提升是隐式类型转换。
强制类型转换是显示类型转换。
表达式的数据类型自动提升：
所有byte、short、char型值将被提升为int型。
如果一个操作数是long型，运算结果就是long型。
如果一个操作数是float型，运算结果就是float型。
如果一个操作数是double型，运算结果就是double型。
分析：int x=3；
x=x+5；
的内存原理：
自动类型提升
如： int x=3；
byte b=5；
x=x+b；
x=x+b；x占四个字节，b占一个字节；运算中b会自动提升为int型。
所以：x=8，这里要注意的是，x+b的值，不能超过x的取值范围。否则数值就会出错。
强制类型转换
如：
byte b=3；
b=b+4；
b在运算中默认提升为int型，4默认为int型。
因为b占一个字节，而b+4的结果是int型，这里就会报错，所以必须进行强制类型转换；改为
b=（byte）（b+4）；就可以了。结果为：7.
那么为什么强转后，还能输出正确结果呢?
因为，被强转为byte后，b+4的值依然在byte取值范围内。那么如果b+4的值大于byte的取值范围，就会产生问题。
所以，强转要慎用!
如：b=（byte）（b+128）；输出结果是个负数，是因为只保留了运算结果的最低8位，也就是一个字节。
字符类型的运算过程：
System.out.println(‘a’);和System.out.println(‘a’+1);的区别？
这里System.out.println(‘a’); 输出字母a。
而 System.out.println(‘a’+1);输出数字98.原因是因为‘a’+1，表达式中的‘a’，会自动提升为int型，又因为，‘a’在ASCII码表的对应数字是97，所以，输出运算结果98.
类型运算细节
如：
A: byte b=4；
b=3+7；
System.out.println（b）； //结果：10
而
B: byte b1=3；
byte b2=7；
b=b1+b2；
System.out.println（b）；//这里就会报错：丢失精度。
那么，区别在哪呢？
在A 中，整数默认为int型，4在byte类型的取值范围类，编译器进行了强转，b=3+7，也是同样的道理。
在B中，b=b1+b2，因为b1和b2是两个变量，他们的值是不确定的，检查不通过，就会报错。
总结：如果表达式右边的确定值，且在byte取值范围内，编译通过。
如果表达式右边的不是确定值，编译报错，除非进行强转（byte b=（byte）（b1+b2））。
2.5 运算符
Java中的运算符包括：算术运算符、自增自减运算、赋值运算符、比较运算符、逻辑运算符、位运算符、三元运算符。
2.5.1 算术运算符
包括：＋(加法)、－（减法）、*（乘法）、／（除法）、％（模运算，取余数）
+号的两种作用：1，加法运算符 2，连接符
任何数和字符串用+号相连，形成一个更大的字符串。如：System.out.println（3+“a”）；就是：3a。
Java的加减乘除运算与数学中的一样。
％（模运算，取余数），也就是取余数运算。
如：System.out.println（5％2）；//结果为：1.
System.out.println（4％2）；//结果为：0.
System.out.println（2％5）；//结果为：2.
总结：模运算，左边>右边，结果为运算的余数。
左边<右边，结果为左边。
左边=右边，结果为0.。
有符号的模运算，如：
System.out.println（-5％2）；//结果为：-1；
System.out.println（5％-2）；//结果为：1；
总结：有符号的模运算，余数的符号，只取决于左边的数。
2.5.2 自增自减运算
＋＋（自增运算）、－－（自减运算）。
自增运算：就是在原有数据基础上加1。
自减运算：就是在原有数据基础上减1.
如：int a=3；
a++；
System.out.println（a）；//结果为：4.
自增自减在某些情况，会有所不同。
如： int a=3，b；
b=a++；
System.out.println("a="+a+",b="+b);//结果：a=4，b=3；
而： int a=3,b;
b=++a;
System.out.println("a="+a+",b="+b);//结果：a=4，b=4；
为什么？
b=a++,原理图：在内存中，先临时存储变量a的值，再
将a的值进行加1运算，运算的结果，再赋给a，原来的
值3被运算结果4覆盖，然后，再将临时存储的值3
赋给变量b。所以，a=4，b=3.
b=++a，原理图：在内存中，先进行a的值加1运算，然
后，再把变量a的值赋给变量b。
所以，a=4，b=4.
2.5.3 赋值运算符
包括：＝、＋＝、－＝、*＝、／＝、％＝。
如： int a=3；
a+=1，相当于：a=a+1;
a-=1，相当于：a=a-1；
a*=1，相当于：a=a*1；
a/=1, 相当于：a=a/1；
a%=1，相当于：a=a%1；
注意：在某些情况下，a+=1，和a=a+1，是有区别的。
如：
byte a=3；
a+=1;结果a的值是4。
a=a+1; 报错。
为什么呢?
整数默认是int类型，因为在编译过程中，a=a+1，a是变量，值不确定，会丢失精度；而a+=1，只要运算结果不超出byte取值范围，底层有一个强转的动作。a+=1,就相当于：a=（byte）（a+1）；所以编译通过，并运算出结果。
2.5.4 比较运算符
包括：＞（大于）、＜（小于）、＞＝（大于等于）、＜＝（小于等于）、！＝（不等于）、＝＝（等于）、instanceof（如 a instanceof b 判断a是否是b类的对象）
比较运算符的运算结果,只能是boolean类型:true or false
如:
class Demo {
public static void main(String []args){
int a=3,b=4;
if(a>b)
System.out.println(“a=”+a);
System.out.println(“b=”+b);
}
}
注意:比较运算符＝＝与赋值运算符＝，是两个不同的运算符,＝＝判断左右两边是否相等，＝是将右边的值，赋给左边。
2.5.5 逻辑运算符
包括:&(与)、|（或）、！（非）、&&（短路与）、||（短路或）、∧（异或）。
&运算特点：
true & false=false
false & true=false
true & true=true
false & false=false
&运算规律：&运算的两边只要有一个为false，结果就是false；只有两边都为true，结果才是true。
|运算特点：
true | false =true
false | true =true
true | true =true
false | false=false
|运算规律：|运算的两边只要有一个为true，结果就是true；只有两边都是false，结果才是false。
∧异或运算特点：
true ∧ false =true
false ∧ true=true
true ∧ true=false
false ∧ false=false
∧运算规律：∧运算的两边只要相同，结果就是false；两边不同，结果是true。
！非运算
就是取相反的一面，如：！true=false、！false=true。
&&运算
&&运算和&运算的运算结果相同，但是两者有区别:
&运算，不管左边是true还是false，右边都参与运算；&&运算，如果左边为true时，右边参与运算，如果左边为false时，右边不参与运算。因为&运算的结果，只要有一个为false，结果就是false，所以，&&运算比&运算要高效，一般都用&&运算。
||运算
||运算和|运算的运算结果相同，但是两者有区别:
|运算，不管左边是true还是false，右边都参与运算；||运算，如果左边为false时，右边参与运算，如果左边为true时，右边不参与运算。因为|运算的结果，只要有一个为true，结果就是true，所以，||运算比|运算要高效，一般都用||运算。
2.5.6 位运算符
位运算符的概念：二进制位的运算符号。
整数有几种表现形式，其中一种就是二进制，一个int类型整数占四个字节，每个字节是8位，那么就是32位，位运算符，就是对这些二进制位进行运算的符号。
位运算符包括：〈〈（左移）、〉〉（右移）、〉〉〉（无符号右移）、 &（与）、｜（或）、 ∧（异或）、 ~（反码）。
〈〈左移运算符：
如：整数3左移2位： 3〈〈2 结果是：12 如图：
由此可见：3〈〈2相当于 3*2（2）=3*4=12
注意：左移时，移除的高位丢弃，空位补0。
左移运算规律：一个数左移几位，就相当于这个数乘以2的几次方。
如：3 〈〈3 相当于：3*2(3)=24.
〉〉右移运算符
如：整数6右移2位:6〉〉2 结果：1 如图：
由此可见：6〉〉2 相当于6/2(2)=6/4=1
注意：右移时，高位是0的，补0；是1，就补1.
右移运算规律：一个数右移几位，就相当于这个数除以2的几次方。
〉〉〉无符号右移运算符
无符号右移与右移基本差不多，只是无论高位是0，还是1，都用0补。
&运算符：就是把二进制位进行与运算。
如：6&2=2
|运算符：就是把二进制位进行或运算。
如：6|2=6
∧运算符：就是把二进制位进行异或运算。
如：6^2=4
注意：一个数异或另一个数两次，结果还是这个数。
如：a^b^b=a
使用异或运算，可以完成数值的交换（不使用第三方变量）。
如：int a=3，b=4；
a=a^b;
b=a^b;
a=a^b;
结果：a=4，b=3。
~运算符：就是把一个数的二进制位取反，1就是0,0就是1.
如：~6=-7，~ -6=5.
个人总结：正数的反码，结果是比这个数大1的负数。
负数的反码，结果是比这个数小1的正数。
注意:负数的二进制位是正数的二进制位取反再加1.
2.5.7 三元运算符
三元运算符概念:三个元素参与运算的符号.
一个元素参与运算的符号是一元运算符.如:＋＋,――等。
二个元素参与运算的符号是二元运算符.如:＋、－、*、／、%等。
格式：
（条件表达式）？表达式1：表达式2
如果，条件表达式结果为true，结果是表达式1.
如果，条件表达式结果为false，结果是表达式2.
如：
int a=3，b=4；
int c=（a>b）?a:b;
int d=（a<b）?a:b;
System.out.println(c);//条件表达式为false，结果是4.
System.out.println(d);//条件表达式为true，结果是3.
2.6 语句
Java中的语句按照程序的流程控制分为三种结构：判断结构、选择结构、循环结构。
2.6.1 判断结构
语句格式：
1， if（条件表达式）{
…执行语句….
}
if语句，只要条件表达式结果为true，就执行其内部语句；如果为false就不执行。
2， if（条件表达式）{
…执行语句…. }
else{
…执行语句….
}
if…..else语句，如果条件表达式结果为true，就执行if的内部语句，如果条件表达式结果为false，则执行else的内部语句。
3,if(条件表达式){
…执行语句….
}else if(条件表达式){
…执行语句….
}else if(条件表达式){
…执行语句….
}……
else{
}
if…..else if……else if…..else语句，可以对多个条件表达式进行依次判断，哪一个结果为true，就执行其内部语句，如果所有条件表达式结果都是false，则执行else中的语句。
注意：判断结构的语句，一次只能执行其中一个语句。
2.6.2 选择结构
switch语句
格式：
switch（表达式）//表达式允许四种类型:byte、short、int、char（jdk1.7增加的String类型）
{
case 取值1：执行语句；
break；
case 取值2：执行语句；
break；
case 取值3：执行语句；
break；
…...
default：执行语句；
break； }
switc语句，会根据表达式，去选择与其匹配的值，从第一个case开始，依次查找，如果找到，就执行对应的case的语句，然后由break，结束switch语句。如果，所有case中都没有找到匹配的值，就执行default的语句，然后，结束switch语句，default也可以不写。
注意：
1,switch语句中，如果找到与表达式匹配的值，就会执行对应case：后的语句，依次执行，直到遇到break或“}”括号。所以，break在switch显得比较重要。
如：
public class Demo
{
public static void main(String args[]){
int x=3;
switch(x){
case 1:x+=1;
break;
case 2:x+=2;
break;
case 3:x+=3;//后面没有break,执行x+=3后,继续执行x+=4,然后,结束switch语句.
case 4:x+=4;
break;
default:System.out.println("没有匹配数字");
}
System.out.println("x="+x);//结果为10;
}
}
2,switch中，多个case可以对应一个执行语句。
如：
switch（表达式）{
case 1：
case 2：
……
执行语句；
break；
case 3：
case 4：
……
执行语句；
break；
……..
default：执行语句；
}
2.6.3 循环结构
1,for（初始化表达式；循环条件表达式；循环后的操作表达式）{循环体；}
for循环的执行顺序：①初始化表达式②循环条件表达式③循环体④循环后的条件表达式，如果依然符合循环条件表达式，则继续循环执行循环体，否则循环结束。
如果for循环中没有任何表达式，就是无限循环。
如；for（；；）{循环体；}
for循环的嵌套：就是大圈套小圈的思想，在某种情况下，当一次对应另一种情况的多次时，就可以使用for嵌套。
如：打印一个由“*”号组成的矩形。
public class Demo
{
public static void main(String args[]){
for(int x=1;x<=5;x++){
for(int y=1;y<=5;y++){
System.out.print("*");
}
System.out.println();
}
}
}
/*打印图形：
*****
*****
*****
*****
*****
*/
2 ,do{
循环体；
}
while（循环条件表达式）；
do while循环语句：会先执行一次循环体，再判断循环条件。所以，无论是否满足条件，循环体都至少执行一次。
如：
public class Demo
{
public static void main(String args[]){
int x=1;
do{
System.out.println("打印"+x+"次");
x++;
}while(false);
}
}
while的循环条件为false，所以只显示一次。
控制台显示：打印1次。
3,while（循环条件表达式）{
循环体；
}
while循环语句：首先判断是否满足循环条件，满足就执行循环体，否则不执行。while循环当循环体每次执行后，都会再判断是否满足循环条件，如果不满足就结束循环。
如果while循环条件是true，就是无限循环。
while（true）{循环体；}
while循环实现累加算法：
如：计算数字1-100的和。
public class Demo
{
public static void main(String args[]){
int x=1;
int sum=0;
while(x<=100){
sum+=x;//从1开始每次相加的结果，与下一个数再相加，直到100。
x++;
}
System.out.println("数字1到100的和="+sum);
}
}
while循环的计数器思想：
如：1-100中6的倍数的个数。
public class Demo
{
public static void main(String args[]){
int x=1;
int count=0;//定义一个变量作为计数器
while(x<=100){
if(x%6==0){//通过if条件来判断1-100中6的倍数。
count++;//只要一个数模于6的结果是0，count就自增一次，进行计数。
}
x++;
}
System.out.println("6的倍数的个数="+count);
}
}
什么时候使用循环？
当某些代码需要运行很多次时。
if和while的区别？
if：只判断条件一次，就不再判断。
while：每次循环结束后，都会再判断是否满足循环条件，会多次判断条件。
for和while的区别?
for和while可以互换。
for循环中定义的变量，循环结束后，变量就释放了。
while循环定义的变量，循环结束后，依然可以使用。
使用循环是要注意什么?
1,代码中哪些需要循环，哪些不需要循环。
2，定义循环的条件和控制循环的次数。
循环语句中两个重要的关键字：break、continue
break和continue有什么不同？
break：终止所在的当前循环，或终止指定的循环（前提是给嵌套循环加上标签）。
continue：终止所在的当前循环的本次循环，继续下一次循环；或继续指定的循环（前提是给嵌套循环加上标签）。
break不仅可以在循环语句中使用，还可以在选择语句中使用，如：switch语句。而continue只能在循环语句中使用。
注意：break和continue下面不能有其他语句，因为执行不到，所以编译时会报错，除非是有条件控制的。
如：
public class Demo
{
public static void main(String args[]){
for(int x=1;x<=5;x++){
for(int y=1;y<=x;y++){
System.out.print("*");
break;
System.out.print(x);// 编译时报错：无法访问的语句。
}
System.out.println();
}
}
}
如果，用if来控制，就可以。
public class Demo
{
public static void main(String args[]){
for(int x=1;x<=5;x++){
for(int y=1;y<=x;y++){
System.out.print("*");
if(x==1)
break;
System.out.print(x);
}
System.out.println();
}
}
}
编译通过。
2.7 函数
函数的概念：定义在类中，具备特定功能的小程序，就是功能代码的封装体。函数也称为方法。
函数定义的格式：
修饰符 返回值类型 函数名（参数列表……）{
功能代码；
return 返回值；
}
如：
public static int add（int x，int y）{
int sum=0；
sum=x+y;
return sum;
}
定义函数要注意：
1，如果函数没有具体返回值，这时函数的返回值类型就不能用具体的类型来表示，则使用关键字void表示，return语句后用“；”号结束，也可以不写return语句。
如：
public static void print（）{
System.out.println（“Hello world！”）；
return；//此语句可以省略不写。
}
2，函数是定义在类中的，函数中只能调用函数，不能定义函数。
public class Demo
{
public static void main(String args[]){//主函数
int sum=add(2,3);//调用自定义函数，并把add方法运算结果赋值给sum变量。
System.out.println(sum);//打印sum变量的值。
}
public static int add(int x,int y){//自定义函数
return x+y;
}
}
3， 函数的返回值应该返回给调用者，由调用者处理。
函数的特点：
1， 函数是将功能代码进行封装。
2， 方便对该功能的复用。
3， 函数只有在被调用时才会执行。
4， 函数的出现提高了代码的复用性。
5， 对于没有具体返回值的函数，函数的返回值类型用void表示，return语句可以省略不写。
函数定义的两个明确：
1， 函数的返回结果是什么？
2， 是否有未知内容参与运算。
函数的特性重载(overload)
什么是重载？
在一个类中，有一个以上的同名函数，且具有不同的参数个数或不同的参数类型。（注意：当所有的参数都是相同类型事，不考虑参数顺序；但是，如果所有参数类型不是相同类型时，要考虑到参数的顺序）
总结函数重载的条件：
1， 同一个类中。
2， 相同的方法名。
3， 不同的参数个数，不同的参数类型，不同的参数顺序。
4， 函数的重载与返回值类型无关。
如：
/*
Demo类中，add方法重载，他们有相同的方法名不同的参数个数、参数类型、参数顺序。
*/
public class Demo
{
public static void main(String args[]){
int a=add(1,2);
int b=add(1,2,3);
double c=add(1.3,2);
double d=add(2,1.3);
System.out.println("a="+a);
System.out.println("b="+b);
System.out.println("c="+c);
System.out.println("d="+d);
}
public static int add(int x,int y){//两个int类型参数。
return x+y;
}
public static int add(int x,int y,int z){//三个int类型参数。
return x+y+z;
}
public static double add(double x,int y){//与下面的add方法有相同的参数，但参数的排列顺序不同。
return x+y;
}
public static double add(int x,double y){
return x+y;
}
}
2.8 数组
什么是数组?
数组就是同一种数据类型的集合，数组也称为容器。
使用数组的好处：数组中存储的元素，会从0开始自动编号，方便对这些元素的操作。
数组定义的格式：
如： int []arr=new int[3];//明确数组的长度。
int []arr=new int[]{1,2,3};//明确数组中的元素。
int []arr={1,2,3};//明确数组中的元素。
注意：数组一旦定义，就要明确长度或数组中的元素，否则，编译失败。
如：
public class Demo
{
public static void main(String args[]){
int []arr=new int[];//编译时报错：缺少数组维数
}
}
桟内存：内存中的一片存储区域，用来存储局部变量。
释放方式：作用域一旦结束，局部变量就自动释放。
堆内存：也是内存中的一片存储区域，用来存储实体，如：数组、对象（数组就是对象）。凡是用new关键字建立的，都存储在堆内存中。
堆内存的特点:
1,堆内存中的每一个实体都有一个首地址值.
2,堆内存中的变量,默认都有一个初始化值,根据类型的不同而不同,如:byte、short、int、long都是0，char是‘\u0000’，
boolean是false、double或float是0.0或0.0f、引用类型是null。
3， 释放方式：JVM的垃圾回收机制。
数组创建时内存中的原理图：
遍历数组：
public class Demo
{
publicstatic void main(String args[]){
int[]arr=new int[3];
for(intx=0;x<arr.length;x++){
System.out.println("arr["+x+"]="+arr[x]);
}
}
多个引用型变量指向同一个数组实体：
如：
public class Demo
{
publicstatic void main(String args[]){
int[]arr_1=new int[3];
int[]arr_2=new int[3];
arr_1[0]=9;
arr_2[2]=34;
arr_1=arr_2;
for(intx=0;x<arr_1.length;x++){
System.out.println("arr_1["+x+"]="+arr_1[x]);
}
}
/*
显示结果：
arr_1[0]=0
arr_1[1]=0
arr_1[2]=34
*/如图：
总结：arr_1=arr_2，就是将arr_2的地址值，赋给arr_1变量，这样arr_1就会指向新的数组实体，实际上就是两个引用型变量arr_1和arr_2，都指向了同一个数组实体，那么arr_1之前指向的实体就是垃圾。所以在遍历arr_1数组时，就是等于在遍历arr_2数组。
总结数组中常见问题：
1， 在数组中对元素的操作，是通过元素的角标来完成的，对元素的存取和其他操作，但是如果用到的角标超出了数组中的角标范围，就会有异常情况发生：ArrayIndexOutOfBoundsException（角标越界异常）。但是，编译是可以通过的，运行时就会报错。
如：
public class Demo
{
publicstatic void main(String args[]){
int[]arr=new int[3];
arr[3]=4;
System.out.println(arr[3]);
}
}
数组的最小角标是0，最大角标是数组的长度-1，就是：数组名.length-1,一旦超出范围就会报此错误。
2， 当数组引用型变量，没有指向数组实体时，还在用这个变量来操作实体，就会发生该异常：NullPointerException（空指针异常）。编译是可以通过的，运行时就会报错。
3，
如：
public class Demo
{
publicstatic void main(String args[]){
int[]arr=null;
arr[3]=4;
System.out.println(arr[3]);
}
}
数组的常见操作：
1， 自定义函数实现数组中元素的位置互换。
public class Demo
{
publicstatic void main(String args[]){
int[]arr={2,3,4,67,89,100,23};
printArray(arr);
reverseArray(arr);
printArray(arr);
}
publicstatic void reverseArray(int []arr){//自定义函数实现数组中元素的反转。
intstart=0;
intend=arr.length-1;
while(start<end){
swap(arr,start,end);//调用自定义函数互换元素的位置
start++;
end--;
}
}
publicstatic void swap(int []arr,int a,int b){//自定义函数实现数组中元素的位置交换。
inttemp=arr[a];//使用第三方变量，完成元素的互换
arr[a]=arr[b];
arr[b]=temp;
}
publicstatic void printArray(int []arr){//自定义函数遍历数组。
System.out.print("[");
for(intx=0;x<arr.length;x++){
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.println(arr[x]+"]");
}
}
}
/*
显示结果：
[2,3,4,67,89,100,23]
[23,100,89,67,4,3,2]
*/2， 二分查找
/*通过给定的元素，在数组中查找到对应的角标，找不到就返回-1*/
public class Demo
{
publicstatic void main(String args[]){
int[]arr={2,3,4,67,89,100,23};
intindex=halfSearch(arr,22);
System.out.println("index="+index);
}
publicstatic int halfSearch(int []arr,int key){//定义函数折半查找指定key的角标
intmin=0;
intmax=arr.length-1;
intmid=(min+max)/2;
while(arr[mid]!=key){
if(arr[mid]>key)
max=mid-1;
if(arr[mid]<key)
min=mid+1;
if(max<min)
return-1;
mid=(min+max)/2;
}
returnmid;
}
}
3， 数组查表法
/*通过输入数字，获取对应的星期*/
public class Demo
{
publicstatic void main(String args[]){
System.out.println(getWeek(6));
}
publicstatic String getWeek(int num){
if(num>7||num<1)
System.out.println("没有匹配的星期");
String[]weeks={"星期一","星期二","星期三","星期四","星期五","星期六","星期日"};
returnweeks[num];
}
}4， 排序
/*选择排序*/
public class Demo
{
publicstatic void main(String args[]){
int[]arr={2,45,6,34,76,88,123,46,89,100};
printArray(arr);
selectSort(arr);
printArray(arr);
}
publicstatic void selectSort(int []arr){//定义函数实现选择排序功能。
for(intx=0;x<arr.length-1;x++){
for(inty=x+1;y<arr.length;y++){
if(arr[x]>arr[y])
swap(arr,x,y);
}
}
}
publicstatic void swap(int []arr,int a,int b){//定义函数实现数组中元素的位置交换。
inttemp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
publicstatic void printArray(int []arr){//定义函数遍历数组中的元素。
System.out.print("[");
for(intx=0;x<arr.length;x++){
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.println(arr[x]+"]");
}
}
}
/*
排序前：[2,45,6,34,76,88,123,46,89,100]
排序后：[2,6,34,45,46,76,88,89,100,123]
*/
/*冒泡排序*/
public class Demo
{
publicstatic void main(String args[]){
int[]arr={2,45,6,34,76,88,123,46,89,100};
printArray(arr);
bubbleSort(arr);
printArray(arr);
}
publicstatic void bubbleSort(int []arr){//定义函数实现冒泡排序
for(intx=0;x<arr.length-1;x++){
for(inty=0;y<arr.length-1-x;y++){
if(arr[y]>arr[y+1])
swap(arr,y,y+1);
}
}
}
publicstatic void swap(int []arr,int a,int b){//定义函数实现数组中元素的位置互换
inttemp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
publicstatic void printArray(int []arr){//定义函数遍历数组
System.out.print("[");
for(intx=0;x<arr.length;x++){
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.println(arr[x]+"]");
}
}
}
/*
排序前：[2,45,6,34,76,88,123,46,89,100]
排序后：[2,6,34,45,46,76,88,89,100,123]
*/2.8.2 二维数组
格式：
元素类型 [ ] [ ]数组名=new 元素类型 [一维数组个数] [一维数组的长度]；
元素类型 [ ] [ ]数组名=new 元素类型 [一维数组个数] [ ]；
元素类型 [ ] [ ]数组名={{指定元素}，{指定元素}，{指定元素}……}；
总结二维数组的创建要明确的条件：
1， 明确二维数组中一维数组的个数和一维数组的长度。
2， 只明确二维数组中一维数组的个数。
3， 明确二维数组中一维数组个数和指定元素。
4， 二维数组创建时，必须要明确一维数组的个数或指定一位数组中的元素，否则编译失败。
如：
public class Demo
{
publicstatic void main(String args[]){
int[][]x=new int[3][2];
int[][]y=new int[3][];
int[][]z={{2,45,6,34},{76,88,123},{46,89,100}};
}
}
二维数组创建内存原理图：
二维数组的遍历：
一维数组遍历用到for循环，二维数组的遍历需要for循环的嵌套。
public class Demo
{
publicstatic void main(String args[]){
int[][]arr={{2,45,6,34},{76,88,123},{46,89,100}};
for(intx=0;x<arr.length;x++){//外循环遍历一维数组。
for(inty=0;y<arr[x].length;y++){//内循环遍历一维数中的元素。
System.out.println(arr[x][y]);
}
}
}
}二维数组什么时候用?
数组时用来存储数据的，数据多了就可以用数组存，那么如果数组多了，就可以使用二维数组来存储，数组的维数是不固定的，甚至还有更多维数的数组。
总结：数组是一个容器，用于存储数据的，对数组中的元素进行操作，就需要用到数组中元素对应的角标，操作数组中元素的角标是要注意：角标越界和空指针两个异常的发生。数组的创建要明确哪些是必须的条件，否则编译失败。数组中的元素类型必须是相同的。
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------
详细请查看：http://edu.csdn.net
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
