数组的定义以及应用
1、数组
- 组就是指多个的意思，在之前我们的代码中使用的数据类型都是单个的，为了将多个相同类型的数据存储在一起，这时候就引出了组的概念
- 数组是存储同一种数据类型是多个元素的集合，也可以看成是一个容器
- 数组可以存储基本数据类型，也可以存储引用数据类型
- 数组是java中的唯一底层容器，集合的底层也使用的是数组
package com.goshawk.array;
/**
* 1、数组的定义
* 数组是一个容器，里面存放着相同数据类型的多个元素
* 2、数组的创建方式
* 1> 创建数组的格式
* 创建一个指定容量的数组
* 数据类型[] 数组名 = new 数据类型[容量];
* 数据类型 数组名[] = new 数据类型[容量];
* 2> 数组的静态初始化和动态初始化
*
* 3> 如何使用数组
* 数组名[下标] 这种方式来使用数组
* */
public class demo1 {
public static void main(String[] args){
int a = 10;
int b = 20;
// 数组
int[] arr = {10, 20, 30, 50};
// 创建一个容量为10的数组，可以存放10个元素的数组
int[] arr1 = new int[10];
// 向数组中添加一个元素
arr1[0] = 100;
// 从数组中取第一个元素
System.out.println(arr1[0]);
}
}2、数组的初始化
- 就是为数组开辟连续的内存空间，并为每个数组元素赋值
- 静态初始化
- 指定内容，数组的长度由jvm自动判断
- 数组类型[] 数组名 = new 数组类型[ ] {元素1, 元素2, 元素3, 元素4…}
- 数组类型[] 数组名 = {元素1, 元素2, 元素3, 元素4 …}
- 动态初始化
- 指定数组的长度，数组中的元素由jvm给出默认值
- 数组类型[] 数组名 = new 数据类型[数组长度]
package com.goshawk.array;
/**
* 1 数组的静态初始化和动态初始化
* 1> 静态初始化：
* 在创建数组的同时，给数组赋值（存元素）
* 1.1> 创建方式1
* 数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3};
* 1.2> 创建方式2
* 数据类型[] 数组名 = 元素1, 元素2, 元素3};
* 2> 动态初始化
* 在创建数组的时候不存元素，但是一定要指明数组的容量，因为不指明容量，jvm无法知道要开辟多大的空间
* 应用场景：
* 只有在使用时才会向数组存元素，所以只能使用动态初始化来创建数组；
* 动态初始化刚完成后，还没有存数据前，数组中数据是什么样----- 数组中的数据是该数据类型的默认值。
* 整型：0
* 浮点：0.0
* 布尔值：false
* 引用数据类型: null
*
* */
public class demo1 {
public static void main(String[] args){
// 静态初始化
// 创建一个存放a,b,c三个字符串元素的数组
String[] arr1 = new String [] {"a","b", "c"}; // 可拆分，如arr3;
String[] arr2 = {"a","b", "c"}; // 不可拆分
String[] arr3;
arr3 = new String[] {"a","b", "c"};
// 动态初始化
String[] arr4 = new String[5];
System.out.println(arr4[0]);
}
}3、存储逻辑
int arr1[] = nwe int[10]; // 连续的空间：32位*10- 程序执行流程
- main方法进入方法栈执行
- 创建数组，JVM会在堆内存中开辟一块连续的内存空间，来存储数组；该内存空间的大小跟数组的数据类型和元素个数相关。
- 数组在内存中会有自己的内存地址，以十六进制数表示（0X1AB）
- 数组中有10个元素，默认值0；这10个空间会有一个首地址（例如：0X1AB），也就是说我只要找到这个刚开始的地址，那么这个连续空间的其它地址也能找到；
- JVM将数组的内存地址赋值给引用类型变量arr1；（将首地址0X1AB赋值给arr1，也就是说arr1这个变量指向的空间里面存储0X1AB）
- 变量arr1保存的是数组内存中的地址，而不是一个具体是数值，因此称为引用数据类型。
- 可以通过数组的下标（索引：从0开始）来选择操作数组这片连续空间中的每一个位置。
4、注意事项
- 数组的长度在创建的时候就固定，中途无法被改变
- 数组是靠角标定位元素，角标值从0开始
- 数组属于引用数据类型
- 数组中元素必须是同一种数据类型
5、数组的基本操作
- 使用数组的角标对数组进行操作，我们可以将数组的一个角标为看作是一个变量
- 获取数组的某个角标为：arr[角标位3]
- 获取到数组中的某个角标之后，就可以获取值和赋值了
- 获取数组的长度（元素的个数）：arr.length
- 遍历数组
- 循环查看数组中每一个元素
public static void print(){
for (int i=0;i<arr.length;i++){
System.out.println(arr[i]+" ");
}
}- 获取数组中的最大值
- 遍历数组，查找最大的值，注意，这个最大值一定是数组的，所以我们不能随便给最大值变量赋予一个默认值
public static void getMax(){
int[] arr = {10,20,30,1,5,16,33,90}
// 定义存储最大值的变量
int max = arr[0]; // int max = 0;
for (int i=1;i<arr.length;i++){
if(arr[i]>max){
max = arr[i];
}
}
System.out.println(max);
return max;
}- 反转数组
- 将数组中的元素按照排列顺序反转，例如角标0和最后一个角标位上的元素交换
package com.goshawk.array;
import java.util.Arrays;
/**
* 反转数组
* 思路：取数组中的一半位置，让尾部向前，头部向后，两个数逐一的互换
* */
public class reversal {
public static void main(String[] args) {
int arr[] = {1,10,5,3,4,12,6,21,8,3};
for (int i=0;i<arr.length/2;i++){
// 两数互换的中间值
int swap = arr[i];
arr[i] = arr[arr.length-i-1];
arr[arr.length-i-1] = swap;
}
System.out.println(Arrays.toString(arr));
}
}- 查找数组中某个值第一次出现的位置
- 对比数组中每个元素，知道匹配成功，返回当前的角标，如果没有查找到，返回一个负数
package com.goshawk.array;
import java.util.Scanner;
/**
* 通过方法，实现查找数组中某个元素第一次出现的位置
* 数组中的元素前后交换，遍历的次数只能是数组长度的一半；
* */
public class first_to_element {
public static void main(String[] args) {
int arr[] = {1,10,5,3,4,12,6,21,8,3};
Scanner scanner = new Scanner(System.in);
System.out.println("请输入要查找的数值：");
int value = scanner.nextInt();
// 遍历数组
// 记录该位置。并返回
int index = indexValue(arr, value);
if (index==-1){
System.out.println("很遗憾。没找到你要找的数值");
}else {
System.out.println("要查找的是21，第一次出现的索引是："+index);
}
}
/**
* 返回数组中某个元素第一次出现的索引位置
* @param array 数组
* @param value 要查找的元素
* @return 第一次出现的该元素的索引位置
*/
public static int indexValue(int[] array, int value){
for (int i=0;i<array.length;i++){
if (value == array[i]){
return i;
}
}
return -1;
}
}举个例子：
package com.goshawk.array;
/**
* 数组的使用
* 1、通过下标来找到数组中某一个具体的元素，下标从0开始，最多只能达到数组的长度-1
* 2、数组的长度
* 数组内元素的个数；注意数组的长度是不可变的。
* 任何一个数组都有一个length属性
* 3、数组的遍历：将数组中每个元素都过一遍；
* 通过循环语句来遍历数组，循环的次数就是数组的长度，通过把循环变量作为数组的下标来遍历数组
*
* */
public class demo2 {
public static void main(String[] args){
// 创建一个存放a,b,c三个字符串元素的数组
String[] arr1 = new String [] {"a","b", "c"};
System.out.println(arr1[0]);
// 获取数组的长度
int len = arr1.length;
System.out.println(len);
// 遍历数组
for (int i=0;i<arr1.length;i++){
System.out.println(arr1[i]);
}
}
}举个例子：
package com.goshawk.array;
import java.util.Scanner;
/**
* 数组的创建和使用demo
* 键盘录入5个学生的年龄，查找年龄为15的学生的录入位置（序号）；
* */
public class demo3 {
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
int[] ages = new int[5];
for (int i=0;i<5;i++){
System.out.println("请输入第"+(i+1)+"个学生的年龄");
int age = scanner.nextInt();
// 存入数组中
ages[i] = age;
}
// 查找年龄为15的学生的录入位置（序号）
for (int i=0;i<ages.length;i++){
if (15 == ages[i]){
System.out.println("找到年龄为15的学生位置："+(i+1));
return;
}
}
System.out.println("没有找到年龄为15的学生位置");
}
}6、数组常见的问题
1、ArrayIndexOutOfBoundsException
- 数组角标越界异常
- 访问了不存在的角标
2、NullPointerException
- 空指针异常
- 栈中的数组变量没有指向堆内存中的数组实体
3、演示
package com.goshawk.array;
/**
* 数组操作常见的问题
*
* */
public class demo4 {
public static void main(String[] args) {
// ArrayIndexOutOfBoundsException
int[] arr1 = new int[] {1,2,3};
System.out.println(arr1[3]);
}
}7、数组的参数传递
1、简单的通过变量来实现两数的互换
package com.goshawk.array;
/**
* 数组的参数传递
* 实现两个数的互换
*
*
* */
public class demo5 {
public static void main(String[] args) {
// 1、简单的通过变了来实现两数的互换
int a = 10;
int b = 20;
int swap = b;
b = a;
a = swap;
}
}2、通过数组来实现两值的互换
package com.goshawk.array;
/**
* 数组的参数传递
* 实现两个数的互换
*
*
* */
public class demo5 {
public static void main(String[] args) {
// 2、通过数组来实现两值的互换
int a1 = 10;
int b1 = 20;
int[] arr = {a1, b1};
swap_(arr[0], arr[1]);
// 遍历数组并打印
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
public static void swap_(int a, int b){
int swap = b;
b = a;
a = swap;
}
}上述代码分析如下：
package com.goshawk.array;
/**
* 数组的参数传递
* 实现两个数的互换
* 关于方法的参数传递：
* 如果是基本数据类型，传的是值；
* 如果是引用数据类型，传的是地址值；
*
*
* */
public class demo5 {
public static void main(String[] args) {
// 2、通过数组来实现两值的互换
int a1 = 10;
int b1 = 20;
int[] arr = {a1, b1};
swapArray(arr);
// 遍历数组并打印
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
public static void swapArray(int[] array){
int swap = array[0];
array[0] = array[1];
array[1] = swap;
}
}上述代码分析如下图：
8、二分查找
8.1 定义
- 使用折半的形式，一次性剔除一般的无效元素，提高了查找的效率
- 使用二分查找的数组必须是有序的
8.2 演示
package com.goshawk.array;
import java.util.Scanner;
/**
* 二分查找
* 要查找的数和中间位置上的数做一次比较，如果等于即找到；如果比中间位置上的数大，那么该数一定在中间位置的右边，反之在左边；
* mid = (start + end)/2 mid==>中间值
* 反复上述循环：start>end，就表示没有找到，即循环结束
* */
public class binarySearch {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6,7,8,12,23,45};
// 定义有效元素开始的角标
int start = 0;
// 定义有效元素结束的角标
int end = arr.length-1;
// 要查找的数据
Scanner scanner = new Scanner(System.in);
System.out.println("请输入要查找的值：");
int input = scanner.nextInt();
while (start<=end){
// 计算中间的角标
int mid = (start + end) / 2;
if (input == arr[mid]){
System.out.println("找到了，位置在："+mid);
return;
}
if (input>arr[mid]){
// 确定新的查找范围： start： 中间位置+1，end不变
// 如果中间角标位上的值小于要查找的值，说明中间的值都不可能匹配上；
start = mid + 1;
}else {
end = mid -1;
}
}
System.out.println("很遗憾，没有找到数值："+input);
}
}9、Arrays工具类
9.1 定义
- 主要用于对数组进行排序、查找、填充、比较等操作
9.2 演示
package com.goshawk.array;
import java.util.Arrays;
/**
* Arrays工具类：直接可以使用的类
* */
public class arraysUtil {
public static void main(String[] args) {
int[] arr = {1,55,12,34,12,13,5,8,14};
// Arrays数组的排序
Arrays.sort(arr);
// 把数组变成字符欻的方法
String str = Arrays.toString(arr);
System.out.println(str);
// 查找 注意二分查找必须在有序的数组执行
int index = Arrays.binarySearch(arr, 12);
System.out.println("找到数据的位置：" + index);
}
}10、可变参数
10.1 定义
- 在方法声明上使用…表示多个相同类型的参数
10.2 注意事项
- 在实际调用中，我们已经在方法内传入多个实参，虚拟机会自动帮我们填充到可变参数上，形成一个数组
10.3 示例
package com.goshawk.array;
/**
* 可变参数
* void method(数据类型... 数组名){}
* 注意事项：
* 1> 在方法的形参中使用
* 2> 可变参数只能是形参列表中的最后一个参数
* 3> 设计重载方法时不要出现重复
* */
public class varParam {
public static void main(String[] args) {
method(10, 20);
method1(10,20,30);
method1(10);
method2("a", "b");
}
public static void method(int... values){
for (int i = 0; i< values.length;i++){
System.out.println(values[i]+"");
}
System.out.println();
}
public static void method1(int a, int... values){
for (int i = 0; i< values.length;i++){
System.out.println(values[i]+"");
}
System.out.println();
}
// 这里注意，与method方法重复了
// public static void method2(int a, int b, int... values){
// for (int i = 0; i< values.length;i++){
// System.out.println(values[i]+"");
// }
// System.out.println();
// }
public static void method3(String... strs){
for(int i=0;i<strs.length;i++){
System.out.println(strs[i]);
}
}
}11、二维数组（多维数组）
11.1 演示
package com.goshawk.array;
/**
* 二维数组（多维数组）
* 1、定义
* 外维数组中的元素，自身就是一个数组；
* 举个例子：创建一个班级，描述班级的每位同学
* 2、创建
* 使用两对[] 来创建
* 3、使用
* 1> 存数据和取数据>>关键是如何定位你要找的数据
* 2> 查数据：遍历（使用嵌套循环，如果是二维，就两层循环；如果是三维，就三层循环；
* 外维控制行数，内维控制列数
* 4、二维数组的使用细节
* 1> 创建二维数组
* 1.1> 静态初始化
* 1.2> 动态初始化
* 动态初始化需要指明几个维度的数组容量，关键是容量可以区别对待；
* 2>
*
* */
public class multidimensional {
public static void main(String[] args) {
// 静态初始化
int[][] arrs = new int[][]{{1, 2, 3}, {3, 4}, {5, 6, 7}};
int[][] arrs1 = {{1, 2, 3}, {3, 4}, {5, 6, 7}};
// 动态初始化
// 动态初始化一，第二维真正存放数据，此时存放的是int类型的默认值0
int[][] arrs2 = new int[3][4];
// 动态初始化二，
int[][] arrs3 = new int[3][];
arrs3[0] = new int[4];
arrs3[1] = new int[]{5, 6, 7};
arrs3[2] = new int[]{8, 9, 10};
// int[][] arrs4 = new int[][4]; 这种方式是不可行的，不知道外维需要开辟多少空间
ergodic(arrs3);
}
public static void ergodic(int[][] arrs){
// 遍历多维数组
for (int i = 0;i<arrs.length;i++){
for (int k = 0;k<arrs[i].length;k++){
System.out.println(arrs[i][k]);
}
// 换行
System.out.println();
}
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
