今日内容

零、 复习昨日
一、作业
二、数组拷贝
三、数组扩容
四、数组排序[面试|笔试]
五、引用类型[重要]
六、二维数组[了解]

零、 复习昨日

数组是用来存储多个数据.

内存是连续空间,有下标,下标从0开始,最大到长度-1
(下标就是位置,参考电影院的座位标号)

取值: int a = arr[0];

赋值: arr[0] = 10;

数组创建后能否改变长度： 不能，固定长度

数组创建后能否存储不同类型的数据： 不能

数组动态创建的语法,以int数组为例：int[] arr = new int[3];

数组静态创建的语法,以int数组为例: int[] arr = new int[]{1,2,3,4};
int[] = {11,22,33};

遍历是什么意思: 一个一个的取出数组中的元素

通过练习发现数组的特点:

1. 存储的顺序和遍历的顺序是一样的
2. 存储的数据能重复

一、作业

1.需求：定义一个方法，找出int数组中，最大值的索引下标[1,2,23,5,6,7,8]

public static int searchMaxIndex() {int a[] = {1,2,23,5,6,7,8};int max = a[0];// 找到最大值for (int i = 1; i < a.length; i++) {if (max < a[i]) {max = a[i];}}// 通过最大数找到它的下标for (int i = 0; i < a.length; i++) {if (max == a[i]){return i;}}return -1;}

第二种方案

   public static int gmax() {int[] arr = {1,2,23,5,6,7,8};int max = arr[0];int index = 0; // 假设最大数的下标是0// 通过找到最大的数for(int i = 1;i < arr.length;i++) {if(arr[i] > max) {max = arr[i];// 这是最大的数index = i; // i就是最大数的下标}}return index;}

3.需求：定义一个方法，在指定的int数组中找出指定的数据第一个的下标,找到返回-1
[1,2,8,4,5,8,7,8,9]

	// 主方法public static void main(String[] args) {int index = findIndexByElement(8);System.out.println(index);}// 根据数据找下标public static int findIndexByElement(int e) {int[] arr = {1,2,8,4,5,8,7,8,9};// 遍历for (int i = 0; i < arr.length; i++) {if (e == arr[i]) {return i;}}return -1;}

4【难-变式】. 在一个数组中，找出所有的 指定数据的下标位置
[1,2,8,4,5,7,8,7,8,9]

	/** 4【难】. 在一个数组中，找出所有的 指定数据的下标位置 并返回[1,2,8,4,5,7,8,7,8,9]-----------------思路: 1. 将找到所有下标存储数组中返回(因为数组存储多个数据)2. 找极端情况,假设数组全是重复数据,认为新数组和原数组一样长*/public static int[] findIndexByElement3(int e) {// 原始数组int[] arr = {1,2,8,4,5,8,7,8,9};// 新数组,存下标int[] indexArr = new int[arr.length];// 假设下标从0开始放int index = 0;for (int i = 0; i < arr.length; i++) {if (e == arr[i]) {indexArr[index] = i;index++;}}// null就是数组的默认值// return null;return indexArr;}

二、数组拷贝

数组拷贝: 将数组中的元素从一个数组赋值到另外一个数组中.例如:

int[] arr1 = {1,2,3,4};
int[] arr2 = new int[5];
// 将arr1里面数组元素赋值到arr2

方案一: 手动实现

	// 数组拷贝public static void copyArray() {// 源数组int[] arr1 = {11,22,33,44};// 目标数组int[] arr2 = new int[arr1.length];// 拷贝前打印arr2for (int i = 0; i < arr2.length; i++) {System.out.print(arr2[i] + " ");}System.out.println("\r\n--------------");// 遍历过程中完成拷贝for (int i = 0; i < arr1.length; i++) {arr2[i] = arr1[i];}// 拷贝完,打印arr2for (int i = 0; i < arr2.length; i++) {System.out.print(arr2[i] + " ");}}

利用拷贝,优化作业题4

	/** 4【难】. 在一个数组中，找出所有的 指定数据的下标位置 并返回[1,2,8,4,5,7,8,7,8,9]-----------------思路: 1. 将找到所有下标存储数组中返回(因为数组存储多个数据)2. 找极端情况,假设数组全是重复数据,认为新数组和原数组一样长3.  再创建一个和下标个数一样长的数组,使用数组拷贝*/public static int[] findIndexByElement3(int e) {// 原始数组int[] arr = {1,2,8,4,5,8,7,8,9};// 临时数组,存下标int[] tempArr = new int[arr.length];// 假设下标从0开始放int index = 0;for (int i = 0; i < arr.length; i++) {if (e == arr[i]) {tempArr[index] = i;index++;}}// 创建最终存储下标数组int[] indexArr = new int[index];// 从临时数组中将下标拷贝到最终数组for (int i = 0; i < indexArr.length; i++) {indexArr[i] = tempArr[i];}// null就是数组的默认值// return null;return indexArr;}

方案二: System类提供一个方法(了解)

// 重点!!!! 使用系统自带方法拷贝/** src : 源(source)* srcPos: 位置(position),从源数组哪里开始拷贝* dest  : 目的地(destination),目标数组* destPos: 目标数组从哪开始放* length: 长度,拷贝多少个*/System.arraycopy(arr1, 1, arr2, 1, 3);

	// System自带拷贝的方法,直接使用即可完成public static void copyArray2() {// 源数组int[] arr1 = {11,22,33,44};// 目标数组int[] arr2 = new int[2 * arr1.length];// 拷贝前打印arr2for (int i = 0; i < arr2.length; i++) {System.out.print(arr2[i] + " ");}System.out.println("\r\n--------------");// 重点!!!! 使用系统自带方法拷贝/** src : 源(source)* srcPos: 位置(position),从源数组哪里开始拷贝* dest  : 目的地(destination),目标数组* destPos: 目标数组从哪开始放* length: 长度,拷贝多少个*/System.arraycopy(arr1, 1, arr2, 1, 3);// 拷贝完,打印arr2for (int i = 0; i < arr2.length; i++) {System.out.print(arr2[i] + " ");}}

方案三: 系统数组工具类完成拷贝(了解)

// 系统自带Arrays数组工具类,完成拷贝
// 参数1是源数组,参数2 是拷贝多少个(从开头开始)
// 将拷贝的元素放入一个新数组返回
int[] arr2 =Arrays.copyOf(arr1, 2);

三、数组扩容

数组本身不能扩容,所谓"扩容",其实是重新创建一个全新数组,容量变大,然后将老数组内的元素拷贝到新数组,然后将数组的名字重新命名为之前的名字,使用时,我们"感觉"像是扩容了.

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

// 练习: 向数组存放元素,一直存放没有大小限制 (其实就是后续学习集合中ArrayList的思想)

// 变式简单点: 现有有一个数组,可以存储4个元素,当存储容量不够时,可以扩容一次变成存储8个元素 (需要限制只能存储非0数据,即认为0是没有存储数据)

四、数组排序[面试|笔试]

int[] arr = {3,2,5,1,4}; ----> {1,2,3,4,5}

4.1 冒泡排序算法

以升序为例: 相邻两个比较大小,如果前一个比后一个大,两者换位

        int[] arr = {6,5,4,3,2,1};		// 开始排序// 外层循环控制比较的趟数// -1 最后一趟不比较for (int i = 0;i < arr.length - 1;i++) {// 内层循环控制每趟比较几次// -1 不让越界// -i 是为了逐次减少比较次数for (int j = 0;j < arr.length - 1 - i;j++) {if(arr[j] > arr[j+1]) {int temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}

4.2 选择排序算法

	public static void sort() {int[] arr = {5,6,4,3,2,1};// 遍历看初始效果for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + " ");}System.out.println("\r ---------------");for (int i = 0; i < arr.length - 1; i++) {int min = i;// 假设第一个最低// 与后续每个人相比,找最低的那个人下标for (int j = i + 1; j < arr.length; j++) {if(arr[j] < arr[min]) {min = j;}}// 找到最低的那个人,与我换位置if(min != i) {int temp = arr[i];arr[i] = arr[min];arr[min] = temp;}}for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + " ");}}

五、引用类型[重要]

Java的数据类型分为两大类:
基本数据类型
引用类型: 数组,类,接口

何为引用类型?
通过一个变量引用内存中的对象.那么这个变量就是引用.
例如: int[] arr = new int[]{1,1,1};
以上代码会在堆内存中开启出一个空间,有地址值.将地址值赋值给变量arr
arr其实就是对象,也是引用.因为arr引用了内存中的数组,我们可以通过arr引用的地址找到数组,操作数组

基本类型: 值传递

	public static void main(String[] args) {int a = 1;System.out.println("1 a = " + a);// 将a变量的值1传递给方法change中的变量achange(a);System.out.println("1 a = " + a);}/** 基本类型的传递: 值传递*/public static void change(int a) {System.out.println("2 a = " + a);a = a * 10;System.out.println("3 a = " + a);}

引用类型传递: 引用传递

  public static void main(String[] args) {// 初始一个数组int[] arr = new int[]{1,1,1};// 第一次输出for (int i = 0; i < arr.length; i++) {System.out.print(arr[i]+" ");}System.out.println("\r\n-----------");// 将数组传递给方法// 其实是将数组引用的地址传递给了方法change2(arr);for (int i = 0; i < arr.length; i++) {System.out.print(arr[i]+" ");}System.out.println("\r\n-----------");}/** 引用类型: 引用传递(地址传递)*/public static void change2(int[] arr) {for (int i = 0; i < arr.length; i++) {System.out.print(arr[i]+" ");}System.out.println("\r\n-----------");// 将每个元素扩大十倍for (int i = 0; i < arr.length; i++) {arr[i] = arr[i] * 10;}for (int i = 0; i < arr.length; i++) {System.out.print(arr[i]+" ");}System.out.println("\r\n-----------");}	

package com.qf.array;/** 利用引用类型的引用传递* 来完成一些效果*/
public class Demo6 {public static void main(String[] args) {int[] arr = {5,4,3,2,1};for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] +" ");}// 将数组的地址传递给方法sort(arr);System.out.println();for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] +" ");}}// 从小到大队数组排序// sort方法arr参数就指向内存那个数组,完成排序public static void sort(int[] arr) {// 外层循环控制比较的趟数for (int i = 0; i < arr.length - 1; i++) {// 内层循环控制每趟比较几次for (int j = 0; j < arr.length - 1 - i; j++) {if (arr[j] > arr[j + 1]) {int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}
}

总结:

1. 基本类型在方法传参数,变量赋值等时候是值传递
2. 引用类型在方法传参,变量赋值等时候是引用传递
3. 方法执行进栈,执行完出栈,方法内的变量会随着方法出栈而消失
4. 凡是new都会在堆内存开辟空间,分配地址,创建对象

六、Arrays工具类[常用]

Java提供的工具类,操作数组的.内部有方法

• copyOf()
• sort()
• toString()

/** Arrays工具类*/
public class Demo7 {public static void main(String[] args) {int[] arr = {5,4,3,2,1};// Arrays.toString()// 将数组中的元素以字符串返回String s1 = Arrays.toString(arr);System.out.println(s1);
//		for (int i = 0; i < arr.length; i++) {
//			System.out.println(arr[i]);
//		}//Arrays.sort(arr) 会将数组按升序排序Arrays.sort(arr);//		for (int i = 0; i < arr.length; i++) {
//			System.out.println(arr[i]);
//		}System.out.println(Arrays.toString(arr));}
}