Java 数组的总结

蔚落 2022-10-20 05:25 202阅读 0赞

Java数组

一.概述

1.定义:数组是一种数据结构，用来存储同一类型值的集合。

2.数组是存在下标索引的，通过下标可以获取指定位置的元素，数组小标是从0开始的，也就是说下标0对应的就是数组中第1个元素，可以很方便的对数组中的元素进行存取操作。

3.数组存在一维数组和多维数组。

二.一维数组

1.声明方式一

A.数据类型数组名= new 数据类型\[个数\]

àString s\[\] = new String\[10\];  
定义了一个长度为10的String类型的一维数组。

B.数据类型\[\]数组名= new 数据类型\[个数\]  
àString\[\] s = new String\[10\];  
定义了一个长度为10的String类型的一维数组。

[![a042f0dbgx6CEk8A7nyb0_690][]][a042f0dbgx6CEk8A7nyb0_690 1]

数组属于引用数据类型，它指向的是内存中的一个对象的地址。只要使用new对象产生一个对象或数组都会在堆内存中创建一块内存空间，然后将这块空间的内存地址赋给引用变量，以上只是声明创建一个大小为10的数组，但是没有给每一个元素赋值，所以体现出来的都是这个数据类型的默认值，即String类型的默认值为null。

2.声明格式二

A.数据类型数组名\[\] =\{ 元素1,元素2,元素3,……数值n\};

àint a\[\] = \{1,3,6,0,2,8,10\};  
声明一个为数组长度为7的int类型数组，并静态的为数组每一个小标对应的元素赋值。

B.数据类型\[\]数组名=\{ 元素1,元素2,元素3,……数值n\};  
àint\[\] a = \{1,3,6,0,2,8,10\};

声明一个为数组长度为7的int类型数组，并静态的为数组每一个小标对应的元素赋值。

[![a042f0dbgx6CEka8kj3cd_690][]][a042f0dbgx6CEka8kj3cd_690 1]

3.创建一个匿名数组  
new int\[\]\{ 1,3,6,0,2,8,10\};

4.数组与数组之间的赋值关系

String s\[\] = new String\[10\];

String t\[\] = s;

![Center][]

5.一维数组长度:数组名.length

6.一维数组的有效最大角标:数组名.length-1

三.二维数组

1.定义:二维数组实际上是指数组元素为一维数组的一维数组，简单说也就是数组中的数组。

2.声明格式一  
数据类型数组名\[\]\[\] = new数据类型\[个数\]\[个数\];

数据类型\[\]\[\]数组名= new数据类型\[个数\]\[个数\];

\-->int arry\[\] \[\] = new int\[5\]\[6\];

上述语句声明了一个二维数组，其中\[5\]表示该数组有(0~4)5行，每行有(0~5)6个元素，因此该数组有30个元素，其中\[5\]也可说是有5个一维数组，\[6\]可以说是每一个一维数组中有6个int型号的元素。

[![a042f0dbgx6CEkh4sxcea_690][]][a042f0dbgx6CEkh4sxcea_690 1]

数组new出来后，就在堆内存中开辟的内存空间，并将所在内存空间地址返回给arry数组变量，因为以上语句只是声明了一个数组并未没一个元素赋值，所以都是类型默认值，为0。

\-->arry\[0\]\[0\]=3;即给第一个一维数组中的第一个元素赋值  
![20130914230245312][]  
  
  
依此方式还可以和其他元素赋值。

3.声明格式二

int\[\]\[\] arr = new int\[3\]\[\];

此二维数组中含有3个一维数组，每个一维数组的默认初始化值都为null，每个一维数组中的元素值都为0；可对每个一维数组赋值，如：  
 arr\[0\] = new int\[3\];

arr\[1\] = new int\[2\];

arr\[2\] = new int\[1\];

对每个一维数组中某个元素赋值：如:

arr\[0\]\[2\]=90;

arr\[1\]\[1\]=89;

arr\[2\]\[2\]=78;

![20130914230323609][]

4.声明格式三

显式初始化二维数组：int\[\]\[\] arr = \{ \{1,5,7\},\{4,8\},\{3,9,20,12\}\}

A.以上数组定义了一个长度为3的数组，arr.length=3

B.数组中第一维数组的长度:arr\[0\].length=3

四.数组的应用代码  
1.  获取一个数组中的最大值和最小值

public class ArrayMaxMinValue
    {
    public static void main(String[] args)
    {
    int[] array = {7,9,6,3,9,8,0,10,2,1};
    System.out.println("最大值:　"+getMaxValue(array));
    System.out.println("最小值:　"+getMinValue(array));
    }
    public static int getMaxValue(int a[])
    {
    int max = a[0];//一开始假设最大值为a[0]
    for(int i = 1 ; i < a.length ;i++)
    {
    if(a[i] > max)
    {
    max = a[i];//每一次比较将大值赋值给max变量存储
    }
    }
    return max;
    }
    public static int getMinValue(int a[])
    {
    int min = 0;//一开始假设最小值为角标为0的元素
    for(int i = 1 ; i < a.length ;i++)
    {
    if(a[i] < a[min])
    {
    min = i;//每一次比较将最小值的角标赋值给min变量存储
    }
    }
    return a[min];
    }
    }

2.对数组进行排序

