IT数码 购物 网址 头条 软件 日历 阅读 图书馆
TxT小说阅读器
↓语音阅读,小说下载,古典文学↓
图片批量下载器
↓批量下载图片,美女图库↓
图片自动播放器
↓图片自动播放器↓
一键清除垃圾
↓轻轻一点,清除系统垃圾↓
开发: C++知识库 Java知识库 JavaScript Python PHP知识库 人工智能 区块链 大数据 移动开发 嵌入式 开发工具 数据结构与算法 开发测试 游戏开发 网络协议 系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑 笔记本 显卡 显示器 固态硬盘 硬盘 耳机 手机 iphone vivo oppo 小米 华为 单反 装机 图拉丁
 
   -> 数据结构与算法 -> 【Java】浅谈Java数组的定义与使用 -> 正文阅读

[数据结构与算法]【Java】浅谈Java数组的定义与使用

在这里插入图片描述

💜写在前边💜

前言
本篇博客主要讲述了以下几点问题


1. 理解数组基本概念
2. 掌握数组的基本用法
3. 数组与方法互操作
4. 熟练掌握数组相关的常见问题和代码~

🎄数组基本用法

🎅什么是数组

【数组】本质上就是让我们能 “批量” 创建相同类型的变量.

例如:
如果需要表示两个数据, 那么直接创建两个变量即可 int a; int b
如果需要表示五个数据, 那么可以创建五个变量 int a1; int a2; int a3; int a4; int a5;
但是如果需要表示一万个数据, 那么就不能创建一万个变量了. 这时候就需要使用数组, 帮我们批量创建.

注意事项: 在 Java 中, 数组中包含的变量必须是 相同类型.

🎅创建数组

基本语法

动态初始化
数据类型[] 数组名称 = new 数据类型 [ ] { 初始化数据 };

如果在创建的同时不初始化数组则必须指定其大小
数据类型[] 数组名称 = new 数据类型 [元素个数] ;

静态初始化
数据类型[] 数组名称 = { 初始化数据 };

代码示例

int[] arr = new int[]{1, 2, 3}; 
int[] arr = new int[3]int[] arr = {1, 2, 3};

注意事项: 静态初始化的时候, 数组元素个数和初始化数据的格式是一致的.

其实数组也可以写成
int arr[] = {1, 2, 3};

这样就和 C 语言更相似了. 但是更推荐写成 int[ ] arr 的形式. int和 [ ] 是一个整体.

🎅数组的使用

代码示例: 获取长度 & 访问元素

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

注意事项
1. 使用 arr.length 能够获取到数组的长度【. 】这个操作为成员访问操作符. 后面在面向对象中会经常用到.
2. 使用 [ ] 按下标取数组元素. 需要注意, 下标从 0 开始计数
3. 使用 [ ] 操作既能读取数据, 也能修改数据.
4. 下标访问操作不能超出有效范围 [0, length - 1] , 如果超出有效范围, 会出现下标越界异常

代码示例: 下标越界

int[] arr = {1, 2, 3}; 
System.out.println(arr[100]); 
// 执行结果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100 
at Test.main(Test.java:4)

抛出了 java.lang.ArrayIndexOutOfBoundsException 异常. 使用数组一定要下标谨防越界.

代码示例: 遍历数组
所谓 “遍历” 是指将数组中的所有元素都访问一遍, 不重不漏. 通常需要搭配循环语句.

int[] arr = {1, 2, 3}; 
for (int i = 0; i < arr.length; i++) { 
   System.out.println(arr[i]); 
}
// 执行结果 
1
2
3

代码示例: 使用 for-each 遍历数组

int[] arr = {1, 2, 3};
for (int x : arr) { 
   System.out.println(x);
}
// 执行结果 
1
2
3

for-each 是 for 循环的另外一种使用方式. 能够更方便的完成对数组的遍历. 可以避免循环条件和更新语句写错.

🎄数组作为方法的参数

🎅基本用法

代码示例: 打印数组内容

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); 
      } 
}
// 执行结果 
1
2
3

在这个代码中

  • int[] a 是函数的形参, int[] arr 是函数实参.
  • 如果需要获取到数组长度, 同样可以使用 a.length

