Java 数组

一.什么是数组？

• 数组是相同类型数据的有序集合。
• 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
• 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问。
  二.数组的声明与创建
• 首先必须声明数组变量，才能在程序中使用数组。声明数组变量语法如下：

dataType[] arrayRefVar; //首选的方法
或
dataType arrayRefVar[]; //效果相同

• java语言使用new操作符来创建数组，语法如下：

dataType[] arrayRefVar=new dataType[arraySize];

• 数组的元素是通过索引访问的，数组索引从0开始。
• 获取数组长度 arrays.length

public class arraysDemo01 {
    public static void main(String[] args) {
        int[]  array;  //1.声明一个数组
        //int array[];
        array=new int[5]; //2.创建一个数组
         //1+2 可以写成  int[] array=new  int[5];
        //3.给数组元素赋值
        array[0]=1;
        array[1]=2;
        array[2]=3;
        array[3]=4;
        array[4]=5;

        for (int i = 0;  i< array.length; i++) {
            System.out.println(array[i]);

        }
    }
}

三.数组的基本特点

• 其长度是确定的，数组一旦被创建，她的大小就是不可以改变的。
• 其元素必须的相同类型，不允许出现混合类型。
• 数组中的元素可以是如何数据类型。包括引用类型和基本类型。
• 数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
• 数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

四.三种初始化

• 静态初始化

int []a={1,2,3};
Man[] mans={new Man(1,1),new Man(2,2)};

• 动态初始化

int[] b=new int[3];
b[0]=10;
b[1]=20;
b[2]=30;

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

public class arraysDemo01 {
    public static void main(String[] args) {
        //静态初始化
        int []a={1,2,3};
        //动态初始化，包含默认初始化
        int[] b=new int[3];
        b[0]=10;
        b[1]=20;
        b[2]=30;
        System.out.print(a[0]);
        System.out.print(" "+a[1]);
        System.out.println(" "+a[2]);
        System.out.println("----------");
        System.out.print(b[0]);
        System.out.print(" "+b[1]);
        System.out.print(" "+b[2]);

        }
    }

五.数组边界

• 下标的合法区间：[0, length-1].如果越界就会报错；
• ArrayIndexOutOfBoundsException：数组下标越界异常！

public class arraysDemo01 {
    public static void main(String[] args) {
        int[] b=new int[2];
        b[0]=10;
        b[1]=20;
        System.out.print(" "+b[2]);  //下标越界

        }
    }

六.数组的使用

• 普通for循环

public class arraysDemo01 {
    //简单的for循环
    public static void main(String[] args) {
        int a[]={1,2,3,4,5};


        //遍历打印数组
        for (int i = 0; i <a.length ; i++) {
            System.out.println(a[i]);
        }
        System.out.println("-------------");

        //求数组元素和
        int sum=0;
        for (int i = 0; i < a.length; i++) {
            sum=sum+a[i];
        }
        System.out.println("sum="+sum);

        //查找最小元素
        int  min=a[0];
        for (int i = 0; i < a.length; i++) {
            if(a[i]<a[0]){
                min=a[i];
            }
        }
        System.out.println("min="+min);
        }
    }

• For-Each循环

public class arraysDemo02 {
    public static void main(String[] args) {
        //增强for循环
        int []b={1,2,3,4,5};
        for (int arrays : b) {
            System.out.println(arrays);
        }
    }
}

• 数组作方法入参

public class arraysDemo02 {
    public static void main(String[] args) {

        int []a={2,7,86,53};
        printA(a);
    }
    //打印数组的方法
    public static void printA(int a[])
    {
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);

        }
    }


}

• 数组作返回值

public class arraysDemo02 {
    public static void main(String[] args) {
        int a[]={9,8,7,6,5,4,3,2,1};
        int[] reverse=reverse(a);
        printA(reverse);
    }
    //反转数组
    public static int[] reverse(int a[])
    {
        int result[]=new int[a.length];
        for (int i = 0,j=result.length-1; i < a.length; i++,j--) {
            result[j]=a[i];
        }
        return result;  //数组作为返回值
    }
    public static void printA(int a[])
    {
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);

        }
    }
}

七.二维数组

• 二维数组

int a[][]=new int[2][3]；

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

public class arraysDemo04 {
    public static void main(String[] args) {
        int[][] a={{1,2,3},{3,4,5},{6,7,8}};
        /*1  2  3  a[0]
          3  4  5  a[1]
          6  7  8  a[2]
       */
        printA(a[0]);
        printA(a[1]);
        printA(a[2]);
        System.out.println("=====");
        System.out.println(a[0][1]);
        System.out.println(a[1][1]);
        System.out.println(a[2][1]);
    }
    public static void printA(int a[])
    {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");

        }
        System.out.println();
    }
}

八.Arrays类

• 数组的工具类java.util.Arrays.
• 查看JDK帮助文档
• API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。

import java.util.Arrays;

public class arraysDemo03 {
    public static void main(String[] args) {
        int[] a={1,2,5,6,3,378};
        //打印数组元素
        System.out.println(Arrays.toString(a));
        //数组进行排序，升序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

    }
}

九.冒泡排序

import java.util.Arrays;

public class arraysDemo05 {
    public static void main(String[] args) {
        int []a={2,4,3,5,4,3,5657};
        int[] sort=sort(a);
        System.out.println(Arrays.toString(sort));
    }
    public static int[] sort(int[] a){
        int temp=0;//临时变量
        //外层循环。判断要走多少次
        for (int i = 0; i < a.length-1; i++) { //a.length-1是因为最后一次比较已经排出来最大的或者最小的
            //内层循环，比较判断两个数，如果第一个数比第二个数大，交换位置
            for (int j = 0; j < a.length-1-i; j++) {
                if(a[j]>a[j+1]){
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }

            }
        }
        return a;
    }
}