【Java 02】第二章 Java的基本语法

第二章 Java的基本语法

1 关键字

文本编辑器 2 标识符

Java中的名称命名规范 3 变量

3.1基本数据类型

整数类型：byte、short、int、long浮点类型：float、double字符类型：char布尔类型 boolean 3.2 引用类型：String类3.3 集成开发环境3.4基本数据类型转换3.5 强制类型转换 4 运算符

4.1算术运算符

算术运算符的注意问题 4.2 赋值运算符4.3比较运算符4.4 逻辑运算符4.5 位运算符

十进制与二进制

十进制转二进制二进制转十进制位运算符 4.6 三目运算符4.7 运算符的优先级 5 程序流程控制

5.1顺序结构5.2 分支结构if-else5.3 分支结构switch

switch语句有关规矩switch和if语句的对比 5.4 循环结构for5.5 循环结构while5.7 嵌套循环5.7 特殊流程控制语句 6 数组

6.1 一维数组的声明6.2一维数组的初始化

数组元素的默认初始化 6.3 数组元素的引用6.4 多维数组6.5 数组中涉及的常见算法6.6 数组排序

6.6.1 插入排序6.6.2 交换6.6.3 选择6.6.4 归并6.6.5 基数排序 6.7 冒泡排序6.8 数组操作常见问题6.9 练习

1 关键字

关键字的定义和特点

定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）特点：关键字中所有字母都为小写
用于定义数据类型的关键字

用于定义数据类型的关键字
class	interface	enum	byte	short
int	long	float	double	char
boolen	void
用于定义数据类型值的关键字
true	false	null
用于定义流程控制的关键字
if	else	switch	case	default
while	do	for	break	continue
return

Java保留字:现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标记符时要避免使用这些保留字
byValue、cast、future、gengeic、inner、operator、outer、rest、var、goto、const 文本编辑器

有颜色和排版区分，查看代码很有用。
可批量修改

竖行修改，按住Alt选中竖行后修改 2 标识符

标识符：

Java对各种变量、方法和类等要素命名时使用的字符序列称为标识符凡是自己可以起名字的地方都叫标识符定义合法标识符规则：

由26个英文字母大小写，0-9，_或$组成数字不可以开头不可以使用关键字和保留字，但能包含关键字和保留字。Java中严格区分大小写，长度无限制。标识符不能包含空格。注意：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。 Java中的名称命名规范 Java中的名称命名规范：

包名：多单词组成时所有字母都小写：xxxxyyyzzz类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz （驼峰命名法）常量名：所有字母都大写。多单词时每个单词用下划线连接XXX_YYY_ZZZ 3 变量

java中变量的定制：数据类型变量名 =变量的值，例如：Int i = 11赋值给变量i

变量的概念：

内存中的一个存储区域该区域有自己的名称（变量名）和类型（数据类型）Java中每个变量必须先声明，后使用该区域的数据可以在同一类型范围内不断变化使用变量注意：

变量的作用域：一对{}之间有效初始化值定义变量的格式：数据类型变量名 = 初始化值变量是通过使用变量名来访问这块区域的
变量的类型：声明的变量的数据类型就是变量的类型 3.1基本数据类型

对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。

在Java中，数据类型分为基本数据类型和引用数据类型，其中基本数据类型有8种，除了这8种之外其他所有的数据类型都是引用数据类型整数类型：byte、short、int、long

Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。java的整形常量默认为int型，声明long型常量须后加‘I’或‘L’

类型	占用存储空间	表数范围
byte	1字节= 8bit	-128~127
short	2字节	-2¹⁵ ~2¹⁵ -1
int	4字节	-2³¹~2³¹-1
long	8字节	-2⁶³~2⁶³-1

byte b = 126
int i = 1
short s = 1
long l = 3l,这个long类型变量赋值的时候要在值的后面跟上一个字母l

bit是什么单位？
0100110，这个就是7bit

浮点类型：float、double

与整数类型类似，Java浮点类型也有固定的表数范围和字段长度，不受具体OS的影响Java的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’浮点型常量有两种表示形式：

十进制数形式：如： 5.12 512.0f .512科学计数法形式：如： 5.12e2 512E2 100E-2

