学习资料
b站狂神说:https://www.bilibili.com/video/BV12J41137hu
数组的定义
数组是相同类型的有序集合.
通过下标来访问数组元素,下标从0开始。
数组也是对象,数组元素相当于对象的成员变量
数组的长度确定后是不可变的,如果越界出现异常:ArrayIndexOutofBounds
package com.zy7y.array;
import java.util.Arrays;
/**
* @ProjectName: JavaSE
* @PackageName: com.zy7y.array
* @Author: zy7y
* @Date: 2020/8/14 下午8:27
* @Description: 数组
*/
public class ArrayStudy {
public static void main(String[] args) {
// 定义一个 int类型 的数组; 将nums存放在栈中
int[] nums;
nums = new int[10]; // 10 为 数组的长度; 将10个int类型数组放在堆中
nums[0] = 1; //给数组赋值
// Arrays.toString(数组) ,打印数组内容
System.out.println(Arrays.toString(nums)); // [1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
int sum = 0;
// 获取数组的长度
for (int i = 0; i < nums.length; i++) {
sum += nums[i];
}
System.out.println(sum);
// 静态初始化: 创建 + 赋值
int[] a = {1,2,3,4,5,6};
System.out.println(a[0]);
// 动态初始化:包含默认初始化
int[] b = new int[]{1,2,3,4,5};
System.out.println(b[1]);
}
}
内存分析
graph LR
Java内存--> 堆
堆-->存放new的对象和数组
堆--> 可以被所有的线程共享,不会存放别的对象引用
Java内存--> 栈
栈-->存放基本变量类型,包含这个基本类型的具体数值
栈-->引用对象的变量,存放这个引用在堆里面的具体地址
Java内存--> 方法区
方法区-->可以被所有的线程共享
方法区-->包含了所有的类和static变量
数组的使用
package com.zy7y.array;
import java.util.Arrays;
/**
* @ProjectName: JavaSE
* @PackageName: com.zy7y.array
* @Author: zy7y
* @Date: 2020/8/14 下午8:53
* @Description:
*/
public class UseArray {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
// 打印所有的元素
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]);
}
for (int array: arrays) {
System.out.println(array);
}
// 计算所有元素的和
int sum = 0;
for (int i = 0; i < arrays.length; i++) {
sum += arrays[i];
}
System.out.println(sum);
int total = 0;
for (int array:arrays) {
total += array;
}
System.out.println(total);
System.out.println(Arrays.toString(reverse(arrays)));
}
// 反转数组
public static int[] reverse(int[] arrays){
int[] result = new int[arrays.length];
// result.length -1 j一开始就是result的最大下标然后依次边小,i是最小下标依次变大
for (int i = 0, j = result.length - 1 ; i < arrays.length; i++, j--) {
result[j] = arrays[i];
}
return result;
}
}
多维数组
数组里面嵌套数组
// 定义一个二维数组并复制
int[][] array = new int[][]{{1,23,1},{2,3}};
System.out.println(array[0][1]); // 23,取数组中的第0个{1,23,1},然后取里面的第一个23
Arrays类
package com.zy7y.array;
import java.util.Arrays;
/**
* @ProjectName: JavaSE
* @PackageName: com.zy7y.array
* @Author: zy7y
* @Date: 2020/8/14 下午9:16
* @Description: Arrays类
*/
public class UseArrays {
public static void main(String[] args) {
int[] a = {1,23,445,123};
int[] b = {1};
System.out.println(Arrays.toString(a));
// 排序
Arrays.sort(a);
System.out.println(Arrays.toString(a));
// 比较两个数组
boolean result = Arrays.equals(a,b);
System.out.println(result);
// 复制一个数组, Arrays.copyOf(数组, copy数组的长度)
int[] c = Arrays.copyOf(a, a.length);
System.out.println(Arrays.toString(c));
printArray(c);
}
// 仿写一个 Arrays.toString
public static void printArray(int[] arrays) {
System.out.print("[");
for (int array:arrays) {
if (array == arrays[arrays.length-1]){
System.out.print(array + "]");
}else {
System.out.print(array + ", ");
}
}
}
}
冒泡排序
package com.zy7y.array;
import java.util.Arrays;
/**
* @ProjectName: JavaSE
* @PackageName: com.zy7y.array
* @Author: zy7y
* @Date: 2020/8/14 下午9:29
* @Description: 冒泡排序
*/
public class Bubble {
public static void main(String[] args) {
// 比较数组中,相邻的两个元素,如果第一个大于第二个则进行交换
// 每一次比较,都会产生一个最大或者最小的数字;
// 下一轮则可少依次排序
int[] arrays = {1,452,23,3455,7786,12,44};
bubbleSort(arrays);
}
public static void bubbleSort(int[] arrays){
// 长度为8,下标则为7,但是排序最终有一个是不会变动位置的
for (int i = 0; i < arrays.length - 1; i++) {
// 给个标示位
boolean off = false;
for (int j = 0; j < arrays.length - 1 - i; j++) {
if (arrays[j] > arrays[j + 1]) {
int temp = arrays[j];
arrays[j] = arrays[j + 1];
arrays[j + 1] = temp;
off = true;
}
}
// 当交换完成时break;
if (!off){
break;
}
}
System.out.println(Arrays.toString(arrays));
}
}
稀疏数组
二维数组的很多值是默认值0,记录了黑多没有意义的数据
package com.zy7y.array;
/**
* @ProjectName: JavaSE
* @PackageName: com.zy7y.array
* @Author: zy7y
* @Date: 2020/8/14 下午9:54
* @Description:
*/
public class SparseArray {
public static void main(String[] args) {
// 生成一个 11 * 11 的二维数组
int[][] array = new int[11][11];
array[3][9] = 27;
array[1][10] = 10;
array[5][8] = 40;
array[0][3] = 30;
// printArrays(array);
printArray(array);
System.out.println("====压缩成稀疏数组====");
System.out.println("行 列 值");
printArray(packedArray(array));
System.out.println("====从稀疏数组还原======");
printArrays(revivification(packedArray(array)));
}
// 打印二维数组的方法
public static void printArrays(int[][] array){
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j] + "\t");
}
System.out.println();
}
}
// 打印二维数组的第二种方法
public static void printArray(int[][] array){
for (int[] arr:array) {
for (int a:arr) {
System.out.print(a + "\t");
}
System.out.println();
}
}
// 压缩成稀疏数组
public static int[][] packedArray(int[][] array){
// 统计有效值的个数,得到行数
int count = 0;
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
if (array[i][j] != 0) {
count += 1;
}
}
}
int[][] packed = new int[count+1][3];
// 原数组行数
packed[0][0] = 11;
// 原数组列数
packed[0][1] = 11;
// 原数组有效值个数
packed[0][2] = count;
int row = 0;
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
if (array[i][j] != 0) {
// 统计有效值的个数,即作为所在的行数
row += 1;
packed[row][0] = i;
packed[row][1] = j;
packed[row][2] = array[i][j];
}
}
}
return packed;
}
// 还原成稀疏数组
public static int[][] revivification(int[][] array) {
int[][] arrays = new int[array[0][0]][array[0][1]];
for (int i = 1; i < array.length; i++) {
arrays[array[i][0]][array[i][1]] = array[i][2];
}
return arrays;
}
}
© 著作权归作者所有
举报
相关热门文章
发表评论
0/200