黑马程序员_Java基础（流程控制、函数、数组）

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

 

------------------程序流程控制   函数  数组

1、if语句（判断结构）

格式：

1、

if(条件表达式)

{

执行语句;

}    

2、

if(条件表达式)

{

执行语句;

}

else

{

执行语句;

}//else只和最近的if配对   

3、

if(条件表达式)

{

执行语句;

}

elseif(条件表达式)

{

执行语句;

}

……

else

{

执行语句;

}

三元运算符是if else 结构的简写格式，可以简写代码，局限性是必须有一个结果

   2、switch语句（选择结构）

格式：

switch(表达式)//表达式的值只接收byte short int char类型

{

    case取值1:

        执行语句;

        break;

    case取值2:

        执行语句;

        break;

    ……

    Default:                //缺省默认

        执行语句;

        break;

}

当多个答案对应同一个执行语句时可以简写：

case取值1：

case取值2；

    执行语句;

    break;

//这时，取值1和取值2执行同一个执行语句

若判断的数值不多而且符合byteshort int char四种类型，建议使用switch语句，效率稍高

对区间判断，结果为boolean类型，使用if语句范围更广

3、循环结构

1、

while(条件表达式)

{

    执行语句

}  //先判断后执行，初始化表达式在循环体外

2、

do

{

    执行语句;

}

while(条件表达式)//先执行后判断，特点是至少执行一次

3、

for(初始化表达式;循环条件表达式;循环后操作表达式)

{

    执行语句;

}//初始化表达式只执行一次，且只在循环体内有效，可稍稍减少内存空间的使用

例：

intx = 1;

for(System.out.print("a");x<3; System.out.print("b"))

{

    System.out.print("b");

    x++;

}//打印结果为acbcb

for循环练习（累加）

public classForTest

{

    publicstaticvoidmain(String[] args)

{

        int sum = 0;

        for(int x = 1; x <= 100;x++)

{

            sum= sum + x;

        }

        System.out.println(sum);

}

}

嵌套循环：就是循环体系里面又有一个循环

实例：打印九九乘法表

public classForTest

{

    publicstaticvoid main(String[] args)

    {

        for(int x = 1; x < 9;x++)

        {

            for(int y = x;y<9;y++)

            {

                System.out.print(x+"*"+y+"="+x*y+" \t");//\t为制表符

            }

            System.out.println();

        }

    }

}

4、break和continue

break(跳出)为跳出循环结构

break默认是跳出break所在循环，可对循环结构进行标号指定跳出，且标号只能用于循环结构。例如：

a:for(;;)

{

    b:for(;;)

    {

        if()

        {

            break a;

        }

    }

}

continue(继续)为结束本次循环,继续下一次循环

5、函数

定义在类中的一段具有独立功能的小程序，函数又称为方法

格式：

修饰符返回值类型函数名(参数类型形式参数1,参数类型形式参数2)//void表示没有返回值

{

    执行语句;

    return返回值;//返回值类型为void时，return语句可以不写

}

定义函数的提高了代码的复用性

函数里面能调用函数，但是不能在函数里面定义函数

所以切记不能在main函数里面定义函数

定义一个函数步骤：

1、   明确函数的运算结果，也就是函数的返回值类型

2、   明确在定义该函数的过程中是否需要位置的内容参与运算，也就是函数的参数类型和参数个数

例如：判断两个数是否相等

public staticboolean conpare(int x,int y)

{

    if(x==y)

    returntrue;

    else

    {

        returnfalse;

    }

}

函数的重载overload

在同一个类中允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不一样

重载和返回值类型无关，只看参数类表，方便阅读，优化了程序设计

例如：

1、求和函数：

    publicstaticint add(int a,int b)

    {

        return a+b;

    }

    publicstaticint add(int a,int b,int c )

    {

        return a+b+c;

}

例2：

//重载和返回值类型无关

    void method(int a,int b)

    {}

    intmethod(int a,char b)

    {}

 

6、数组

同一种类型数据的集合，数组就是一个容器

数组的好处是给每一个元素都编号了，方便操作

格式：

元素类型[]数组名 =new元素类型[元素个数]{元素1，元素2……};

int[]arr =newint[3];

int[]arr =newint[]{1,2,3,4,5};

int[]arr = {1,2,3,4,5};

内存结构：

在java程序运行过程中，为了提高运行效率，对内存空间划分为5个不同的区域，每一片区域都有特定的处理数据方式和内存管理方式

栈内存、堆内存、方法区、本地方法区、寄存器

