数组

最新推荐文章于 2024-04-17 00:05:10 发布

你还说你不会武功

最新推荐文章于 2024-04-17 00:05:10 发布

阅读量113

点赞数

本文链接：https://blog.csdn.net/antogriezmann/article/details/101424194

版权

数组

我们的Java学习路线：其实就是数据如何存储

变量
数组
类和对象
对象数组
集合（List、Set、Map…）
IO流文件操作
XML文件（解析和读取都比较麻烦）
数据库（Database）
- RDB：MySQL、Oracle、PostgreSQL、SQLlite…
- NoSQL：Redis、MongoDB、Memcashed…
数据库的集群
数据库的水平拆分、垂直拆分
HBase…大数据存储
…

数组是一个难点，因为他会有一个新的引用数据类型<堆>

1、理解数组的作用

2、掌握数组的定义

3、掌握数组的基本使用

4、掌握数组的常用操作

5：引用数据类型的名称来源【初始-堆】

6：数组工具Arrays

7：冒泡排序

8：多维数组（二维数组）

数组的作用

问题：变量仅仅是一种单一的数据类型，存储值只能存储简单的数据，如果想同时存储更多的数据，无法实现，同时关于变量的操作比较简单，我们需要寻找一种能够同时存储更多的数据，并且操作更加丰富的数据类型。

前面学习的变量只能一个变量储存一个值
```
  数组可以一个变量储存多个值
```

变量就是在内存空间划出一块空间

  数组就是在内存空间划出一串连续空间

数组的定义

数组：一组数据、数据的组合

有限个相同类型的变量的集合，就被成为是数组

数组中的变量称为是数组的分量或元素。

它是一种引用数据类型，他的数据是存储在JVM的堆中的。

变量是存储在栈中。

数组的基本使用

数组的基本要素

标识符：遵循驼峰命名规则
数组元素：存放的内容
元素下标（从0开始）：每个数组下标从0开始一直到数组的长度-1，数组中的每个元素都可以通过下标访问。
元素类型：数组中所有元素必须是相同数据类型
数组的长度（一个数组里能存放元素的总个数）声明以后固定不变

数组的定义：

数据类型[] 数组名 = new 数据类型[数组长度]
数组名[元素] = 值;

数据类型[] 数组名 = {元素1，元素2，元素3，....}

int数据类型系统默认赋值是0

double数据类型系统默认赋值是0.0

String数据类型系统默认赋值是null（空）

//要求：输入5名学生的成绩，并输出第3名学生的成绩
import java.util.Scanner;
public class Demo {
	public static <input> void main(String[] args) {
		Scanner input = new Scanner(System.in);
		double[] scores = new double[5];
		for(int i =0;i<scores.length;i++) {
			System.out.println("第"+(i+1)+"个学生的成绩是：");
			scores[i] = input.nextDouble();
		}
		System.out.println("第三个学生的分数是："+scores[2]);
	}
}

数组名.length 就可以获得数组的长度

获取数组中的所有数据：(遍历)

// 增强for循环
int[] nums = {xx,xx,xx,xx,xx};
for(int num : nums) {
    System.out.println(num);
}

// for循环
// 定义数组
int[] nums = {xx,xx,xx,xx,xx};
// 遍历数组
for(int i = 0; i < scores.length; i++) {
    System.out.println(scores[i]);
}

掌握数组的常用操作

求最值

// 需求：使用键盘录入输入5位学生的成绩，然后计算最高分
import java.util.Scanner;
public class Demo {
	public static <input> void main(String[] args) {
		Scanner input = new Scanner(System.in);
		double[] scores = new double[5];
		for(int i =0;i<scores.length;i++) {
			System.out.print("第"+(i+1)+"个学生的成绩是：");
			scores[i] = input.nextDouble();
		}
		double max = scores[0];
		for(double score : scores) {
			for(int i = 1; i < scores.length; i++) {
			    if(max < scores[i]) {
			        max = scores[i];
			    }
			}
		}
		System.out.print("最高分是："+max);
	}
}

引用数据类型的名称来源

Java中的数据类型：

基本数据类型：数据储存在栈中（数据独立不共享）
- 数值型：
  - 整数型：byte short int long
  - 浮点型：float double
- 非数值型：char boolean
引用数据类型：数据储存在堆中（数据线程共享）
- 数组、类、接口、枚举…

数组工具Arrays

我们有些问题处理起来很麻烦，因此有时候会需要借助到工具，工具可以帮我们提升工作效率，将一些常见的、复杂的工作实现起来变的容易！

int[] nums = {1,2,4,3,5};

// 1.将数组转化为字符串
String num = Arrays.toString(nums);
System.out.println(num);
或者
System.out.println(Arrays.toString(nums));

// 2.数组的升序排列
Arrays.sort(nums); 
// 降序排列后输出
for(int i = nums.length - 1; i >= 0; i--) {
    System.out.print(nums[i]+" ");
}

// 3.将数组的内容复制到一个新数组中,并将新数组指定长度
int[] nums1 = Arrays.copyOf(nums, 6);

// 4.在arr中寻找指定数字的位置
int num = Arrays.binarySearch(nums,5);

// 5. 将一个数组内填充为一个指定的值
Arrays.fill(nums,0);

// 6.比较两个数组的内容是否相同
int[] nums1 = {1,2,4,3,5};
int[] nums2 = {1,3,2,4,5};
System.out.println(Arrays.equals(num, num1));// true
System.out.println(Arrays.equals(num, num2));// false

冒泡排序

目前常用的排序方式主要有8种。称为八大排序
算法：一个算法就是解决一个问题的进程，在处理相似问题时，我们不用每次都用不同的算法、
冒泡排序就是一种算法：当我们为一行数字进行排序时，通常从左向右进行两两比较，小的向前，大的向后排，比较一次后再从第二个数字开始继续两两比较，需要进行多次两两比较才能最终排序完成。（冒泡排序是按照升序排列的）

数组中通常采用多重循环的方式进行表示。

外层循环控制行数内层循环控制每行的内容。
外层循环控制轮数，内层循环控制每轮的比较。

import java.util.Arrays;
public class demo1 {
	public static void main(String[] args) {
		// 要求：将下列数组按照冒泡排序排列
		// 定义一个数组
		int[] nums = {1,2,4,5,6,9,3,7};
		// 外层循环控制行数
		for(int i = 0; i < nums.length-1; i++) {
			// 内层循环控制轮数
		    for(int j = 0; j < nums.length-1-i; j++) {
		        // 相邻两两比较，小的往前排
		        if(nums[j] > nums[j+1]) {
		            // 定义一个中间数进行临时的数据储存达到两数换位的目的
		            int temp = nums[j];
		            nums[j] = nums[j+1];
		            nums[j+1] = temp;
		        }
		    }
		}
		System.out.println(Arrays.toString(nums));
	}
}

多维数组（二维数组）

需求:储存5个班的各五名学生的成绩

double[] scores1 = new double[5];
double[] scores2 = new double[5];
double[] scores3 = new double[5];
double[] scores4 = new double[5];
double[] scores5 = new double[5];

这种方法虽然可以实现，但是当需求大的时候，工程量也很大，因此我们需要借助多维数组来进行实现

多维数组：在Java的内存模型并不存在多维数组，但是语法层面上支持。 意味着本质上还是一个一维数组。

// 语法
// 1.
double[][] scores = new double[5][5];
// 2.
double[][] scores = {{},{},{},{},{}};
// 3.写法较为灵活
double[][] scores = new double[5][];
scores[0] = new double[5];
scores[1] = new double[5];