本文详细介绍了Java中的数组，包括数组的概念、创建、初始化、使用注意事项、数组的拷贝、转换为字符串、排序、查找和反转等操作。此外，还展示了如何通过工具类Arrays进行操作，以及提供了多个实战示例，如计算平均值、顺序查找和二分查找等。
目录
数组
1. 什么是数组
数组：可以看成是相同类型元素的一个集合。在内存中是一段连续的空间。比如现实中的车库：
一组连续的空间,存放的是一组相同数据类型的数据
int[] array = {1,2,3,4,5,6,7,8,9,10};
array[下标]
2. 基本语法
2.1 数组的创建
T[] 数组名 = new T[N];
T：表示数组中存放元素的类型
T[]：表示数组的类型
N：表示数组的长度
2.2 数组的初始化
数组的初始化主要分为动态初始化以及静态初始化。
- 动态初始化：在创建数组时，直接指定数组中元素的个数
// 动态初始化
数据类型[] 数组名称 = new 数据类型 [] { 初始化数据 };
int[] arr = new int[]{1, 2, 3};
int[] arr = new int[10]; //大小为10,默认存储的就是0
- 静态初始化：在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定
语法格式： T[] 数组名称 = {data1, data2, data3, …, datan};
// 静态初始化
数据类型[] 数组名称 = { 初始化数据 };
int[] arr = {1, 2, 3};
int[] array1 = new int[10]; // 创建一个可以容纳10个int类型元素的数组
double[] array2 = new double[5]; // 创建一个可以容纳5个double类型元素的数组
String[] array3 = new double[3]; // 创建一个可以容纳3个字符串元素的数组
【注意事项】
- 静态初始化虽然没有指定数组的长度，编译器在编译时会根据{}中元素个数来确定数组的长度。
- 静态初始化时, {}中数据类型必须与[]前数据类型一致。
- 静态初始化可以简写，省去后面的new T[]。
注：
int[] array1 = {1,2,3,4,5}; //整体初始化，只有一次机会，
int[] array1 = new int[10];
array = {1,2,3,4,5}; //这样是会出错的
3. 数组的使用
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
System.out.println(array.length); //获取数组长度
System.out.println(array[0]); //获取0下标数据
System.out.println(array[1]); //获取1下标数据
array[0] = 999; //修变数组的值
System.out.println(array[0]);
}
注意事项
- 使用 arr.length 能够获取到数组的长度. . 这个操作为成员访问操作符. 后面在面向对象中会经常用到.
- 使用 [ ] 按下标取数组元素. 需要注意, 下标从 0 开始计数
- 使用 [ ] 操作既能读取数据, 也能修改数据.
- 下标访问操作不能超出有效范围 [0, length - 1] , 如果超出有效范围, 会出现下标越界异常
下标越界问题
打印数组的三种方法
public static void main(String[] args) {
int[] array = {1,2,8,4,5};
//System.out.println(array[6]);
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
System.out.println("========增强for循环=========="); //for-each
for (int val :array){ // for (数组当中每个元素的类型的变量 :数组名)
System.out.print(val + " ");
}
System.out.println("==========使用操作数组的工具类Arrays============");
String ret = Arrays.toString(array);
System.out.println(ret);
}
Arrays.sort(array); //给数组排序
public static void main(String[] args) {
int[] array = new int[10];
System.out.println(Arrays.toString(array));
/* Arrays.fill(array,99); //整个数组 填充99
System.out.println(Arrays.toString(array));*/
Arrays.fill(array,3,6,99); //从[3,6) 赋值99
System.out.println(Arrays.toString(array));
}
数组作为方法的返回值
public static int[] func5(int[] array){ //并没有在原来数组的基础上上修改,而是重新把修改之后的元素放到了一个新的数组当中
int[] ret = new int[array.length];
for (int i = 0; i < array.length; i++) {
ret[i] = array[i] * 2;
}
return ret;
}
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
/* func3(array);
System.out.println(Arrays.toString(array));
int[] ret = func4(array);
System.out.println(Arrays.toString(ret));*/
int[] v = func5(array);
System.out.println(Arrays.toString(v));
}
4. 数组转字符串Arrays
Arrays是操作数组的工具类
实现自己的数组转字符串
public static String myToString(int[] tmp) {
//assert tmp != null 是否可以用断言判断是否为空 TODO:提示：可能需要设置一些参数。
if(tmp == null) return "null";
String ret = "[";
for (int i = 0; i < tmp.length; i++) {
ret += tmp[i];
if (i != tmp.length - 1) {
ret += ",";
}
}
ret += "]";
return ret;
}
public static void main(String[] args) {
int[] array = {1,2,2,4,4,4};
String x = myToString(array);
System.out.println(x);
5. 数组的拷贝
public static void main(String[] args) {
int[] array1 = {1,2,2,4,4,4};
// int[] array2 = array1; //不算copy，因为根本没有产生新的空间
//自己写的拷贝
int[] array2 = new int[array1.length];
for (int i = 0; i < array1.length; i++) {
array2[i] = array1[i];
}
System.out.println(Arrays.toString(array1));
System.out.println(Arrays.toString(array2));
//数组的拷贝 Arrays.copy
int[] array3 = Arrays.copyOf(array1,array1.length);
System.out.println(Arrays.toString(array3));
//扩容2倍
int[] array4 = Arrays.copyOf(array1,2*array1.length);
System.out.println(Arrays.toString(array4));
}
copyof源码
arraycopy
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
arraycopy可以实现将一个数组的指定个数元素复制到另一个数组中。
//局部拷贝
int[] array1 = {1,2,2,4,4,4,5,7,7,7,9};
int[] copy = new int[array1.length];
System.arraycopy(array1,0,copy,3,array1.length -4);
System.out.println(Arrays.toString(copy));
将array1的第0个元素，copy到copy数组中的第3个元素中，copy的元素数量为array1.length -4，也就是7个。
//局部拷贝
int[] array1 = {1,2,2,4,4,4,5,7,7,7,9};
int[] array5 = Arrays.copyOfRange(array1,2,5); //[2,5)
System.out.println("array5"+Arrays.toString(array5));
克隆
int[] array6 = array1.clone();
System.out.println("array6"+Arrays.toString(array6));
6.数组练习
6.1 求数组中元素的平均值
public static void main3(String[] args) {
int[] arr = {1,2,3,4,5,6};
System.out.println(avg(arr));
}
public static double avg(int[] arr) {
int sum = 0;
for (int x : arr) {
sum += x;
}
return (double)sum / (double)arr.length;
}
6.2 查找数组中指定元素(顺序查找)
给定一个数组, 再给定一个元素, 找出该元素在数组中的位置
public static int find(int[] array,int key) {
for (int i = 0; i < array.length; i++) {
if (array[i] == key) {
return i;
}
}
return -1;
}
6.3 查找数组中指定元素(二分查找)
针对有序数组, 可以使用更高效的二分查找
public static int binarySearch(int[] arr, int key){
int left = 0;
int right = arr.length - 1;
while (left <= right){
int mid = (left + right) / 2;
if (arr[mid] < key) {
left = mid + 1;
}else if (arr[mid] > key) {
right = mid - 1;
} else {
return mid;
}
}
return -1;
}
public static void main5(String[] args) {
int[] array1 = {1,3,4,6,12,5,7,7,7,9};
Arrays.sort(array1);
System.out.println(Arrays.toString(array1));
int index = binarySearch(array1,9);
//Arrays.binarySearch Arrays自带的二分查找
int index_1 = Arrays.binarySearch(array1,9);
System.out.println(index);
System.out.println(index_1);
}
6.4 数组排序(冒泡排序)
给定一个数组, 让数组升序 (降序) 排序.
算法思路
假设排升序：
- 将数组中相邻元素从前往后依次进行比较，如果前一个元素比后一个元素大，则交换，一趟下来后最大元素就在数组的末尾
- 依次从上上述过程，直到数组中所有的元素都排列好
public static void bubbleSort1(int[] array){
//i控制趟数
for (int i = 0; i < array.length - 1; i++) {
for (int j = 0; j < array.length - 1; j++) {
if (array[j] > array[j + 1]) {
int tmp = array[j];
array[j] = array[j + 1];
array[j + 1] = tmp;
}
}
}
}
public static void bubbleSort2(int[] array){
//i控制趟数
for (int i = 0; i < array.length - 1; i++) {
//j < 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;
}
}
}
}
public static void bubbleSort3(int[] array){
//i控制趟数
//优化：检查某一趟之后，是否有序了？
//在对某个元素进行判断前，先定义flg = false,如果存在array[j] > array[j + 1]，说明发生交换，设置flg为true,
//如果不存在交换，设置flg == false，说明程序已经有序，返回。
for (int i = 0; i < array.length - 1; i++) {
boolean flg = false;
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;
flg = true;
}
}
if (flg == false) {
return;
}
}
}
冒泡排序性能较低. Java 中内置了更高效的排序算法
Arrays.sort()
6.5 数组逆序
给定一个数组, 将里面的元素逆序排列.
思路
设定两个下标, 分别指向第一个元素和最后一个元素. 交换两个位置的元素。然后让前一个下标自增, 后一个下标自减, 循环继续即可.
//数组逆序
public static void reverse(int[] array){
int left = 0;
int right = array.length - 1;
while (left < right) {
int tmp = array[left];
array[left] = array[right];
array[right] = tmp;
left++;
right--;
}
}
public static void main(String[] args) {
int[] array1 = {1,3,4,6,12,5,7,7,7,9};
reverse(array1);
System.out.println(Arrays.toString(array1));
}
6.6 将数组初始为某值
//将数组初始为某值
public static void main(String[] args) {
int[] array1 = new int[10];
Arrays.fill(array1,-1);
System.out.println(Arrays.toString(array1));
int[] array2 = new int[10];
Arrays.fill(array2,2,4,-1);
System.out.println(Arrays.toString(array2));
}
6.7 判断数组是否相等
//判断数组是否相等
public static void main7(String[] args) {
int[] array1 = {1,3,4,6,12,5,7,7,7,9};
int[] array2 = array1;
boolean val = Arrays.equals(array1,array2);
System.out.println(val);
}
7.二维数组
在尝试用一维数组的Arrays.toString()对二维数组进行输出时，发现输出的是两个地址。
扫一扫
3833
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
