9数组

1.1概念

数组Array是用于储存多个相同类型数据的集合即存储多个相同数据类型的元素的容器,想要获取数组中的元素值，可以通过脚标（下标）来获取，下标是从0开始的。

1.2创建数组 ，数组定义之后长度不变

1.第一种定义格式

数据类型[] 数组名=new 数据类型[数组元素个数]

int[] arr=new int[3];//定义了数组长度位3的整型数组arr

int[] arr1;

arr1=new int[3];

2.第二种定义格式

数据类型[]数组名=new 数组类型[]{元素1，元素2，元素3 ....}；每个元素值确定之后长度也确定了

int[] arr=new int[]{1,3,4};  //此时不能书写数组长度

3.第三种定义格式

数据类型[]数组名={元素值1,元素值2,元素值3...}

int[] arr={1,2,3}; //这个不能分开写，因为没有new 关键词无法开辟空间存放数组，只有在一系列动作一起的时候，底层就不会通过别的技术动态开辟空间。如 int[] arr; arr={1,2,3};这是错的

2.数组内存地址

public class HellowWorld {
public static void main(String[] argv ) {

int[] arr=new int[6];
System.out.println(arr);
}
}

输出的结果是 [I@15db9742   总的代表的是对象的内存地址

[ 代表的是对象是数据类型

I 代表的是数组里的元素的数据类型是int

@代表的是后面是内存地址

15db9742代表的是内存地址的哈希码16进制表现形式

所以打印数组名就是得到数组的地址

java会默认对数组里的元素进行编号,从0开始,通过地址和编号就可以确认数组的元素--数组名[编号]

数组的应用

1.数组的遍历 ：一次输出数组元素

int[] arr= {1,2,3,4,6};
for(int i=0;i<arr.length;i++)
{
    System.out.print("	"+arr[i]);
}

结果

增强for循环（数组元素的数据类型 变量名:要去遍历的数组的名称)

int[] arr= {1,2,3,4,6};
//增强for遍历，只能做数组的遍历(增强for就是把原来数组元素的值的拷贝一份)
for(int i:arr)
{
    System.out.print("	"+i);
}
    

增强for无法改变原来数组的值

    public static void main(String[] args) {
        int[] arr= {1,5,7,5,8};
        for(int i:arr)   //只能遍历不能做别的事情，i的改变对堆中的数组的值，没有影响
        {
            i++;             
            System.out.print(i+" ");
            
        }
        System.out.println();
        for(int i=0;i<arr.length;i++)
        {
            System.out.print(arr[i]+" ");
        }
    }
}

结果

2 6 8 6 9
1 5 7 5 8

3.第三种遍历

1.导包 import java.util.Arrays;

import java.util.Arrays;
public class HellowWorld {
    //判断一个32位的整数的二进制有几个1
public static void main(String[] argv ) {
int[] arr= {1,2,3,4,6};
System.out.println(Arrays.toString(arr));
    
}//endmain
}//endclass

结果

返回的是一个字符串

2.最值

public static void main(String[] argv ) {
int[] arr= new int[]{1,3,6,58,9};
int max=arr[0];
for(int i:arr)
{
    if(i>max)
    {
        max=i;
    }
}
    System.out.println(max);
}//endmain

3逆序

import java.util.Arrays;
public class HellowWorld {
public static void main(String[] argv ) {
int[] arr= new int[]{1,3,6,58,9};
int temp=0;
for(int i=0;i<arr.length/2;i++)
{
    temp=arr[i];
    arr[i]=arr[arr.length-1-i];
    arr[arr.length-1-i]=temp;
}
System.out.println(Arrays.toString(arr));
}//endmain
}//endclass

就是相关位数的交换

4查找

返回和查找数一致的元素的下标

效率比较低来一个二分法查找 -----详情去看https://www.cnblogs.com/xuwangqi/p/11031866.html

5排序

 冒泡排序

选择排序

哈希排序

堆排序

https://www.cnblogs.com/xuwangqi/p/11019768.html

可以用封装好的

6扩容 

上面讲到了数组定义之后长度不变，那么我们还是给它扩容了。但是准确来讲这不是数组扩容而应该是数组复制

import java.util.Arrays;
public class HellowWorld {
public static void main(String[] argv ) {
int[] arr= new int[]{1,6,6,9,3,4,21,26,30,35};
//第一个是要扩容的数组，第二个参数是扩容后的数组长度 相当于要创建新数组的长度
arr=Arrays.copyOf(arr,20);
System.out.println(Arrays.toString(arr));
}//endmain
}//endclass

 结果

底层用的还是数组复制 system.arraycopy ,先创建一个新数组 ，复制给新数组

https://www.cnblogs.com/xuwangqi/p/11038271.html

2.数组的初始化和填充

Array.full:

public static void fill(int[] a,
                        int fromIndex,
                        int toIndex,
                       int val)
a:你要填充的数组
fromIndex：从数组索引的那个位置开始填充，包括此索引
toIndex:填充终止到数组的索引，不包括此索引
val:要填充的值
例子:

    int[]a= new int[6];
    Arrays.fill(a,1,5,100);
    System.out.println(Arrays.toString(a));//[0, 100, 100, 100, 100, 0]

3.同类型的"可变"数组

我们在项目中开发的时候，不一定知道要定义的数组的长度大小，所以一般都是用的集合，但是同类型下数组的操作速度比集合要快，所以我们一个设置一个可变数组是有必要的

        int[] a= {}; //声明一个a的一维数组并且开辟空间,数组长度为0
        //int[] a;// sop(a)输出的就是null,没有开辟空间
        a=Arrays.copyOf(a,10);
        System.out.println(a.length);
        a[0]=1;
        for(int i:a)
        {
            System.out.print(i+"	");//1    0    0    0    0    0    0    0    0    0    
        }