类型	占用存储空间	表数范围	精度
单精度	4字节	-2¹²⁸~2¹²⁸	7位有效数字
双精度double	8字节	-2¹⁰²⁴~2¹⁰²⁴	16位有效数字

double d = 1.22
float f = 1.22f,float类型变量赋值时，值后面跟上字符f

字符类型：char

char 型数据用来表示通常意义上“字符”（2字节）字符型常量的表现形式：

字符常量是用单引号（‘’）括起来的单个字符，涵盖世界上所有书面语的字符。例如：char c1 = 'a'; char c2 = '中'; char c3 = '9';Java中还允许使用转义字符‘’来将其后的字符转变为特殊字符型常量。例如：char c3 = ‘n’;// 'n’表示换行符 char类型是可以进行运算的。因为它都对应有Unicode码。

转义字符	说明
b	退格符
n	换行符
r	回车符
t	制表符
"	双引号
’	单引号
	反斜线

布尔类型 boolean

boolean类型适用于逻辑运算，一般用于程序流程控制:

if 条件控制语句while循环控制语句do-while循环控制语句for循环控制语句 boolen类型数据只允许取值true和false，无Null

不可以0或非0的整数替代false和true，这点和C语言不同

boolean b1 = true
boolean b2 = false

练习1

3.2 引用类型：String类

值null可以赋值给任何引用类型(类、接口、数组)的变量，用以表示这个引用类型变量中保存的地址为空String类属于引用类型，可用null赋值String类是一个典型的不可变类，String对象创建出来就不可能被改变。创建出的字符串将存放在数据区，保证每个字符串常量只有一个，不会产生多个副本。

字符串就是由0到多个字母数字符号共同组成一个串，这个串要用英文的双引号括起来
引用类型，都可以用null作为值，也就是说可以在初始化的时候赋值为null

String s0 = "hello";
String s1 = "hello";
String s2 = "he" + "ll" + "o";
System.out.println(str);

例如：int i = 0;int i1 = 0;会在内存中存储两个0的值
String s0 ="hello";String s1 = "hello";在内存中是不会存在两个hello的字符串，只存在一个
假设“hello”内存地址xxxxx，声明s0变量时给s0赋值实际上让s0变量引用“hello”的内存地址xxxxx。当我们再声明变量s1也赋值“hello”的时候实际上也是直接把已经存在的“hello”的内存地址给s1引用

String s3 ="he"+"llo";多级拼接

3.3 集成开发环境

之前写代码都是，创建一个java文件，用文本编辑器打开，写代码，打开dos界面，javac编译，java运行，过于麻烦。
集成开发环境就是为了解决所说的问题，里面包含文本编辑工作，自动编译，简化运行，随时进行代码的调试
比较流行的 eclipse 、IDEA、NetBeans
注意：安装的软件和jdk位数要保持一致，必须都是32位或64位
这里使用idea
https://blog.csdn.net/qq_24990383/article/details/121674868查看3 idea入门

练习2: 变量可以赋值给变量

3.4基本数据类型转换

自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：（从左到右，由小到大）
有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。数字类型的从小到大分别是byte、short、int、long、float、double。数字类型的运算中，多个相同类型变量参与的运算，变量要先转换为相对应的数据类型的默认类型（比如两个byte类型的变量相加，会先把两个byte类型的变量转换成默认的int类型之后再计算，得到的结果是int 类型）。这种情况适用于变量的数据类型的容量比默认类型的容量小，（比如byte,short都比int小）byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型

数据容量大的不可赋值给小的，可能会有损失（如图的这种异常是编译异常，只有在javac的时候可以发现（因为无语法错误））

byte,short,char计算时转换为int类型，再赋值给byte类型可能会有损失

char类型的数据在与数字进行数学运算的时候，是转换为相对应的ASCII码值然后再进行的计算

当把任何基本类型的值和字符串值进行连接运算时（+），基本数据类型的值将自动转化为字符串类型。（当有一系列的+的运算，如果其中某个部分含有字符串，那么这个字符串前边挨着的+开始就是按照字符串拼接去看）

