Java基础语法(三)---数组

2023-07-24 18:39:10

一、概念

        同一种类型数据的集合。简单的来说就是一容器，用来装东西的。

使用数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。

二、一维数组的格式

格式1：元素类型 [ ]数组名 = new 元素类型 [元素个数或数组长度] ;

如： int []  arr = new int [3];  也可以写成： int arr[] = new int[3];

格式2：元素类型 []数组名 = new 元素类型 [ ]{元素1,元素2,…};

如： int []  arr = new int []{1,2,3,4,5};

还有一种简写的静态初始化格式：如： int [] arr={1,2,3,4,5};

其中：new是用来在堆内存中产生一个容器实体。

数组也被称为引用数据类型。在内存中的分配如下图：

Java基础语法(三)---数组

注：1、System.out.println(arr);得到的结果是一个哈希值，也叫地址值。

2、数组在堆内存开辟空间后，就有默认的初始化值。如：int默认0；boolean默认false。

内存小知识：

Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。

堆内存：1、数组和对象，通过new建立的实例都存放在堆内存中。

2、每一个实体都有内存地址值。

3、实体中的变量都有默认初始化值。

4、实体不在被使用，会在不确定的时间内被垃圾回收器回收。

三、数组操作常见问题

1、数组脚标越界异常(ArrayIndexOutOfBoundsException)。例：

int[] arr = new int[2];

System.out.println(arr[3]);

访问到了数组中的不存在的脚标时发生。

2、空指针异常人生感悟(NullPointerException)。例：

int[]arr = null;

System.out.println(arr[0]);

             arr引用没有指向实体，却在操作实体中的元素时。

四、数组中的数组

也称多维数组，这里我们主要讲二维数组。

格式1： int[][] arr= new int[3][2];

解释：以上格式表示定义了名称为arr的二维数组。有3个一维数组，每一个一维数组中有2个元素。一维数组的名称分别为arr[0],arr[1],arr[2]。给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78。

格式2： int[][] arr= new int[3][];

注：此种格式中每个一维数组都是默认初始化值null。

格式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};//每一个一维数组中具体元素都初始化了。

注：一种特殊定义伤感的句子写法：int[]x,y[]; x是一维数组，y是二维数组。

二维数组在内存中的分配情况示例：

Java基础语法(三)---数组

五、数组常见操作

1、 数组排序：

常见的排序方式：冒泡排序和选择排序。在Java已经定义好了一种排序方式，在开发使用中，直接调用即可。排序的方式有很多，其中最快的排序方式为希尔排序。

下面是我自己敲的选择和冒泡两种排序方式的程序：

选择排序程序：

  1. //使用选择排序方式对指定的数组进行排序
  2. class  Demo
  3. {
  4. public static void main(String[] args)
  5. {
  6. int[] arr= {1,11,5,3,9,55,23,67,18};
  7. //输出原数组
  8. printArray(arr);
  9. //调用排序方法
  10. selectSort(arr);
  11. //输出排序后的数组
  12. printArray(arr);
  13. }
  14. /*
  15. 选择排序
  16. 1、先用0角标上的元素依次与其他元素进行比较，将较小值元素存放到0角标。
  17. 2、然后再拿1角标上的元素依次进行比较，以此类推。
  18. */
  19. public static void selectSort(int[] arr)
  20. {
  21. //外循环遍历数组
  22. for (int x=0;x<arr.length-1;x++)
  23. {
  24. //内循环比较大小
  25. for (int y=x+1;y<arr.length;y++)
  26. {
  27. //如果后一个元素比拿去比较的元素大，就交换两元素位置
  28. if(arr[x]>arr[y])
  29. {
  30. //arr[x]=arr[y];
  31. //arr[y]=temp;
  32. swap(arr,x,y);
  33. }
  34. }
  35. }
  36. }
  37. //遍历数组
  38. public static void printArray(int[] arr)
  39. {
  40. System.out.print("[");
  41. for (int x=0;x<arr.length;x++)
  42. {
  43. if(x!=arr.length-1)
  44. System.out.print(arr[x]+",");
  45. else
  46. System.out.print(arr[x]+"]");
  47. }
  48. //换行
  49. System.out.println();
  50. }
  51. //互换方法
  52. public static void swap(int[] arr,int a,int b)
  53. {
  54. arr[a]=arr[a]^arr[b];
  55. arr[b]=arr[a]^arr[b];
  56. arr[a]=arr[a]^arr[b];
  57. }
  58. }

输出结果：

Java基础语法(三)---数组

冒泡排序程序：

  1. //使用冒泡排序方式对指定程序进行排序
  2. class Demo1
  3. {
  4. public static void main(String[] args)
  5. {
  6. int arr[]={22,63,89,13,6};
  7. //打印原数组
  8. printArray(arr);
  9. //调用排序方法
  10. bubbleSort(arr);
  11. //打印排序后的数组
  12. printArray(arr);
  13. }
  14. /*
  15. 冒泡排序
  16. 1、先从头角标相邻两个元素之间进行比较，将较大值存放在后一个元素中，然后再与后一个元素的进行比较，直至最大值存放到最后一个元素中。
  17. 2、再重复1操作，每次计较次数减一，一圈比完后存放的较大元素不再参与比较。
  18. */
  19. public static void bubbleSort(int[] arr)
  20. {
  21. for (int x=0;x<arr.length-1;x++)
  22. {
  23. for (int y=0;y<arr.length-1-x;y++)//-x:让没每一次比较的元素减少。-1：避免角标越界。
  24. {
  25. if(arr[y]>arr[y+1])
  26. swap(arr,y,y+1);
  27. }
  28. }
  29. }
  30. //遍历数组
  31. public static void printArray(int[] arr)
  32. {
  33. System.out.print("[");
  34. for (int x=0;x<arr.length;x++)
  35. {
  36. if(x!=arr.length-1)
  37. System.out.print(arr[x]+",");
  38. else
  39. System.out.print(arr[x]+"]");
  40. }
  41. //换行
  42. System.out.println();
  43. }
  44. //互换方法
  45. public static void swap(int[] arr,int a,int b)
  46. {
  47. arr[a]=arr[a]^arr[b];
  48. arr[b]=arr[a]^arr[b];
  49. arr[a]=arr[a]^arr[b];
  50. }
  51. }