public class ArraySortTool
    {
    public static void main(String[] args)
    {
    int[] array = {7,9,6,3,9,8,0,10,2,1};
    System.out.println("排序前:");
    printArray(array);
    bubblSort(array);
    System.out.println("排序后:");
    printArray(array);
    }
    //选择排序
    public static void SelectSort(int[] a)
    {
    //外层循环写成i < a.length-1，是因为选择排序，
    //当到最后一个元素的时候，就不需要进行选择排序的，因为数序已经确定了
    for(int i = 0 ; i < a.length-1 ; i++)
    {
    //内层循环写成i < a.length，是因为每一个选择用来比较的元素都要比较到最后//一个元素，
    //int j = i+1是因为没一个元素都不需要和自身比较
    for(int j = i+1 ; j < a.length ; j++)
    {
    if(a[i] > a[j])
    {
    //交换两个值
    int temp = a[j];
    a[j] = a[i];
    a[i] = temp;
    }
    }
    }
    }
    //冒泡排序
    public static void bubblSort(int a[])
    {
    //a.length-1冒泡排序是每一次相邻两个元素进行比较，总共要比较a.length-1次
    //int i=0 是因为比较是从角标0开始的
    for(int i = 0 ; i < a.length-1; i++)
    {
    //a.length-1-i，第一轮全部计较，每轮比较都产生一个最值，
    //下一轮这个最值就不用参与比较了
    //int j = i+1因为是相邻比较，所以要改成int j = i+1
    for(int j = 0 ; j < a.length-1-i ; j++)
    {
    //因为是两两比较所以要写成a[j] > a[j+1]
    if(a[j] > a[j+1])
    {
    int temp = a[j+1];
    a[j+1] = a[j];
    a[j] = temp;
    }
    }
    }
    } 
    //用来打印数组
    public static void printArray(int a[] )
    { 
    System.out.print("[");
    for(int i = 0 ; i < a.length ; i++)
    {
    if(i == a.length-1)
    {
    System.out.println(a[i]+"]");
    }
    else
    {
    System.out.print(a[i]+",");
    } 
    }
    }
    }

3.查找数组中指定值的索引位置

public class ArraySearchTool
    {
    public static void main(String[] args)
    {
    int[] array = {1,5,9,11,20,21,25,30};
    System.out.println(halfSearch2(array , 25));
    // System.out.println(oneByoneSearch(array , 10));
    }
    //遍历判断查找
    public static int oneByoneSearch(int[] a , int value)
    {
    for(int i = 0 ; i < a.length ; i++)
    {
    if(a[i] == value)
    {
    return i;
    }
    }
    return -1;
    }
    //二分查找1
    public static int halfSearch(int[] a , int value)
    {
    int left = 0;
    int right = a.length-1;
    int mid = (left+right) >> 1;
    while( a[mid] != value)
    {
    
    if(a[mid] > value)
    {
    right = mid-1;
    }
    else
    {
    left = mid+1;
    }
    if(left > right)
    {
    return -1;
    }
    mid = (left+right)>>1;
    }
    return mid;
    }
    //二分查找2
    public static int halfSearch2(int[] a, int value)
    {
    int left = 0;
    int right = a.length-1;
    int mid;
    while( left <= right)
    {
    mid = (left+right) >> 1;
    if(a[mid] == value)
    {
    return mid;
    }
    else if(a[mid] > value)
    {
    right = mid -1;
    }
    else
    {
    left = mid+1;
    }
    }
    return -1;
    }
    }

5.编写一个类，类中提供方法可以将任何int类型的数值做八进制、二进制、十六进制转换

public class toBintoHextoOctalDemo
    {
    
    
    public static void main(String[] args)
    {
    System.out.println(toBintoHextoOcta( 500 , 15 , 4 ));
    
    }
    
    public static String toBintoHextoOcta( int n , int a , int m )
    {
    char[] c = { '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F' };
    char[] ch = new char[32];
    StringBuilder sb = new StringBuilder();
    int pos = ch.length;
    while( n != 0)
    {
    ch[--pos] = c[ n & a ];
    n = n >>> m ;
    }
    for(int i = pos ; i < ch.length ; i++)
    {
    sb.append(ch[i]);
    }
    return sb.toString();
    }
    
    
    
    }

6.扩展应用

int\[\] x ,y\[\];àx一维数组，y二维数组。

拆解步骤:

int\[\] x;

int\[\] y\[\];

A.x\[0\] = y;错误

B.y\[0\] = x;正确

C.y\[0\]\[0\]=X;错误

D.x\[0\]\[0\] =y;错误

E.y\[0\]\[0\] =x\[0\]正确

[a042f0dbgx6CEk8A7nyb0_690]: /images/20221020/9bf5fa0eccc24a5bb6afe116f92504f8.png
[a042f0dbgx6CEk8A7nyb0_690 1]: http://blog.photo.sina.com.cn/showpic.html#url=http://album.sina.com.cn/pic/a042f0dbgx6CEk8A7nyb0
[a042f0dbgx6CEka8kj3cd_690]: /images/20221020/8812819975444f348bf98c8384afe52a.png
[a042f0dbgx6CEka8kj3cd_690 1]: http://blog.photo.sina.com.cn/showpic.html#url=http://album.sina.com.cn/pic/a042f0dbgx6CEka8kj3cd
[Center]: /images/20221020/d0ca206f47f145cd9406523ed3b1cc14.png
[a042f0dbgx6CEkh4sxcea_690]: /images/20221020/140fcff1a456461e88550d1fcaf6e05d.png
[a042f0dbgx6CEkh4sxcea_690 1]: http://blog.photo.sina.com.cn/showpic.html#url=http://album.sina.com.cn/pic/a042f0dbgx6CEkh4sxcea
[20130914230245312]: /images/20221020/593656422372429da296afc75df97435.png
[20130914230323609]: /images/20221020/ea25ed43103a438ba968ca5ef4b590a8.png