练习3
判断对错
String str1 = 4;
String str2 = 3.5f+"";
判断输出
System.out.println(str2);
System.out.println(3+4+“Hello!”);
System.out.println(“Hello!”+3+4);
System.out.println(‘a’+1+“Hello!”);
System.out.println(“Hello!”+‘a’+1);

错误，String类型需带双引号括起字符
正确，有连接运算，3.5f被转化为字符串类型，结果为字符串 3.5
3.5
34Hello!错，正确为7Hello! 解析加法从前往后，3+4为加号
Hello!34 ，解析最开始为字符串，则为连接符加3形成一个新的字符串再去连接
a1Hello!错，正确为98Hello！同理为加号，‘a’的ASCII码值为97
Hello!a1

练习4
判断能否通过编译
1）short s = 5;
s = s - 2;
2) byte b = 3;
b = b + 4;
b = (byte)(b+4);
3)char c = ‘a’;
int i = 5;
double d = .314;
double result = c+i+d;
4)byte b = 5;
short s = 3;
short t = s+b;
错错对对错

3.5 强制类型转换

自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制类型转换符(),但可能造成精度降低或溢出，格外要注意。通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。

如：String a = “43”;int i = Integer.parselnt(a);
boolean类型不可以转换为其它的数据类型。

强转

4 运算符 4.1算术运算符

运算符	运算	范例	结果
+	正号	+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
+	字符串连接	“He”+“llo”	“Hello”

算术运算符的注意问题

如果对负数取模，可以把模数负号忽略不计，如： 5%-2 = 1。但被模数是负数则不可忽略。此外，取模运算的结果不一定总是整数。对于除号/，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。
例如： int x = 3510;x = x/1000*1000;x的结果是？3000"+"除字符串相加功能外，还能把非字符串转换成字符串，例如：
System.out.println(“5+5=”+5+5);//打印结果是？5+5=55以下二者的区别：
System.out.println(’*’+’t’+’* ’ );//数字
System.out.pintln("*"+’t’+’*’);//字符

练习5：算数运算符：自增，自减
public class TestSign{
public static void main(String[] args){
int i1 =10,i2=20;
int i = i1++;
System.out.println(“i=”+i);
System.out.println(“i1=”+i1);
i = ++i1;
System.out.println(“i=”+i);
System.out.println(“i1=”+i1);
i = i2–;
System.out.println(“i=”+i);
System.out.println(“i2=”+i2);
i = --i2;
System.out.println(“i=”+i);
System.out.println(“i2=”+i2);
}
}

i = 10
i1 = 11

i = 12
i1 = 12

i = 20
i2 = 19

i= 18
i2 =18;

4.2 赋值运算符

符号：

当“=”两侧数据类型不一致时，可以使用自用类型转换或使用强制类型转换原则进行处理。支持连续赋值扩展赋值运算符： +=、-=、*=、/=、%=字符串的+=是字符串的拼接

上述实例：

思考1：short s = 3;
s = s+2;
s+= 2;
这两句有什么区别
思考2：
int i = 1；
i* = 0.1;
System.out.println(“i”);
i++
System.out.println(“i”);

1.前面提到过short,char,byte在计算时首先转换为int类型
在使用扩展运算符时，变量在参与运算时会把结果强制转换为当前变量的类型
2.
0(相当于 i =(int) (i*0.1))
1

