Java数组
Java数组
1. 数组概述
- 数组的定义
- 数组是相同类型的有序集合
- 数组描述的是相同类型的若干数据，按照一定的先后顺序排列组合而成
- 其中，每个数据称为一个数组元素，没个数组元素可以通过一个下表来访问
2. 数组的声明创建
-
首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的方法：
dataType[] arrayRefVar;//首选方法 datadype arrayRefVar[];//效果相同 -
Java语言使用new操作符来创建数组，语法如下：
dataType[] arrayRefVar = new dataType[arraySize]; -
数组的元素是通过索引访问的，数组索引从0开始
-
获取数组长度：arrays.length
-
例子：
public class ArrayDemo01 { //变量的类型 变量的名字 变量的 = 变量的值; //数组类型 public static void main(String[] args) { int[] nums;//定义 //int nums2[];//第二种方法 nums = new int[10];//可以存放10个int类型的数字 //int[] nums = new int[10]//写一起 nums[0] = 1; nums[1] = 2; nums[2] = 3; nums[3] = 4; nums[4] = 5; nums[5] = 6; nums[6] = 7; nums[7] = 8; nums[8] = 9; nums[9] = 10; //计算所有元素的和 int sum = 0; for (int i = 0; i < 10; i++) { sum = sum + nums[i]; } System.out.println(sum); } }
3. 三种初始化及内存分析
3.1 Jav内存分析
graph LR
Java内存-->堆
Java内存-->栈
Java内存-->方法区
堆-->存new的对象和数组
堆-->可以被所有的线程共享-不会被别的对象引用
栈-->存放基本变量的类型会-包含这个基本类型的具体数值
栈-->引用对象的变量-会存放这个引用在堆里面的具体地址
方法区-->可以被所有的线程操控
方法区-->包含可所有的-和-变量
包含所有的class和stratic变量
3.2 数组三种初识化状态
-
静态初始化：创建+赋值
int[] a = {1,2,3,4,5,6,7,8}; System.out.println(a[0]); -
动态初始化：包含默认初始化
int[] b = new int[10]; b[0] = 10; System.out.println(b[0]);
4. 数组使用
- For-Each循环（增强的For循环）
- 数组做方法入参
- 数组作为返回值
public class ArrayDemo04 {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
//
// for (int array : arrays) {
// System.out.println(array);
// }
//printArray(arrays);
int[] reverse = reverse(arrays);
printArray(reverse);
}
//打印数组元素
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+"\t");
}
}
//反转数组
public static int[] reverse(int[] arrays){
int[] resoult = new int[arrays.length];
for(int j = resoult.length - 1, i = 0; i < arrays.length; j--,i++){
resoult[j] = arrays[i];
}
return resoult;
}
}
5. 多维数组
-
多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个与元素都是一个一维数组
-
二维数组
int a[][] = new int[2][5]; 上面的数组a可以看作一个两行五列的数组
-
数组的使用
public class ArrayDemo05 {
public static void main(String[] args) {
int[][] array = {{1,2}, {2,3}, {3,4}, {4,5}, {5,6}};
System.out.println(array.length);//输出行数
System.out.println(array[0].length);//输出某行列数
//输出数组中每个数
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.println(array[i][j]);
}
}
}
}
6. Arrays类
- 数组的工具类java.util.Arrays
- 由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本操作
- 查看JDK帮助文档
- Arrays类中的方法都是stratic修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意是不用 而不是 不能）
- 具有以下常用功能：
- 给数组赋值：通过fill方法
- 对数组进行排序：通过sort方法，按升序
- 比较数组：通过equals方法比较数组中元素值是否相等
- 查找数组元素：通过binarySearch方法能对排序好的数据进行二分查找法操作
import java.util.Arrays;
public class ArrayDemo06 {
public static void main(String[] args) {
int[] a = {1,2,3,4,9090,31231,543,21,3,23};
System.out.println(a);//[I@1b6d3586
//打印数组元素Arrays。toString
System.out.println(Arrays.toString(a));
//数组进行排序: 升序
Arrays.sort(a);
//对数组进行填充
Arrays.fill(a,0);//所有元素填充为0
Arrays.fill(a,2,4,0);//2~4之间的数字填充为0
printArray(a);
}
public static void printArray(int[] a){
for (int i = 0; i < a.length; i++) {
if(i == 0){
System.out.print("[");
}
if(i == a.length - 1){
System.out.print(a[i]+"]");
}
else{
System.out.print(a[i]+", ");
}
}
}
}
7. 冒泡排序
-
冒泡排序是最出名的排序算法之一，总共有把八大排序
-
冒泡的代码还是相当简单的，两层循环，外层冒泡轮转，里层依次比较，江湖中人尽皆知
-
我们看到嵌套循环，应该立马就可以看出这个算法的时间复杂度o（n2）
-
冒泡排序
1. 比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们交换他们的位置
2. 每次排序都会产生一个最大或最小的数字
3. 下一轮则可以少一轮排序
4. 一次循环
import java.util.Arrays;
public class ArrayDemo07 {
public static void main(String[] args) {
int[] a = {1,3,2,5,8,6};
System.out.println(Arrays.toString(sort(a)));
}
//冒泡排序
//1. 比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们交换他们的位置
//2. 每次排序都会产生一个最大或最小的数字
//3. 下一轮则可以少一轮排序
//4. 一次循环
public static int[] sort(int[] array){
int temp;
//外层循环，判断我们这个要走多少次
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]){
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
//优化
flag = true;
}
}
if(flag){
break;
}
}
return array;
}
}
8. 稀疏数组
-
作用：当数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组，节约储存
-
系数数组的处理方式：
- 记录数组一共几行几列，共有多少不同值
- 把具有不同值的元素和行列记录在一个小规模数组中，从而缩小程序的规模
-
如下图，左边是原始数组，右边是稀疏数组
-
![img]()
-
原始数据代码
int[][] array1 = new int[11][11]; array1[1][2] = 1; array1[2][3] = 2; //输出原始数据 for (int[] ints : array1) { for (int anInt : ints) { System.out.print(anInt+"\t"); } System.out.println(); } -
稀疏数组代码
//创建一个稀疏数组 int[][] array2 = new int[sum + 1][3]; array2[0][0] = array1.length; array2[0][1] = array1[1].length; array2[0][2] = sum; //遍历二维数组，将非零的值，存放于稀疏数组中 int count = 0; for (int i = 0; i < array1.length; i++) { for (int j = 0; j < array1[1].length; j++) { if(array1[i][j] != 0){ count++; array2[count][0] = i; array2[count][1] = j; array2[count][2] = array1[i][j]; } } } //输出稀疏数组 for (int i = 0; i < array2.length; i++) { System.out.println(array2[i][0]+"\t" +array2[i][1]+"\t" +array2[i][2]+"\t"); } -
还原
//还原 int[][] array3 = new int[array2[0][0]][array2[0][1]]; for (int i = 1; i < array2.length; i++) { array3[array2[i][0]][array2[i][1]] = array2[i][2]; } for (int[] ints : array1) { for (int anInt : ints) { System.out.print(anInt+"\t"); } System.out.println(); }
浙公网安备 33010602011771号