Java笔记----3. 流程控制与数组

一. 分支结构

1. if

2. switch

expression 只能是byte,short,char,int 四个整数类型和枚举类型
java7还允许使用 java.lang.String类型

二. 循环结构

1. while

2. do while

3. for

三. 控制循环结构

1. break
用于完全结束一个循环，只能跳出一个循环

如果要跳出多个循环，可以用break lableName; 注意lableName必须在break之前定义

2. continue

3. return

四. 数组

数组本身是一种引用类型。

一旦数组初始化完成，数组在内存中所占的空间将被固定下来，长度将不可改变。

1. 定义数组

type[] arrayName; //推荐使用
type arrayName[];

定义数组时不能指定数组的长度，定义数组只是定义了一个引用变量，并 未指向任何有效的内存空间，所以还没有空间来存储数组元素，因此这个数组也不能使用，只有对数组进行初始化后才可以使用。

2. 数组的初始化
所谓初始化，就是为数组的元素 分配内存空间，并为每个数组元素 赋初始值

静态初始化：显示指定每个元素的初始值，由系统决定数组长度。

// 定义一个int数组类型的变量，变量名为intArr.
int[] intArr;

// 使用静态初始化，初始化数组时只指定数组元素的初始值，不指定数组长度。
intArr = new int[]{5, 6, 8 , 20};

// 数组的定义和初始化同时完成，使用简化的静态初始化写法
int[] a = {5, 6 , 7, 9};

动态初始化：只指定数组长度，由系统为数组元素分配初始值

//数组的定义和初始化同时完成，使用动态初始化语法
int[] prices = new int[5];

// 数组的定义和初始化同时完成，初始化数组时元素的类型是定义数组时元素类型的子类
Object[] books = new String[4];

// 输出objArr数组的第二个元素，将输出字符串"李刚"
System.out.println(objArr[1]);
// 为objArr2的第一个数组元素赋值
objArr2[0] = "Spring";

// 访问数组元素指定的索引等于数组长度，所以下面代码将在运行时出现异常
// System.out.println(objArr2[2]);

注意：不要同时使用静态初始化和动态初始化，即不要即指定长度又分配初值

int[] prices = new int[5]{1, 2, 3, 4, 5}; //报错

3. foreach循环

String[] books = {"轻量级Java EE企业应用实战" ,
    "疯狂Java讲义",
    "疯狂Android讲义"};

// 使用foreach循环来遍历数组元素，
// 其中book将会自动迭代每个数组元素
for (String book : books)
{
    System.out.println(book);
}

五. 深入数组

1. 内存中的数组
数组引用变量只是一个引用，实际的数组对象被存储在堆(heap)内存中，引用变量存储在(stack)内存中。

// 定义一个a数组
int[] a = new int[]{5, 7 , 20};
int[] b = new int[4];

System.out.println("b数组长度为：" + b.length); //输出4

内存分配如下图所示：

b = a;
System.out.println("b数组长度为：" + b.length); //输出3
此时内存如下图所示

2. 基本类型数组的初始化

int[] iArr;

iArr = new int[5];

for(int i=0; i<iArr.length; i++)
{
    iArr[i] = i+10;
}

3. 多维数组

// 定义一个二维数组
int[][] a;

// 把a当成一维数组进行初始化，初始化a是一个长度为4的数组
// a数组的数组元素又是引用类型
a = new int[4][];

// 把a数组当成一维数组，遍历a数组的每个数组元素
for (int i = 0 , len = a.length; i < len ; i++ )
{
    System.out.println(a[i]);
}

// 初始化a数组的第一个元素
a[0] = new int[2];

// 访问a数组的第一个元素所指数组的第二个元素
a[0][1] = 6;

// a数组的第一个元素是一个一维数组，遍历这个一维数组
for (int i = 0 , len = a[0].length ; i < len ; i ++ )
{
    System.out.println(a[0][i]);
}

// 同时初始化二维数组的2个维数
int[][] b = new int[3][4];

// 使用静态初始化的语法来初始化一个二维数组
String[][] str1 = new String[][]{new String[3]
    , new String[]{"hello"}};

// 使用简化的静态初始化语法来初始化二维数组
String[][] str2 = {new String[3]
    , new String[]{"hello"}};

System.out.println(str1[1][0]);
System.out.println(str2[1][0]);

4. 操作数组的工具类

// 定义一个a数组
int[] a = new int[]{3, 4 , 5, 6};

// 定义一个a2数组
int[] a2 = new int[]{3, 4 , 5, 6};

// a数组和a2数组的长度相等，每个元素依次相等，将输出true
System.out.println("a数组和a2数组是否相等："
    + Arrays.equals(a , a2));

// 通过复制a数组，生成一个新的b数组
int[] b = Arrays.copyOf(a, 6);
System.out.println("a数组和b数组是否相等："
    + Arrays.equals(a , b));

// 输出b数组的元素，将输出[3, 4, 5, 6, 0, 0]
System.out.println("b数组的元素为："
    + Arrays.toString(b));

// 将b数组的第3个元素（包括）到第5个元素（不包括）赋为1
Arrays.fill(b , 2, 4 , 1);
// 输出b数组的元素，将输出[3, 4, 1, 1, 0, 0]
System.out.println("b数组的元素为："
    + Arrays.toString(b));

// 对b数组进行排序
Arrays.sort(b);
// 输出b数组的元素，将输出[0, 0, 1, 1, 3, 4]
System.out.println("b数组的元素为："
    + Arrays.toString(b));