黑马程序员——学习日记之--流程语句与数组知识

——- android培训、java培训、期待与您交流！ ———-

1—流程控制

java程序是按照代码出现的先后顺序执行的，通过流程控制语句可以有效组织代码执行顺序。

一：判断语句

if

–形式：

if (boolean)
{
[code];
}

如果boolean为真，code代码块会执行。

如果boolean为假，就直接跳过它控制的代码块。

当if控制的语句只有一句时，可以不写大括号。

if 语句的嵌套：

if (boolean)
{
if (bool)
{
if (b){ System.out.println("nihao"); }
}
}

仅当boolean bool b 全为真时，才会输出nihao。

if else

–形式：

if (boolean)
{
[code1];
}
else
{
[code2];
}

如果boolean为真，执行code1代码块。

如果boolean为假，执行code2代码块。

同样，当if或else只控制一条语句时，可以不写大括号。

if - else if

–形式：

if (boolean)
{
[code1];
}
else if (bool)
{
[code2];
}

boolean为真，执行code1代码块。然后跳过code2代码块。

boolean为假，跳过code1，判断code2。

三个判断语句的区别

if语句只是单纯的判断是否满足某一个条件。

if-else则是两个条件之间的互斥选择，即两个互斥的条件只能选择其一。

if-else可以看成 if (bool) - else (!bool)的简写。

而bool和 !bool 组成的集合为1，这时候就是如果不是bool，肯定是 !bool 。

if - else if 是在bool和!bool组成的集合不是1的情况下，这时候如果不是bool，也不一定是 ！bool 。

需要根据条件的性质选择适合的判断语句。

switch

可以进行有限遍历操作。

–形式：

switch (3)
{
case 1 : System.out.println(1);
break;
case 2 : System.out.println(2);
break;
case 3 : System.out.println(3);
break;
default : System.out.println("无");
}

switch 只适用于 int ， byte ， short ， char 四种类型。

代码块中会把表达式与每个case碰一碰比较是否相等，如果相等，就执行对应语句。

如果匹配的case没有表明break跳出循环，程序会顺序往下面读，不判断case和default了，直到出现break或者程序执行完才结束。

注意：switch中的default可以没有顺序，多个case的执行语句相同时也可以几个case合起来写。

有限的匹配结果时，选择 switch 。

举例：多种方式输出星期几

判断语句的使用条件。

（1）//if - else if

int x=3;
if (x==1)
System.out.println("星期一");
else if (x==2)      //如果不用else if ，而是if，那么当上面判断语句是真时，此语句仍会被判断。
System.out.println("星期二");
else if (x==3)
System.out.println("星期三");
else if (x==4)
System.out.println("星期四");
else if (x==5)
System.out.println("星期五");
else if (x==6)
System.out.println("星期六");
else
System.out.println("星期天");

（2）//switch

int x=4;
switch (x)
{
case 1:
System.out.println("星期一");
break;  //此处如果不写break跳出循环，那么当case1满足时，后面的所有case都会被忽略而直接执行可执行语句，出现混乱。
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;
default:    //当以上所有case都不符合条件是执行的语句。
System.out.println("星期天");
break;  //最后一个break最好写上，有时候case是缺少break语句的。
}

注意：如果对有限的数值判断时，可以用switch，注意switch只接收四种类型：byte，short，int，char。

其他情况比如对区间判断和对布尔型判断，用 if 比较方便。

二：循环语句

while

–形式：

while (boolean)
{
[code];
}

当boolean满足条件，code就可以执行。

如果boolean一直为真，程序就会陷入死循环，一直执行code代码块，跳不出来。

如：

int sum=0;
int x=0;
while (x<10)
{
sum*=2;
x++;
}

while 循环的判断条件的变量要在外部定义好。

while语句中一般有变量自增或自减的语句，好让循环是有限的。

如果判断条件一开始就不满足，while语句一次都不会执行，直接跳过。

循环语句的嵌套：

while (boolean)
{
while (bool){}
}

do while

–形式：

do
{
[code];
}
while(boolean);

这种形式的循环是把代码块现在前面，循环条件写在后面。

所以即使循环条件boolean不满足，代码块也会执行一次。

do while 和 while 只是循环条件和代码块的执行顺序不一样。

注意： while 语句后面要加分号。

举例：随机产生大写字母，直到出现Z停止。

import java.math.*;
class Demo
{
public static void main(String [] args)
{
char c;
do
{
c=(char)('A'+(int)(Math.random()*26))
System.out.println(c+"，");
}
while(c!='Z');
}
}

for

–形式：

for (int x=0;x<10;x++)
{
[code];
}

for 执行时首先要执行初始化动作，就是 int x=0;

然后判断循环终止条件， x<10;如果满足就可以执行code代码块。

