推荐一个网站给想要了解或者学习人工智能知识的读者,这个网站里内容讲解通俗易懂且风趣幽默,对我帮助很大。我想与大家分享这个宝藏网站,请点击下方链接查看。 https://www.captainbed.cn/f1
Java数组是用于存储固定大小、相同类型数据序列的数据结构,可通过索引
数组是一种数据结构,用于存储相同类型的多个元素。它可以在内存中连续地存储多个元素,并通过索引访问每个元素。数组通常具有固定的大小,一旦创建后,大小不能改变。每个元素在数组中都有一个唯一的索引,可以使用索引来获取或修改特定位置的元素。数组可以用于存储整数、浮点数、字符和其他任意类型的数据。
数组本质上就是让我们能 “批量” 创建相同类型的变量.
在 Java 中, 数组中包含的变量必须是 相同类型.
// 动态初始化
数据类型[] 数组名称 = new 数据类型 [] { 初始化数据 };
// 静态初始化
数据类型[] 数组名称 = { 初始化数据 };
int[] arr = new int[]{1, 2, 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
arr.length
能够获取到数组的长度. . 这个操作为成员访问操作符. 在面向对象中会经常用到.[ ]
按下标取数组元素. 需要注意, 下标从 0 开始计数[ ]
操作既能读取数据, 也能修改数据.[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
在Java中,Math类提供了许多数学函数。下面是一些常用的Math
函数:
abs()
:返回一个数的绝对值。int num = -5;
int absNum = Math.abs(num); // absNum的值为5
ceil()
:返回大于或等于给定参数的最小整数。double num = 4.3;
double ceilNum = Math.ceil(num); // ceilNum的值为5.0
floor()
:返回小于或等于给定参数的最大整数。double num = 4.9;
double floorNum = Math.floor(num); // floorNum的值为4.0
round()
:将一个浮点数舍入为最接近的整数。double num = 4.6;
long roundNum = Math.round(num); // roundNum的值为5
max()
:返回两个参数中的最大值。int num1 = 5;
int num2 = 8;
int maxNum = Math.max(num1, num2); // maxNum的值为8
min()
:返回两个参数中的最小值。int num1 = 5;
int num2 = 8;
int minNum = Math.min(num1, num2); // minNum的值为5
pow()
:返回一个数的指定次幂。double base = 2.0;
double exponent = 3.0;
double result = Math.pow(base, exponent); // result的值为8.0
这只是Math
类中的几个函数,还有很多其他可以进行数学计算的函数可供使用。要使用Math
类中的函数,需要导入java.lang.Math
包。
在Java中,Math类还提供了一个非常有用的函数:Math.random()
。这个函数可以生成一个0到1之间的随机浮点数。
要使用Math.random()
函数,可以像下面这样使用它:
double randomNum = Math.random();
上述代码将生成一个0到1之间的随机浮点数,并将其赋值给randomNum
变量。
如果需要生成一个指定范围内的随机数,可以通过以下方法实现:
int randomInt = (int) (Math.random() * N);
例如,要生成0到10之间(不包括10)的随机整数,可以使用上述代码。
int randomInt = (int) (Math.random() * (B - A + 1)) + A;
例如,要生成1到100之间(包括1和100)的随机整数,可以使用上述代码。
需要注意的是,Math.random()
函数生成的随机数是一个伪随机数,在每次程序运行时都会生成一个不同的随机数序列。如果需要更复杂的随机数生成功能,可以使用Java中的Random
类。
在Java中,Random
类是一个用于生成伪随机数的工具类。它提供了多种方法来生成不同类型的随机数。
要使用Random
类,首先需要创建一个Random
对象,然后可以使用其提供的方法来生成随机数。以下是Random
类的一些常用方法:
boolean
值:Random random = new Random();
boolean randomBool = random.nextBoolean();
Random random = new Random();
int randomInt = random.nextInt(); // 生成整数的范围是所有可能的int值
如果需要生成一个指定范围内的随机整数,可以使用nextInt
方法的重载版本:
Random random = new Random();
int randomInt = random.nextInt(N); // 生成0到N-1之间的随机整数
Random random = new Random();
double randomDouble = random.nextDouble(); // 生成0到1之间的随机浮点数
如果需要生成一个指定范围内的随机浮点数,可以使用nextDouble
方法的重载版本:
Random random = new Random();
double randomDouble = random.nextDouble() * (B - A) + A; // 生成A到B之间的随机浮点数
Random
类还提供了其他一些方法,用于生成随机长整数、随机字节、随机字节数组等。可以根据具体需求选择合适的方法来生成随机数。
需要注意的是,Random
类生成的随机数也是伪随机数,每次程序运行时会生成一个不同的随机数序列。如果需要更高质量的随机数,可以考虑使用SecureRandom
类。
import java.util.Scanner;
import java.lang.Math;
class test
{
public static void main(String []args)
{
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
int []arr = new int [100];
for(int i = 0 ; i < num ;i++)
{
arr[i] = (int)(Math.random()*100);
}
for(int i = 0 ; i < num ; i++)
{
System.out.print(arr[i]+ " ");
}
sc.close();
}
}
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
我们尝试以下代码
public static void main(String[] args) {
int num = 0;
func(num);
System.out.println("num = " + num);
}
public static void func(int x) {
x = 10;
System.out.println("x = " + x);
}
// 执行结果
x = 10
num = 0
我们发现, 修改形参 x
的值, 不影响实参的 num
值.
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]);
}
// 执行结果
a[0] = 10
arr[0] = 10
我们发现, 在函数内部修改数组内容, 函数外部也发生改变.
此时数组名 arr
是一个 “引用” . 当传参的时候, 是按照引用传参.
针对 int[] arr = new int[]{1, 2, 3}
这样的代码, 内存布局如图:
new int[]{1, 2, 3}
的时候, 相当于创建了一块内存空间保存三个 int
int[] arr = new int[]{1, 2, 3}
相当于又创建了一个 int[]
变量, 这个变量是一个引用类型, 里面只保存了一个整数(数组的起始内存地址)int[] a = arr
, 内存布局如图
a[0]
, 此时是根据 0x100
这样的地址找到对应的内存位置, 将值改成 100
此时已经将 0x100
地址的数据改成了 100
.
那么根据实参 arr
来获取数组内容 arr[0]
, 本质上也是获取 0x100
地址上的数据, 也是 100
.
内存就是指我们熟悉的 “内存”. 内存可以直观的理解成一个宿舍楼. 有一个长长的大走廊, 上面有很多房间.
每个房间的大小是 1 Byte (如果计算机有 8G 内存, 则相当于有 80亿 个这样的房间).
每个房间上面又有一个门牌号, 这个门牌号就称为 地址
内存(Memory)是计算机中用于存储数据和指令的硬件设备。它是计算机的重要组成部分,不仅影响着机器的性能,还直接关系到程序的执行效率。
内存可以分为主存(Main Memory)和辅助存储器(Auxiliary Storage)两种类型。主存是计算机的主要工作空间,它存储了当前正在执行的程序和相关的数据。主存通常是易失性存储器,即当计算机断电时,内存中的数据就会丢失。辅助存储器则是指硬盘、固态硬盘(SSD)等非易失性存储介质,它可以用于长期存储数据。
内存的容量通常以字节(Byte)为单位来衡量,1字节等于8位。常见的内存容量单位有千字节(KB)、兆字节(MB)、千兆字节(GB)和太字节(TB)。内存的容量越大,计算机可以同时存储和处理的数据量就越大。
在计算机中,每个内存单元都有一个唯一的地址,通过这个地址可以访问到其中存储的数据。内存的访问速度很快,相比于辅助存储器,它可以更快地读取和写入数据。这也是为什么计算机将程序和数据加载到内存中进行处理。
内存的管理是计算机系统的重要任务之一。操作系统负责分配和回收内存空间,以确保程序能够正常运行并避免内存泄漏的问题。程序员也需要编写高效的代码,尽量减少内存的占用和浪费,提高程序的性能。
总之,理解内存是理解计算机工作原理的重要一环。通过合理利用内存资源,可以提高计算机的性能和效率。
引用相当于一个 “别名”, 也可以理解成一个指针.
创建一个引用只是相当于创建了一个很小的变量, 这个变量保存了一个整数, 这个整数表示内存中的一个地址
所谓的 “引用” 本质上只是存了一个地址.
Java 将数组设定成引用类型, 这样的话后续进行数组参数传参, 其实只是将数组的地址传入到函数形参中. 这样可以避免对整个数组的拷贝(数组可能比较长, 那么拷贝开销就会很大).
null
在 Java 中表示 “空引用” , 也就是一个无效的引用.
int[] arr = null;
System.out.println(arr[0]);
// 执行结果
Exception in thread "main" java.lang.NullPointerException at Test.main(Test.java:6)
null
的作用类似于 C 语言中的 NULL
(空指针), 都是表示一个无效的内存位置.
因此不能对这个内存进行任何读写操作. 一旦尝试读写, 就会抛出 NullPointerException.
注意: Java 中并没有约定 null
和 0 号地址的内存有任何关联.
一个宿舍楼会划分成几个不同的区域: 大一学生, 大二学生… 计算机专业学生, 通信专业学生…内存也是类似, 这个大走廊被分成很多部分, 每个区域存放不同的数据.
JVM 的内存被划分成了几个区域, 如图所示:
int[] arr
这样的存储地址的引用就是在这里保存.new
创建的对象都是在堆上保存 (例如前面的 new int[]{1, 2, 3}
)JVM 是一个基于 C++ 实现的程序. 在 Java 程序执行过程中, 本质上也需要调用 C++ 提供的一些函数进行和操作系统底层进行一些交互. 因此在 Java 开发中也会调用到一些 C++ 实现的函数.
这里的 Native 方法就是指这些 C++ 实现的, 再由 Java 来调用的函数.
我们发现, 在上面的图中, 程序计数器, 虚拟机栈, 本地方法栈被很多个原谅色的, 名叫 Thread(线程) 的方框圈起来了,并且存在很多份. 而 堆, 方法区, 运行时常量池, 只有一份.
new
出的对象保存在堆上.// 直接修改原数组
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;
}
}
这样的话就不会破坏原有数组了.
另外由于数组是引用类型, 返回的时候只是将这个数组的首地址返回给函数调用者, 没有拷贝数组内容, 从而比较高效.
二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组.
数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };
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.printf("%d\t", arr[row][col]);
}
System.out.println("");
}
}
// 执行结果
1 2 3 4
5 6 7 8
9 10 11 12
二维数组的用法和一维数组并没有明显差别, 因此我们不再赘述.
同理, 还存在 “三维数组”, “四维数组” 等更复杂的数组, 只不过出现频率都很低.