Java数组详解-优快云博客

本文链接：https://blog.youkuaiyun.com/sunkaiqiang/article/details/51589366

定义1

数组的定义方式1：
1.元素类型[] 数组名 = new 元素类型[元素个数或长度]
好处：数组可以存储多个数据，而且可以对数据进行编号，
从0开始。操作元素可以通过编号(索引)完成.
2.数组是引用型变量，变量是指向的堆里的首地址。

int[] arr = new int[3];//通过new关键字创建了一个长度为3，元素类型是int的数组实体

java内存

Java对内存空间的划分：五部分：
栈，队，方法区，本地方法区，寄存器。

栈内存：存储局部变量。只要是方法内定义的变量都是局部变量。
      一旦变量的生命周期结束该变量就被释放。

堆内存：存储的都是实体(对象)，凡是用new创建的都在堆里边。
      每一个实体都有一个首地址值
      堆内存的变量都有一个默认初始值。不同数据类型不一样。int-0    double-0.0    boolean-false    char-'\u0000'
     当实体不在使用时，就会被垃圾回收机制处理。

arr使用结束后，赋值为arr=null，释放。不再指向任何堆地址。

常见问题

1.超限，运行时会提示ArrayIndexOutOfBoundsException
2.指向空，运行时会提示NullPointerException

public class ArrayDemo2
{
    public static void main(String[] args)
    {
        int[] arr = new int[3];
        //System.out.print(arr[3]);//ArrayIndexOutOfBoundsException: 3
        arr = null;
        System.out.print(arr[0]);//NullPointerException
        }
    }

定义2

int[] arr=new int[] {1,2,3,4};
或者
int[] arr = {1,2,3,4};
数组的长度：arr.length

应用

求和
遍历求和

public class ArrayDemo2
{
    public static void main(String[] args)
    {
        int[] arr = new int[] {1,2,3,4,5};
        int sum = add(arr);
        System.out.print(sum);
        }

        //多个数求和的功能。
        //明确1：返回值类型，int；
        //明确2：参数？数组，包含多个int类型元素的数组
    public static int add(int[] arr)
    {
        int sum = 0;
        for(int i=0; i<arr.length; i++)
        {
            sum = sum + arr[i];
            }
        return sum;
        }
    }

2.求最值

public class ArrayDemo2
{
    public static void main(String[] args)
    {
        int[] arr = new int[] {1,7,9,4,9,11};
        int i = max2(arr);
        System.out.print(i);
        }

    /*
    求一个数组里面的最大值
    明确1：返回值类型int；
    明确2:参数类型为一个数组int；
    */
    public static int max(int[] arr2)
    {
        int i = arr2[0];                                //数据的第一个数作为第一个比较值
        for(int j=1; j<arr2.length; j++)
        {
            if(i < arr2[j])
            {
                i = arr2[j];
                }
            }
        return i;
        }
    public static int max2(int[] arr2)
    {
        int i = 0;                                          //i作为下标来使用
        for(int j=1; j<arr2.length; j++)
        {
            if(arr2[i] < arr2[j])
            i = j;
        }
        return arr2[i];
        }
    }

3.将数组转为字符串
定义一个功能将数组转化为字符串，{10,80,89}变为[10,80,89]
明确1：返回值为string类型；
明确2：参数？为数组
思路：简单的利用字符串和如何数相加都是相连接

public class Arraytostring
{
    public static void main(String[] args)
    {
        int[] arr = {10,80,89};
        String str = tostring(arr);
        System.out.println(str);
        }

    public static String tostring(int[] arr)
    {
        //定义一个字符型变量
        String temp = "[";
        //遍历数组并相加
        for(int i=0; i<arr.length; i++)
        {
            if(i != arr.length-1)
                temp = temp + arr[i] + ",";
            else
                temp = temp + arr[i] + "]"; 
            }
        return temp;
        }

    }

4.查表法
数组使用的条件

5.十进制转为十六进制(查表法)

public class DectoHex3 
{
    public static void main(String[] args)
    {
        int num = 55;
        String str = toHex(num);
        System.out.println(str);
        }
    /*
    功能：实现十进制转十六进制
    明确1:返回字符串String；
    明确2：参数为整型；
    十六进制元素有个数固定，而且有对应编号，所以可以使用查表法

    */
    static String toHex(int num)
    {
        //创建表
        char[] cha = new char[] {'0','1','2','3',
                                    '4','5','6','7',
                                    '8','9','a','b',
                                    'c','d','e','f'};
        //创建临时容器
        char[] arr = new char[8];
        //创建临时容器的角标
        int index = arr.length;
        //右移num循环， & 运算
        while(num != 0)
        {
            int temp = 0;
            temp = num & 15;
        //根据&运算的结果作为角标，查表，获取对用的字符并存在临时容器中
            arr[--index] = cha[temp];
        //对num进行右移
            num = num >>> 4;
            }
        return "0x"+toString(arr,index);
        }
        //数组转化为字符串
    static String toString(char[] arr,int index)
        {
            String str = "";
            for(int x=index; x<arr.length; x++)
                str = str + arr[x];
            return str;
            }
    }

