【学懂Java】(三)数组

时间:2023-01-16 16:54:57

一.概述

a.数组是相同类型数据的有序集合:

  • 相同类型的若干个数据,按照一定先后次序排列组合而成。
  • 其中,每一个数据称作一个数组元素
  • 每个数组元素可以通过一个下标来访问它们.

b.数组特点:

  • 其长度是确定的。数组一旦被创建,它的大小就是不可以改变的。
  • 其元素必须是相同类型,不允许出现混合类型。
  • 数组中的元素可以是任何数据类型,包括基本类型和引用类型。

c.数组属引用类型:

  • length, elements of the array

d.注意

  • 声明一个变量就是在内存空间划出一块合适的空间,声明一个数组就是在内存空间划出一串连续的空间
  • 数组只有一个名称,即标识符
  • 元素下标标明了元素在数组中的位置,从0开始
  • 数组中的每个元素都可以通过下标来访问
  • 数组长度固定不变,避免数组越界

二.使用

1、声明数组: 告诉计算机数据类型是什么--数据类型[ ] 数组名 ;​int[] array;​

2、分配空间: 告诉计算机分配几个连续的空间--数据类型[ ] 数组名 = new 数据类型[大小] ;​array = new int[5];​

3、赋值:向分配的格空间里放数据​​array[0] = 0;​

4、处理数据:​​array[0] = array[0] + 1;​

(1)一维数组

1.声明并申请空间

​int[] arr = new int[5];​

​int [] arr = new int[5];​

​int arr[] = new int[5];​

2.声明并且赋值

​int[] arr = new int[]{1,2,3,4,5};//这样说明数组大小为5​

​int[] arr = {1,2,3};​

3.处理

​System.out.println(arr1.length);​打印数组长度,为申请空间的长度,不管是否赋值。

4.初始化

动态初始化

  • 数组定义与为数组元素分配空间并赋值的操作分开进行
int a[] = null;
a = new int[3];
a[0] = 3;
a[1] = 2;
a[2] = 1;

静态初始化

  • 除了用new关键字来产生数组以外,还可以直接在定义数组的同时就为数组元素分配空间并赋值。
  • 格式: 类型 [] 数组名 = {元素1, 元素2 ......};

【学懂Java】(三)数组

默认初始化

数组是引用类型,它的元素相当于类的实例变量,因此数组一经分配空间,其中的每个元素也被按照实例变量同样的方式被隐式初始化。

  • int: 0
  • boolean:false
  • String:null

5.数组范围

数组元素下标从0开始;长度为n的数组合法下标取值范围: 0 ~ n-1;

(2)数组排序*

因为数组相当于是数据结构的一种,很多数据经常要使用数组.因此需要了解:

  1. 某种排序算法
  1. 冒泡排序
  2. 选择排序
  3. 插入排序
  4. 快速排序
  1. 排序算法的时间复杂度,空间复杂度:
  1. 衡量一个数据结构是否合适的衡量标准
  1. 排序算法的稳定性:
  1. 排序之后的值跟排序之前的值位置是否发生变化

冒泡排序

public static void bubbleSort(int array[]) 
{
int t = 0;
for (int i = 0; i < array.length - 1; i++)
{
for (int j = 0; j < array.length - 1 - i; j++)
{
if (array[j] > array[j + 1])
{
t = array[j];
array[j] = array[j + 1];
array[j + 1] = t;
}
}
}
}

选择排序

public static void selectionSort(int[] array) 
{
for (int i = 0; i < array.length; i++)
{
int index = i;
for (int j = i; j < array.length; j++)
{
if (array[j] < array[index])
index = j;
}
int temp = array[index];
array[index] = array[i];
array[i] = temp;
}
}

插入排序

public static void insertionSort(int[] array) {
int current;
for (int i = 0; i < array.length - 1; i++) {
current = array[i + 1];
int preIndex = i;
while (preIndex >= 0 && current < array[preIndex]) {
array[preIndex + 1] = array[preIndex];
preIndex--;
}
array[preIndex + 1] = current;
}
}

快速排序

public static int[] QuickSort(int[] array, int start, int end) {
if (array.length < 1 || start < 0 || end >= array.length || start > end) return null;
int smallIndex = partition(array, start, end);
if (smallIndex > start)
QuickSort(array, start, smallIndex - 1);
if (smallIndex < end)
QuickSort(array, smallIndex + 1, end);
return array;
}
public static int partition(int[] array, int start, int end) {
int pivot = (int) (start + Math.random() * (end - start + 1));
int smallIndex = start - 1;
swap(array, pivot, end);
for (int i = start; i <= end; i++)
if (array[i] <= array[end]) {
smallIndex++;
if (i > smallIndex)
swap(array, i, smallIndex);
}
return smallIndex;
}
public static void swap(int[] array, int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}

(3)二维数组

二维数组的使用

public class TwoArray
{

public static void main(String[] args)
{

int[] arr = new int[6];
int[][] arr2 = new int[3][];
//创建二维数组的对象
arr2[0] = new int[5];
arr2[1] = new int[3];
arr2[2] = new int[4];
//赋值
arr2[0][0] = 1;
arr2[0][1] = 2;
arr2[0][2] = 3;
arr2[0][3] = 4;
arr2[0][4] = 5;

arr2[1][0] = 6;
arr2[1][1] = 7;
arr2[1][2] = 8;

arr2[2][0] = 9;
arr2[2][1] = 10;
arr2[2][2] = 11;
arr2[2][3] = 12;

for(int i = 0;i<arr2.length;i++)
{
for(int j = 0;j<arr2[i].length;j++)
{
System.out.print(arr2[i][j]+"\t");
}
System.out.println();
}
}
}

注意

1.二维数组举例:

​int [][] a = {{1,2},{3,4,0,9},{5,6,7}};​

Java中多维数组不必须是规则矩阵形式,例如

【学懂Java】(三)数组

int[] arr = new int[6];
int[][] arr2 = new int[3][];
//创建二维数组的对象
arr2[0] = new int[2];
arr2[1] = new int[4];
arr2[2] = new int[3];

2.二维数组可以看成以数组为元素的数组

Java中多维数组的声明和初始化应按从高维到低维的顺序进行,例如:

【学懂Java】(三)数组

3.二维数组的初始化

【学懂Java】(三)数组

  • 动态初始化
  • ​int [ ][ ] arr=new int [4][3]; ​​也可以理解为“4行3例”
  • 静态初始化
  • 数据类型 [ ][ ] 数组名 = {{元素1,元素2…},{元素1,元素2…},{元素1,元素2…}…};
  • 举例:​​int [ ][ ] arr={{1,2,3},{1,3,4,5},{1,5,6,7,9}};​
  • 注意
  • ​int [][]arr=new int[3][]; 正确​
  • ​int [][]arr=new int[][3]; 错误​
  • 二维数组可以不定义列数,但必须定义行数。
  • 因为每行的列数可能不一样,所以这类数组的实现方法为:先创建制定行数,列数缺省的二维数组,然后对数组的每一行重新初始化
int [][]arr=new int[3][];
arr[0]=new int[7];
arr[1]=new int[4];
arr[2]=new int[5];