[数据结构与算法]Java基础学习5

数组

什么是数组

数组是相同类型数据的有序集合，每个数组中的元素可以通过下标来访问

声明创建数组

int[] a = new int[10];

赋值

a[0]=1;

如果不赋值则为默认值—0

获取数组长度

a.length

简单的内存分析

Java内存

1. 堆：

   • 存放new的对象和数组
   • 可以被所有的线程共享，不会存放别的对象引用

2. 栈：

   • 存放基本变量类型
   • 引用对象的变量

3. 方法区：

   • 可以被所有的线程共享
   • 包含了所有的class和static变量

三种初始化

• 静态初始化

int[] a={1,2,3};

• 动态初始化

int[] a = new int[10];
a[0]=1;

• 数组的默认初始化

数组的特点

• 长度一定，一旦被创建，大小不可改变
• 元素必须是相同类型
• 数组中的元素可以是如何数据类型，包括基本类型和引用类型
• 数组对象本身实在堆里的

数组的使用

1. For-Each循环(增强for)

   int[] a = new int[10];
   for(int b:a) {
   	System.out.println(b);
   

2. 数组作方法入参

   public static void c(int[] a) {
   	for(int i=0;i< a.length;i++) {
   		System.out.print(a[i]+" ");
   	}
   

3. 数组作返回值

多维数组

二维数组

int[][] a= {{1,0},{1,1},{2,0},{2,1}};

可以理解为几行几列，a.lengh=4 a[0].lengh=2

多维和二维一样，一直嵌套，如三维：a={{{1,2},{1,1}},{{2,1},{2,0}}};

Arrays类

• 打印数组元素

int[] a = new int[10];
System.out.println(Arrays.toString(a));

• 给数组赋值：fill方法

Arrays.fill(a, 1);

• 对数组排序：sort方法，按升序
• 比较数组：equals方法比较数组中元素是否相等
• 查找数组元素：binarySearch方法能对排序好的数组进行二分查找法操作

冒泡排序

比较数组中两个相邻的元素的大小，小的向前/后，大的向后/后

public static void d(int[] arrays) {
	int temp=0;
	for(int i=0;i<arrays.length-1;i++) {  //判断要循环几次
		for(int j=0;j<arrays.length-1-i;j++) {  //每次把要比较的元素中最小的向最后排
			if(arrays[j+1]>arrays[j]) {
				//两个数交换
				temp=arrays[j];
				arrays[j]=arrays[j+1];
				arrays[j+1]=temp;
			}
		}
	}
}

优化思路

public static void d(int[] arrays) {
	boolean flag=false;
    int temp=0;
	for(int i=0;i<arrays.length-1;i++) {
		for(int j=0;j<arrays.length-1-i;j++) {
			if(arrays[j+1]>arrays[j]) {
				//两个数交换
				temp=arrays[j];
				arrays[j]=arrays[j+1];
				arrays[j+1]=temp;
                flag=true;
			}
		}
        if(flag==false){
            break;
        }
	}
}

还有一个知识点：稀疏数组

稀疏数组

稀疏数组就是压缩数组中有用的元素，去除重复的元素

int[][] a1 = new int[11][11];
	a1[1][2] = 1;
	a1[2][3] = 1;
	for(int[] b:a1) {
		for(int b1:b) {
			System.out.print(b1+"\t");
		}
		System.out.println();
	}
	System.out.println("=============");
	int sum = 0;
	for(int i=0;i<a1.length;i++) {
		for(int j=0;j<a1[i].length;j++) {
			if(a1[i][j]!=0) {
				sum++;
			}
		}
	}
	int[][] a2 = new int[sum+1][3];
	a2[0][0]=a1.length;
	a2[0][1]=a1[0].length;
	a2[0][2]=sum;
	int count =0;
	for(int i=0;i<a1.length;i++) {
		for(int j=0;j<a1[i].length;j++) {
			if(a1[i][j]!=0) {
				count++;
				a2[count][0] = i;
				a2[count][1] = j;
				a2[count][2] = a1[i][j];
			}
		}
	}
	System.out.println("打印稀疏数组：");
	for(int[] b:a2) {
		for(int b1:b) {
			System.out.print(b1+"\t");
		}
		System.out.println();
	}
	System.out.println("========================");
	System.out.println("还原");
	int[][] a3 = new int[a2[0][0]][a2[0][1]];
	for(int i=1;i<a2.length;i++) {
		a3[a2[i][0]][a2[i][1]] = a2[i][2];
	}
	for(int[] b:a3) {
		for(int b1:b) {
			System.out.print(b1+"\t");
		}
		System.out.println();
	}