数组的基础

        博主第一次写 如有误解请联系博主 所有学习内容来自java狂神说

数组的定义：

        1.数组是相同类型的有序集合 

        2.其中每一个数据元素称作为数组元素，每个数组元素都可以通过下标来访问

数组的声明和创建：

        1.数组的下标是从0开始的

        2.数组的长度是arrays.length (arrays是数组的名字)

int [] a;
int a [] ;


int[] a =new int[8];表示数组可以存放8个元素
对数组进行赋值
        a[0]=2;
        a[1]=3;
        a[2]=4;
        a[3]=5;
        a[4]=6;
        a[5]=6;
        a[6]=7;
        a[7]=8;
根据数组是从下标为0开始的 我们可以将他对应的数值输出出来
System.out.println(a[0]);

数组的三种初始化：

        1.静态初始化

int[] a={1,2,3};
Man []man={new man{1,2},new man{3,4}};

        2.动态初始化

int [] a=new a[3];
a[0]=1；
a[1]=2;
a[2]=3

        3.默认初始化

                如果没有给他赋值的话他会根据你定义的类型来赋值默认值，int的默认值是0，所以输出的所有数组中的元素全是0

int [] a=new a[2];

数组中的内存分析

        堆：用来存放new对象和数据，可以被所有的线程共享，不会存放别的对象引用。

        栈：用来存放基本变量类型（包含这个基本类型的具体数值），引用对象的变量（会存放这个引用在堆里面的具体地址）

        方法区：包含了class和static变量（可以被所有的线程共享）

        

 数组的基本特点：

        1.数组的长度是确定的，一旦定义了，就不能改变了。

        2.数组中元素的类型是相同的

        3.数组可以存放任何数据类型，包括基本数据类型和引用数据类型

        4.数组变量属于引用类型，数组可以看成是对象，数组中的每个元素可以看成对象中的成员变量，数组本身就是对象，Java的对象是在堆中，所以数组也在堆中。

数组的长度：

        数组长度的区间是[0,length-1]。

        如果超出这个长度会产生一个异常：ArrayIndexOutOfBoundsException(下标越界异常)

       

  int[] a =new int[2];
  System.out.println(a[2]);

        

遍历数组：

        1.常用方法

int []b =new b[8];
for (int i = 0; i < b.length; i++) {
            System.out.println(b[i]);
        }

        2.使用增强for循环

        这里的a表示数组名字 定义一个int类型的是用来表示他的下标

int []a ={1,32,43,5,2};
for (int x:a){
            System.out.println(x);
        }

 数组常用方法：

        1.用来输出数组 arrays.toString()

 int []a ={11,2,3,4,5,6,1234};
        //打印数组元素
        System.out.println(Arrays.toString(a));
        

        2.给数组赋值 arrays.fill()

 int []a ={11,2,3,4,5,6,1234};
        Arrays.fill(a,0);
        //将2到4之间的数字被填充
        Arrays.fill(a,2,4,1);
        System.out.println(Arrays.toString(a));

        3.给数组排序 arrays.sort()      

  Arrays.sort(a);
        System.out.println(Arrays.toString(a));

更多的方法请查看JDK帮助文档

冒泡排序： 

 public static void main(String[] args) {
        //冒泡排序

        int []a={123,2313,53,657,867987};
        int[] array = array(a);
        System.out.println(Arrays.toString(array));
    }
    public static int[] array(int [] a){
        //定义一个中间量
        int tmp=0;
        //首先第一步是外层循环 为什么要减一呢是因为 最后一次的话就冒泡完了 就不用比较了
        for (int i = 0; i < a.length-1; i++) {
            //简化操作 如果说已经是排好序的
            boolean tape=false;
            //内层循环 就是进行比较 为什么要减i呢 因为没比较一次就少比较了一次
            for (int j = 0; j < a.length-1-i; j++) {
                if(a[j]>a[j+1]){
                    tmp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=tmp;
                    //如果进来了的话就变成
                    tape=true;
                }
            }
            if(tape==false){
                break;
            }
        }
        return a;
    }