🎅理解引用类型(敲黑板!!!)

我们知道Java是一门纯面向对象的语言,我们在使用Java语言编程时,到处都在使用对象(《Thinking in Java》一书中提到"Everything is object")
程序在运行时,对象是在堆内存(heap)中存储的,那么我们如何来访问对象呢?在C/C++中是通过指针,而Java中是通过引用,引用储存了对象在堆内存(heap)中的地址。

这里我们要先从内存开始说起.
如何理解内存?
内存就是指我们熟悉的 “内存”. 内存可以直观的理解成一个宿舍楼. 有一个长长的大走廊, 上面有很多房间.每个房间的大小是 1 Byte (如果计算机有 8G 内存, 则相当于有 80亿 个这样的房间).
每个房间上面又有一个门牌号, 这个门牌号就称为 地址

那么啥又是引用?
什么是引用?
引用相当于一个 “别名”, 也可以理解成一个指针.
创建一个引用只是相当于创建了一个很小的变量, 这个变量保存了一个整数, 这个整数表示内存中的一个地址.

请仔细看下图(引用其实和指针很像)
在这里插入图片描述

引用与指针区别
(1)类型:
引用其值为地址的数据元素,Java封装了的地址,可以转换成字符串查看,长度也可以不必担心。
C指针是一个装地址的变量,长度一般是计算机字长,可以认为是个int。
(2)所占内存:
引用声明时没有实体,不占空间。
C指针如果声明之后会用到才会赋值。如果用不到不会分配内存。
(3)类型转换:
引用的类型转换,也可能不成功,运行时抛异常或者编译就不能通过。
C指针指示个内存地址,指向内存,对程序来说还都是一个地址,但可能所指的地址不是程序想要的。
(4)初始值:
引用初始值为java关键字null。
C指针是int,如不初始化指针,那它的值就不是固定的了,这很危险。
(5)计算:
引用不可以计算。
C指针是int,他可以计算,如++或–,所以经常用指针来代替数组下标。
(6)内存泄露:
Java引用不会产生内存泄露。
C指针是很容易产生内存泄露的,所以程序员要小心使用,及时回收。

🎅认识null

null 在 Java 中表示 “空引用” , 也就是一个无效的引用.
null 的作用类似于 C 语言中的 NULL (空指针), 都是表示一个无效的内存位置. 因此不能对这个内存进行任何读写操作. 一旦尝试读写, 就会抛出 NullPointerException.

注意: Java 中并没有约定 null 和 0 号地址的内存有任何关联.

🎅 初时JVM内存区域划分(敲黑板!!!)

在这里插入图片描述

  • 程序计数器 (PC Register): 只是一个很小的空间, 保存下一条执行的指令的地址.
  • 虚拟机栈(JVM Stack): 重点是存储局部变量表(当然也有其他信息). 我们刚才创建的 int[] arr 这样的存储地址的引用就是在这里保存.
  • 本地方法栈(Native Method Stack): 本地方法栈与虚拟机栈的作用类似. 只不过保存的内容是Native方法的局部变量. 在有些版本的 JVM 实现中(例如HotSpot), 本地方法栈和虚拟机栈是一起的.
  • 堆(Heap): JVM所管理的最大内存区域. 使用 new 创建的对象都是在堆上保存 (例如前面的 new int[]{1, 2, 3} )
  • 方法区(Method Area): 用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据. 方法编译出的的字节码就是保存在这个区域.
  • 运行时常量池(Runtime Constant Pool): 是方法区的一部分, 存放字面量(字符串常量)与符号引用. (注意 从 JDK1.7 开始, 运行时常量池在堆上).

Native 本地方法:
JVM 是一个基于 C++ 实现的程序. 在 Java 程序执行过程中, 本质上也需要调用 C++ 提供的一些函数进行和操作系统底层进行一些交互. 因此在 Java 开发中也会调用到一些 C++ 实现的函数.
这里的 Native 方法就是指这些 C++ 实现的, 再由 Java 来调用的函数.

我们发现, 在上面的图中, 程序计数器, 虚拟机栈, 本地方法栈被很多个基佬紫的, 名叫 Thread(线程) 的方框圈起来了,并且存在很多份. 而 堆, 方法区, 运行时常量池, 只有一份.

