java基础学习04（数组与方法）

数组与方法

一、完成的目标

1. 掌握数组的定义、使用方法、引用传递
2. 掌握方法及其方法的重载
3. 使用方法接收和返回一个数组
4. java新特性对数组的操作支持

二、数组的定义和使用

数组是一组相关数据的集合，一个数组实际上就是一连串的变量，数组可以分为一维数组、二维数组、多维数组。

一维数组
一维数组可以存放很多数据，这些数据的类型是完全相同的。使用Java数组必须经过两个步骤：声明数组、分配内存给数组。

数据类型 数组名 [] = null; //声明一维数组

也可以使用如下声明：
数据类型 [] 数组名 = null; //声明一维数组

数组名 = new 数据类型 [长度]；//分配内存给数组

数组的声明格式里，“数据类型”是声明数组元素的数据类型，常见的类型有整型、浮点型与字符型等。“数组名”是用来统一这组相同数据类型的元素的名称，其命名规则和变量的相同。

数组声明后实际上是在栈内存中保存了此数组的名称，接下来便是要在堆内存中配置数组所需的内存，其中“长度”是告诉编译器，所声明的数组要存放多少个元素，而“new”则是命令编译器根据括号里的长度开辟空间。

int score [] = null; //声明整型数组score  
score = new int [3]; //为整型数组score分配内存空间，元素个数位3

声明一个整型数组score时，score并没有包含任何内容，编译器只会在栈内存中分配一块内存给它，用来保存指向数组实体的地址名称。  
堆内存分配操作，一个数组开辟了堆内存之后，将在堆内存中保存数据，并将堆内存的操作地址给了数组名称score。 

堆、栈内存理解：一个堆内存可被多个栈内存空间指向，好比一个人(堆内存)有多个名字（栈内存）。 

声明数组同时分配内存：

数据类型 数组名 [] = new 数据类型[个数]; //声明一维数组  

int num [] = new int[10];

数组排序
在数组的操作中，数组的排序是一种很常见的操作。

/**
*1.对整型数组按照由小到大的顺序进行排列（冒泡排序）
*2.冒泡排序：把数组中的每一个元素进行比较，如果第i个元素大于第i+1个元素，那么就把两个数字进行交换
*/
class TestDemo{
    public static void main(String [] args){        
        int score [] = {69,79,87,89,100,75,90};  //定义整型数组
        System.out.println("***比较开始***");
        for(int i=1;i<score.length;i++){        //循环判断
            for(int j=0;j<score.length;j++){
                if(score[i] < score[j]){        //交换位置
                    int temp = score[i];
                    score[i] = score[j];
                    score[j] = temp;
                }
            }
            System.out.print("第"+i+"轮"+"排序结果：");
            for(int j=0;j<score.length;j++){
                System.out.print(score[j]+"	");
            }   
            System.out.println();
        }

        System.out.print("从小到大的排序最终结果：");       
        for(int i=0;i<score.length;i++){
            System.out.print(score[i]+"	");
        }   
    }
}

Process started >>>
***比较开始***
第1轮排序结果：69  100 79  87  89  75  90  
第2轮排序结果：69  79  100 87  89  75  90  
第3轮排序结果：69  79  87  100 89  75  90  
第4轮排序结果：69  79  87  89  100 75  90  
第5轮排序结果：69  75  79  87  89  100 90  
第6轮排序结果：69  75  79  87  89  90  100 
从小到大的排序最终结果：69  75  79  87  89  90  100 <<< Process finished. (Exit code 0)

/*
*1.冒泡排序另外一种方法
*/

public class BubbleSortTest
{
    public static void  bubbleSort(int [] a)
    {
        for(int i = 0 ;i < a.length - 1;i++)
        {
            for(int j = 0;j < a.length - i - 1;j++ )
            {
                if(a[j] > a[j+1])
                {
                    int temp = a[j+1];
                    a[j+1] = a[j];
                    a[j] = temp;
                }
            }
            System.out.println("第"+(i + 1)+"轮循环:");
            for(int k = 0 ;k < a.length; k++)
            {
                System.out.print(a[k]+" ");
            }
            System.out.println();
        }
    }
    public static void main(String[] args)
    {
        int [] a = {2,7,6,9,5,3};
        bubbleSort(a);
    }
}

Process started >>>
第1轮循环:
2 6 7 5 3 9 
第2轮循环:
2 6 5 3 7 9 
第3轮循环:
2 5 3 6 7 9 
第4轮循环:
2 3 5 6 7 9 
第5轮循环:
2 3 5 6 7 9 
<<< Process finished. (Exit code 0)

方法的递归调用 
递归调用是一种特殊的调用形式，是方法自己调用自己。

/**
*1.方法的递归调用
*/
class TestDemo{
    public static void main(String [] args){        
        System.out.println("***计算结果***"+sum(100));//调用操作
    }
    public static int sum(int num){     //定义方法用于求和操作
        if(num == 1){                   //判断是否加到最后一个数
            return 1;
        }else{
            return num + sum(num - 1);  //递归调用
        }
    }
}

Process started >>>
***计算结果***5050
<<< Process finished. (Exit code 0)