栈内存：用于存储局部变量，当数据用完空间会自动释放，

堆内存：数组，对象，实例等都在堆内存中。每一个实体都有内存地址值，实体中的变量都有默认初始化值，实体在不被使用的时候，会在不确定的时间内被垃圾回收机制回收

在数组的定义过程中：int[]arr = new int[]{1,2,3};

1、在栈内存中生成一个变量arr

2、new出来的对象都在堆内存中，开辟一片内存空间，存储数组中的元素。并把arr[0]的内存地址值赋值给栈内存中的arr，这时称为arr指向(引用)了这个数组

 

默认初始化值

变量类型	int	float	int[]	boolean	double
默认初始化值	0	0.0f	\u0000	false	0.0

 

垃圾回收机制：

当一个实体在堆内存中没有任何引用使用的话，那么该实体会被JVM视为垃圾，会在不确定的时间内被垃圾回收机制回收

数组中常见的问题

int[] arr =newint[3];

System.out.println(arr[3]); //ArrayIndexOutOfBoundsException:数组脚标为越界异常，数组访问到了不存在的脚标

int[] arr =newint[3];

arr = null;

System.out.println(arr[3]); //NullPointerException空指针异常，当引用没有任何指向值为null时，该引用还在操作实体

数组的遍历

就是获取数组中元素的操作   例：

public classArrayDemo

{

    publicstaticvoid main(String[] args)

    {

        int[] arr = {3,6,2,6,5};

        for(int i = 0;i<arr.length;i++)//arr.length为数组的长度

        {

            System.out.println("arr["+i+"]="+arr[i]);

        }

    }

}

数组的常见操作

1、获取数组中的最大值

    publicstaticint getMax(int arr[])

    {

        int max = arr[0];//这里可以将max初始化为数组中的任一元素

        for(int i = 0;i<arr.length;i++)

        {

            if(max<arr[i])//这里判断max与arr[i]的大小，<号则最大值 >号则最小值

            {

                max= arr[i];// max小于arr[i]时进行赋值操作

            }

        }

        return max;

    }

这里：相当于数组中每一个元素都和max进行比较，当数组中的元素小于max中的值时，进行赋值操作；

3、   选择排序

原理：用循环嵌套的方式，让每一个元素(最后一个元素除外)和它后面的元素一一进行比较，若大于(或者小于)后面的某一个元素，则执行互换操作

public static void sortArray(int arr[])

    {

        for(int i=0;i<arr.length-1;i++)

        {

            for(int j=i+1;j<arr.length;j++)//嵌套循环

            {

                if(arr[i]>arr[j])//这里进行判断操作，大于则执行互换操作,>升序  <降序

                {

                    int temp = arr[j];

                    arr[j]= arr[i];

                    arr[i]= temp;

                }

            }

        }

    }

特点：内循环结束一次，则最值出现在头脚标位置上

4、   冒泡排序法

原理：相邻的两个元素进行比较，大于(或者小于)时换位

public staticvoidbubbleSort(int[] arr)

    {

        for(int i=0;i<arr.length-1;i++)

        {

            for(int j=0;j<arr.length-i-1;j++)//-x让每一次比较的元素减少，-1避免数组脚标越界

            {

                if(arr[j]>arr[j+1])//相邻两个元素进行比较，大于则元素互换，大于则升序，小于则降序

                {

                    int temp = arr[j];

                    arr[j]= arr[j+1];

                    arr[j+1]= temp;

                }

            }

        }

}

冒泡排序法的特点：每一圈，最值出现在后位

5、   折半查找

前提：数组是有序的，可以理解为猜数字游戏(老师你好萌)

可以提高查找的效率

    publicstaticint halfFound(int[]arr,int key)

    {

        int min = 0;

        int max = arr.length-1;

        int mid = (min + max)/2;

        while(arr[mid]!=key)//arr[mid] !=key说明还没有找到，

        {

            if(key<arr[mid])//key小于arr[mid]则将mid-1的赋值给最大值max

                max= mid-1;

            elseif(key>arr[mid]) //key大于arr[mid]则将mid+1的赋值给最小值min

                min= 1 + mid;

            mid= (max + min)/2;//每判断完一次，mid就变为(max + min)/2

            if(min>max)    //当min大于max说明数组中找不到key，返回-1；

                return -1;

        }

        return mid;

    }

7、二维数组

可以理解为数组中的数组，把数组作为元素存入到数组中

格式：int[][]arr= new int[2][3];//定义了一个arr数组，这个数组存入了2个小数组（这个二维数组的元素），这两个数组都有两个元素

 

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