Java第四章【流程控制与数组、数组的操作【遍历、排序、查找】】

1.分支结构：用于实现根据条件来选择地执行某段代码。if  switch

2.循环结构：用于实现根据循环条件重复执行某段代码。while 、do  while 、for 、foreach循环以更简单的方式来遍历集合和数组元素。

一、顺序结构：程序从上到下逐行地执行，中间没有任何判断和跳转。

1.if条件语句：使用布尔表达式或者布尔值作为分支条件来进行分支控制。

   (***)一个逻辑表达式，即这个表达式的返回值只能是boolean（布尔值）:ture或者flase.

注：使用if......else语句时，尽量先出现包含范围更小的情况

if(a>b)
{
	//执行代码
	int temp;
	temp = a;
	a = b;
	b = temp
}

int a = 3;
if(a>4)
{
	System.out.println("a大于4");
}
else
{
	System.out.println("a不大于4");
}

int age = 30;
if(a>60)
{
	System.out.println("老年人");
}
else if(a>40)
{
	System.out.println("中年人");
}
else
{
	System.out.println("年轻人");
}

2.switch分支语句

switch语句由一个控制表达式和多个case标签组成，switch后面的控制表达式的数据类型只能是byte,short,int ,char,String和枚举类型。

class ForTest 
{
	public static void main(String[] args) 
	{
		String season = "夏天";
		switch (season)
		{
		case "春天":
			System.out.println("春天");
		break;
		case "夏天":
			System.out.println("夏天");
		break;
		case "秋天":
			System.out.println("秋天");
		break;
		default:
			System.out.println("冬天");
		}
	}
}

注：switch语句先求出表达式的值，然后拿这个结果与case标签的中的值比较，如果匹配则执行case标签下的所有代码，除非遇到break才结束。

二、循环结构

1.while(条件表达式)｛循环代码｝//先判断条件是否满足，满足则接着执行循环代码段

	public static void main(String[] args) 
	{
		int count = 0;
		while(count < 10)
		{
			System.out.println(count);
			count++;
		}
	}

2.do{循环代码}while(条件表达式)

		int a = 10;
		do
		{
			System.out.println("a="+a);
			a--;
		}
		while (a>0);

3.for（int i＝0;i<10;i++）for(int i=0,j=0;i<10 && j<8;i++)

		for(int i=0;i<10;i++)
		{
			System.out.println("i="+i);
		}

		for(int b=0,s=0,p=0;b<10 && s<4 && p<10;p++)
		{
			System.out.println(b++);
			System.out.println(++s+p);
		}

		int count = 0;
		for(;count<10;)
		{
			System.out.println(count);
			count++;
		}

4.嵌套循环

		//外层循环
		for(int i=0;i<4;i++)
		{
			//内层循环
			for(int j=0;j<4;j++)
			{
				System.out.println("i="+i+",j="+j);
			}
		}

5.控制循环结构【break,continue,return】

break：用于完全结束一个循环，跳出循环体。

		for(int i=0;i<10;i++)
		{
			System.out.println("i="+i);
			if(i==2)
			{
				break;//结束本次循环
			}
		}

 break语句不仅仅可以结束其所在的循环，也可以直接结束其外层循环。

		//外层循环
		outer:
		for(int i=0;i<4;i++)
		{
			//内层循环
			for(int j=0;j<4;j++)
			{
				System.out.println("i="+i+",j="+j);
				if(j==1)
				{
					break outer;
				}
			}
		}
		//结果：i=0,j=0
        //      i=0,j=1

	//外层循环
		for(int i=0;i<4;i++)
		{
			//内层循环
			outer:
			for(int j=0;j<4;j++)
			{
				System.out.println("i="+i+",j="+j);
				if(j==1)
				{
					break outer;
				}
			}
		}
		/*
			i=0,j=1
			i=1,j=0
			i=1,j=1
			i=2,j=0
			i=2,j=1
			i=3,j=0
			i=3,j=1
		*/

continue：用于跳出本次循环。与break类型的是，continue后的标签也必须是一个有效标签，即这个标签通常应该放在continue所在的外层循环之前定义。

return：并不是专门用来结束循环的，其功能是结束一个方法。

三、数组：一种数据结构，用于存储多个数据，每个数据元素存放一个数据，可通过数组元素的索引访问数组元素（赋值、取值）

注：一个数组只能存储一种数据类型的数据，它是一种引用类型。一旦数组的初始化完成后，数组在内存中所占的看见就被固定下来。

1.定义数组：int[] arr;  type[] arrayName;

2.初始化：就是为数组的数组元素分配内存空间，并为每个数据元素赋值。【初始化之后才可以使用】

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

动态初始化：程序员值给定数组的长度，由系统为数组元素分配初始值。

int arr[];
arr = new int[]{1,2,3,4,5}
String book = new String[] {"黑马程序","传智播客"};//静态初始化

int arr[] = new int[4];//动态初始化

执行动态初始化，只需给定数组的长度，即为每个数组元素指定所需的内存空间，系统为这些数组分配初始值。

整数类型：（byte,short,int,long），则数组元素的值为0；

浮点类型：（float,double），则数组元素的值为0.0.

字符类型：（char），则数组元素的值为'\u0000'。

布尔类型：（boolean），则数组元素的值为flase。

引用类型：（类、接口、数组），数组元素的值为null。

3。可以通过下标或者索引来查看数组中元素的值，其中索引值为0~数组长度减一，如果索引值小于0，或者大于等于数组的长度，编译程序不会出现任何错误，但运行程序时会出现异常：java.lang.ArrayIndexOutOfBoundsException:N(数组索引越界异常)，异常信息后的N是程序员试图访问的数组索引。

		int[] array = new int[]{1,5,8,3,4};
		//通过数组名.length获得数组的长度，通过for循环语句遍历数组
		for(int i=0;i<array.length;i++)
		{
			System.out.print(array[i]+" ");
		}
		System.out.println();
		//通过foreach循环遍历数组的元素，其无须获得数组的长度，无须根据索引来访问数组的元素。
		//for(type 形参名：数组名)
		for(int num : array)
		{
			System.out.print(num+" ");
		}

四、深入数组

数组是一种引用数据类型，数组对象被存储在堆内存中，而数组引用变量被存储在栈内存中。

注：当一个方法执行时，每个方法都会建立自己的内存栈，在这个方法内定义的变量会逐个放在这块栈内存里，随着方法的执行结束，这个方法在内存栈中也将自然被销毁。

所有放在方法中的局部变量都放在栈内存中的。经常访问的数据放在堆内存中，比如对象。

五、操作数组的工具类

		int binarySearch(type[] type key);//查询key元素值在数组中出现的索引，不包含返回负数。数组必须是升序排列
		int binarySearch(type[] int fromIndex,int toIndex,type key);
		//只搜索数组中fromIndex到toIndex索引的元素，数组同样是升序排列。
		type[] copyOf(type[] original,int length);//把数组original数组复制成一个新数组，但要注意新数组的length.
		type[] copyOfRange(type[] original,int from,int to);
		boolean equals(type[] a1,type[] a2);//如果数组a1和a2的长度且数组元素一一相等，返回true。
		void fill(type[] a,type val)//将数组元素值都赋值为val
		void fill(type[] a,int fromIndex,int toIndex,type val);
		void sort(type[] a)//排序
		void sort(type[] a,int fromIndex,int toIndex);//formIndex到toIndex-1
		String toString(type[] a)

注：要import java.util.*

因为Arrays类在该包下。