非常重要的: 方法设计(参数,返回值,调用)
数组也重要,但是后续很少用! 是因为后期有更简单的【集合】，重要在于是一种思想，也是一种代码逻辑
关于数组:
- 声明创建
- 取值,存值
- 遍历
- 面试|算法 --> 排序
- 内存图(堆,栈,引用)
今天
- 数组工具类:Arrays
- 数组扩容(拷贝)
- 作业
一、Arrays
Arrays , 数组工具类, 主要提供一系列操作数组的方法,常用的
- String toString(数组参数) 将数组的元素以字符串的形式返回(
将数组转成字符串后返回)- void sort(数组参数), 将数组按照升序排序
- copy
package com.qf.array;
import java.util.Arrays;
/**
* @desc
*/
public class Demo1 {
public static void main(String[] args) {
// 数组声明创建方式1
int[] arr1 = new int[3];
// int arr2[];// 语法不错,但是不建议
// 数组声明创建方式2
int[] arr2 = new int[]{1,2,3,4};
// 数组声明创建方式3
int[] arr3 = {1,2,3,4};
/**
* 使用数组工具类,用法
* 返回值 = 类名.方法名(参数)
*------------------------------
* toString方法,作用是将数组以字符串形式返回
*-----------------------------
* 作用:
* 主要用来遍历数组元素,方便查看
*/
// String s = Arrays.toString(arr3);
// System.out.println(s );
System.out.println( "遍历" + Arrays.toString(arr3));
/**
* Arrays工具第二个常用方法
* void sort(数组),作用是将数组按照升序排序
*/
int[] arr4 = {5,2,3,1,4};
// 排序前遍历一遍,看效果
System.out.println("排序前: "+Arrays.toString(arr4));
// 调用方法完成排序
Arrays.sort(arr4);
System.out.println("排序后: "+Arrays.toString(arr4));
}
}
二、数组扩容
数组特点是长度固定,那还怎么扩容?
- 为什么扩容? 因为装不下
- 怎么扩? 其实是重新创建一个大一点(一般是1.5倍,2倍)的数组,将之前数组的元素拷贝到新的数组
三、拷贝
3.1 手动
思路
- 手动创建一个数组(假定原数组2倍长度)
- 遍历老数组取出元素,挨个存储到新数组
package com.qf.array;
import java.util.Arrays;
/**
* @desc 数组扩容+拷贝
*/
public class Demo2 {
public static void main(String[] args) {
// 现有数组
int[] arr = {1,2,3,4,5};
System.out.println("扩容前: " + Arrays.toString(arr) );
// 继续往里存储数据,但是存储不了
// arr[5] = 6; // 报错,越界
// 现在想将数组扩容,后再存储
arr = copy1(arr);
arr[5] = 6;
System.out.println("扩容后: " + Arrays.toString(arr) );
}
// 需求: 将数组长度扩大2倍
// 拷贝方式1: 手动实现
public static int[] copy1(int[] arr) {
// 创建一个新数组是原来的2倍
int[] arr2 = new int[arr.length * 2];
// System.out.println("拷贝前: " + Arrays.toString(arr2) );
// 开始拷贝
for (int i = 0; i < arr.length; i++) {
// 取出老数组中的元素赋值给新数组
arr2[i] = arr[i];
}
// System.out.println("拷贝后: " + Arrays.toString(arr2) );
return arr2;
}
}
3.2 System工具【重要】
package com.qf.array;
import java.util.Arrays;
/**
* @desc 数组扩容+拷贝(工具实现)
*/
public class Demo3 {
public static void main(String[] args) {
// 现有数组
int[] arr = {1,2,3,4,5};
System.out.println("扩容前: " + Arrays.toString(arr) );
// 继续往里存储数据,但是存储不了
// arr[5] = 6; // 报错,越界
// 现在想将数组扩容,后再存储
arr = copy(arr);// 将新数组地址值覆盖给变量
// 即arr现在指向新的数组
arr[5] = 6;
System.out.println("扩容后: " + Arrays.toString(arr) );
}
public static int[] copy(int[] arr) {
/**
* 现在使用jdk自带工具方法完成数组拷贝
* 参数1: src,资源(原始、源），即原数组
* 参数2: srcPos,原始数组位置
* 参数3: dest,目的地即新数组
* 参数4: destPos,新数组位置
* 参数5: length,长度即拷贝的元素个数
*
* 从原数组的指定位置拷贝指定个数到新数组指定位置
*/
int[] arr2 = new int[arr.length * 2];
System.arraycopy(arr,0,arr2,0,arr.length);
return arr2;// 返回的是新数组的地址值
}
}
3.3 Arrays工具
public class Demo4 {
public static void main(String[] args) {
// 现有数组
int[] arr = {1,2,3,4,5};
System.out.println("扩容前: " + Arrays.toString(arr) );
// 继续往里存储数据,但是存储不了
// arr[5] = 6; // 报错,越界
// 现在想将数组扩容,后再存储
/**
* Arrays提供的方法
* copyOf方法内部创建了新数组,长度是指定长度
* 而且还会将之前老数组的元素拷贝到新数组
* 最后将新数组的地址值返回给变量arr
* 即arr指向最新的数组
*/
arr = Arrays.copyOf(arr,arr.length*2);
arr[5] = 6;
System.out.println("扩容后: " + Arrays.toString(arr) );
}
}
四、作业
题19
请创建一个长度为5的整数数组，并为数组中的元素赋值。遍历数组，打印所有元素，元素之间用空格隔开。比如：
数组为：1,2,3,4,5
打印结果：[1,2,3,4,5]
public static void main(String[] args) {
int[] arr = {11, 22, 33, 44, 55};
String s = toStrPro(arr);
System.out.println(s );
Arrays.toString(arr);
}
// 请创建一个长度为6的整数数组，并为数组中的元素赋值。遍历数组，打印所有元素，元素之间用空格隔开。比如：
// 数组为：1,2,3,4,5
// 打印结果：[1,2,3,4,5]
public static void toStr(int[] arr) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {// 是不是最后一个
System.out.print(arr[i] + "]");
} else {
System.out.print(arr[i] + ",");
}
}
}
// 模拟Arrays.toString()方法,将数组元素以字符串形式返回
public static String toStrPro(int[] arr) {
String s = "[";
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {// 是不是最后一个
s += arr[i] + "]";
} else {
s += arr[i] + ",";
}
}
return s;// "[1,2,3]"
}
题目23
写一个方法 用于合并两个int类型的数组 合并法则如下
{1,2,5,8,9}{1,3,0}---->{1,2,5,8,9,1,3,0} (合并)
public static void main(String[] args) {
int[] arr1 = {1,2,5,8,9};
int[] arr2 = {1,3,0,6,10};
int[] arr3 = concatArray(arr1,arr2);
System.out.println(Arrays.toString(arr3) );
}
/**
* 扩展知识:
* 整型默认值: 0
* 浮点型默认值: 0.0
* char默认值: ' '
* boolean默认值: false
* ---
* 引用类型: 数组,类,接口
* 引用类型的默认初始值都是null
*/
// {1,2,5,8,9}{1,3,0}---->{1,2,5,8,9,1,3,0} (合并)
public static int[] concatArray(int[] arr1, int[] arr2) {
// 创建新数组,存储所有元素
int[] arr3 = new int[arr1.length + arr2.length];
// 方式1
// for (int i = 0; i < arr1.length; i++) {
// arr3[i] = arr1[i];
// }
// for (int i = 0; i < arr2.length; i++) {
// arr3[arr1.length+i] = arr2[i];
// }
// 方式2
// for (int i = 0; i < arr3.length; i++) {
// if (i < arr1.length) {
// arr3[i] = arr1[i];
// } else {
// arr3[i] = arr2[i - arr1.length];
// }
// }
// 方式3
System.arraycopy(arr1,0,arr3,0,arr1.length);
System.arraycopy(arr2,0,arr3,arr1.length,arr2.length);
return arr3;
}
题目24
写一个方法 用于合并两个int类型的数组 合并法则如下
{1,2,5,3,8,9}{1,3,0}---->{0,1,1,2,3,3,5,8,9} (合并并排序不需要去重)
public static void main(String[] args) {
int[] arr1 = {1,2,5,8,9};
int[] arr2 = {1,3,0,6,10};
int[] arr3 = concatSortArray(arr1,arr2);
System.out.println(Arrays.toString(arr3) );
}
// 合并并排序
// {1,2,5,3,8,9}{1,3,0}---->{0,1,1,2,3,3,5,8,9} (合并并排序不需要去重)
public static int[] concatSortArray(int[] arr1, int[] arr2) {
// 创建新数组,存储所有元素
int[] arr3 = new int[arr1.length + arr2.length];
System.arraycopy(arr1,0,arr3,0,arr1.length);
System.arraycopy(arr2,0,arr3,arr1.length,arr2.length);
Arrays.sort(arr3);
return arr3;
}
题目25
写一个方法 用于合并去重两个int类型的数组 合并法则如下
{1,2,5,3,8,9}{1,3,0}---->{0,1,2,3,5,8,9} (合并并排序需要去重)
public static void main(String[] args) {
int[] arr1 = {1,2,5};
int[] arr2 = {1,6,2,3,10};
int[] arr3 = concatSortDistinctArray(arr1,arr2);
System.out.println(Arrays.toString(arr3) );
}
// 写一个方法 用于合并去重两个int类型的数组 合并法则如下
// {1,2,5,3,8,9}{1,3,0}---->{0,1,2,3,5,8,9} (合并并排序需要去重)
public static int[] concatSortDistinctArray(int[] arr1, int[] arr2) {
// 创建新数组,合并所有元素
int[] arr3 = new int[arr1.length + arr2.length];
System.arraycopy(arr1,0,arr3,0,arr1.length);
System.arraycopy(arr2,0,arr3,arr1.length,arr2.length);
// 排序
Arrays.sort(arr3);
// 去重
// [0,1,1,2,3,5,8,9] --> [0,1,2,3,5,8,9]
/**
* 要新建数组存储去重后的元素
* 利用极值思想,那就创建一个根原数组一样大的数组存储
*/
int[] arr4 = new int[arr3.length];
int index = 0;
for (int i = 0; i < arr3.length; i++) {
int e = arr3[i];
boolean flag = false;// 判断是否有重复元素的标志,false是没有重复元素
for (int j = 0; j < arr4.length; j++) {
if (e == arr4[j]) {
flag = true;// 有重复,标志改动
break;
}
}
if (!flag) {
arr4[index] = e;
index++;
}
}
// 只存储不重复的元素
int[] arr5 = new int[index];
System.arraycopy(arr4,0,arr5,0,index);
return arr5;
}