重点理解 虚拟机栈 和 堆.
在这里插入图片描述

  • 局部变量和引用保存在栈上, new 出的对象保存在堆上.
  • 堆的空间非常大, 栈的空间比较小.
  • 堆是整个 JVM 共享一个, 而栈每个线程具有一份(一个 Java 程序中可能存在多个栈).

🎅数组作为方法的返回值

代码示例: 写一个方法, 将数组中的每个元素都 * 2

// 直接修改原数组 
class Test { 
 public static void main(String[] args) {
  int[] arr = {1, 2, 3}; 
   transform(arr);
   printArray(arr); 
 }

 public static void printArray(int[] arr) { 
   for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    } 
 }

 public static void transform(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        arr[i] = arr[i] * 2; 
    }
 }
}

这个代码固然可行, 但是破坏了原有数组. 有时候我们不希望破坏原数组, 就需要在方法内部创建一个新的数组, 并由方法返回出来.

// 返回一个新的数组 
class Test { 
  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.println(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; 
     }
}

这样的话就不会破坏原有数组了.
另外由于数组是引用类型, 返回的时候只是将这个数组的首地址返回给函数调用者, 没有拷贝数组内容, 从而比较高效.

🎄数组练习

🎅二分查找

public class 二分查找 {
    public static int binarySearch(int []arr, int target) {
        int left = 0;
        int right = arr.length-1;
        while (left <= right) {
            int mid=(left+right)/2;
            if (arr[mid]<target){
                left = mid+1;
            }
            else if (arr[mid]>target){
                right = mid-1;
            }
            else
                return mid+1;
        }
        System.out.println("没有这个数");
        return -1;
    }

    public static void main(String[] args) {
        int target = 8;
        int arr[] = {1,2,3,4,5,6,7,8};
        System.out.println("要查找的数是第"+binarySearch(arr,target)+"个");
    }
}

🎅冒泡排序

import java.util.Arrays;