最后再执行迭代部分，x++。

只要满足循环终止条件，代码块就会一直执行。

注意：x 在这里是局部变量，循环已结束，变量就消失。

* 变量x可以在外面定义。

int x=0;
for ( ;x<10;x++){}

*最简单的无线for循环。

for ( ; ; ){}

这里默认的循环终止条件为true。

*可以有多个变量。

for (int x=0,y=10;x<y;x++,y--){}

举例：for循环嵌套打印99乘法表

for (int y=1;y<10;y++)
{
for (int x=1;x<10;x++)
{
System.out.prin(x+"*"+y+"="+x*y+"   ");
}
System.out.println();
}

输出数字阵列。语句嵌套运用

1

12

123

1234

12345

for (int x=1;x<6;x++)
{
for (int y=1;y<=x;y++)
{
System.out.println(y);
}
}

for和while的区别

for中的一般是局部变量，在for循环外无效。可以节省内存。

while中的变量是外部定义好的。

如果变量仅用于控制循环，在循环外部基本无用，就使用for循环。

一般能用for循环的语句，也可以用while。

三：跳转语句

break

break语句可以跳出循环。

break语句在拥有标签的嵌套循环中也可以标签化中断：

out : for (int x=0;x<10;x++)
{
in : for (int y=1;y<5;y++)
{
if (x=3) break out; //可以根据循环的标签指定要跳出那个循环。
}
}

continue

结束本次循环并进入下一个循环。

continue 也可以标签化继续。

return

return可以返回一个结果并结束该方法。

单独写return是指从当前方法退出。

return 可以标签后返回并退出。

注意：

这三个跳转语句的下面不能直接跟上一条语句，否则这条语句永远执行不到，在程序编译时会报错。

四：递归

递归的思想是“自己调用自己”。

递归需要有递归头，即什么时候不再调用自身。

如：调用一个方法method().求阶乘。

public static int method(int x)
{
if (x==1)
return 1;
else
return x*method(x-1);
}

注意：递归程序比较耗用内存，递归层次较多时比循环结构慢得多。

——————————————————————————————————————

2—数组

写法

int [] arr = new int [4]; //新生成一个数组，容量是4，都已经初始化为0。或者 int arr []形式。

int [] arr = new int [] {1,2}; //静态数组，声明时已经赋值。

int [] arr = {1,2,3,4,5}; //静态数组，最简形式。

其他类型的数组同理，修改类型就可以。

数组是三大引用类型之一，还有类和接口。

数组中的常用方法：

array.length 代表数组的长度。

数组引用类型的特点：

int [] arr={1,2,3};
arr=null;
System.out.println(arr[0]);

栈中的数组变量arr重新指向一个空值，不再指向堆中的实体{1,2,3}，打印arr[0] 会出错：空指针异常。

数组有下标，arr[0]表示数组的第一个元素。

但对于长度为n的数组，最大可以有arr[n-1]，arr
会角标越界。

堆和栈的特点：

堆中存放实体数据，实体数据都有默认值： int 初始为0，double初始为 0.0 ，float初始为 0.0f ，布尔初始为 false 。

堆中的实体都有内存地址值，堆有一个特有的垃圾回收机制，不定时的清除内存中的垃圾。

栈内存中数据使用完毕可以自动释放。局部变量都是在栈内存中。

工具类的使用和说明文档的制作：

-对于别人写好的class文件形式的工具，我们可以set classpath=[dir]; 调用这个工具类。

要想详细了解这个工具的使用方法，就需要有一个工具类的说明文档。

介绍一下工具类的说明文档的制作：

对于一个写好的java文件，需要用文档注释工具编译，形式如下：

javadoc    -d    c:\pack  -author -version  Tool.java
-------------------------------------------------------
//编译工具 + 目录为 + 具体路径 + 作者  +   版本  +  java文件
//作者和版本可以不写。

注意：

需要生成注释文档的类必须是public修饰的，否则权限不足以公开。

