数组

数组的定义

数组是相同类型数据的有序集合，其中，每一个数据成为一个数组元素，每个数组元素可以通过一个下标来访问它们。

数组声明创建

首先声明数组变量：

dataType[] arrayRefVar;  //首选方法
或者
dataType arrayRefVar[];  //效果相同，但不是首选方法

然后使用new操作符创建数组：

dataType =new dataType[arraySizi];

声明和创建可以一行代码解决：

dataType[] arrayRefVar=new dataType[arraySizi];

其中，数组的元素是通过索引访问的。数组索引从0开始

获取数组的长度：arrayRefVar.length

int[] numbers=new int[3];
numbers[0]=1;
numbers[1]=2;
numbers[2]=3;
int sum=0;
for (int i = 0; i <numbers.length ; i++) {
    sum+=numbers[i];
}System.out.println(sum);//输出结果6

数组一经创建，长度就是不可变的，如果越界，则报错：java.lang.ArrayIndexOutOfBoundsException

内存分析

java内存：

堆：存放new的对象和数组；可以被所有的线程共享，不会存放别的对象引用
栈：存放基本变量类型(会包含这个基本类型的具体数值)；引用对象的变量(会存放这个引用在堆里面的具体地址)
方法区：可以被所有的线程共享；包含了所有的class和static变量

三种初始化

静态初始化
```
int[] num={1,2,3};
```
动态初始化
```
int[] num=new int[2];
num[0]=1;
num[1]=2;
```
数组的默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

数组的使用

普通的for循环
for-each循环(增强for循环)
数组做方法入参
数组做返回值

package com.array;

public class Demo02 {
    public static void main(String[] args) {
        int[] nums={1,2,3,4,5};
        one(nums);
        System.out.println("------------------");
        two(nums);
        System.out.println();
        System.out.println("------------------");
        three(nums);
        System.out.println();
        System.out.println("------------------");
        int[] four = four(nums);
       three(four);
    }
    //普通for循环  求和
    public static void one(int[] num){
        int sum=0;
        for (int i = 0; i <num.length ; i++) {
            sum+=num[i];
        }
        System.out.println("sum="+sum);
    }
    //for each循环  打印数组元素
    public static void two(int[] num){
        for (int num1:num) {
            System.out.print(num1+"\t");
        }
    }
    //数组做方法入参  打印数组元素
    public static void three(int[] num){
        for (int i = 0; i <num.length ; i++) {
            System.out.print(num[i]+"\t");
        }
    }
    //数组做返回值  求反转数组
    public static int[] four(int[] num){
        int[] result=new int[num.length];
        for (int i = 0,j=num.length-1; i <num.length ; i++,j--) {
            result[j]=num[i];
        }
        return result;
    }
}

/*输出结果
sum=15
------------------
1   2   3   4   5   
------------------
1   2   3   4   5   
------------------
5   4   3   2   1
*/

多维数组

多维数组可以看出是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。

二维数组：

int a[][]=new int[2][5];

以上二维数组a可以看成一个两行五列的数组。

package com.array;

public class Demo03 {
    public static void main(String[] args) {
        int[][] a={{1,2},{3,4}};
        three(a[1]);//打印
    }
    //打印数组元素
    public static void three(int[] num){
        for (int i = 0; i <num.length ; i++) {
            System.out.print(num[i]+"\t");
        }
    }
}
/*
3	4
*/

扩展

Arrays类

数组的工具类是java.util.Arrays
数组对象本身并没有什么方法供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本操作，可以通过查看JDK帮助文档。
Array类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用

以下常用功能

打印数组：toString方法
给数组赋值：fill方法
对数组排序：sort方法，升序
比较数组：equals方法比较两数组中元素值是否被相等
查找数组元素：binarySearch方法能对排序好的数组进行二分查找法操作。

package com.array;

import java.util.Arrays;

public class Demo04 {
    public static void main(String[] args) {
        int[] a={1,2,5,9,8,6,5,10,100000};
        //打印数组的方法 toString
        System.out.println( Arrays.toString(a));
        System.out.println("----------------------------");
        //填充方法 fill
        Arrays.fill(a,1,4,0);
        System.out.println( Arrays.toString(a));
        System.out.println("----------------------------");
        //对数组排序 sort(升序)
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        System.out.println("----------------------------");
        //比较两个数组内元素值是否相等 equals
        int[] b1={50,60,40};
        int[] b2={50,60,40};
        System.out.println(Arrays.equals(b1, b2));
        System.out.println("----------------------------");
        //查找数组元素  binarySearch   下方是求1对应的下标为：3
        Arrays.binarySearch(a, 1);
        System.out.println( Arrays.binarySearch(a, 1));
    }
}
/* 控制台输出：
[1, 2, 5, 9, 8, 6, 5, 10, 100000]
----------------------------
[1, 0, 0, 0, 8, 6, 5, 10, 100000]
----------------------------
[0, 0, 0, 1, 5, 6, 8, 10, 100000]
----------------------------
true
----------------------------
3
 */

冒泡排序

冒泡排序：最为出名的排序算法之一，总共有八大排序

八大排序：冒泡排序、快速排序、直接插入排序、希尔排序、简单选择排序、堆排序、归并排序、基数排序

冒泡的代码：两层循环，外层冒泡轮数，里层依次比较，时间复杂度是O(n2).

package com.array;

import java.util.Arrays;

public class Demo05 {
    //冒泡排序
    //1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，就交换他们的位置
    //2.每一轮的比较，都会产生一个最大或者一个最小的数字
    //3.下一轮就可以减少一次排序
    //4.依次循环，直到结束
    public static void main(String[] args) {
        int[] a={1,5,8,9,6};
        int[] text = text(a);  //调用完自己写的排序方法后，返回一个排序后的数组
        System.out.println(Arrays.toString(text));
    }
    public static int[] text(int[] array){
        //临时变量
        int temp=0;
        //外层循环，判断要走多少次
        for (int i = 0; i < array.length-1; i++) {
            //内层循环，比较判断两个数，如果第一个数比第二个数大 交换位置
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j+1]>=array[j]){
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
        return array;
    }
}
/**
 * [9, 8, 6, 5, 1]
 */