欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

java中数组的定义与使用

程序员文章站 2024-02-17 17:45:28
...

数组:本质上就是让我们能 “批量” 创建相
定义:
int[ ]array={1,2,3,4,5} ; int[]array=new int [ ] {1,2,3,4,5} (前两个经过了初始化)
int[]array3=new int[5]
JAVA中数组初始化有两种方式,一种是动态初始化、另一种是静态初始化。

动态初始化:指数组首先开辟空间内存,再进行内容设置的方式称为动态初始化;

静态初始化:指数组在定义时直接设置其内容。
数组动态初始化格式:

数据类型[] 数组名称=new 数据类型[长度];
eg:int[] arr=new int[5];

数组静态初始化格式:

数据类型[] 数组名称=new 数据类型[]{值1,值2,……};(推荐使用完整格式)
eg:int[] arr=new int[]{1,3,5,7,9};
简化格式:
数组类型[] 数组名称={值1,值2,……}

注意事项:
1.数组不能越界访问。
当数组越界之后会出现"java.lang.ArrayIndexOutOfBoundsException"的错误提示
2.每个数组都有一个length属性来指明它的长度,数组.length 指明数组的长度。length不是方法是一个属性
3…for循环和foreach 的区别
for循环遍历数组

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

foreach遍历数组

int[] arr = {1, 2, 3};
for (int x : arr) {
    System.out.println(x);
    }   

1.foreach在循环次数未知或者计算起来较复杂的情况下效率比for循环高。
2.foreach与for循环的明显差别在于foreach循环时循环对象(数组、集合)被锁定,不能对循环对象中的内容进行增删改操作。
3.foreach不能用下标去访问。

java中数组的内存分析
java中数组的定义与使用
数组的使用

  1. 数组的拷贝
    (1)clone方法是从Object类继承过来的,基本数据类型(String,boolean,char,byte,short,float,double.long)都可以直接使用clone方法进行克隆,注意String类型是因为其值不可变所以才可以使用。
    int类型展示
        int a1[]={1,3};
        int a2[]=a1.clone();
        a1[0]=666;
        System.out.println(Arrays.toString(a1));//[666,3]
        System.out.println(Arrays.toString(a2));//[1,3]

(2)System.arraycopy方法是一个本地的方法
源码定义:

public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

参数含义:
(原数组,原数组的开始位置,目标数组,目标数组的的开始位置,拷贝的个数)
用法示例:

        int  a1[]={1,2,3,4,5};
        int a2[]=new int[10];
        System.arraycopy(a1,1,a2,3,3);
        System.out.println(Arrays.toString(a1));//[1, 2, 3, 4, 5]
        System.out.println(Arrays.toString(a2));//[0, 0, 0, 2, 3, 4, 0, 0, 0, 0]

注意这个方法,需要我们自己new一个新的数组
(3)Arrays.copyOf(arr,arr.length)
参数(原数组,数组长度)
数组长度也可以改为想拷贝的个数
用法示例

        int[] arr = {1,2,3,4,5,6}; 
        int[] newArr = Arrays.copyOf(arr, arr.length); 
        System.out.println("newArr: " + Arrays.toString(newArr));

(4)Arrays.copyOfRange
参数(原数组,开始位置,拷贝个数)
用法示例

        int  a1[]={1,2,3,4,5};
        int a2[]=Arrays.copyOfRange(a1,0,1);
        System.out.println(Arrays.toString(a1));//[1, 2, 3, 4, 5]
        System.out.println(Arrays.toString(a2));//[1]

2.查找数组中的指定元素
(1)顺序查找

public static void main(String[] args) { 
       int[] arr = {1,2,3,10,5,6}; 
       System.out.println(find(arr, 10)); 
} 
public static int find(int[] arr, int toFind) { 
       for (int i = 0; i < arr.length; i++) { 
       if (arr[i] == toFind) { 
       return i; 
       } 
   } 
 return -1; // 表示没有找到
} 

(2)二分法

public static void main(String[] args) { 
       int[] arr = {1,2,3,4,5,6}; 
       System.out.println(binarySearch(arr, 6)); 
} 
public static int binarySearch(int[] arr, int toFind) { 
       int left = 0; 
       int right = arr.length - 1; 
       while (left <= right) { 
          int mid = (left + right) / 2; 
          if (toFind < arr[mid]) { 
          // 去左侧区间找
          right = mid - 1; 
           } else if (toFind > arr[mid]) { 
               // 去右侧区间找
               left = mid + 1; 
           } else { 
          // 相等, 说明找到了
             return mid; 
          } 
 } 
 // 循环结束, 说明没找到
            return -1; 
}

(3)冒泡排序
算法思路
每次尝试找到当前待排序区间中最小(或最大)的元素, 放到数组最前面或最后面
代码示例


public static void bubbleSort(int[] arr) { 
       for (int bound = 0; bound < arr.length; bound++) { 
             for (int cur = arr.length - 1; cur > bound; cur--) { 
                  if (arr[cur - 1] > arr[cur]) { 
                       int tmp = arr[cur - 1]; 
                       arr[cur - 1] = arr[cur]; 
                       arr[cur] = tmp; 
                       } 
                } 
        } 
}

二维数组
二维数组本质上也是一维数组,只不过每个元素又是一个一维数组
两种初始化形式

格式1: 动态初始化
数据类型 数组名 [ ][ ] = new 数据类型[m][n]
数据类型 [ ][ ] 数组名 = new 数据类型[m][n]
数据类型 [ ] 数组名 [ ] = new 数据类型[m][n]
举例:int [ ][ ] arr=new int [5][3]; 也可以理解为“5行3例”
格式2: 静态初始化
数据类型 [ ][ ] 数组名 = {{元素1,元素2…},{元素1,元素2…},{元素1,元素2…}…};
举例:int [ ][ ] arr={{22,15,32,20,18},{12,21,25,19,33},{14,58,34,24,66},};
静态初始化可用于不规则二维数组的初始化

二维数组遍历

public static void getElements(int[][] array){
		for (int i = 0;i < array.length ;i++) {
			for (int j = 0;j < array[i].length;j++) {
				System.out.print(array[i][j] + " ");
			}
			System.out.println();
		}
	}