javadoc 只会提取文件中public或者protected修饰的方法上的/* /中的内容，提取出来的文档也是以网页形式存储的。

如果不需要该类创建对象，可以不用public修饰类中的构造函数，就不会创建对象。

数组的排序与获取最值的工具类

/**
这是一个对数组操作的工具类。可以实现数组的求最值，排序，打印的功能。
@author 自己
@version V1.1.12
*/
public class Tool
{
private Tool(){}    //将构造函数私有化，外界没有权限创建对象，针对创建对象没有意义的情况。

/**获取一个整型数组中的最大值。
@param arr 接收一个int类型的数组。
@return 返回数组的最大值。
*/
public static int getMax(int [] arr)
{
int max=arr[0];
for (int x=1;x<arr.length;x++)
{
if (max<arr[x])
max=arr[x];
}
return max;
}

/**获取一个整型数组的最小值。
@param arr 接收一个int类型的数组。
@return 返回数组的最小值。
*/
public static int getMin(int [] arr)
{
int min=0;
for (int x=1;x<arr.length;x++)
{
if (arr[min]>arr[x])
min=x;
}
return arr[min];
}

/**给整型数组选择排序。
@param arr 接收一个int类型数组。
*/
public static void selectSort(int [] arr)
{
for (int x=0;x<arr.length-1;x++)
{
for (int y=x+1;y<arr.length;y++)
{
if (arr[x]>arr[y])
swap(arr,x,y);
}
}
}

/**给整型数组冒泡排序。
@param arr 接收一个int类型数组。
*/
public static void bubbleSort(int [] arr)
{
for (int x=arr.length-1;x>0;x--)
{
for (int y=0;y<x;y++)
{
if (arr[y]>arr[y+1])
swap(arr,y,y+1);
}
}
}

/**对数组元素进行置换操作。
@param arr 要接收的int型数组。
@param a 要置换的元素角标。
@param b 要置换的元素角标。
*/
private static void swap(int [] arr,int a,int b)
{
int t=arr[a];
arr[a]=arr;
arr[b]=t;
}

/**数组遍历输出。
@param arr 接收一个int型数组。
*/
public static void printArray(int [] arr)
{
System.out.print("[");
for (int x=0;x<arr.length;x++)
{
if (x==arr.length-1)
System.out.print(arr[x]+"]");
else
System.out.print(arr[x]+",");
}
}
}

[b]小知识点：java调用包的排序

import java.util.*;
class ArrayDemo
{
public static void main(String [] args)
{
int [] arr={8,1,2,4,3,7,2,5,0,9,6};
printArray(arr);
Arrays.sort(arr);       //调用包Arrays直接自然排序。
printArray(arr);
}
public static void printArray(int [] arr)
{
System.out.print("[");
for (int x=0;x<arr.length;x++)
{
if (x==arr.length-1)
System.out.print(arr[x]+"]");
else
System.out.print(arr[x]+",");
}
}
}

数组元素查找

遍历数组元素，判断与要查找的数是否相同。找到了就直接return角标位，没找到就return -1.

如果数组比较长，效率比较低，可以选择折半查找的方式。

注意：折半查找首先要求数组有顺序。

//在有序数组中折半查找一个元素。

public static int halfSearch(int [] arr,int key)
{
int min=0,max=arr.length-1; //定义最值。
while (min<=max)
{
int mid=(min+max)/2;    //定义中间值。
if (arr[mid]==key)      //等于key可以直接结束。
return mid;
else
{
if (arr[mid]<key)   //小于key说明key在arr[mid]右边。
min=mid+1;
else                //这里arr[mid]肯定大于key，说明arr[mid]在左边。
max=mid-1;
}
}
return -1;
}

数组元素插入

插入一个元素也要求数组有序。

遍历数组元素与key比较，当第一次key大于数组中的某个元素时，这个元素的角标就是插入位。

当数组比较长时，效率就比较低，可以选择折半插入的方式。

//在有序数组中折半插入一个元素。

public static int halfInsert(int [] arr,int key)
{
int min=0,max=arr.length-1;
if (arr[max]<key)
return -1;
while (min<=max)
{
int mid=(min+max)/2;

if (arr[min]>=key)
return min;
if (arr[max]<=key)
return max+1;
if (arr[mid]==key)
return mid;
if (arr[mid]>key)
max=mid-1;
if (arr[mid]<key)
min=mid+1;

}
}

二维数组

int [] [] arr=new int [3] [4]; 定义一个包含3个一维数组的二维数组，每个一维数组包含四个元素。

一维数组的长度可以不指定，但二维数组的长度必须指定。

二维数组的另一种写法： int [] [] arr={{},{},{}};

如果写成 int [] x,y []; 就相当于： int [] x; int [] y []; x是一维数组，y是二维数组。

arr [2] [3]=2; 对第二个一维数组的第三个元素赋值为2.

System.out.println(arr) 打印的是二维数组的地址值。

System.out.println(arr[1]); 打印的是一维数组的内存地址值。

System.out.println(arr[0] [0]); 如果一维数组元素初始化了，打印的就是0，否则打印null。

注意：给数组分配长度，就会使数组初始化。

二维数组元素求和

public static void getSum()
{
int [] [] erarr={{8,12,6,10,7},{8,6,4,12,7},{6,4,11,8,5},{9,5,11,8,13}};
int sum=0;
for (int x=0;x<erarr.length;x++)
{
for (int y=0;y<erarr[x].length;y++)
{
sum=sum+erarr[x][y];
}
}
System.out.println(sum);
}