二．Java基本语法
转载自：Java笔记目录
【标识符】：
Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符。
凡是自己可以起名字的地方都叫标识符
命名规则：（一定要遵守，不遵守就会报编译的错误）
由26个英文字母大小写，0-9 ，_或 $ 组成
数字不可以开头。
不可以使用关键字和保留字，但能包含关键字和保留字。
Java中严格区分大小写，长度无限制。
标识符不能包含空格。
注意：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
Java中的名称命名规范：（不遵守，也不会出现编译的错误）
包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
【关键字】：
被Java语言赋予了特殊含义，用做专门用途的字符串（单词），关键字中所有字母都为小写。
用于定义数据类型的关键字：
class interface enum byte short int long float double char boolean void
用于定义数据类型值的关键字：true false null
用于定义流程控制的关键字：
If else switch case default while do for break continue return
用于定义访问权限修饰符的关键字：private protected public
用于定义类，函数，变量修饰符的关键字：abstract final static synchronized
用于定义类与类之间关系的关键字：extends implements
用于定义建立实例及引用实例，判断实例的关键字：new this super instanceof
用于异常处理的关键字：try catch finally throw throws
用于包的关键字：package import
其他修饰符关键字：native strictfp transient volatile assert
保留字：
Java版本尚未使用，但以后版本可能会作为关键字使用。
自己命名标记符时要避免使用这些保留字：
byValue、cast、future、 generic、 inner、 operator、 outer、 rest、 var 、 goto 、const
l 变量的概念：
- 内存中的一个存储区域
- 该区域有自己的名称（变量名）和类型（数据类型）和值
- Java中每个变量必须先声明，再赋值，然后才能使用
- 该区域的数据可以在同一类型范围内不断变化
- Java 中的变量有四个基本属性：变量名，数据类型，存储单元和变量值
变量名：合法的标识符
变量的数据类型：可以是基本类型和引用类型（必须包含类型）
存储单元：存储单元大小是由数据类型决定的，如：int 为4 个字节32 位
变量值：在存储单元中放的就是变量值（如果是基本类型放的就是具体值，如果是引用类型放的是内存地址，如果null，表示不指向任何对象）
l 定义变量的格式：数据类型 变量名 = 初始化值
l 变量是通过使用变量名来访问这块区域的
//int是一种数据类型，是整型。
int a; //在内存中开辟一块空间，这块空间的类型是整型，给这块空间起名叫a
//赋值
a = 100;
//通过变量名去访问那块内存。
System.out.println(a);
//重复访问
System.out.println(a);
l 使用变量注意：
- 变量的作用域：一对{ }之间有效。出了大括号就不认识了。
- 初始化值
- 变量可以重复赋值，但不能重复声明，在同一个域中，变量名不能重复。
2.1 关于java中的字面值：
1.什么是字面值？
一眼看上去就知道是多少的数据，就是字面值
2.字面值本质：
字面值是有数据类型的：
整型 100
浮点型 3.14
布尔型 true/false
字符型 '中'
字符串型 "ABC"
在内存中占用空间。
字面值就是内存中的一块空间，这块空间有类型，有值。
只有字面值内存无法得到重复利用。
java语言中所有的字符都采用“单引号”括起来
java语言中所有的字符串都采用“双引号”括起来。
public class ConstTest01{
public static void main(String[] args){
System.out.println(10); //整数型的字面值
System.out.println(3.14); //浮点型的字面值
System.out.println(true); //布尔型字面值
System.out.println(false);
System.out.println('a'); //字符字面值
System.out.println("Hello"); //字符串字面值
System.out.println(10); //新内存
//Error
//System.out.println('AB'); //AB本身不是一个字符，而是字符串.
System.out.println("A"); //这是一个字符串类型。
}
}
2.2 java中变量按照数据类型来分类：
>引用类型默认值：null
>8种基本数据类型：注意定义值时不能超过范围
整型：byte（8 bit） short int（默认类型）long：变量值的末尾要加“L”或“l”
eg：byte = 1，存储在计算机上为 0000 0001。
浮点型：float：末尾要加上“F”或“f”、 double (默认类型)
字符型：char（用‘ ’括起来）只能表示一个字符（英文/中文/标点/转义字符等），默认值是“\u0000”，要定义多个字符用string。
布尔类型： boolean（只能取值为true 或false，不能取null），默认值是false。
2.3 java中变量按照声明位置的不同来分类：
2.4进制（了解）：
2.4.1二进制：计算机底层都是用二进制来存储、运算。
2.4.2二进制与十进制之间的转换。
二进制转换为十进制：从右向左，2^0 + 2^1 +···+2^n
十进制转换为二进制：
2.4.3二进制在底层存储：正数、负数都是以补码的形式存储的。（原码、反码、补码）
正数：原码、反码、补码三码合一
负数：正数的原码符号位由0变1è负数的原码è负数原码除符号位按位取反è负数的反码è负数反码加1è负数的补码
2.4.4四种进制间的转换
2.5变量的运算：不考虑布尔Boolean类型
①自动类型转换：容量小的数据类型自动转换为容量大的数据类型。
short s = 12; int i = s + 2; char c1 = ’a’;//97 char c2 = ‘A’;//65
注意：byte 、short、 char之间做运算，结果为int型！èlong èfloatèdouble
②强制类型转换：是①的逆过程。使用“（）”实现强转。
会导致精度的损失（高位截掉了）。Eg: long a1 = 12345L; int a2 = (int)a1;
----------------------------------------------------------------------------------------------------------------------
//字符串与基本数据类型之间的运算:只能是连接运算：+。得到的结果仍为一个字符串
String str = "abc";
String str1 = str + m1;//abc12345
System.out.println(str1);
----------------------------------------------------------------------------------------------------------------------
//题目：
String st1 = "hello";
int myInt1 = 12;
char ch1 = 'a';//97
System.out.println(str1 + myInt1 + ch1);//输出：hello12a
System.out.println(myInt1 + ch1 + str1);//输出：109hello
System.out.println(ch1 + str1 + myInt1);//输出：ahello12
-------------------------------------------------------------------------------------------------
======================================================================
补充
一、关于变量
1.java中如何定义变量，语法：
数据类型 变量名;
2.如何给变量赋值，语法：
变量名 = 值;
3.变量的本质是什么？
变量就是内存中的一块空间，这块空间有“类型”，“名字”，“值”
public class VarTest01{
public static void main(String[] args){
//int是一种数据类型，是整型。
int a; //在内存中开辟一块空间，这块空间的类型是整型，给这块空间起名叫a
//赋值
a = 100;
//通过变量名去访问那块内存。
System.out.println(a);
//重复访问
System.out.println(a);
System.out.println(a);
}
}
二、变量的声明
public class VarTest02{
public static void main(String[] args){
//申请一块int类型的空间，起名i，并赋值10
int i = 10;
System.out.println(i);
//重新赋值
i = 100;
System.out.println(i);
//变量可以重新赋值，但不能重复声明
//在同一个域中，变量名不能重复。
//int i = 200; //Error
//java语言中的变量必须先声明，再赋值，才能使用。
int a;
a = 10;
System.out.println(a);
//声明三个变量i1,i2,i3，类型都是int类型，i1,i2两个变量没有赋值，只有i3变量赋值。
int i1,i2,i3 = 456;
//Error
//System.out.println(i1); //i1没有赋值不能访问。
System.out.println(i3);
}
public static void m1(){
int i = 10; //不在同一个区域中可以声明。
}}
三、关于变量的作用域：有效范围。作用范围。
出了大括号就不认识了。
public class VarTest03{
//类体
//声明变量
int m = 100;
public void m1(){
int m = 200;
System.out.println(m); //200 (就近原则.)
}
public static void m(){
int k = 10;
}
public static void main(String[] args){
int i = 10;
System.out.println(i);
//Error
//无法访问m方法中的k变量.
//System.out.println(k);
//for循环
/*
for(int j=0;j<10;j++){
System.out.println(j);
}
//Error,j变量是属于for循环的。
System.out.println(j);
*/
//j的作用域在整个main方法中。
int j;
for(j=0;j<10;j++){
System.out.println(j);
}
System.out.println(j);}}
四、变量根据出现的位置可以分为两种：
1.局部变量,在方法体中声明的变量叫做局部变量。包括形式参数列表。
2.成员变量,在类体中，方法之外声明的变量统称成员变量。
public class VarTest04{
//成员变量
int i = 10;
//成员变量
int m;
public void m1(int m){ //m也是局部变量.
int k = 10; //局部变量
}
public void m2(){
System.out.println(m); //0
}
public static void main(String[] args){
VarTest04 vt = new VarTest04();
vt.m2();
}
}
五、关于整型类型：一个整数默认是int类型
byte 1byte(8bit) -128~127
short 2byte
int 4byte
long 8byte
整数型有三种表示方式：
十进制
八进制 以0开始
十六进制 以0x开始
public class DataTypeTest01{
public static void main(String[] args){
//十进制
int i1 = 10; //常用.
//八进制
int i2 = 010;
//十六进制
int i3 = 0x10;
System.out.println(i1); //10
System.out.println(i2); //8
System.out.println(i3); //16
//将一个int类型100字面值赋值给i4变量。
int i4 = 100;
//将一个int类型的123字面值赋值给long类型的l1
//int类型容量小于long类型.
//以下程序存在类型转换.只不过叫“自动类型转换”
long l1 = 123;
//由于123后面有一个L，所以上来就会把123看做long类型。
//所以以下程序不存在类型转换，只是一个普通的赋值运算。
long l2 = 123L;
//可以(int类型-->long类型，自动类型转换)
long l3 = 2147483647;
//程序将2147483648看做int类型，但是这个数据本身已经超出了int的取值范围。
//long l4 = 2147483648;
long l4 = 2147483648L;
}
}
六、整型类型间转换
public class DataTypeTest02{
public static void main(String[] args){
long l1 = 1000L;
//将long类型转换成int类型，不能自动类型转换.
//int i1 = l1;
//需要强制类型转换
//需要加强制类型转换符
//以下的程序虽然编译通过了，但是程序在运行阶段可能损失精度，所以一定要谨慎使用。
int i1 = (int)l1; //大容量向小容量转换，需要强制类型转换.
//记忆一个规则：如果这个整数没有超出byte的取值范围，可以直接将这个整数赋值给byte类型.
byte b1 = 10;
byte b2 = 127;
//Error
//128本身已经超出了byte的取值范围。
//byte b3 = 128;
//如果整数本身没有超出short的取值范围，可以将这个整数直接赋值给short
short s1 = 32767;
//short s2 = 32768;
//最后结论：如果整数没有超出byte,short,char的取值范围，可以直接将这个整数赋值给byte,short,char
char c1 = 97;
char c2 = 65535;
//char c3 = 65536;
}
}
七、关于浮点类型：一个小数默认是double类型
float 4个字节
double 8个字节
public class DataTypeTest03{
public static void main(String[] args){
double d1 = 1.2;
//强制类型转换
//float f1 = 3.2;
float f1 = (float)3.2;
//自动赋值运算
float f2 = 3.2F;
}
}
八、关于char类型
char是字符类型，java中采用UNICODE编码。
底层占用两个字节。
char类型涉及到字符编码方式：
1.字符编码方式是现实世界中的文字和计算机的表示方式的转换规则。
ASCII
'a' 97
'A' 65
'0' 48
ISO-8859-1
GB2312<GBK<GB18030
unicode UTF-8 UTF-16 UTF-32
2.字符如果采用的编码和解码不一致的话，会出现乱码。
public class CharTest01{
public static void main(String[] args){
char c1 = 'a';
//Error
//char c2 = 'ab';
//汉子占用2个字节，所以java中的char可以存储一个汉字。
char c3 = '中';
System.out.println(c1);
System.out.println(c3);
}
}
九、关于转义字符
public class CharTest02{
public static void main(String[] args){
/*
char c1 = 't';
System.out.print(c1);
System.out.println("abc");
*/
// 斜线在java语言中有转义功能，可以将普通t字符，转换成“制表符”
char c1 = '\t';
System.out.print(c1);
System.out.println("abc");
//这是一个普通的“单引号”字符
char c2 = '\'';
System.out.println(c2);
//这是一个普通的“斜线”字符
char c3 = '\\';
System.out.println(c3);
//这是一个普通的“双引号”字符
char c4 = '\"';
System.out.println(c4);
//这是一个普通的换行符。
char c5 = '\n';
System.out.print("abc");
System.out.print(c5);
System.out.print("def");
char c6 = '中';
char c7 = '\u4e2d'; //'中'对的unicode码是 4e2d
System.out.println(c6);
System.out.println(c7);
}
}
十、关于布尔类型
1.boolean类型的数据只有两个值：true/false,没有1和0。
2.boolean类型的数据主要用在逻辑运算和条件控制语句中。
public class DataTypeTest04{
public static void main(String[] args){
//Error:boolean只能是true/false
//boolean b1 = 1;
boolean sex = false;
if(sex){
System.out.println("男");
}else{
System.out.println("女");
}
}
}
十一、混合类型间运算
//byte,short,char做混合运算的时候先各自转换成int在做运算。
public class DataTypeTest05{
public static void main(String[] args){
byte b1 = 10;
short s1 = 20;
int i1 = b1 + s1;
System.out.println(i1); //30(int)
//java程序分编译期和运行期
//编译阶段只是知道b1+s1的结果是int类型。
//int类型无法直接赋值给byte类型.
//byte b2 = b1 + s1;
//可以.
byte b3 = 100;
}
}
十二、关于基本数据类型转换规则
1. 8种基本数据类型除boolean类型之外都可以相互转换.
2. 小容量向大容量转换叫做自动类型转换：
byte<short<int<long<float<double
char<
3. byte,short,char做混合运算的时候，各自都先转换成int在做运算
4.大容量向小容量转换是强制类型转换，需要加强制转换符，
编译虽然通过，运行期可能损失精度。谨慎使用。
5.如果整数没有超出byte,short,char的取值范围，可以直接将这个整数赋值给byte,short,char
6.多种数据类型做混合运算，先转换成容量最大的那种再做运算。
public class DataTypeTest06 {
public static void main(String[] args) {
//出现错误，1000超出了byte的范围
//byte a = 1000;
//正确，因为20没有超出byte范围
//所以赋值
byte a = 20;
//变量不能重名
//short a = 1000;
//正确，因为数值1000没有超出short类型的范围
//所以赋值正确
short b = 1000;
//正确，因为默认就是int，并且没有超出int范围
int c = 1000;
//正确，可以自动转换
long d = c;
//错误，出现精度丢失问题，大类型-->>小类型会出现问题
//int e = d;
//将long强制转换成int类型
//因为值1000，没有超出int范围，所以转换是正确的
int e = (int)d;
//因为java中的运算会会转成最大类型
//而10和3默认为int,所以运算后的最大类型也是int
//所以是正确的
int f = 10/3;
//声明10为long类型
long g = 10;
//出现错误，多个数值在运算过程中，会转换成容量最大的类型
//以下示例最大的类型为double，而h为int，所以就会出现大类型（long）到小类型（int）的转换，将会出现精度丢失问题
//int h = g/3;
//可以强制转换,因为运算结果没有超出int范围
//int h = (int)g/3;
//可以采用long类型来接收运算结果
//long h = g/3;
//出现精度损失问题，以下问题主要是优先级的问题
//将g转换成int，然后又将int类型的g转换成byte,最后byte类型的g和3运算，那么它的运算结果类型就是int，所以int赋值给byte就出现了精度损失问题
//byte h = (byte)(int)g/3;
//正确
//byte h = (byte)(int)(g/3);
//不能转换,还有因为优先级的问题
//byte h = (byte)g/3;
//可以转换，因为运算结果没有超出byte范围
//byte h = (byte)(g/3);
//可以转换，因为运算结果没有超出short范围
short h = (short)(g/3);
short i = 10;
byte j = 5;
//错误，short和byte运算，首先会转换成int再运算
//所以运算结果为int，int赋值给short就会出现精度丢失问题
//short k = i + j;
//可以将运算结果强制转换成short
//short k = (short)(i + j);
//因为运算结果为int，所以可以采用int类型接收
int k = i + j;
char l = 'a';
System.out.println(l);
//输出结果为97，也就是a的ascii值
System.out.println((byte)l);
int m = l + 100;
//输出结构为197,取得a的ascii码值，让后与100进行相加运算
System.out.println(m);
}
}
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。包括：算术运算符、赋值运算符、比较运算符（关系运算符）、逻辑运算符、位运算符、三元运算符。
3.1算术运算符：
正号： + 负号： -
加号： + 减号： - 乘号： * 除号： / 取模： %
前/后置加： ++ 前/后置减 –
连接符： +
注意：1）除：/
int i = 12;
int j = i/5;
double d = i / 5;
double d1 = i/5.0;
System.out.println(j);//2
System.out.println(d);//2.0
System.out.println(d1);//2.4
2）取模：%：取余数. 结果的符号取决于被模数（%左边的数）
int i1 = 12 % 5;
int i2 = -12 % 5;
int i3 = 12 % (-5);
int i4 = -12 % (-5);
System.out.println(i1);//2
System.out.println(i2);//-2
System.out.println(i3);//2
System.out.println(i4);//-2
3）前++:先自增1，后做运算；后++:先做运算，后自增1
--------------------------------------------------------------------------
int myInt1 = 10;
int myInt2 = myInt1++;//后++
System.out.println(myInt1);//11
System.out.println(myInt2);//10
------------------------------------------------------------------------
int myInt3 = 10;
int myInt4 = ++myInt3;//前++
System.out.println(myInt3);//11
System.out.println(myInt4);//11
-----------------------------------------------------------------------------
4）连接符 +：String字符串与其他数据类型只能做连接运算，且结果为String类型。
“+”除字符串相加功能外，还能把非字符串转换成字符串。
【举例】：
class Testjia
{
public static void main(String[] args)
{
System.out.println("5+5="+5+5); //输出：5+5=55
System.out.println('*' + '\t' +'*');//输出：93
System.out.println("*" + '\t' +'*');//输出：* *
}
}
3.2赋值运算符：
= += -= *= /= %=
【举例】
int i= 12；
i = i * 5;
i *= 5;//与上一行代码同样的意思
【注意】
short s = 10;
s = s + 5;//报编译的异常
s = (short)(s + 5);//不建议如此实现，容易损失精度
s += 5;//既可以实现运算，又不会改变s的数据类型。
3.3比较运算符（关系运算符）
== !=
> < > = <=
instanceof 检查是否是类的对象
【举例】
|
范例 |
结果 |
|
“Hello” instanceof String |
true |
|
“Hello” instanceof System |
false |
【注意】
① 区分 == 与 = 区别。
② 进行比较运算操作以后，返回一个boolean类型的值，要么是true，要么是false。
4 >= 3 表达的是4 > 3或者 4 = 3。结果是true。
③if(i > 1 && i < 10){ } 不能写为：if(1 < i < 10){ }
3.4逻辑运算符（运算符的两端是boolean值）
& 逻辑与 | 逻辑或 ！ 逻辑非
&& 短路与 || 短路或 ^ 逻辑异或
|
a |
b |
a&b |
a|b |
!a |
a^b |
a&&b |
a||b |
|
true |
true |
true |
true |
false |
false |
true |
true |
|
true |
false |
false |
true |
false |
true |
false |
true |
|
false |
true |
false |
true |
true |
true |
false |
true |
|
false |
false |
false |
false |
true |
false |
false |
false |
【注意】
①逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。
②“&”和“&&”的区别：
- 单&时，左边无论真假，右边都进行运算；
- 双&时，如果左边为真，右边参与运算，如果左边为假，则右边不参与运算。
“|”和“||”区别同理，||时：左边为真，右边不参与运算。我们使用的时候，选择&&和||
③异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。
理解：异或，追求的是“异”!
3.5位运算符(两端是数值类型的数据)
位运算是直接对二进制进行运算，注意：无<<<（无符号左移）
|
运算符 |
运算 |
范例 |
|
<< |
左移 |
3 << 2 = 12 --> 3*2*2=12 ;m<<n结果：m*（2^n） |
|
>> |
右移 |
3 >> 1 = 1--> 3/2=1 ;m>>n结果：m/（2^n） |
|
>>> |
无符号右移 |
3 >>> 1 = 1 --> 3/2=1;m>>>n结果：m/（2^n） |
|
& |
与运算 |
6 & 3 = 2 |
|
| |
或运算 |
6 | 3 = 7 |
|
^ |
异或运算 |
6 ^ 3 = 5 |
|
~ |
反码 |
~6 = -7 |
【规则】
① 左移（二进制左移n位，低位补0）有限度，正数的二进制左移后，首位变1了就错了
② 右移：二进制右移n位，原来最高位是几，高位就补几
③ 无符号右移：二进制右移n位，无论高位是几，高位都补0
④ 与运算：左右两端数的二进制所对应位都是1则变1，否则为0，所得二进制数为结果
⑤ 或运算：左右两端数的二进制所对应位至少有一个是1则变1，否则为0，所得二进制数为结果
⑥ 异或运算：左右两端数的二进制所对应位不同则变1，否则为0，所得二进制数为结果
⑦ 反码：该数的二进制对应位1变0，0变1，最后所得二进制数为结果
【小练习】
交换两个变量的值
//方法一：提供一个临时变量。
Int temp = m;
m = n;
n = temp;
System.out.println("m:" + m + " n:" + n);
//方法二：当m和n较大时，有可能出现精度损失
m = m + n;//m = 12 + 5;
n = m - n;//n = 17 - 5;
m = m - n;//m = 17- 12
System.out.println("m:" + m + " n:" + n);
//方法三：优点：没有上面两种方法的缺点。缺点：难！
m = m ^ n;
n = m ^ n; //(m ^ n) ^ n == m
m = m ^ n; //(m ^ n) ^ m == n
System.out.println("m:" + m + " n:" + n);
3.6三元运算符
(条件表达式)？表达式1 ：表达式2；
若条件表达式结果为true，运算后的结果是表达式1；
若条件表达式结果为false，运算后的结果是表达式2；
【注意】
① 既然是运算符，一定会返回一个结果，并且结果的数据类型与表达式1，2的类型一致
② 表达式1与表达式2 的数据类型一致。
③ 三元运算符与if-else的联系与区别：三元运算符可简化if-else语句；三元运算符要求必须返回一个结果；if后的代码块可有多个语句；使用三元运算符的，一定可以转换为if-else，反之不一定成立。
【小练习】如何使用三元运算符，输出三个数中的较大值。
int m = 12;int n = 23;int k = -9;
int max1 = (m > n)? m : n;
int max2 = (max1 > k)? max1 : k;
System.out.println(max2);
3.7运算符的优先级
●运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如下表，上一行运算符总优先于下一行；只有单目运算符、三元运算符、赋值运算符是从右向左运算的。
【小练习】输出60的十六进制。
int i = 60;
//法一：自动调用Integer类现成的方法
String binary = Integer.toBinaryString(i);System.out.println(binary);
String hex = Integer.toHexString(i);System.out.println(hex);
//法二：手动的方式，从控制台输出60的十六进制。
/*
char c = 'a';
char c1 = (char)(c + 2);
System.out.println(c1);//c
*/
int j = i & 15;//获取到i的最低4位对应的值。
String k1 = (j <= 9)? j + "" : (char)(j - 10 + 'a') + "";
i = i >> 4;
int z = i & 15;
String k2 = (z <= 9)? z + "" : (char)(z - 10 + 'a') + "";
System.out.println(k2 + k1);
4.1关于代码的三种结构
①顺序结构
程序从上到下逐行地执行，中间没有任何判断和跳转。
②分支结构
根据条件，选择性地执行某段代码。有if…else和switch-case两种分支语句。
③循环结构
根据循环条件，重复性的执行某段代码。有while(){}、do{}while()、for(;;){}三种循环语句。（注：JDK1.5提供了for each循环，方便的遍历集合、数组元素）
4.2分支结构
4.2.1条件判断： if-else语句
第一种结构：
|
if(boolean表达式){ java语句; } |
第二种结构：
|
if(boolean表达式){ java语句; }else{ java语句; } |
第三种结构：
|
if(boolean表达式){ java语句; }else if(boolean表达式){ java语句; }else if(boolean表达式){ java语句; } |
第四种结构：
|
if(boolean表达式){ java语句; }else if(boolean表达式){ java语句; }else { java语句; } |
注意：
①一旦满足某个条件表达式，则进入其执行语句块执行，执行完毕，跳出当前的条件判断结构，不会执行其以下的条件结构语句。即在if语句中只要有一个分支执行，则整个if语句结束。上面的结构二和四可以保证一定会有一个分支语句执行，因为他们都有else语句。
②如果诸多个条件表达式之间为“互斥”关系，多个结构可以上下调换顺序。如果诸多个条件表达式之间为“包含”关系，要求条件表达式范围小的写在范围大的上面。
③分支语句中，如果只有一条java语句，大括号可以省略。不推荐使用，别人这样写能看懂就行。
|
if(isSuccess) System.out.println("登录成功"); else System.out.println("登录失败"); |
④例题：
系统给定人的年龄.[1-100]
系统给定程序，通过人的年龄，来判断这个人处于生命的哪个阶段：
[1-5] 幼儿 [6-18] 少年 [19-35] 青年 [36-55] 中年 [56-100] 老年
|
public class IfTest02{ public static void main(String[] args){ //该程序假定年龄是合法的。 int age = 56; /*if(age>=1 && age<=5){ System.out.println("幼儿"); }else if(age<=18){ System.out.println("少年"); }else if(age <= 35){ System.out.println("青年"); }else if(age<= 55){ System.out.println("中年"); }else{ System.out.println("老年"); }*/ //String不是基本数据类型，是引用类型 String grade = "老年"; if(age>=1 && age<=5){ grade = "幼儿"; }else if(age<=18){ grade = "少年"; }else if(age <= 35){ grade = "青年"; }else if(age<= 55){ grade = "中年"; } System.out.println(grade); }} |
4.2.2选择结构：switch语句
格式：
|
switch(变量){ case 常量1:语句1;break; case 常量2:语句2;break; … … case 常量N:语句N;break; default:语句;break; } |
规则：
①switch(表达式)中表达式的返回值必须是下述几种类型之一：byte，short，char，int，枚举，String；
②case子句中的值必须是常量，且所有case子句中的值应是不同的；
③default是可以省略的，并且其位置也是灵活的，但是通常将其放在case语句之后，当没有匹配的case时，执行default；
④break语句用来在执行完一个case分支后使程序跳出switch语句块；break语句也可以没有，如果没有break，程序会顺序执行到switch结尾。
switch和if语句的对比：
⑤如果判断的具体数值不多，而且符合byte、 short 、int、 char这四种类型。虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高。
⑥其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。
4.3循环结构
l 循环语句功能
- 在某些条件满足的情况下，反复执行特定代码的功能
l 循环语句的四个组成部分
- 初始化部分（init_statement）
- 循环条件部分（test_exp）
- 循环体部分（body_statement）
- 迭代部分（alter_statement）
l 循环语句分类
- for 循环
- while 循环
- do/while 循环
4.3.1 for 循环
|
for(表达式1;表达式2;表达式3){ java语句; } |
表达式1是初始化表达式，最先执行，只执行一次。表达式2必须是boolean类型的表达式。
for循环开始执行，先执行表达式1，并只执行一次。进而判断表达式2的结果，如果是true，则执行java语句。再执行表达式3，然后再判断表达式2的结果，直到表达式2的结果是false，则for循环结束。
注：①死循环
|
for(;;){ System.out.println("Test"); } |
doc环境下按ctrl+c 停止，强制退出。
②关于for循环的嵌套，所有控制语句都可以嵌套在一起使用。
|
public class ForTest02{ public static void main(String[] args){ for(int i=5;i>0;i--){ for(int j=0;j<i;j++){ System.out.print(j+" "); } //换行 //System.out.println(); System.out.print("\n"); } } } |
练习：①使用嵌套的for循环打印九九乘法表
1*1=1
2*1=2 2*2=4
.......
9*1=9...............9*9=81
|
public class ForTest03{ public static void main(String[] args){ for(int i=1;i<=9;i++){//一共有9行 for(int j=1;j<=i;j++){//每行有i个等式 System.out.print(i + "*"+ j +"=" + (i*j) + " "); } System.out.println(); } }} |
②计算1-100之间所有奇数的求和。
|
public class ForTest04{ public static void main(String[] args){ /* int sum = 0; for(int i=1;i<=100;i++){
if(i%2 != 0){ //奇数 //追加 sum += i; } } System.out.println(sum); */ //加入人为因素 //效率高. int sum = 0; for(int i=1;i<=99;i+=2){ sum += i; } System.out.println(sum); } } |
4.3.2 while 循环语句（while循环的次数是：0-N次）
|
while(boolean表达式){ java语句; } |
4.3.3 do-while 循环语句（该循环执行的次数是：1-N）
|
do{ java语句; }while(boolean表达式); |
注：①不同的循环结构之间可以相互转换
②while和do-while的区别：do-while程序至少会执行一次。while先判断符合条件才执行，do-while循环先执行一次再判断。
③死循环：
|
while(true){ System.out.println("Test"); } |
④嵌套循环：循环结构还可以声明循环。让内层循环结构整体充当外层循环的循环体。若外层循环执行m次，内层循环执行n次，整个程序执行m*n次。
⑤格式：①初始化条件②循环条件③迭代部分④循环体
|
for(①;②;③){ ④ } |
|
① while(②){ ④ ③ } |
|
① do{ ④ ③ }while(②); |
【题目1】
打印下面图形
******
******
******
|
for(int i = 0;i < 3;i++){ for(int j = 0;j < 6;j++){ System.out.print("*"); } System.out.println(); } |
说明：外层循环控制行数，内层循环控制列数
【题目2】输出100内的质数。（两种）
法一：
|
class TestPrimeNumber{ public static void main(String[] args){ boolean flag = false; long start = System.currentTimeMillis();//获取系统当前的毫秒数 for(int i = 2;i <= 100000;i++){//实现100以内的自然数的遍历 //如何判断i是否为一个质数 for(int j = 2;j <= Math.sqrt(i);j++){ if(i % j == 0){ flag = true; break; } } if(!flag){//if(flag == false){//System.out.println(i);} flag = false; } long end = System.currentTimeMillis(); System.out.println("所花费的时间为：" + (end - start)); //35535--加上break：10059--使用Math.sqrt():}} |
法二：
|
class TestPrimeNumber1{ public static void main(String[] args){ //boolean flag = false; long start = System.currentTimeMillis();//获取系统当前的毫秒数 l:for(int i = 2;i <= 100000;i++){//实现100以内的自然数的遍历 //如何判断i是否为一个质数 for(int j = 2;j <= Math.sqrt(i);j++){ if(i % j == 0){ //flag = true; //break; continue l;}} //if(!flag){//if(flag == false){ System.out.println(i); //} //flag = false;} long end = System.currentTimeMillis(); System.out.println("所花费的时间为：" + (end - start)); //35535--加上break：10059--使用Math.sqrt():}} |
4.2.4 无限循环结构
|
for(;;){ ... if( ){ break; } ... } |
或者
|
while(true){ ... if( ){ break; } ... } |
往往我们在无限循环结构内部提供循环的终止条件，使用break关键字。否则，此循环将无限制的执行下去，形成死循环！死循环是我们要避免的。
4.4 break&continue
4.4.1 break
使用switch-case结构或者循环结构中，一旦执行到break，就跳出当前循环体，默认情况下结束离它最近的一个循环。
4.4.2 continue
使用在循环结构中，一旦执行到continue，就跳出当次循环。
|
for(int i = 1;i <= 10;i++){ if(i % 4 == 0){ //break; //123 continue; //123567910 } System.out.print(i); } |
在嵌套循环中，使用带标签的break和continue，可通过标签指明要终止的是哪一层语句块。
label:for(int i = 1;i < 5;i++){
for(int j = 1;j <= 10;j++){
if(j % 4 == 0){
//break;
//continue;
//break label;
continue label;
}
System.out.print(j);
}
System.out.println();
}
4.4.3 return
①并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束。
②与break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环之内。
注意：
①break只能用于switch语句和循环语句中。
②continue 只能用于循环语句中。
③二者功能类似，但continue是终止本次循环，break是终止本层循环。
④break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。
⑤标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。
方法就是一段代码片段，这个片段可以完成特定的功能，并且可以重复利用。
5.1 方法的定义
5.1.1方法的定义格式
[方法修饰列表] 返回值类型 方法名（方法参数列表）{
方法体
}
①方法修饰列表
是可选项，方法的修饰符可以包括：public,protected,private,abstract,static, final,synchronized，其中public,protected,private 不能同时存在。
②返回值类型
如果没有返回值使用void 关键字，如果存在返回值可以是基本类型和引用类型；如果存在返回值，必须使用 return语句，return语句后面不能再执行语句，因为不可能会执行到，编译会发生错误。
③方法名：任意合法的标识符。
④方法参数列表
参数列表可以有多个，也可以没有参数。如：method1(int a，int b)，多个采用逗号分割。
5.1.2普通方法示例
|
public class MethodTest02{ public static void main(String[] args){ //入口 //在main方法中对sumInt方法进行调用，完成功能. //注意：加有static的方法，调用的时候必须采用“类名.”的方式调用。 MethodTest02.sumInt(10,20); MethodTest02.sumInt(50,100); //调用 } //定义方法，完成两个整数的求和。 //注意：目前所有的方法请定义成public static . public static void sumInt(int a,int b){ int c = a + b; System.out.println(a + "+" + b +"=" +c); } } |
|
public class MethodTest03{ public static void main(String[] args){ //入口 //方法调用. MethodTest03.println("Hello World"); //"Hello World" 是实际参数(实参) //方法调用 MethodTest03.m1(13,15); MethodTest03.m2(); //调用m3 int retValue = MethodTest03.m3(100,200);
System.out.println("计算结果是："+retValue);} //方法的定义 //方法的形式参数列表中起决定性作用的是参数的类型。 //参数的名字(局部变量的名字)是随意的只要是合法的标识符即可。 public static void println(String msg){ //String msg 是形式参数列表(形参) System.out.println(msg); } public static void m1(int a,int b){ System.out.println(a+"+"+b+"="+(a+b)); } public static void m2(){ System.out.println("呵呵"); } //该方法有返回值，程序必须使用return语句返回值。 public static int m3(int a,int b){ int c = a + b; return c; //程序执行到此处m3方法执行结束。并返回值c //return语句下面不能再有其他代码，因为根本无法执行到。 //System.out.println("ABC"); //编译无法通过。 } } |
|
public class MethodTest04{
//入口 public static void main(String[] args){ A.m1(); //Error:在当前类中没有m1方法. //m1(); MethodTest04.m2(); //前提：在当前类中. //类名. 可以省略 m2(); } public static void m2(){ System.out.println("m2....."); } } class A{ public static void m1(){ System.out.println("A's m1 method invoke!"); } }
|
|
public class MethodTest06{ public static void main(String[] args){ m1(0); System.out.println("ABC"); //以下程序编译可以通过。（程序分编译期和运行期，编译期只看语法不运算） if(true){ return; } System.out.println("bjpowernode"); } |
5.2方法的重载（overload）
5.2.1重载的条件:
①方法名相同
②方法的参数类型，个数，顺序至少有一个不同
③方法的返回类型可以不同（不依靠返回类型来区分重载）
④方法的修饰符可以不同，因为方法重载和修饰符没有任何关系
⑤方法重载只出现在同一个类中
5.2.2重载的优点:
①程序员只需要记忆很少的方法名,方便调用
②代码更加美观。
|
public class MethodTest08{ //入口 public static void main(String[] args){ //对于程序来说需要记忆1个方法名. System.out.println(Compute.sum(10,20)); System.out.println(Compute.sum(1.0,2.0)); System.out.println(Compute.sum(10L,20L)); } //以下都构成方法重载 public static void m1(int a){} public static void m1(double a){} public static void m2(int a,int b){} public static void m2(int a){} public static void m3(int a,double b){} public static void m3(double a,int b){}
//以下两个m4方法并没有构成重载. //方法重复。错误的。 //public static void m4(int a){} //public static void m4(int b){} //方法的重载和方法的返回值类型无关. /* public static void m5(){} public static int m5(){ return 100; } */ //方法的重载和方法的修饰符列表无关 /* static void m6(){} public static void m6(){} */ } class Compute{ public static int sum(int a,int b){ return a + b; } public static double sum(double a,double b){ return a + b; } public static long sum(long a,long b){ return a + b; } } |
分析：System.out.println();这个println方法是否构成了方法的重载？
一个类中可以有多个main方法（要求与程序入口的main方法参数列表类型、个数或顺序不同），只不过是与程序入口的main方法构成了重载
|
public class MethodTest09{ public static void main(String[] args){ //System.out是 SUN提供的PrintStream类型 //println是PrintStream类型的方法，该方法已经构成了重载。 System.out.println(10); System.out.println(3.14); System.out.println(true); System.out.println('a'); System.out.println("Hello World!");
} } |
5.3 加深对方法的理解
5.3.1方法的执行原理
①方法在调用的时候，才会给该方法在内存中分配空间；如果这个方法只是定义没有调用，则不会在内存中分配空间。
②方法在调用的时候在“栈”中分配空间。(JVM内存中有一块内存是栈内存。)
③方法调用其实就是“压栈（push）”，方法结束其实就是“弹栈（pop）”。
5.3.2 栈的结构
方法的递归调用就是方法自身调用自身。
以下程序因为递归没有结束的条件，所以一直压栈，没有弹栈，导致栈内存溢出错误！所以递归必须要有结束条件。
|
public class RecursionTest01{ //入口 public static void main(String[] args){ m1(); } public static void m1(){ m1(); //java.lang.StackOverflowError } } |
【例题1】：不使用递归，计算1-N的求和。
|
public class RecursionTest02{ public static void main(String[] args){ int n = 5; //调用该方法完成1-N的求和 int retValue = method1(n); System.out.println(retValue); //15 } //该方法完成1-N的求和. public static int method1(int n){ int sum = 0; for(int i=0;i<=n;i++){ sum += i; } return sum; } } |
【例题2】：使用递归，计算1-N的求和。
|
public class RecursionTest03{ public static void main(String[] args){ int n = 5; //调用该方法完成1-N的求和 int retValue = method1(n); System.out.println(retValue); //15 }
//该方法完成1-N的求和. //1+2+3+4+5+...N public static int method1(int n){ if(n==1){ return 1; }else{ return n + method1(n-1); }}} |
【练习】：计算N的阶乘。两种方式：使用递归和不使用递归。
|
public class RecursionTest04{ public static void main(String[] rgs){ System.out.println(method1(5)); //120 } public static int method1(int n){ //不使用递归 int result = 1; for(int i=1;i<=n;i++){ result *= i; } return result; //使用递归 if(n==1){ return 1; }else{ return n * method1(n-1); } } } |
7.1数组
l 数组是多个相同类型数据的组合，实现对这些数据的统一管理
l 数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型
l 数组属引用类型，数组型数据是对象(object)，数组中的每个元素相当于该对象的成员变量
7.2一维数组
public class TestArray {
public static void main(String[] args) {
int i1;
i1 = 12;
boolean b = true;
//1.如何定义一个数组
//1.1数组的声明
String[] names;
int scores[];
//【注】Java语言中声明数组时不能指定其长度(数组中元素的数)， 例如： int a[5]; //非法
//1.2初始化
//第一种：静态初始化:初始化数组与给数组元素赋值同时进行。
names = new String[]{"周爽","郭强强","俞乾龙"};
//第二种：动态初始化：初始化数组与给数组元素赋值分开进行。
scores = new int[4];
//2.如何调用相应的数组元素：通过数组元素的下角标的方式来调用。
//下角标从0开始，到n -1 结束。其中n表示的数组的长度。
scores[0] = 87;
scores[1] = 89;
scores[3] = 98;
//3.数组的长度：通过数组的length属性。
System.out.println(names.length);//3
System.out.println(scores.length);//4
//4.如何遍历数组元素
for(int i = 0;i < names.length;i++){
System.out.println(names[i]);
}}}
//声明数组的错误写法：
1）String[] names = new String[5]{"AA","BB","CC"};//右边[ ]中的5不用写了
2）int i[10];//正确写法：int i[] = new int[10];
3）int i = new int[];//[ ]中要指明数组长度
【注】不管是动态还是静态初始化数组，一定在创建的时候，就指明了数组的长度！每个数组都有一个属性length指明它的长度，例如：a.length 指明数组a的长度(元素个数)。数组一旦初始化，其长度是不可变的。
关于数组元素的默认初始化值
//关于数组元素的默认初始化值：
1)byte short int long 而言：0
2)float double 而言：0.0
3)char而言：空格
4)boolean而言：false
5)引用类型变量而言:null
//初始化时的一些其他正确写法：
1.Int[] myInt; myInt = new int[]{1,2,3};
2.int[] myInt = {1,2,3};
// 错误:
int myInt;
myInt = {1,2,3};
//数组的内存结构
【练习1】
/*
1.(1)定义类Pritimive，在类中定义一个有3个元素的boolean类型的数组t作为其成员变量。数组元素未赋值。
定义类TestPritimive，在TestPritimive的main()方法中创建Pritimive对象d，输出其成员变量t的三个元素值。
练习目的：检验基本数据类型数组创建时的自动赋值。
(2)给对象d的成员变量t赋值为{true,true,true}，并输出t的三个元素值。
*/
public class TestPritimive {
public static void main(String[] args) {
//创建Pritimive的对象d
Pritimive d = new Pritimive();
//遍历d的数组元素
for(int i = 0;i < d.t.length;i++){
System.out.println(d.t[i]);
}
//给d的数组元素重新赋值
d.t[0] = true;
d.t[1] = true;
d.t[2] = true;
for(int i = 0;i < d.t.length;i++){
System.out.println(d.t[i]);
}
}
}
class Pritimive{
boolean[] t = new boolean[3];
}
【练习2】
/* 从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
成绩>=最高分-10 等级为’A’
成绩>=最高分-20 等级为’B’
成绩>=最高分-30 等级为’C’
其余 等级为’D’
提示：先读入学生人数，根据人数创建int数组，存放学生成绩。
*/
import java.util.Scanner;
public class TestStudentScore {
public static void main(String[] args) {
//1.创建Scanner的对象,并从键盘获取学生的个数n
Scanner s = new Scanner(System.in);
System.out.println("请输入学生的个数：");
int count = s.nextInt();//count用来记录学生的个数
//2.根据输入的学生的个数n，创建一个长度为n的int型的数组
int[] scores = new int[count];
int maxScore = 0;
//3.依次从键盘获取n个学生的成绩，并赋给相应的数组元素，并获取n个学生中的最高分
System.out.println("请输入" + count + "个成绩：");
for(int i = 0;i < scores.length;i++){
int score = s.nextInt();//依次从键盘获取学生的成绩
scores[i] = score;
if(scores[i] > maxScore){
maxScore = scores[i];
}
}
//4.遍历学生成绩的数组，并根据学生成绩与最高分的差值，赋予相应的等级，并输出
System.out.println("最高分为：" + maxScore);
for(int i = 0;i < scores.length;i++){
char level;
if(scores[i] >= maxScore - 10){
level = 'A';
}else if(scores[i] >= maxScore - 20){
level = 'B';
}else if(scores[i] >= maxScore - 30){
level = 'C';
}else{
level = 'D';
}
System.out.println("student " + i + " score is " + scores[i] + " grade is " + level);
}}}
//输出效果：
7.3二维数组
public class TestArray2 {
public static void main(String[] args) {
int[] scores1 = new int[10];
int[][] scores2;
String[][] names;
//1.二维数组的初始化
scores2 = new int[][]{{1,2,3},{3,4,5},{6}};//静态初始化
names = new String[6][5];//动态初始化的方式一
names = new String[6][];//动态初始化的方式二
names[0] = new String[5];
names[1] = new String[4];
names[2] = new String[7];
names[3] = new String[5];
names[4] = new String[8];
names[5] = new String[5];
//错误的初始化方式
//names = new String[][];
//names = new String[][5];
//2.如何来引用具体的某一个元素
int[][] i = new int[3][2];//int[] i[] = new int[3][2];
i[1][0] = 90;
i[2][1] = 100;
//3.数组的长度
//二维数组的长度：length属性
System.out.println(i.length);//3
//二维数组中元素的长度
System.out.println(i[0].length);//2
System.out.println(names.length);//6
System.out.println(names[4].length);//8
System.out.println();
//4.如何遍历二维数组
for(int m = 0;m < scores2.length;m++){//控制行数
for(int n = 0;n < scores2[m].length;n++){
System.out.print(scores2[m][n] + " ");}
System.out.println();}
//5.内存结构
int[] x,y[];
//int[] x;//一维
//int[] y[];//二维
y = new int[3][2];
x = y[0];
x[0] = y[1][2];}}
【练习1】
public class TestGetSum {
public static void main(String[] args) {
int[][] m = new int[][]{{3,8,2},{2,7},{9,0,1,6}};
int sum = 0;
for(int i = 0;i < m.length;i++){
for(int j = 0;j < m[i].length;j++){
System.out.print(m[i][j] + "\t");
sum += m[i][j];
}
System.out.println();
}
System.out.println("总和为：" + sum);
}
}
【练习2】
【练习3】
public class TestYangHui {
public static void main(String[] args) {
int[][] yangHui = new int[10][];
//1.初始化二维数组
for(int i = 0;i < yangHui.length;i++){
yangHui[i] = new int[i + 1];
}
//2.显式的为二维数组的每个元素赋值
for(int i = 0;i < yangHui.length;i++){
for(int j = 0;j < yangHui[i].length;j++){
yangHui[i][0] = yangHui[i][i] = 1;
if(i > 1 && j > 0 && j < i){
yangHui[i][j] = yangHui[i-1][j] + yangHui[i-1][j-1];
}
}
}
//遍历二维数组
for(int i = 0;i < yangHui.length;i++){
for(int j = 0;j < yangHui[i].length;j++){
System.out.print(yangHui[i][j] + "\t");
}
System.out.println();
}
}
}
7.4数组的常见异常
public class TestException {
public static void main(String[] args) {
//1.数组下标越界的异常:java.lang.ArrayIndexOutOfBoundsException
int[] i = new int[10];
i[0] = 90;
i[10] = 99;
for(int m = 0;m <= i.length;m++){
System.out.println(i[m]);
}
//2.空指针的异常：NullPointerException
//第一种：
boolean[] b = new boolean[3];
b = null;//b指向的地址变成null了，找不到b[0]了
System.out.println(b[0]);
//第二种：
String[] str = new String[4];
//str[3] = new String("AA");//str[3] = "AA";//没有这两句中的一句，就会出现异常
System.out.println(str[3].toString());
//第三种：
int[][] j = new int[3][];
j[2][0] = 12;
}
}
7.5数组的常用算法问题
1.求数组元素的最大值、最小值、平均数、总和等
【练习】定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值，最小值，平均值，和值，并输出出来。
【代码】
public class TestArray3 {
public static void main(String[] args) {
int[] arr = new int[] { 12, 43, 9, 0, -65, -99, 100, 9 };
// 最大值
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (max < arr[i]) {
max = arr[i];}}
System.out.println("数组的最大值为：" + max);
// 最小值
int min = arr[0];
for (int i = 1; i < arr.length; i++) {
if (min > arr[i]) {
min = arr[i];
}
}
System.out.println("数组的最小值为：" + min);
// 总和
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
System.out.println("总和为：" + sum);
// 平均数
int avg = 0;
avg = sum / arr.length;
System.out.println("平均值为：" + avg);
}
}
【输出函数的快捷键】syso +alt+/
2.数组的复制、反转
【练习】
使用简单数组
(1)创建一个名为TestArray的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数组。
(2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。
(3)显示array1的内容。
(4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)。打印出array1。
思考：array1和array2是什么关系？array2 = array1：表示将array1的地址值赋给了array2
拓展：修改题目，实现array2对array1数组的复制
【代码】修改array2的时候，array1也被改变了，类似“快捷方式”
public class TestArray {
public static void main(String[] args) {
int[] array1, array2;
array1 = new int[] { 2, 3, 5, 7, 11, 13, 17, 19 };
// 遍历array1
for (int i = 0; i < array1.length; i++) {
System.out.print(array1[i] + "\t");
}
System.out.println();
System.out.println(array1);
array2 = array1;
System.out.println(array2);
// 修改array2
for (int i = 0; i < array2.length; i++) {
if (i % 2 == 0) {
array2[i] = i;
}
}
// 遍历array1
for (int i = 0; i < array1.length; i++) {
System.out.print(array1[i] + "\t");
}}}
正确的复制方式：
public class TestArray3 {
public static void main(String[] args) {
int[] arr = new int[] { 12, 43, 9, 0, -65, -99, 100, 9 };
// 数组的复制
int[] arr1 = new int[arr.length];
for (int i = 0; i < arr1.length; i++) {
arr1[i] = arr[i];
}
// 数组元素的反转（逆序）
//方法一：
for(int i = 0;i < arr.length/2;i++){
int temp = arr[i];
arr[i] = arr[arr.length-1 - i];
arr[arr.length - 1 - i] = temp;
}
//方法二：
for (int x = 0, y = arr.length - 1; x < y; x++, y--) {
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
System.out.println("反转以后：");
// 遍历
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}}}
3.数组元素的排序（面试前看一看）
l 插入排序
- 直接插入排序、折半插入排序、希尔（Shell）排序
l 交换排序
- 冒泡排序、快速排序（或分区交换排序）
l 选择排序
- 简单选择排序、堆排序
l 归并排序
l 基数排序
public class TestArray3 {
public static void main(String[] args) {
int[] arr = new int[] { 12, 43, 9, 0, -65, -99, 100, 9 };
// 使用冒泡排序使数组元素从小到大排列
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;}
}
}
//使用直接选择排序使数组元素从小到大排列
for(int i = 0; i < arr.length - 1; i++){
int t = i; //默认i处是最小的
for(int j = i;j < arr.length;j++){
//一旦在i后发现存在比其小的元素，就记录那个元素的下角标
if(arr[t] > arr[j]){
t = j;}}
if(t != i){
int temp = arr[t];
arr[t] = arr[i];
arr[i] = temp;}
}
Arrays.sort(arr);
System.out.println("排序以后：");
// 遍历
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}}}
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
· 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
· 【自荐】一款简洁、开源的在线白板工具 Drawnix
· 园子的第一款AI主题卫衣上架——"HELLO! HOW CAN I ASSIST YOU TODAY
· Docker 太简单，K8s 太复杂？w7panel 让容器管理更轻松！