内容介绍
1 数组的基本使用
1.1 什么是数组
c语言中我们学过数组就是存放一组相同类型数据的集合。
注意: 在 Java 中, 数组中包含的变量必须是相同类型.
1.2 创建数组
java中有三种创建数组的方法：
⭐️1：
// 动态初始化
数据类型[] 数组名称 = new 数据类型 [] { 初始化数据 };
⭐️2:
// 静态初始化
数据类型[] 数组名称 = { 初始化数据 };
⭐️3:
数据类型[] 数组名称 = new 数据类型[数组长度]
注意：该初始化方法会将数组初始化为0。
代码示例：
1： int[] arr = new int[]{1, 2, 3};
2： int[] arr = {1, 2, 3};
3： int[] arr = new int[5];
1.3 数组的使用
💫举个栗子：
public class TestDemo {
public static void main(String[] args) {
int[] arr = {1, 2, 3}; // 获取数组长度 System.out.println("length: " + arr.length); // 执行结果: 3
// 访问数组中的元素
System.out.println(arr[1]); // 执行结果: 2
System.out.println(arr[0]); // 执行结果: 1
arr[2] = 100;
System.out.println(arr[2]); // 执行结果: 100
}
}
注意：数组的使用过程中一定不能越界，在Java中一旦越界就会直接报错。
报错示例：
🐾在数组遍历访问的时候还可以用for-each循环来实现
public class TestDemo {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
for (int x : arr) {
System.out.println(x);
}
}
}
结果：
2 数组作为方法的参数
2.1 基本用法
💫举个栗子：
public class TestDemo {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
printArray(arr);
}
public static void printArray(int[] a) {
for (int x : a) {
System.out.println(x);
}
}
}
注意
int[] a是函数的形参,int[] arr是函数实参.- 如果需要获取到数组长度, 同样可以使用
a.length在Java中函数定义在main函数前后都没关系
2.2 引用类型介绍
💫举个栗子：
public class TestDemo {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
func(arr);
System.out.println("arr[0] = " + arr[0]);
}
public static void func(int[] a) {
a[0] = 10;
System.out.println("a[0] = " + a[0]);
}
}
结果：
这里我们发现在函数内部修改数组元素的内容元素外面数组的内容也随之改变，这个时候arr就代表的是一个
引用类型
🔥什么是引用？
引用相当于一个 “别名”, 也可以理解成一个
指针.
创建一个引用只是相当于创建了一个很小的变量, 这个变量保存了一个整数, 这个整数表示内存中的一个地址.
2.3 null介绍
null 在 Java 中表示
"空引用", 也就是一个无效的引用
注意：要跟c语言区分开来，C语言是大写，Java中是小写。
null 的作用类似于 C 语言中的 NULL (空指针), 都是表示一个无效的内存位置. 因此不能对这个内存进行任何读写操作. 一旦尝试读写, 就会抛出 NullPointerException错误。
注意：Java中并没有约定 null 和 0 号地址的内存有任何关联
2.4 初识JVM内存区
- 局部变量和引用保存在栈上, new 出的对象保存在堆上.
- 堆的空间非常大, 栈的空间比较小.
堆是整个 JVM 共享一个,而栈每个线程具有一份(一个 Java 程序中可能存在多个栈)
🐾:小知识
Native 方法:
JVM 是一个基于 C++ 实现的程序. 在 Java 程序执行过程中, 本质上也需要调用 C++ 提供的一些函数进行和操作系统底层进行一些交互. 因此在 Java 开发中也会调用到一些 C++ 实现的函数.这里的 Native 方法就是指这些 C++ 实现的, 再由 Java 来调用的函数.
3 数组作为方法的返回值
代码示例: 写一个方法, 将数组中的每个元素都 * 2
public class TestOne {
public static void main(String[] args) {
int[] arr = {1, 2, 3};
int[] output = transform(arr);
printArray(output);
}
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
}
public static int[] transform(int[] arr) {
int[] ret = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
ret[i] = arr[i] * 2;
}return ret;
}
}
结果：
4 数组例题
4.1 数组转字符串
public class TestOne {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6};
String newArr = Arrays.toString(arr);
System.out.println(newArr);
}
结果：
注意：这里要使用
Arrays.toString需要引入import java.util.Arrays;
⭐️自己实现toString方法：
public class TestOne {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6};
System.out.println(toString(arr));
}
public static String toString(int[] arr) {
String ret = "[";
for (int i = 0; i < arr.length; i++) {
// 借助 String += 进行拼接字符串
ret += arr[i];
// 除了最后一个元素之外, 其他元素后面都要加上 ", "
if (i != arr.length - 1) {
ret += ", ";
}
}
ret += "]";
return ret;
}
4.2 数组拷贝
public class TestOne {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6};
int[] newArr = Arrays.copyOf(arr, arr.length);
System.out.println("newArr: " + Arrays.toString(newArr));
//拷贝某个范围
newArr = Arrays.copyOfRange(arr, 2, 4);
System.out.println("newArr2: " + Arrays.toString(newArr));
}
注意事项:
相比于 newArr = arr 这样的赋值,copyOf 是将数组进行了浅拷贝, 即又创建了一个数组对象,拷贝原有数组中的所有元素到新数组中。 因此, 修改原数组, 不会影响到新数组。
⭐️自己实现拷贝方法：
public static int[] copyOf(int[] arr) {
int[] ret = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
ret[i] = arr[i];
}
return ret;
}
4.3 找数组中的最大元素
public static int findMax(int[] arr){
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i]>max){
max = arr[i];
}
}
return max;
}
public static void main(String[] args) {
int[] arr = new int[]{1,2,3,4};
int ret = findMax(arr);
System.out.println("最大值是： "+ret);
}
结果：
4.4 求数组元素的平均值
public class TestDemo {
public static double countAverge(int[] array){
double sum = 0;
for (int i = 0; i < array.length; i++) {
sum += array[i];
}
return sum/ array.length;
}
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
double ret = countAverge(array);
System.out.println(ret);
}
}
4.5 查找数组中指定的元素（顺序查找）
public class TestDemo {
public static int findArr(int[] arr, int n){
for (int i = 0; i < arr.length; i++) {
if (arr[i] == n){
return i;
}
}
return -1;
}
public static void main(String[] args) {
int[] arr = new int[]{1,2,3,4};
Scanner scanner = new Scanner(System.in);
int toFind = scanner.nextInt();
int pos = findArr(arr,toFind);
if (pos>=0){
System.out.println("找到了！ 下标为： "+pos);
}else {
System.out.println("没有该元素！");
}
}
}
结果：
4.6 查找数组中指定的元素（二分查找）
public static int binerFind(int[] array, int num){
int left = 0;
int right = array.length;
int mid = 0;
while (left<=right){
mid = (left+right) / 2;
if (array[mid] > num){
right--;
}else if(array[mid] < num){
left++;
}else {
return mid;
}
}
return -1;
}
public static void main(String[] args) {
int[] array = {1,2,4,8,6};
int ret = binerFind(array,8);
if (ret>=0){
System.out.println("找到了！ 下标为： "+ret);
}else {
System.out.println("没找到！");
}
}
4.7 检查数组的有序性
public static boolean judgeSort(int[] array){
boolean flag = true;
for (int i = 0; i < array.length-1; i++) {
if (array[i]>array[i+1]){
flag = false;
}
}
return flag;
}
public static void main(String[] args) {
int[] array = {1,2,4,6,8};
boolean ret =judgeSort(array);
if (ret == true){
System.out.println("有序！");
}else {
System.out.println("无序！");
}
}
4.8 数组冒泡排序
public class TestDemo {
public static void bubbleSort(int[] array){
int tep = 0;
for (int i = 0; i < array.length-1; i++) {
boolean flag = false;
for (int j = 0; j < array.length-1-i; j++) {
if (array[j+1]<array[j]){
tep = array[j];
array[j] = array[j+1];
array[j+1] = tep;
flag = true;
}
}
if (flag == false){
return;
}
}
}
public static void main(String[] args) {
int[] array = {1,2,4,8,6};
bubbleSort(array);
System.out.println(Arrays.toString(array));
}
}
4.9 数组逆序
public static int[] reverseArr(int[] arr){
int[] reverse = new int[arr.length];
for (int i = 0; i < arr.length ; i++) {
reverse[i] = arr[arr.length-1-i];
}
return reverse;
}
public static void main(String[] args) {
int[] arr = new int[]{1,2,3,4};
int[] ret = reverseArr(arr);
System.out.println(Arrays.toString(ret));
}
结果：
4.10 数组数字排列
💫给定一个整型数组, 将所有的偶数放在前半部分, 将所有的奇数放在数组后半部分
public static int[] arrgeArr(int[] arr){
int left = 0;
int right = arr.length-1;
int tep = 0;
while (left<right){
while (left<right && arr[left]%2 == 0){
left++;
}
while (left<right && arr[right]%2 == 1){
right--;
}
tep = arr[left];
arr[left] = arr[right];
arr[right] = tep;
}
return arr;
}
public static void main(String[] args) {
int[] arr = new int[]{1,2,3,4,5,6};
int[] ret = arrgeArr(arr);
System.out.println(Arrays.toString(arr));
}
结果：
5 二维数组
二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组.
基本语法:
数据类型[][] 数组名称 =
new数据类型 [行数][列数] { 初始化数据 };
🔑代码示例：二维数组的几种打印方式
public class TestDemo {
public static void main(String[] args) {
int[][] arr = { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12} };
//两层for循环打印
for (int row = 0; row < arr.length; row++) {
for (int col = 0; col < arr[row].length; col++) {
System.out.print(arr[row][col]+" ");
}
System.out.println("");
}
System.out.println("--------------");
//for each循环打印，右边是数组，左边是数组元素的类型
for (int[] ret:arr) {
for (int x:ret) {
System.out.print(x+" ");
}
System.out.println();
}
System.out.println("--------------");
//用Java库里面的函数直接打印
System.out.println(Arrays.deepToString(arr));
}
}
运行结果：
我们来看一段代码：
public class TestDemo {
public static void main(String[] args) {
int[][] arr = { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12} };
for (int row = 0; row < arr.length; row++) {
for (int col = 0; col < arr[row].length; col++) {
System.out.print(arr[row][col]+" ");
}
System.out.println("");
}
System.out.print("二维数组的长度：");
System.out.println(arr.length);
}
}
这里我们看到二维数组的长度为3，这是因为
在Java中数组其实就是一个特殊的一维数组，数组里面每一个元素放着引用来指向一个一位数组。
图解：
作者水平有限，若文章有任何问题欢迎私聊或留言，希望和大家一起学习进步！！！
创作不易，再次希望大家👍支持下，谢谢大家🙏
扫一扫
90
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