public class Test2{
	public static void main(String[] args)
	{
		int i0 = 1,i1 = 3,i2 = 5;
		i0 = i1 = i2 = 8;                        //等号可以连续赋值
		System.out.print(i0+","+i1 +","+i2);     //输出正常
		System.out.print(i0+','+i1 +','+i2);     //为ascii码值相加，结果是112
		
		short s =2;
		s = s+3;//错误，s+3为int型
		//变量参与运算时候，java程序不知道具体的这个变量在做完运算后会不会查重当前变量的范围，
		//所以会先把变量转换为一个更大长度，这个例子中，short是一个短整形数据，会转化为默认的int类型
		s = (short)(s+3);
		s += 3;//同上，且不用强转
		//在使用扩展运算符时，变量在参与运算时会把结果强制转换为当前变量的类型
}

4.3比较运算符

运算符项目	运算	范例	结果
==	相等于	4 ==3	false
!=	不等于	4！=3	true
<	小于	4<3	false
>	大于	4>3	true
<=	小于等于	4<=3	false
>=	大于等于	4>=3	true

比较运算符的结果都是boolean型，也就是要么是true，要么是false 4.4 逻辑运算符

&逻辑与（都为真才真）， | 逻辑或（有一个真为真），!逻辑非（取反）
$$短路与，||短路或，^逻辑异或(两个真假性不同为真)

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中不可以写成33 & x<6“&”和“&&”的区别

单&时，左边无论真假，右边都进行运算双&时，如果左边为真，右边参与运算。如果左边为假，那么右边不参与运算。 “|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。异或^与或|的不同之处是：当左右都为true时，结果为false

练习6：写出每题的输出结果

int x = 1;
int y = 1;
if (x++ == 2 & ++y == 2){
			x = 7;
}
System.out.println("x="+x+",y="+y);//2,2

int x = 1, y =1;
if(x++ == 2 && ++y == 2){
			x = 7;
}
System.out.println("x="+x+",y="+y);//2,1

int x = 1, y =1;
if(x++ == 2 | ++y == 2){
			x = 7;
}
System.out.println("x="+x+",y="+y);//7,2

int x = 1, y =1;
if(x++ == 2 || ++y == 2){
			x = 7;
}
System.out.println("x="+x+",y="+y);//7,1

4.5 位运算符十进制与二进制

十进制，1,2，3,……，9,10逢10 进1
进制的意思就逢几进1，进到上一位
10进制计算
1+8 = 9
9+1 = 10二进制，逢2进1
0+1 = 1
1+1 = 10
10+1 = 11
11+1 = 110
计算机内部表示数的字节单位是定长的，如8位，16位或32位。位数不够时，高位补0。
8个二进制代码占的空间就是1bit(位) ，是计算机自己存东西用的最小单位，1Byte(字节）=8bit（位），通常我们说cpu是32（64）位的就是说它每次能处理4（8）个字节，一个英文字母占的空间，一个汉字是占两个字节负数的二进制
以15和-15为例子
15的二进制 00000000 00000000 00000000 00001111
-15的二进制 11111111 11111111 11111111 11110001
计算过程：补码（负数的二进制） = 反码+1
正数二进制->反码->加1->（补码）->负数二进制
负数二进制->减1->反码->原码->正数二进制十进制转二进制

正整数
正整数转成二进制。除二取余，然后余数倒序排列，高位补零。则为该十进制数对应的二进制表示方式。除的过程中到商为0或1时为止。
如图，规范写法（42）10 = （0010 1010）2

负整数
先将对应的正数转换成二进制，再取原码的反码后加一得到补码，即为该正数对应负数的二进制。

正小数
对小数点之后的数乘2，取结果的整数部分，再取结果的小数小数部分乘以2……以此类推，直到小数部分为0 或位数已满停止。把取出的整数部分依次排列得到小数的二进制。

二进制转十进制

正整数
将二进制补齐位数，首位为0代表是正数，首位为1代表是负数。
若为正数，按位取2的对应次方后相加即可得到对应十进制。

负整数
首位为1代表是负数，则二进制为补码，减一后取反得到原码。原码按正整数的二进制转十进制方式后，带符号即可

小数
将二进制中的四位按位取2的对应次方后相加得到小数的十进制。

位运算符

注意：无<<<

运算符	运算	范例
<<	左移	3<<2 = 12 -> 322 = 12 ，m< m* 2^n
>>	右移	3>>1 = 1 -> 3/2 = 1, m>>n->m*2^-n
>>>	无符号右移	3>>>1 = 1->3/2 = 1，与正数右移一致
&	与运算	6 & 3 = 2
\|	或运算	6
^	异或运算	6^3 = 5
~	反码 ~6 = -7

位运算是直接对二进制进行运算左移时，多出的数字砍掉不要，缺的低位补0右移时，多出的数字砍掉不要，缺的高位正数（原数字最高位为0）补0，（原数字最高位为1）负数补1无符号右移，多出的数字砍掉不要，缺的高位直接补0

练习如图
负数右移，负数无符号右移

正数左移，右移
无符号右移负数
正数左移

正负数按位取反

4.6 三目运算符

格式：

（条件表达式）？表达式1 ：表达式2 ；
条件表达式为true执行表达式1，为false，运算后的结果为表达式2
== 三目运算符本身作为一条表达式的值为表达式1或2，但是比较运算符表达式本身的结果真假性为boolean类型无法自动转化为int ==

练习，获取两个数中的较大数：

获取三个数中的较大数：
1.笨蛋方法
2.嵌套三目

4.7 运算符的优先级

运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如右表，上一行运算符总优先于下一行。只有单目运算度、三元运算符、赋值运算符是从右向左运算的。（）是所有的运算符里优先级最高

优先级	运算符	结合性
1	(),[]	从左到右
2	！, +（正）, -（负）,~（取反）,++ , --	从右到左
3	* ,/, %	从左向右
4	+（加），-（减）	从左到右
5	<< ， >> ， >>>	从左到右
6	< ， <=， >， >=	从左到右
7	== ， !=	从左到右
8	&（按位与）	从左到右
9	^（异或）	从左到右
10	\|	从左到右
11	&&	从左到右
12	\|\|	从左到右
13	？；	从右到左
14	=， += ，-=， *= ，/= ，%=， \|=， ^=， ~=， <<=， >>=， >>>=	从右到左

5 程序流程控制

顺序结构
程序从上到下逐行地执行，中间没有任何判断和跳转。分支结构
根据条件，选择性地执行某段代码
有if……else和switch两种分支语句循环结构
根据循环条件，重复性的执行某段代码
有while、do……while、for三种循环语句
注：JDK1.5之后提供了foreach循环，方便的遍历集合、数组元素。 5.1顺序结构

Java中定义成员变量时采用合法的前向引用。如：

5.2 分支结构if-else

if语句三种格式
1.

if(true){
		执行代码块；
}

if(条件表达式){
	执行代码块；
}
else{
	执行代码块；
}

if(条件表达式){
	执行代码块；
}
else if (条件表达式){
	执行代码块；
}
……
else{
	执行代码块；
}

练习：if语句例题1：
判断小明的期末成绩。
当成绩为100分时，奖励一辆BMW
当成绩为（80,99]时，奖励一台iphone5s
当成绩为[60,80]时，奖励一本参考书
其它时，什么奖励都没有。

练习：对下列代码，若有输出，指出输出结果
if-else可以嵌套使用
int x = 4;
int y = 1;
if(x > 2){
	if(y >2){
			System.out.println(x+y);
			System.out.println("atguigu");
	}
}
else{
System.out.println("x is" + x);
}
x is 4

5.3 分支结构switch

switch(变量){
case 常量1:
	语句1;
	break;
case 常量2:
	语句2;
	break;
……
case 常量N:
	语句N;
	break;
default:
	语句;
	break;

练习：输出星期

	int i = 1;
    switch(i){
        case 1:
            System.out.println("星期一");
            break;
        case 2:
            System.out.println("星期二");
            break;
        case 3:
            System.out.println("星期三");
            break;
        case 4:
            System.out.println("星期四");
            break;
        case 5:
            System.out.println("星期五");
            break;
        case 6:
            System.out.println("星期六");
            break;
        case 7:
            System.out.println("星期天");
            break;
            default:
                System.out.println("输出错误");

    }

switch语句有关规矩

switch (表达式)中表达式的返回值必须是下述几种类型之一：byte,short,char,int,枚举,String；case子句中的值必须是常量（case后面），且所有case子句中的值应是不同的；default子句是可任选的，当没有匹配的case时，执行defaultbreak语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有break，程序会顺序执行到switch结尾break必须写，不然程序就从case匹配到的位置开始一直向下执行到尾

练习1：
使用switch把小写类型的char型转为大写。只转换a,b,c,d,e.其它的输出“other”

 char i = 'a';
        switch(i) {
            case 'a':
                System.out.println('A');
                break;
            case 'b':
                System.out.println('B');
                break;
            case 'c':
                System.out.println('C');
                break;
            case 'd':
                System.out.println('D');
                break;
            case 'e':
                System.out.println('E');
                break;
            default:
                System.out.println("other");
                break;
        }

练习2：对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。

 int score = 75;
    switch(score>=60? 0 : 1){
        case 1:
            System.out.println("不合格");
            break;
        case 0:
            System.out.println("合格");
            break;
        default:
            System.out.println("输出错误");
            break;

    }

练习3：根据用于指定月份，打印该月份所属的季节。3，4，5春季6,7，8夏季9,10,11秋季，12,1，2冬季

 int month = 1;
    switch(month){
        case 3:
        case 4:
        case 5:
            System.out.println("春季");
            break;
        case 6:
        case 7:
        case 8:
            System.out.println("夏季");
            break;
        case 9:
        case 10:
        case 11:
            System.out.println("秋季");
            break;
        case 12:
        case 1:
        case 2:
            System.out.println("冬季");
            break;
        default:
            System.out.println("输入错误");
            break;

    }

switch和if语句的对比

if和switch语句很像，具体什么场景下，应用哪个语句呢？
主要是使用if

如果判断的具体数值不多，而且符合byte、short、int、char这四种类型。虽然l两个语句都可以使用，建议使用switch语句。因为效率稍高。其他情况;对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广 5.4 循环结构for

循环语句功能

在某些条件满足的情况下，反复执行特定代码的功能循环语句的四个组成部分

初始化部分（init statement)循环条件部分(test_exp)循环体部分(body_statement)迭代部分(alter_statement) 循环语句部分

for循环while循环do/while循环语法格式

练习:输出五次hello,world

//连续输出5次hello,world
        for(int i = 0 ;i<5;i++){//初始化表达式；布尔值测试表达式；更改表达式
            System.out.println(i);
            System.out.println("Hello,world");
        }
        //初始化变量，咱们这里的变量是i，判断i<5.如果是，执行代码{},执行更改表达式i++给i重新赋值，值就变为1
        //判断变量i<5，i为1，执行代码块{}，执行更改表达式i++给i重新赋值，变为2
        //判断变量i<5，i为2，执行代码块{}，执行更改表达式i++给i重新赋值，变为3
        //……
        //判断i<5,当前的i是5，判断结果是false，不再往下执行，结束循环

练习：编写程序FooBaz.java，从1循环到150并在每行打印一个值，另外在每个3的倍数行上打印出"foo",在每个5的倍数行上打印"biz",在每个7的倍数行上打印输出"baz"。
//重点问题在换行

//写法1
int a = 1;
        for(a = 1;a<=150;a++){
            System.out.print("n"+a);
            if(a%3 == 0){
                System.out.print("    foo");
            }
            if(a%5 == 0){
                System.out.print("   biz");
            }
            if(a%7 == 0){
                System.out.print("   baz");
            }
        }

//写法2,用String类拼接
int a = 1;
        for(a = 1;a<=150;a++){
            String str = "";
            str += i;
            if(a%3 == 0){
                str += foo;
            }
            if(a%5 == 0){
                str += biz;
            }
            if(a%7 == 0){
                str += baz;
            }
            System.out.println(str);
        }

练习：打印1~100之间所有奇数的和

