java数组编译后_java 数组详解

最新推荐文章于 2022-05-01 17:51:16 发布

网红教父

最新推荐文章于 2022-05-01 17:51:16 发布

阅读量190

点赞数

文章标签： java数组编译后

本文链接：https://blog.csdn.net/weixin_35709751/article/details/114248748

版权

数组

概念：数组是一个定长的容器,数组中存储的数据类型需要是一致的

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

数组的四种定义方式：

数据类型是数组中元素的数据类型

数组是有默认值的{0,0,0,0,0,0,0,0,0,0,}

int数据类型是数组中元素的数据类型

数组的数据类型是 int[]

元素 --> 数组中储存的值

数组的长度 --> 数组中的元素个数

//数据类型[] 数组名 = new 数据类型[数组中元素的个数]

int[] array = new int[10];

2.先声明数组，然后再进行赋值

//在类中，定义成员变量，方法传递

int[] array2;

array2= new int[10];

3.创建数组的同时，给定当前数组中储存元素的值

//数组的长度：后面{}中储存多少个值，数组就有多长

int[] array3 = new int[]{1,2,3,4}

4.第3的简化版本

int[] array4 = {1,2,3,4}

数组的概念

同一种类型数据的集合。其实数组就是一个容器。运算的时候有很多数据参与运算,那么首先需要做的是什么.不是如何运算而是如何保存这些数据以便于后期的运算，那么数组就是一种用于存储数据的方式，能存数据的地方我们称之为容器，容器里装的东西就是数组的元素, 数组可以装任意类型的数据，虽然可以装任意类型的数据,但是定义好的数组只能装一种元素，也就是数组一旦定义，那么里边存储的数据类型也就确定了。

数组的内存分析

数组声明后实际上是在栈内存中保存了此数组的名称，接下来便是要在堆内存中配置数组所需的内存，其中“元素的个数”(数组的长度)是告诉编译器，所声明的数组要存放多少个元素，而“new”则是命令编译器根据括号里的长度开辟空间。

二维数组：

Arrays的使用

遍历： toString() 将数组的元素以字符串的形式返回

排序： sort() 将数组按照升序排列

int[] arr = {23,64,2,37,43,67,1};

Arrays.sort(arr);//升序

for(int i=0;i

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

}

查找： binarySearch()在指定数组中查找指定元素，返回元素的索引，如果没有找到返回(-插入点-1) 注意：使用查找的功能的时候，数组一定要先排序。

二维数组：实质就是存储是一维数组。

数组定义：

数组类型[][] 数组名 = new 数组类型[一维数组的个数][每一个一维数组中元素的个数];

数组排序：

数组排序有很多中:冒泡 ,选择,插入,快速,堆等等

* 速度最快的就是堆排序

冒泡排序 ( 两两相比 )

是相邻的两个数组元素进行比较

若当前元素大于后面的元素,交换两个元素的位置

若当前元素不大于后面的元素,就不交换

比较所有相邻的元素,最终的到一个有序的结果

冒泡最大的特点就是会先找出最大的值,然后放到数组的最后一位

升序(从小到大),降序(从大小) --> 默认排序都是升序

只要经过一轮排序,肯定会有一个数放到正确的位置上

3,7,4,6,9,1 --> 存储到数组中是无序,通过冒泡排序,数组升序排列

3,4,6,7,1,9 -- > 9

3,4,6,1,7,9 --> 7,9

3,4,1,6,7,9 --> 6,7,9

3,1,4,6,7,9 --> 4,6,7,9

1,3,4,6,7,9 --> 1,3,4,6,7,9

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]){int tmp =array[j];

array[j]= array[j+1];

array[j+ 1] =tmp;

}

选择排序 ( 固定一位一次向后比 )

升序(从小到大),降序(从大小) --> 默认排序都是升序

固定一个元素,依次和后面的元素进行比较

若当前元素大于后面的元素,交换

若当前元素不大于后面的元素,不交换

每次比较完成们都会有一个数放到正确的位置上,小的那个数

3,7,4,6,9,1 --> 存储到数组中是无序,通过冒泡排序,数组升序排列

1,7,4,6,9,3 --> 1

1,3,7,6,9,4 --> 1,3

1,3,4,7,9,6 --> 1,3,4

1,3,4,6,9,7 --> 1,3,4,6

1,3,4,6,7,9 --> 1,3,4,6,7,9

for(int i = 0 ; i < array.length ; i++){for(int j = i+1 ; j < array.length ;j++){if(array[i] >array[j]){int tmp =array[i];

array[i]=array[j];

array[j]=tmp;

}

数组的复制

int[] a = {10,20,30,40,50};//数组的扩容(创建了新的数组并将源数组的数据复制过去了)

a = Arrays.copyOf(a,a.length+1); //for(int i=0;i

System.out.println(a[i]); //10 20 30 40 50 0

}

int[] a = {10,20,30,40,50};//a:源数组//a1:目标数组//6:目标数组的长度(多则补默认值，少则截取)

int[] a1 = Arrays.copyOf(a,6); //灵活性差

for(int i=0;i

System.out.println(a1[i]); //10 20 30 40 50 0

}

int[] a = {10,20,30,40,50};int[] a1 = new int[6]; //0,0,0,0,0,0//a:源数组//1:源数组的起始下标//a1:目标数组//0:目标数组的起始下标//4:要复制的元素个数

System.arraycopy(a,1,a1,0,4); //灵活性好

for(int i=0;i

System.out.println(a1[i]); //20 30 40 50 0 0

}

操作数组的工具类：Arrays

java.util.Arrays类包含了用来操作数组(比如排序和搜索)的各种方法，它提供的所有这些方法都是静态的。

Arrays拥有一组static方法：

public static int binarySearch(Object[] a, Object key)

用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。

public static boolean equals(long[] a, long[] a2)

如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型(Byte，short，Int等)。

public static void fill(int[] a, int val)

将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型(Byte，short，Int等)。

public static void sort(Object[] a)

对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型(Byte，short，Int等)。

public classTest {public static voidmain(String[] args) {int array[] = { 2, 5, 8, 3, 1, 4, 9, 6, 7 }; //声明一个整型数组

System.out.println("Object的toString："array.toString()); //Object的toString()方法

Arrays.sort(array); //数组排序

System.out.println("排序后的数组:" +Arrays.toString(array)) ;int point = Arrays.binarySearch(array, 3) ; //检索数据位置

System.out.println("元素‘3’的位置在：" +point) ;

Arrays.fill(array,6) ; //填充数组

System.out.print("数组填充：" +Arrays.toString(array)) ;

}