第四节：java数组

数组的定义

数组是引用数据类型三种当中的其中一种。

概念：同一种类型数据的集合。其实数组就是一个容器。
格式1：元素类型[]  数组名 = new  元素类型[元素个数];
格式2：元素类型[]  数组名 = new  元素类型[] {元素，元素，......}; 
int[] arr = new int[] {3,5,1,7};
int[] arr = {3,5,1,7};

int [] x = new int[3] 结构说明

左边在栈内存中定义一个x,凡是局部变量都在栈内存里。
（右边）new 在堆内存中产生一个是数组。并指定了元素的类型和个数，每个元素都有一个角标。
关系：new会把这个数组的内存地址赋值给x。int[] 是定义数组元素的数据类型。栈里面的x只是调用了堆里的数组的地址。

arr是数组类型，元素是int类型。

class ArrayDemo2
{
    public static void main(String[] args)
    {
        //int[] arr = new int[2]; //定义数组方法一
        //int arr[] = new int[2]; //定义数组方法二
        arr[0] = 90; //赋值
        arr[1] = 78;
        int[] arr = new int[]{3,1,6,5,4};
        int[] arr = {3,1,6,5,4}; //静态初始化（定义）数组
        System.out.println(arr[0]);
    }
}

栈内存：

用于存储局部变量，当数据使用完，所占空间会自动释放。

堆内存：

通过new建立的实例都存放在堆内存中。
有内存地址值
有默认初始化值
被垃圾回收器回收。会不定时的清理垃圾。

什么是局部变量呢？

　　定义在方法里面的变量，

　　定义在方法的参数里的变量，

　　定义在for循环里面的变量全都是局部变量。

堆内存中的实体中的数据都有默认初始化值：

　　int型数组的话默认就是0，

　　double默认就是0.0 ；

　　float默认就是0.0F ；

　　Boolean类型的数组，默认初始化值就是false。

四、Java数据类型在内存中的存储：

1）基本数据类型的存储原理：基本数据类型都是直接存储在内存栈上的，数据本身的值就是存储在栈空间里面，而Java语言里面八种数据类型是这种存储模型；

2）引用类型的存储原理:引用类型继承于Object类（也是引用类型），“引用”是存储在有序的内存栈上的，而对象本身的值存储在内存堆上的；

区别:基本数据类型和引用类型的区别主要在于基本数据类型是分配在栈上的，而引用类型是分配在堆上的（需要java中的栈、堆概念）

数组的操作：

打印数组中所有的元素，元素间用逗号隔开

class ArrayDemo3
{
    public static void main(String[] args)
    {
        //int[] arr = new int[3];
        int[] arr = {1,8,9};
        printArray(arr);  //如果System.out.print(arr) 将打印出类似[I@8ad82ed 这样的数据：[代表数组，I代表int类型。@后面的是数组的内存地址。
    }
    public static void printArray(int[] arr) //打印哪个数组的元素，要给出一个参数。
    {
        //获取数组元素个数：length
        //使用方式：数组名称.length =
        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]+"]");
        }
    }
}

求数组元素的和

class ArrayDemo3
{
    public static void main(String[] args)
    {
        //int[] arr = new int[3];
        int[] arr = {1,8,9};
        int sum = 0;
        for(int x=0; x<arr.length; x++)
        {
            sum += arr[x];
        }
        System.out.println(sum);
    }
}

给定一个数组{5,1,6,4,2,8,9}，获取数组中的最大值，以及最小值。

/*
思路：
    1，获取最值需要进行比较。每一次比较都会有一个较大的值。通过一个变量进行临时存储。
    2，让数组中的每一个元素都和这个变量中的值进行比较。把大的值赋值给变量。
    
步骤：
    1：定义变量，初始化为数组中任意一个元素即可。
    2：通过循环语句对数组进行遍历。
    3：在循环过程中定义判断条件，两个元素哪个大就赋值给变量。
    
需要定义一个功能（函数），以便提高代码的复用性。
    1，已明确的结果，数组中的元素为int型
    2，未知内容：是哪个数组
    */
class ArrayTest
{
    public static int getMax(int[] arr)
    {
        int max = 0;
        for(int x=1; x<arr.length; x++)
        {
            if(arr[x]>arr[max])
                max = x;
        }
        return arr[max];
    }
    
    public static void main(String[] args)
    {
        int[] arr = {5,1,6,4,2,8,9};
        int max = getMax(arr);
        System.out.println("max="+max);
    }
}

//获取double类型数组的最大值。因为功能一致，所以定义相同函数名称，以重载形式存在。
public static double getMax(double[] arr)
{
    
}

在编译的时候不会报出异常，在执行的时候会报错。

访问了数组中不存在的角标。

红框中的内容为报错提示为什么报错。黄框中的内容提示报错的位置。

选择排序

class ArrayTest2
{
    /*
    选择排序。
    内循环结束一次，最值出现头角标位置上。
    */
    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])
                {
                    int temp = arr[x];
                    arr[x] = arr[y];
                    arr[y] = temp;
                }
            }
        }
    }
    public static void main(String[] args)
    {
        int[] arr = {5,1,6,4,2,8,9};
        //排序前
        printArray(arr);
         
        //排序
        selectSort(arr);
         
        //排序后
        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]+"]");
        }
    }
}

冒泡排序：

class ArrayTest3
{
    /*
    冒泡排序
    */
    public static void bubbleSort(int[] arr)
    {
        for (int x=0; x<arr.length-1; x++)
        {
            for(int y=0; y<arr.length-x-1; y++) //-x让每次比较的元素减少，-1：避免角标越界。
            {
                if(arr[y]>arr[y+1])
                {
                    int temp = arr[y];
                    arr[y] = arr[y+1];
                    arr[y+1] = temp;
                }
            }
        }
    }
    public static void main(String[] args)
    {
        int[] arr = {5,1,6,4,2,8,9};
        //排序前
        printArray(arr);
         
        //排序
        //selectSort(arr);
        bubbleSort(arr);
         
        //排序后
        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.println(arr[x]+"]");
        }
    }
}

堆内存中换位置比较消耗资源。

先把需要换位置的角标和值记录到栈内存中，都比较完之后将最大的值放到最后。比较一圈只在堆内存中换了一次位置。

用内置方法排序：

import java.util.*;
 
class ArrayTest4
{
    public static void main(String[] args)
    {
        int[] arr = {5,1,6,4,2,8,9};
        //排序前
        printArray(arr);
        //排序
        Arrays.sort(arr);
        //排序后
        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.println(arr[x]+"]");
        }
    }
}