JavaSE全套学习笔记day05

二，数组

2.1 为什么需要数组

​ 考虑问题1：存储一个人的考试成绩，double score = 100;

​ 考虑问题2：存储60个人的成绩，??? 数组更合适、

2.2数组是什么

​ 数组相对于容器，可以装载（存储）多个数据。

​ 特点：

​ 1. 数组一旦创建，容量（长度）固定

​ 2. 一旦创建，他存储的数据类型就固定

内存空间的特点：

ps:程序在jvm中运行，Java程序运行需要耗费电脑内存空间。

数组的内存空间特点：

1,在堆中创建

2.是连续空间

3.每个空间位置有下标（索引）

三.数组的使用

数组的声明：声明；创建，存取数据

3.1 数组的声明

数据类型 [ ] 数组名；数组类型 数组 [ ] ;

3.2 数组创建

int [] arr1 = new int [3];

3.3使用数组

arr int [3]

遍历，存储等！！！

四 ：数组的内存图

方法申请会进栈，凡是new的，都会在堆中开辟空间。

地址值的解析： “[” 几维数组 I是指Integer数组，@地址分隔符，

new int [3]; 这行代码做了什么？

​ 1.会在堆中开辟连续空间

​ 2.且给空间设置下标，0-长度-1

​ 3.且给每个空间默认初始值

​ 4.给这个空间设置了内存地址

int [] arr = new int [3]; 赋值给arr其实是数组在内存的地址

System.out .println(); // 输出地址值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZLx7XVmy-1676432988042)(D:\前锋学习笔记\笔记\image-20230207144739993.png)]

int a = arr[0]; 这个代码做了什么？

​ 1.通过arr,arr背后是数组的地址找到数组

​ 2.arr[0],找到数组中下标为的0的那个准确的位置

3. arr[0] = 11; // 这个代码干了什么

   通过arr背后的地址值找到数组。

   通过[0] 找到对应下标位置‘

   4.以后这个位置就是11除非再次修改

   数组的静态初始化

   int [] arr = new int [3];动态初始化，没有给数组赋值

静态的是提前确定数据，不指定长度这样就是静态初始化。

int [] arr = new int []; int [] arr = new int [] {44,55,66}

**静态初始化指定数据，不指定长度会自动计算（length） **

静态初始化的简化格式；

数据类型 [] 数组名 = {值1，值2，值3，…}

简化格式有类型转换得情况。

五数组的遍历

遍历：一个一个的找到数组的元素进行操作。

//遍历输出数组中的信息。

六 总结：

声明，使用，创建2种方案，取值，存值 重点！！！数组的内存图会画。

七:数组进阶

7.1数组拷贝

​ 数组拷贝：将数组中的元素从一个数组赋值到另一个数组中

​ 方法一：手动实现

​

public static void main(String[] args) {
		copyArray();
	}
	public static void copyArray() {
		// 原数组
		int [] arr1 = {11,22,33,44};
		// 目标数组
		int [] arr2 = new int [arr1.length];
		// 遍历数组
		for (int i = 0; i < arr1.length; i++) {
			arr2 [i] = arr1[i];
		}
		for (int i : arr2) {
			System.out.print(i+" ");
		}
	}

方案二：

​ 拷贝

 @param      src      the source array
     .源数组。
 @param      srcPos   starting position in the source array.
     源数组中的起始位置。
 @param      dest     the destination array.
     目标数组
 @param      destPos  starting position in the destination data.
     目标数据中的起始位置。
 @param      length   the number of array elements to be copied.
     要复制的数组元素的个数。
    System.arraycopy(src, srcPos, dest, destPos, length);

方案三:

​ 拷贝

​ Arrays,copyOf(); 拷贝数组

7.2数组扩容

​ 数组的本身不能扩容所谓的”扩容”，其实是重新创建一个全新数组，容量变大，然后将老数组内的元素拷贝到新数组，然后将数组的名字重新命名以为之前的名字，使用时，让我们感觉是扩容啦。

public static void main(String[] args) {
		resize();
		// 原数组
		int [] arr = {11,22,33,44};	
		int n = resize2(arr);
	}
		public static void resize() {
		// 原数组
		int [] arr = {11,22,33,44};	
		System.out.println("数组的长度"+arr.length);
		// 将数组扩容为原来的两倍
		int [] arr2 = new int [2 * arr.length];	
		// 数组拷贝，将原数组内容拷贝到新数组	
		System.arraycopy(arr, 0, arr2, 0, arr.length);	
		arr = arr2;
		System.out.println("数组的长度"+arr.length);
	}
		
		/*
		 * 数组拷贝2
		 */
		public static int resize2(int [] arr) {
		
		// 将数组扩容为原来的两倍
		int [] arr2 = new int [2 * arr.length];	
		// 数组拷贝，将原数组内容拷贝到新数组	
		System.arraycopy(arr, 0, arr2, 0, arr.length);	
		arr = arr2; // 引用重新赋值
		System.out.println("数组的长度"+arr.length);
		return arr.length;
	}

7.3数组排序是[面试 | 笔试]🔺🔺🔺

	##### 		                                                             冒泡

相邻比较大小然后交换位

package test;
/*
 * 34 4 56 17 90 65
 * 
 * 4 34 17 56 65 90   5次
 * 4 17 34 56 65	  4次
 * 4 17 34 56		  3次
 * 4 17 34			  2次
 * 4 17				  1次
 */
public class 冒泡排序 {
	public static void main(String[] args) {
		int [] nums = {34,4,56,17,90,65}; // 待排序的数组
		for (int i = 0; i < nums.length-1; i++) { // 控制几轮次数    推广比较n-1次[arr.lenght-1]次
			for (int j = i; j < nums.length; j++) { // 每轮比较的次数
				if(nums[i]>nums[j]) {
					int tmp;
					tmp = nums[i];
					nums[i] = nums[j];
					nums[j] = tmp;
				}
			}
		}
		for (int i:nums) {
			System.out.print(i+" ");
		}
	}
}

public static void main(String[] args) {
		int [] arr = {1};
		sort1(arr);
	}
	public static void sort1(int [] arr) {
		for (int i = 0; i < arr.length; i++) {
			for (int j = i; j < arr.length-1; j++) {
				if (arr[i] > arr[j]) {
					arr[i] = arr[i]^arr[j];
					arr[j] = arr[i]^arr[j];
					arr[i] = arr[i]^arr[j];
				}
			}
		}
		for (int i : arr) {
			System.out.print(i);
		}
	}

选择排序

package test;
/*34 4 56 17 90 65
 * 
 * 4 34 56 17 90 65		5次
 * 4 17 56 34 90 65		4次
 * 4 17 34 56 90 65 	3次
 * 4 17 34 56 90 65		2次
 * 4 17 34 56 65 90		1次
 * 
 * 
 */
public class 选择排序 {
	public static void main(String[] args) {
		int arr [] = {34,4,56,17,90,65};
		for (int i = 0; i < arr.length-1; i++) {  // 外层循环n-1次
			int min = i;  // 记录最小值下标
			for (int j = i+1; j < arr.length; j++) {  // 内层比较的次数
				if (arr[j] < arr[min]) {
					min = j; 
				} 
			}
			// 值传递
			if(i != min) {
				int tmp = arr[i];
				arr[i] = arr[min];
				arr[min] = tmp;
			}
		}
		// 遍历
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]);
		}
	}
}

7.4引用类型[重要]❤❤❤❤

​ Java的数据类型分为两大类，

​ 1.基本数字据类型

值传递：将种方法的中的变量传给了方法中，方法怎么处理不影响主方法中的值，方法中的就自己销毁啦

​ 2.引用数据类型（数组，类，接口）

​ 通过一个变量引用内存中的对象，那么这个变量就引用，

何为引用类型？

int [] arr = new int [] {1,1,1}

以上代码会，在堆中开启出一个空间地址值，将地址值赋给变量arr

总结

1.基本数据类型是值传递，变量赋值的时候是值传递。

2.引用类型在方法的地址传递给方法。

7.5二维数组 ---- 省略