 int count = 0;
        for(int i = 1;i<=100;i++){
            if(i%2 != 0){
                count += i;
            }
        }
        System.out.println(count);
        //2500

练习：打印1~100之间所有是7的倍数的整数的个数及总和（体会设置计数器的思想）

 int count = 0;
        int pre = 0;
        for(int i = 1;i<=100;i++){
            if(i%7 == 0){
                count += i;
                pre++;
            }
        }
        System.out.println("个数为"+pre+"总和"+count);
        //个数为14总和735

练习：输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。
例如：153 = 111 +555+333

int a = 0, b = 0, c = 0;
        for(int i = 100;i<=999;i++){
            //取a百位,b十位，c个位
            a = i/100;//145/100 = 1
            b = (i/10)%10;//或（145-100)/10 =4
            c = i%10;//145-1*100 -4*10 = 5
            if(a*a*a+ b*b*b+c*c*c == i){
                System.out.println(i);
            }
        }
        //153  370  371   407

5.5 循环结构while

语法格式

[初始化语句]
	while(布尔值测试表达式）{
		语句或语句块；
		[更改语句；]
	}

应用举例

public class WhileLoop{
	public static void main(String[] args){
		int result = 0;
		int i = 1;
		while(i<=100){
			result += 1;
			i++;
		}
			System.out.println("result = "+result);
	}
}

do -while

练习1：求1到100之间所有偶数的和。用for和while语句分别完成。

//1到100之间偶数的和
		//for写法
		int i = 0,s = 0;
        for(i = 1;i<=100;i++){
            if(i%2 == 0){
                s += i;
            }
        }
        System.out.println(s);
        //要在for循环之外输出最后的结果，因为只有全部循环计数完毕才有1到100之间所有偶数的和
        
        //while写法
        int i = 1,s = 0;
        while(i<=100){
            if(i%2 == 0){
                s+=i;
            }
            i++;
        }
        System.out.println(s);
        
        //do-while写法
        i = 1;s = 0;
        do{
            if(i%2 == 0){
                s += i;
            }
            i++;
        }while(i<=100);
        System.out.println(s);
//2550

补充：无限循环

for(;;){
}
while(true){
}

5.7 嵌套循环

注意：在写嵌套循环的时候，尽量保证外层循环的循环次数小于内层的循环次数
原因:

//大小循环
        for(int i = 0;i<4;i++){
            System.out.println("大循环---"+i);
            for(int  j = 0;j<2;j++){
                System.out.println("大循环---"+i+"下的小循环---"+j);
            }
        }

练习1）九九乘法表

//九九乘法表
        for(int i = 1 ;i<10;i++){
            for(int j = 1; j <= i;j++){
                System.out.print(""+j +'*'+ i +'='+ j * i+"  ");

            }
            System.out.println("n");
        }

2）1-100之间所有的质数

//1-100所有质数
        for(int i =1;i<=100;i++) {
            //用i除所有比它小的数字，如果能整除说明不是质数
            int k = 0;//计数，判断被整除了几次
            for (int j = 1; j <= i; j++) {//如果做j 
5.7 特殊流程控制语句 
break语句 
break语句用于终止某个语句块的执行 
{ ……
break;
……
}
 
前面学到switch中有break用来结束case 
 
 如下图，break用来中止循环
 
 break在嵌套循环中，只跳出内层循环。终止当前所在的循环
  
 
continue语句用于跳过某个循环语句块的一次执行，进入下一次循环
  
 
 下图对比break和continue
 break是终止本层（本层有很多次）循环，continue是终止本次循环
 
  
 
return 结束当前方法
 
 在单层循环里使用break和return看起来效果相同，实际一个是结束所在循环，一个是结束所在方法。 
 
特殊流程控制语句说明 
 
6 数组 
想把多个数组放到一个变量？使用数组 
6.1 一维数组的声明 
 
6.2一维数组的初始化 
一维数组可以互相直接赋值
  
int[] i1 = new int[4];//声明一个能放4个int类型数据的数组
        int[] i2 = new int[]{1,2,3};
        int[] i3 = {5,6,7};
        String[] strs = new String[]{"12","d","67"};
        //数组内的元素都有i个引用的元素下标，这个的下标是个数字，数字是
        System.out.println(strs[1]);
        System.out.println("str数组的长度为"+i3.length);
        
 strs[2] = "0v0";
 
数组元素的默认初始化 
使用动态初始化的时候，数组的元素会有默认值，数字类型的默认值是0，对象的默认类型是null
  
6.3 数组元素的引用 
 
6.4 多维数组 
一维数组中的每一个元素都是一个数组，这样的数组就是二维数组
  
   int[][] ii = new int[][]{
                {1,2},
                {4,2}
        };
        System.out.println(ii[1][0]);//4

        int[][] i5 = new int[2][3];
        //第一维部分的长度是2，第二维也就是第一维的每个元素的长度是三
        //{
        //{1,2,3},
        //{ 5,6,7}
        // };

        int[][] i6 = new int[2][];//只定义第一维的长度，第二维不定义
 
注意1：数组中，静态初始化是定义与赋值同步完成。动态初始化是先定义再赋值
 特殊写法：int[] x,y[];//x为一维数组，y为二维数组
  
 
 练习2:获取arr数组中所有元素的和。使用for的嵌套循环即可。
  
 
 //求和
        int[][]arr = new int[][]{
                {3,8,2},
                {2,7},
                {9,0,1,6}
        };
        int len = arr.length;
        int res = 0;
        for(int i = 0;i 
 
 
 练习：
  
 
6.5 数组中涉及的常见算法 

 1.求一个数组中的最大值，最小值，总和，平均数 
int[] i1 = new int[]{3,3,4,6,1,2,11,7,9,6};
        int max = i1[0],min = i1[0];
        for(int i = 0;imax ? i1[i]:max;
        }
        System.out.println("最大值为"+max);

        for(int i = 0;i 
2.复制会在内存中产生新的一段空间，而赋值不会，这与之前的string类似 
        //1.赋值数组
        int[] i2 = i1;
        //打印赋值数组i2
        System.out.println("打印i2");
        for(int i = 0;i 

 2.反转数组
 思路：倒序输出原数组，正序赋值给新数组
 数组长度-正序=倒序 
        int[] arr ={6,4,8,2,4};
        int[] copy =new int[arr.length];

        for(int i = arr.length-1;i>=0;i--){
            copy[copy.length-1-i] = arr[i];

        }
        //打印两个数组
        for(int i = 0;i 
3.数组元素的排序（冒泡排序） 
		//冒泡排序，每次排好一个数字的位置
        //例如，一个数组7个元素，第一次找出最大的数字放在第7位
        //第二次找出前6个位置里最大的数字放在第6位
        //……以此类推，直到找出前2个位置里最大的数字则排序完成
        int[] arr = {9,5,3,1,6,2,5,6,19};
        int tmp = 0;
        for(int i = arr.length;i>1;i--){//i的取值范围length~2
            //外循环，规定每次排序的长度，由9,8,7，……,2
            for(int j = 1; j 
 
6.6 数组排序 
6.6.1 插入排序 
6.6.2 交换 
6.6.3 选择 
6.6.4 归并 
6.6.5 基数排序 
6.7 冒泡排序 
排序思想：
 相邻两元素进行比较，如有需要则进行交换，每完成一次循环就将最大元素排在最后（如从小到大排序），下一次循环是将其他的数进行类似操作。 
 
 例1：例如4个元素的数组
 [4,7,3,1]
 [4,3,1,7]第一轮得到一个最大的数字，放在倒数第一位
 [3,1,4,7]第二轮得到除最后一个数字之外的最大数字，放在倒数第二位
 [1,3,4,7]第三轮得到除最后两个数字之外的最大数字，放在倒数第三位
 例2：排序例1 
 
int[] arr2 = new int[]{4,7,3,1};
        int pre = 0;
        for(int i = 0;i
                //正序与倒序排序，其他的都是一致的，在判断两个相邻的元素在声明情况下做交换不一样
                //如果是正序，前面的大于后面，交换
                //如果是倒序，前面的小于后面，交换
                    pre = arr2[j];
                    arr2[j] = arr2[j+1];
                    arr2[j+1] = pre;
                }

            }
        }
 
6.8 数组操作常见问题 
 
数组下标越界异常两个元素的数组，下标范围0~1
 编译不报错，运行报错空指针异常 
6.9 练习 

 思考：array1和array2是什么关系？
 拓展： 修改题目，实现array2对array1数组的复制 
练习代码及运行结果： 
int[] array1 = {2,3,5,7,11,13,17,19};
        int[] array2 = new int[array1.length];

		//打印array1
        System.out.println("array1:");
        for(int i = 0;i 
 
思考拓展
 array1和array2的关系类似于一块数组空间的两个名字，直接进行数组赋值操作。并不会开辟新的数组空间，而是共用，所以其中一个数组进行修改另一个也会随之改变
 
 实现array2对array1数组的复制代码 
 for(int i = 0;i 
copy上篇“赋值数组的代码”查看修改后结果

【Java 02】第二章 Java的基本语法

Java相关栏目本月热门文章