输出结果

Java基础语法(三)---数组

2、 折半查找

程序：

  1. /*
  2. 需求：将一个已知元素插入到一个有序数组中，要求不改变数组顺序，打印元素应该插入数组位置的角标。
  3. 思路：1、可以利用折半查找的方式，先定义两个变量，一个初始化0角标，作为最小值，一个初始化为最后一个角标，作为最大值，
  4. 再定义一个变量，存储最小值与最大值的一半，也就是中间位置，然后将已知元素与中间值位元素进行比较。
  5. 2、如果比中间值元素大，则将最小值变为中间值加1，继续取最小值与最大值的中间值元素与已经元素进行比较，以此反复
  6. 3、如果比中间值元素小，则将最大值变为中间值减1，继续取最小值与最大值的中间值元素与已经元素进行比较，以此反复
  7. */
  8. class  HalfSearch
  9. {
  10. public static void main(String[] args)
  11. {
  12. int[] arr={2,6,9,11,15,19,22,30};
  13. //打印数组
  14. printArray(arr);
  15. int key=20;
  16. //用第一种折半方式输出插入的角标值
  17. System.out.println("当key=20在数组arr中插入的角标位置是："+halfSearch1(arr,key));
  18. key=1;
  19. //用第二种折半方式输出插入的角标值
  20. System.out.println("当key=1在数组arr中插入的角标位置是："+halfSearch2(arr,key));
  21. }
  22. //折半查找<一>
  23. public static int halfSearch1(int[] arr,int key)
  24. {
  25. int min=0,max=arr.length-1,mid=(max+min)/2;
  26. while(key!=arr[mid])
  27. {
  28. if(min>max)
  29. return min;
  30. else if(key>arr[mid])
  31. min=mid+1;
  32. else
  33. max=mid-1;
  34. mid=(max+min)>>>1;//折半操作
  35. }
  36. return mid;
  37. }
  38. //折半查找<二>
  39. public static int halfSearch2(int[] arr,int key)
  40. {
  41. int min=0,max=arr.length-1,mid;
  42. while(min<max)
  43. {
  44. mid=(max+min)>>>1;//折半操作
  45. if(key>arr[mid])
  46. min=mid+1;
  47. else if(key<arr[mid])
  48. max=mid-1;
  49. else
  50. return mid;
  51. }
  52. return min;
  53. }
  54. //遍历数组
  55. public static void printArray(int[] arr)
  56. {
  57. System.out.print("[");
  58. for (int x=0;x<arr.length;x++)
  59. {
  60. if(x!=arr.length-1)
  61. System.out.print(arr[x]+",");
  62. else
  63. System.out.print(arr[x]+"]");
  64. }
  65. //换行
  66. System.out.println();
  67. }
  68. }

运行结果：

Java基础语法(三)---数组

3、 进制转换

十进制转换为二进制、八进制、十六进制的小程序：

  1. /*
  2. 使用查表法将十进制转换为二进制、八进制、十六进制
  3. */
  4. class  Conversion
  5. {
  6. public static void main(String[] args)
  7. {
  8. int num=60;
  9. toBin(num);
  10. toOct(0);
  11. toHex(-num);
  12. }
  13. //转换为二进制
  14. public static void toBin(int num)
  15. {
  16. conversion(num,1,1);
  17. }
  18. //转换为八进制
  19. public static void toOct(int num)
  20. {
  21. conversion(num,7,3);
  22. }
  23. //转换为十六进制
  24. public static void toHex(int num)
  25. {
  26. conversion(num,15,4);
  27. }
  28. //转换
  29. public static void conversion(int num,int diwei,int yiwei)
  30. {
  31. //如果num等于0，结果输出为0
  32. if(num==0)
  33. {
  34. System.out.println("num="+0);
  35. return;
  36. }
  37. //定义一个包含二进制、八进制、十六进制的表
  38. char[] chs={'0','1','2','3','4','5','6','7',
  39. '8','9','A','B','C','D','E','F',};
  40. //定义一个临时容器
  41. char[] arr=new char[32];
  42. //定义一个操作数组的指针
  43. int pos=arr.length;
  44. //利用与低位最大值的方式取出低位，存到临时数组中
  45. while(num!=0)
  46. {
  47. arr[--pos]=chs[num&diwei];//--pos倒着往临时容器里存
  48. num >>>=yiwei; //无条件右移相应位数
  49. }
  50. //打印转换后的结果
  51. for(int x=pos;x<arr.length; x++)
  52. System.out.print(arr[x]);
  53. //换行
  54. System.out.println();
  55. }
  56. }

输出结果：

Java基础语法(三)---数组

上一篇：层层递进Struts1（七）详解DispatchAction


下一篇：MindSpore 数据加载及处理