public class 冒泡排序 {
    public static int[] bubble(int arr[]) {
        for (int i = 0; i < arr.length-1; i++){
            for (int j = 0; j < arr.length-1-i; j++){
                if (arr[j]>arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        return arr;
    }
    public static void main(String[] args) {
        int arr [] = {1,1,4,7,2,4,6,9,2,6,5};
        System.out.println(Arrays.toString(bubble(arr)));
    }
}

🎅判断数组是否有序

public class 判断数组是否有序 {
    public static boolean judgment(int arr[]) {
        for (int i = 0; (i+1)<arr.length; i++){
            if (arr[i]>arr[i+1])
                return false;
        }
        return true;
    }
    public static void main(String[] args) {
        int arr1[] = {1,2,3,4};
        int arr2[] = {2,1,4,3};
        if (judgment(arr1))
            System.out.println("arr1"+"有序");
        else
            System.out.println("arr1"+"无序");
        if (judgment(arr2))
            System.out.println("arr2"+"有序");
        else
            System.out.println("arr2"+"无序");
    }
}

🎅只出现一次的元素

public class 只出现一次的数字 {
    public static int Only(int arr[]) {
         int tmp = 0;
         for (int i = 0; i < arr.length; i++) {
             /*
                涉及到异或运算,对于这道题,你应该了解异或有什么样性质
                1. 任何数与0异或,都为原数
                2. 与本身自己异或,则为0
                3. 交换律和结合律(解决这道题的关键),你把整个循环的计算写成数学运算过程,你会发现要利用交换律和结合律,可以实现这道题的要求
                 */
             tmp ^= arr[i];
         }
         return tmp;
    }
    public static void main(String[] args) {
        int arr[] = {2,0,0,1,1,2,6};
        System.out.println(Only(arr));
    }
}

🎅改变原有数组的值

import java.util.*;

public class 改变原有数组元素的值 {
    public static int[] transform(int[]array2) {
        for (int i = 0; i < array2.length; i++) {
            array2[i] *=2;
        }
        return array2;
    }

    public static void main(String[] args) {
        int [] array1 = {1,2,3,};
        System.out.println(Arrays.toString(array1));

        System.out.println("×2改变之后数组="+ Arrays.toString(transform(array1)));
    }
}

🎅数组所以元素之和

public class 数组所有元素之和 {
    public static float sum(int[]array) {
        int sum = 0;
        for (int i = 0; i < array.length; i++)
            sum += array[i];

        return sum;
    }

    public static void main(String[] args) {
        int [] array = {1,2,3,};
        for (int i = 0; i < array.length; i++)
            System.out.print(array[i]+" ");
        System.out.println();
        System.out.println("所以元素之和="+sum(array));
    }
}

🎅 数组拷贝

import java.util.Arrays;
public class 数组的拷贝 {
    public static  int[] copyOf(int []arr1) {
        int []arr2;
        arr2 = new int[arr1.length];
        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }
        return arr2;
    }
    public static void main(String[] args) {
        int []arr1={1,2,3,4,5};
        System.out.println("arr1="+Arrays.toString(arr1));
        System.out.println("arr2="+Arrays.toString(copyOf(arr1)));
    }
}

🎅数组转字符串

public class 数组转字符串 {
    public static void printString(int[]arr) {
        String a ="[";
        for (int i = 0; i < arr.length; i++){
            a+=arr[i];
        if(i != arr.length -1)
            a += ",";
        }
        a+="]";
        System.out.println(a);
    }

    public static void main(String[] args) {
        int arr[] = {1,2,3,4,5};
        printString(arr);
    }
}

🎅求数组元素平均值

public class 求数组的平均值 {
    public static float avg(int[]array) {
        float avg;
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        avg = sum / array.length;

        return avg;
    }

    public static void main(String[] args) {
        int [] array = {1,2,3,};
        for (int i = 0; i < array.length; i++)
        System.out.print(array[i]+" ");
        System.out.println();
        System.out.println("平均数="+avg(array));
    }
}

🎄二维数组

二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组.

基本语法

数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };

代码示例
二维数组的用法和一维数组并没有明显差别, 因此我们不再赘述.
不过要注意一个点,C里每行数组会跟列对齐,会自动补0,java里不会自动补,如下代码

import java.util.Arrays;

public class test {
   public static void main(String[] args) {
       int[][] arr;
       arr = new int[][]{ {1, 2, 3}, {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.printf("%d\t", arr[row][col]);
           }
           System.out.println("");
       }// 执行结果
       // 1  2  3
       // 5  6  7  8
       // 9 10 11 12
   }
}

🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙
????????原创不易,如有错误,欢迎评论区留言指出,感激不尽?
???????????????????????如果觉得内容不错,给个三连不过分吧~ ?????? ?
????????????????????????????????????看到会回访~ ??????????????? ???????????????????? ?
🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙🌙

  数据结构与算法 最新文章
【力扣106】 从中序与后续遍历序列构造二叉
leetcode 322 零钱兑换
哈希的应用:海量数据处理
动态规划|最短Hamilton路径
华为机试_HJ41 称砝码【中等】【menset】【
【C与数据结构】——寒假提高每日练习Day1
基础算法——堆排序
2023王道数据结构线性表--单链表课后习题部
LeetCode 之 反转链表的一部分
【题解】lintcode必刷50题<有效的括号序列
上一篇文章      下一篇文章      查看所有文章
加:2021-10-30 12:45:07  更:2021-10-30 12:45:14 
 
开发: C++知识库 Java知识库 JavaScript Python PHP知识库 人工智能 区块链 大数据 移动开发 嵌入式 开发工具 数据结构与算法 开发测试 游戏开发 网络协议 系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑 笔记本 显卡 显示器 固态硬盘 硬盘 耳机 手机 iphone vivo oppo 小米 华为 单反 装机 图拉丁

360图书馆 购物 三丰科技 阅读网 日历 万年历 2024年3日历 -2024/3/28 22:44:08-

图片自动播放器
↓图片自动播放器↓
TxT小说阅读器
↓语音阅读,小说下载,古典文学↓
一键清除垃圾
↓轻轻一点,清除系统垃圾↓
图片批量下载器
↓批量下载图片,美女图库↓
  网站联系: qq:121756557 email:121756557@qq.com  IT数码