提升：十进制转换为不同的进制，只需要改变与运算的对象、右移的位数，2个变量即可，
所以提高代码的利用率可优化程序，见DectoHex4.java

数组排序

选择排序

程序

public class sort1
{
    public static void main(String[] args)
    {
        int[] arr = new int[]{34,56,9,43,6,3,12,55};
        String str1 = toString(arr);
        System.out.println("原数组：" + str1);
        String str = sort(arr);
        System.out.println("排序后：" + str);
        }

    /*选择排序，打圈套小圈，每一个数都与后面的数做比较
        该方法比较麻烦！！！
    */
    static String sort(int[] arr)
    {
        //外圈循环从0开始
        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 = 0;
                    temp = arr[x];
                    arr[x] = arr[y];
                    arr[y] = temp;
                    }
                }
            }
        return toString(arr);
        }
    //数组转字符串
    static String toString(int[] arr)
        {
            String str = "";
            for(int x=0; x<arr.length; x++)
                if(x==arr.length-1)
                    str = str + arr[x];
                else
                    str = str + arr[x]+",";
            return str;
            }
    }

2.冒泡排序
这里写图片描述
程序

static String sort(int[] arr)
    {
        for(int x=0; x<arr.length-1; x++)
        {
            //此处arr.length-x-1,可以减少一个变量定义
            for(int y=0; y<arr.length-x-1; y++)
            {
                if(arr[y]>arr[y+1])
                {   
                    int temp = 0;
                    temp = arr[y];
                    arr[y] = arr[y+1];
                    arr[y+1] = temp;
                }
            }

        }
        return toString(arr);
    }

二分法查找

二分查找。前提;数组必须是有序的！！！
思路：
1. 通过角标先获取中间角标上的元素；
2. 让该元素与要找的数据比较；
3. 若要找的数比中间值大，则缩小范围至中间角标+1—-尾角标；
4. 若若要找的数比中间值小，则缩小范围至头角标—中间角标-1；

public class Search
{
    public static void main(String[] args)
    {
        int[] arr = new int[]{4,12,23,34,45,56,67,99};
        int key = binsearch(arr,45);
        System.out.println("key=" + key);
        }

    //二分法查找
    static int binsearch(int[] arr,int key)
    {
        //定义三个变量min,mid,max
        int min = 0;
        int max = arr.length-1;
        int mid = (min+max)>>1;
        /*while(arr[mid]!=key)  
        {
            if(key>arr[mid])
                min = mid + 1;
            else if(key<arr[mid])
                max = mid - 1;
            //判断元素是否存在
            if(min>max)
                return -1;//元素不存在，一般返回-1        
            mid = (min+max)>>1;
            }
        return mid;
        */
        //改变循环条件
        while(min<=max)
        {
            if(key>arr[mid])
                min = mid + 1;
            else if(key<arr[mid])
                max = mid - 1;
            else
                return mid;
            mid = (min+max)>>1;
            }
        return -1;
        }
    }

二维数组

定义方式1

1.int[][] arr = new int[3][2]
该二维数组中包含3个一维数组，每个一维数组中包含2个元素。

public class Doublearray
{
    public static void main(String[] args)
    {
        int[][] arr = new int[3][2];

        System.out.println(arr);
        /*输出[[I@1db9742，其中
            1.两个中括号"[["表示二维数组,@为分隔符
            2.1db9742  为哈希值，表示实体在内存中的位置即地址
            3.I，根据数组的类型而定。
        */
        System.out.println(arr[0]);//一维数组，[I@106d69c
        System.out.println(arr[0][0]);//一维数组中的元素
        }
}

2。int[][] arr = new int[3][] 明确了二维数组的长度，没有明确具体的一维数组。
所以

System.out.println(arr);//输出[[I@1db9742
System.out.println(arr[0]);//输出null
System.out.println(arr[0][0]);//报错，空指针

再定义该二维数组中的一维数组
arr[0] = new int[2];
arr[1] = new int[1];
arr[2] = new int[4];
可以定义不同的长度。
二维数组的长度:arr.length
一维数组的长度;arr[0].length

定义方式2

int[][] arr = {{2,3,4,5},{3,345,3}.{6,523,34,44,21,55}};
遍历求和，大圈套小圈，比较简单