3 流程控制
3.1 程序结构--主要包括顺序结构、选择结构、循环结构
3.2 条件语句
（1）if条件语句--告诉程序在某个条件下执行某段语句，而在另一种情况下执行另外的语句。
主要有简单的if条件语句--使用if语句，可选择是否要执行条件之后的语句。关键字if之后是作为条件的‘布尔表达式’，如果该表达式结果为true则执行其后的语句、反之则不执行
if……else条件语句--如果满足某种条件，就进行某种处理、反之则进行另一种处理
if……else if多条件分支语句--如果满足某种条件，就进行某种处理；如果满足另一种条件，就进行另一种处理。
if的三种形式的条件语句互相之间是可以嵌套的。
（2）switch多分支语句--可以将动作组织起来，以一个简单的方式实现‘多选一’的操作
语法如下：switch (用于判断的参数){
case 常量表达式1：语句1；[break;]
case 常量表达式2：语句2；[break;]
……
case 常量表达式n：语句n；[break;]
default :语句 n+1;[break]
}
switch语句中的参数必须是整型、字符型、枚举类型和字符串类型。switch语句先计算参数的值，如果参数的值和某个case后的常量表达式相同，则执行该case语句后的若干语句，知道遇到break语句为止。如case语句中没有break语句将继续进行后面若干个case语句。
break语句的作用就是跳出整个switch语句。
default语句可以不写，如果它不存在而且switch语句中表达式的值不与任何case的常量值相同，则switch语句不做处理
3.3 循环语句
（1）while循环语句--while语句的循环方式为利用一个条件来控制是否要继续反复执行这个语句。
语法：while（条件表达式）{ 执行语句 }
（2）do…while 循环语句--先执行一次循环后再判断条件是否成立。
语法 do{ 执行语句 }while（条件表达式）；
while语句和do…while语句最大区别就是一个先判断、另一个先进行循环。
（3）for循环语句--可以用来重复执行某条语句，知道某个条件满足。
语法：for（表达式1；表达式2；表达式3）{ 语句 }
表达式1：通常是一个赋值表达式，负责设置循环的起始值，也就是给控制循环的变量赋初值；
表达式2：通常是一个关系表达式，用控制循环的变量和循环变量允许的范围值进行比较。
表达式3：通常是一个赋值表达式，对控制循环的变量进行增大或减小。
（4）foreach语句--是for语句的特殊简化版本，通常用在遍历数组方面
语法：for（循环变量 x：遍历对象 obj）{ 引用了x的java语句 }
遍历对象 obj：一次去读obj中元素的值。
循环变量x:将obj遍历读取出的值赋给x。
3种循环语句之间也是可以相互嵌套的。
3.4 跳转语句
（1）break语句--在循环结构中，用break语句跳出当前循环体，中断当前循环。多层嵌套是break只能跳出内层循环。
如果想让break语句跳出外层循环可以用‘标签’。语法：标签名 ： 循环体{ break 标签名 }。
（2）continue语句--不是立即跳出循环体，而是跳过本次循环结束前的语句，回到循环条件测试部分，重新开始执行循环。
continue也支持标签功能。语法：标签名 ： 循环体{ continue 标签名 }。
4 数组
4.1 一维数组--实质上就是一组相同类型数据的线性集合；
（1）一维数组的创建：1.数组元素类型 数据名 [ ]; 2数据元素类型 [ ] 数组名；
为数组分配空间的语法：数据名=new 数组元素类型[数组元素得个数]；
声明数组并分配空间的语法：数组元素类型 数组名=new 数据元素类型[数据元素的个数];
（2）初始化数组--就是给数组赋初值
int a [ ] = { 1, 2, 3, };
int b [ ] =new int [ ] { 4, 5, 6, };
int c [ ] =new int [3];
c [ 0 ]= 7; c [ 1 ]= 8; c [ 2 ]= 9;
（3）获取数组长度--arr.length属性直接获取 arr：数组名 length：数组长度属性，返回int值。
（4）简单的一维数组的使用
public class GetDay {
publicstatic void main(String[] args) {
//创建并初始化一维数组
intday[] = new int[] { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
for(int i = 0; i < 12; i++) { // 利用循环将信息输出
System.out.println((i+ 1) + "月有" + day[i] + "天"); // 输出的信息
}
}
}
结果
4.2 二维数组
（1）创建二维数组1.数组元素类型 数据名 [ ][ ]; 2数据元素类型 [ ][ ] 数组名；
内存分配 1. int a [ ] [ ]; a= new int[2][4]; 2. int b [ ] [ ]; b= new int [2] [ ];b[0]= new int [2]; b[1]= new int [2];
（2）初始化二维数组
public class InitTDArray {
publicstatic void main(String[] args) {
/*第一种方式 */
inttdarr1[][] = { { 1, 3, 5 }, { 5, 9, 10 } };
/*第二种方式 */
inttdarr2[][] = new int[][] { { 65, 55, 12 }, { 92, 7, 22 } };
/*第三种方式 */
inttdarr3[][] = new int[2][3]; // 先给数组分配内存空间
tdarr3[0]= new int[] { 6, 54, 71 }; // 给第一行分配一个一维数组
tdarr3[1][0]= 63; // 给第二行第一列赋值为63
tdarr3[1][1]= 10; // 给第二行第二列赋值为10
tdarr3[1][2]= 7; // 给第二行第三列赋值为7
}
}
（3）二维数组简单应用
public class Poetry {
publicstatic void main(String[] args) {
chararr[][] = new char[4][]; // 创建一个4行的二维数组
arr[0]= new char[] { '春', '眠', '不', '觉', '晓' }; // 为每一行赋值
arr[1]= new char[] { '处', '处', '闻', '啼', '鸟' };
arr[2]= new char[] { '夜', '来', '风', '语', '声' };
arr[3]= new char[] { '花', '落', '知', '多', '少' };
/*横版输出 */
System.out.println("-----横版-----");
for(int i = 0; i < 4; i++) {// 循环4行
for(int j = 0; j < 5; j++) {// 循环5列
System.out.print(arr[i][j]);//输出数组中的元素
}
if(i % 2 == 0) {
System.out.println(",");//如果是一、三句，输出逗号
}else {
System.out.println("。");// 如果是二、四句，输出都好
}
}
/*竖版输出 */
System.out.println("\n-----竖版-----");
for(int j = 0; j < 5; j++) {// 列变行
for(int i = 3; i >= 0; i--) {// 行变列，反序输出
System.out.print(arr[i][j]);//输出数组中的元素
}
System.out.println(); //换行
}
System.out.println("。，。，");//输出最后的标点
}
}
结果
4.3 数组的基本操作
（1）遍历数组--通常遍历数组都是用for循环实现，一维数组遍历可以使用foreach语句比较简单。下面举例介绍二维数组的遍历
public class Trap {
publicstatic void main(String[] args) {
intb[][] = new int[][] { { 1 }, { 2, 3 }, { 4, 5, 6 } }; // 定义二维数组
for(int k = 0; k < b.length; k++) {
for(int c = 0; c < b[k].length; c++) { // 循环遍历二维数组中的每个元素
System.out.print(b[k][c]);// 将数组中的元素输出
}
System.out.println();// 输出换行
}
}
}
结果：
二位数组要用双重for循环进行遍历
（2）填充和替换数组--使用Arrays类的静态方法fill()对数组中元素进行分配，可以起到填充和替换的效果，下面介绍fill()的两种用法，以int型数组为例
1. fill（ int[ ] a , int value ）--将指定的int值分配给int型数组的每个元素
语法： Arrays.fill（int[ ] a , int value） a：要进行元素分配的数组。value：要存储数组中所有元素的值。
例：import java.util.Arrays;
public class Swap {
publicstatic void main(String[] args) {
intarr[] = new int[5]; // 创建int型数组
Arrays.fill(arr,8); // 使用同一个值对数组进行填充
for(int i = 0; i < arr.length; i++) { // 循环遍历数组中的元素
//将数组中的元素依次输出
System.out.println("第" + i +"个元素是：" + arr[i]);
}
}
}
结果：
2.fill（int [ ] a, int fromIndex, int toIndex, int value）--将指定的int值分配给int型数组指定范围中的每个元素。
语法：Arrays.fill（int [ ] a, int fromIndex, int toIndex, int value）
a:要分配的数组
fromIndex：要使用指定值填充的第一个元素的索引（包括）。
toIndex：要使用指定值填充的最后一个元素的索引（不包括）。
value：要存储数组中所有元素的值。
例：import java.util.Arrays; //导入java.util.Arrays类
public class Displace {
publicstatic void main(String[] args) {
intarr[] = new int[] { 1,8,6,1,2,3,4,5,6,7,8}; //定义并初始化int型数组arr
Arrays.fill(arr,3, 7, '*'); // 使用fill()方法对数组进行填充
for(int i = 0; i < arr.length; i++) { // 循环遍历数组中的元素
//将数组中的每个元素输出
System.out.println("第" + i +"个元素是：" + arr[i]);
}
}
}
结果：
（3）复制数组
1. copyOf（）方法
语法：Arrays.copyOf（arr ， int newlength） arr：要进行复制的数组。newlength：int型常量，指复制后的新数组的长度。
2. copyOfRange（）方法
Arrays.copyOfRange（arr ，int fromIndex， int toIndex）
fromIndex：指定开始复制数组的索引位置（包括）
toIndex：指定复制范围的最后索引位置（不包括）
4.4 数组的排序
（1）冒泡排序
-
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
-
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
-
针对所有的元素重复以上的步骤，除了最后一个。
-
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
算法实现
public class BubbleSort {
/**
*冒泡排序方法
*
* @param array
* 要排序的数组
*/
public void sort(int[] array) {
for(int i = 1; i < array.length; i++) {
//比较相邻两个元素，较大的数往后冒泡
for(int j = 0; j < array.length - i; j++) {
if(array[j] < array[j + 1]) {//如果前一个元素比后一个元素大，则两元素互换
inttemp = array[j]; // 把第一个元素值保存到临时变量中
array[j]= array[j + 1]; // 把第二个元素值保存到第一个元素单元中
array[j+ 1] = temp; // 把临时变量（也就是第一个元素原值）保存到第二个元素中
}
}
}
showArray(array);// 输出冒泡排序后的数组元素
}
/**
* 显示数组中的所有元素
*
* @param array
* 要显示的数组
*/
public void showArray(int[] array) {
System.out.println("冒泡排序的结果：");
for(int i : array) { // 遍历数组
System.out.print(i+ " "); // 输出每个数组元素值
}
System.out.println();
}
public static void main(String[] args) {
//创建一个数组，这个数组元素是乱序的
int[]array = { 63, 4, 24, 1, 3, 15 };
//创建冒泡排序类的对象
BubbleSortsorter = new BubbleSort();
//调用排序方法将数组排序
sorter.sort(array);
}
}
结果
（2）选择排序
算法思想：选择排序是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
算法实现
public class SelectSort {
/**
* 直接选择排序法
*
* @param array
* 要排序的数组
*/
public void sort(int[] array) {
intindex;
for(int i = 1; i < array.length; i++) {
index= 0;
for(int j = 1; j <= array.length - i; j++) {
if(array[j] < array[index]) {
index= j;
}
}
//交换在位置array.length-i和index(最大值)上的两个数
inttemp = array[array.length - i]; // 把第一个元素值保存到临时变量中
array[array.length- i] = array[index]; // 把第二个元素值保存到第一个元素单元中
array[index]= temp; // 把临时变量也就是第一个元素原值保存到第二个元素中
}
showArray(array);// 输出直接选择排序后的数组值
}
/**
* 显示数组中的所有元素
*
* @param array
* 要显示的数组
*/
public void showArray(int[] array) {
System.out.println("选择排序的结果为：");
for(int i : array) { // 遍历数组
System.out.print(i+ " "); // 输出每个数组元素值
}
System.out.println();
}
public static void main(String[] args) {
//创建一个数组，这个数组元素是乱序的
int[]array = { 63, 4, 24, 1, 3, 15 };
//创建直接排序类的对象
SelectSortsorter = new SelectSort();
//调用排序对象的方法将数组排序
sorter.sort(array);
}
}
结果
（3）Arrays.Sort()方法
通过Arrays类的静态方法Sort（）方法可实现对数组的排序。sort（）方法可对任意数组进行升序排列。
语法：Arrays.sort(object)； object：被排序的数组
算法实现
importjava.util.Arrays;
public classTaxis {
public static void main(String[] args) { // 主方法
intarr[] = 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]+""); // 将排序后数组中的各个元素输出
}
}
}
结果：
