Java基础知识之数组

80 阅读 0 评论 53 点赞

我是靠谱客的博主开心电源，最近开发中收集的这篇文章主要介绍Java基础知识之数组，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

1、Java语言中的数组是一种引用数据类型。不属于基本数据类型。数组的父类是Object。
2、数组实际上是一个容器，可以同时容纳多个元素。（数组是一个数据的集合。）
数组：字面意思是“一组数据”
3、数组当中可以存储“基本数据类型”的数据，也可以存储“引用数据类型”的数据。
4、数组因为是引用类型，所以数组对象是堆内存当中。（数组是存储在堆当中的）
5、数组当中如果存储的是“java对象”的话，实际上存储的是对象的“引用（内存地址）”，数组中不能直接存储java对象。
6、数组一旦创建，在java中规定，长度不可变。（数组长度不可变）
7、数组的分类：一维数组、二维数组、三维数组、多维数组...（一维数组较多，二维数组偶尔使用！）
8、所有的数组对象都有length属性(java自带的)，用来获取数组中元素的个数。
9、java中的数组要求数组中元素的类型统一。比如int类型数组只能存储int类型，Person类型数组只能存储Person类型。
例如：超市购物，购物袋中只能装苹果，不能同时装苹果和橘子。（数组中存储的元素类型统一）
10、数组在内存方面存储的时候，数组中的元素内存地址(存储的每一个元素都是有规则的挨着排列的)是连续的。内存地址连续。
这是数组存储元素的特点（特色）。数组实际上是一种简单的数据结构。
11、所有的数组都是拿“第一个小方框的内存地址”作为整个数组对象的内存地址。
（数组中首元素的内存地址作为整个数组对象的内存地址。）
12、数组中每一个元素都是有下标的，下标从0开始，以1递增。最后一个元素的下标是：length - 1
下标非常重要，因为我们对数组中元素进行“存取”的时候，都需要通过下标来进行。
13、数组这种数据结构的优点和缺点是什么？
优点：查询/查找/检索某个下标上的元素时效率极高。可以说是查询效率最高的一个数据结构。
为什么检索效率高？
第一：每一个元素的内存地址在空间存储上是连续的。
第二：每一个元素类型相同，所以占用空间大小一样。
第三：知道第一个元素内存地址，知道每一个元素占用空间的大小，又知道下标，所以
通过一个数学表达式就可以计算出某个下标上元素的内存地址。直接通过内存地址定位
元素，所以数组的检索效率是最高的。

数组中存储100个元素，或者存储100万个元素，在元素查询/检索方面，效率是相同的，
因为数组中元素查找的时候不会一个一个找，是通过数学表达式计算出来的。（算出一个
内存地址，直接定位的。）
缺点：
第一：由于为了保证数组中每个元素的内存地址连续，所以在数组上随机删除或者增加元素的时候，
效率较低，因为随机增删元素会涉及到后面元素统一向前或者向后位移的操作。
第二：数组不能存储大数据量，为什么？
因为很难在内存空间上找到一块特别大的连续的内存空间。

注意：对于数组中最后一个元素的增删，是没有效率影响的。
14、怎么声明/定义一个一维数组？
语法格式：
int[] array1;
double[] array2;
boolean[] array3;
String[] array4;
Object[] array5;
15、怎么初始化一个一维数组呢？
包括两种方式：静态初始化一维数组，动态初始化一维数组。
静态初始化语法格式：
int[] array = {100, 2100, 300, 55};
动态初始化语法格式：
int[] array = new int[5]; // 这里的5表示数组的元素个数。
// 初始化一个5个长度的int类型数组，每个元素默认值0
String[] names = new String[6]; // 初始化6个长度的String类型数组，每个元素默认值null。

16.// 如果一个数组只有六个元素当输出下标为6表示第7个元素，第7个元素没有，下标越界了。会出现什么数组越界异常
//System.out.println(a[6]); //ArrayIndexOutOfBoundsException（比较著名的异常。）

17. 一维数组的深入，数组中存储的类型为：引用数据类型
对于数组来说，实际上只能存储java对象的“内存地址”。数组中存储的每个元素是“引用”。

18.关于一维数组的扩容。
* 在java开发中，数组长度一旦确定不可变，那么数组满了怎么办？
* 数组满了，需要扩容。
* java中对数组的扩容是：
* 先新建一个大容量的数组，然后将小容量数组中的数据一个一个拷贝到大数组当中。
*
* 结论：数组扩容效率较低。因为涉及到拷贝的问题。所以在以后的开发中请注意：尽可能少的进行数组的拷贝。
* 可以在创建数组对象的时候预估计以下多长合适，最好预估准确，这样可以减少数组的扩容次数。提高效率。

例如：

System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length);

src:原数组

srcPos：从原数组哪个元素开始拷贝

dest：目标数组

destPos：从目标数组的第几个元素开始导入原数组

length：导入长度

//注意此方法中length参数不能写成数组.length的形式,否则会出现数组越界异常

19.数组工具类类包：java.util.Arrays;

排序方法：Arrays.sort(数组名称); 支持多种数据类型的数组

二分法查找：Arrays.binarySearch(数组名称，需要查找的值) 其中数组必须要先排序，如果找到返回值所在数组下标，否则返回-(low+1)

例如：int[] arrs={23,3543,543,53}; 如查找235 则会返回-3 具体代码参见Arrays.binarySearch源代码

20.冒泡排序算法代码：

public class BubbleSort {
public static void main(String[] args) {
int[] arr={4,6,9,3,5,1};
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
//外层循环遍历5次
int temp;
int count=0,count1=0;
for(int i=arr.length-1;i>0;i--){
//6个元素交换5次
//5个元素交换4次
for(int j=0;j<i;j++){
//记录比较次数
count++;
//交换元素
if(arr[j]>arr[j+1]){
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
//记录交换次数
count1++;
}
}
}
System.out.println("-------------------");
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
System.out.println("比较次数："+count);
System.out.println("交换次数"+count1);
}
}

21.比较排序算法代码：

public class SelectSort {
public static void main(String[] args) {
int[] arr={4,6,9,3,5,1};
int count=0,count1=0;
//外层循环
for(int i=0;i<arr.length;i++){
//定义一个标记指向每轮比较元素的第一个元素
//int startValue=arr[i];
//标记最小元素下标
int temp=i;
//找出每一轮中最小的值
for(int j=i+1;j<arr.length;j++){
//记录比较次数
count++;
if(arr[temp]>arr[j]) {
//startValue = arr[j];
temp = j;
}
}
if(temp!=i){
//交换最小元素和starValue指向元素的位置
int temp1;
temp1=arr[i];
arr[i]=arr[temp];
arr[temp]=temp1;
//记录交换次数
count1++;
}
}
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
System.out.println("比较次数："+count);
System.out.println("交换次数："+count1);
}
}