Java数组入门超详细-Java教程(尚硅谷笔记-数组这一篇就够了)

一、数组的描述

  1. 数组就是存储数据长度固定的容器,保证多个数据的数据类型要一致。
  2. 数组的相关概念:
  • 2.1.数组名
  • 2.2.元素
  • 2.3.角标、下标、索引
  • 2.4.数组的长度(元素的个数)

3.数组的分类:

  • 3.1. 按照维数:一维数组、二维数组、三维数组……
  • 3.2.按照数组元素类型:基本数据类型元素的数组、引用类型元素的数组

4.数组的特点:

  • 4.1.数组属于引用类型的变量。数组的元素,既可以是基本数据类型,也可以是引用数据类型。
  • 4.2.创建数组对象会在内存中开辟一整块连续的空间;
  • 4.3.数组的长度一旦确定,就不能修改;
  • 4.5.数组是有序排列的。

二、 一维数组

2.1、一维数组的基本使用

  • 一维数组的声明和初始化
  • 如何调用数组的指定位置的元素
  • 如何获取数组的长度
  • 如何遍历数组
  • 数组元素的默认初始化值:见ArrayTest1.java
  • 数组的内存解析:见ArrayTest1.java
代码案例1——ArrayTest.java
public class ArrayTest {
	public static void main(String[] args) {
		
		//1. 一维数组的声明和初始化
		int num;	//声明
		num = 10;	//初始化
		int id = 1001;	//声明 + 初始化
		
		int[] ids;	//声明
		//1.1静态初始化:数组的初始化和数组元素的赋值操作同时进行
		ids = new int[]{1001,1002,1003,1004};	
		//1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
		String[] names = new String[5]; 
		
		//错误的写法:
//		int[] arr1 = new int[];	//未赋值、未指明长度
//		int[5] arr2 = new int[5];
//		int[] arr3 = new int[3]{1,2,3};
		
		//也是正确的写法:
		int[] arr7 = {1,2,3,5,4};//类型推断
		
		/*总结:数组一旦初始化完成,其长度就确定了。
		*/
		
		//2.如何调用数组的指定位置的元素:通过角标的方式调用。
		//数组的角标(或索引)从0开始的,到数组的长度-1结束
		names[0] = "张郃";
		names[1] = "王陵";
		names[2] = "张学良";
		names[3] = "王传志";	//charAt(0)
		names[4] = "李峰";
//		names[5] = "周礼";	//如果数组超过角标不会通过编译,运行失败。
		
		//3.如何获取数组的长度
		//属性.length
		System.out.println(names.length);	//5
		System.out.println(ids.length);	//4
		
		//4.如何遍历数组
//		System.out.println(names[0]);
//		System.out.println(names[1]);
//		System.out.println(names[2]);
//		System.out.println(names[3]);
//		System.out.println(names[4]);
		
		for(int i = 0;i < names.length;i++){
			System.out.println(names[i]);
		}
		
	}
}

代码案例2——ArrayTest1.java
/*
 * ⑤ 数组元素的默认初始化值
 * 		> 数组元素是整形:0
 * 		> 数组元素是浮点型:0.0
 * 		> 数组元素是char型:0或'\u0000',而非'0'
 * 		> 数组元素是boolean型:false
 * 
 * 		> 数组元素是引用数据类型:null 
 */
public class ArrayTest1 {
	public static void main(String[] args) {
		//5.数组元素的默认初始化值
		int[] arr = new int[4];
		for(int i = 0;i < arr.length;i++){
			System.out.println(arr[i]);
		}
		System.out.println("*****************");
		
		short[] arr1 = new short[4];
		for(int i = 0;i < arr1.length;i++){
			System.out.println(arr1[i]);
		}
		System.out.println("*****************");
		
		float[] arr2 = new float[5]; 
		for(int i = 0;i < arr2.length;i++){
			System.out.println(arr2[i]);
		}
		System.out.println("*****************");
		
		char[] arr3 = new char[5]; 
		for(int i = 0;i < arr3.length;i++){
			System.out.println("----" + arr3[i] + "****");
		}
		
		if(arr3[0] == 0){
			System.out.println("你好!");
		}
		System.out.println("*****************");
		
		boolean[] arr4 = new boolean[5];
		System.out.println(arr4[0]);
		
		System.out.println("*****************");
		String[] arr5 = new String[5];
		System.out.println(arr5[0]);
		//验证
		if(arr5[0] == null){
			System.out.println("北京天气好差!");
		}
		
	}
}

2.2、一维数组的内存解析

int[] arr = new int[]{1,2,3};
String[] arr1 = new String[4];
arr1[1] = “刘德华”;
arr1[2] = “张学友”;
arr1 = new String[3];
System.out.println(arr1[1]);//null

Java数组入门超详细-Java教程(尚硅谷笔记-数组这一篇就够了)_第1张图片

2.3、练习题

/*
 * 升景坊单间短期出租4个月,550元/月(水电煤公摊,网费35元/月),空调、卫生间、厨房齐全。
 * 屋内均是IT行业人士,喜欢安静。所以要求来租者最好是同行或者刚毕业的年轻人,爱干净、安静。
 * eclipse代码一键格式规范化:Ctrl+Shift+F
 */
public class ArrayDemo {
	public static void main(String[] args) {
		int[] arr = new int[] { 8, 2, 1, 0, 3 };
		int[] index = new int[] { 2, 0, 3, 2, 4, 0, 1, 3, 2, 3, 3 };
		String tel = "";
		for (int i = 0; i < index.length; i++) {
			tel += arr[index[i]];
		}
		System.out.println("联系方式:" + tel);
	}
}

三 、二维数组

3.1、二维数组的概念

  • 对于二维数组的理解,我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。
  • 其实,从数组底层的运行机制来看,其实没有多维数组。

3.2、二维数组的使用:

  • 二维数组的初始化
  • 如何调用数组的指定位置的元素
  • 如何获取数组的长度
  • 如何遍历数组
  • 数组元素的默认初始化值:见ArrayTest3.java
  • 数组的内存解析:见ArrayTest3.java

代码案例——ArrayTest2.java

public class ArrayTest2 {
	public static void main(String[] args) {
		//1.二维数组的声明和初始化
		int[] arr = new int[]{1,2,3};
		//静态初始化
		int[][] arr1 = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
		//动态初始化1
		String[][] arr2 = new String[3][2];
		//动态初始化2
		String[][] arr3 = new String[3][];
		
		//错误的情况
//		String[][] arr4 = new String[][];
//		String[][] arr5 = new String[][4];
//		String[][] arr6 = new String[4][3]{{1,2,3},{4,5,6},{7,8,9}};
		
		//正确的情况:
		int arr4[][] = new int[][]{{1,2,3},{4,5,12,6},{7,8,9}};
		int[] arr5[] = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
		int[][] arr6 = {{1,2,3},{4,5,6},{7,8,9}};		
		
		//2.如何调用数组的指定位置的元素
		System.out.println(arr1[0][1]);	//2
		System.out.println(arr2[1][1]);	//null
		
		arr3[1] = new String[4];	//定义arr3的[1]为长度为4的字符数组
		System.out.println(arr3[1][0]);	//没有上句,会报错
		
		//3.获取数组的长度
		System.out.println(arr4.length);	//3
		System.out.println(arr4[0].length);	//3
		System.out.println(arr4[1].length);	//4
		
		//4.如何遍历二维数组
		for(int i = 0;i < arr4.length;i++){
			for(int j = 0;j < arr4[i].length;j++){
				System.out.print(arr4[i][j] + " ");
			}
			System.out.println();
		}
	}
}

代码案例——ArrayTest3.java

/*
 * 二维数组的使用:
 * 	规定:二维数组分为外层数组的元素,内层数组的元素
 * 	int[][] arr = new int[4][3]; 
 *  外层元素:arr[0],arr[1]等
 *  内层元素:arr[0][0],arr[1][2]等
 *  
 * 	⑤ 数组元素的默认初始化值
 * 	针对于初始化方式一:比如:int[][] arr = new int[4][3];
 * 		外层元素的初始化值为:地址值
 * 		内层元素的初始化值为:与一维数组初始化情况相同
 * 	
 * 针对于初始化方式而:比如:int[][] arr = new int[4][];
 * 		外层元素的初始化值为:null
 * 		内层元素的初始化值为:不能调用,否则报错。
 * 
 * 	⑥ 数组的内存解析
 */
public class ArrayTest3 {
	public static void main(String[] args) {
		
		int[][] arr = new int[4][3];
		System.out.println(arr[0]);	//[I@15db9742
		System.out.println(arr[0][0]);	//0
		
//		System.out.println(arr);	//ArrayTest3.java
		
		System.out.println("***********************");
		float[][] arr1 = new float[4][3];
		System.out.println(arr1[0]);	//地址值
		System.out.println(arr1[0][0]);	//0.0
		
		System.out.println("***********************");
		
		String[][] arr2 = new String[4][2];
		System.out.println(arr2[1]);	//地址值
		System.out.println(arr2[1][1]);	//null
		
		System.out.println("*********************");
		double[][] arr3 = new double[4][];
		System.out.println(arr3[1]);	//null
//		System.out.println(arr3[1][0]);	//报错
	}
}

3.3、二维数组的内存解析

int[][] arr1 = new int[4][];
arr1[1] = new int[]{1,2,3};
arr1[2] = new int[4];
arr1[2][1] = 30;

Java数组入门超详细-Java教程(尚硅谷笔记-数组这一篇就够了)_第2张图片

3.4、练习题

Java数组入门超详细-Java教程(尚硅谷笔记-数组这一篇就够了)_第3张图片

public class ArrayEver1 {
	public static void main(String[] args) {
		int[][] arr = new int[][]{{3,5,8},{12,9},{7,0,6,4}};
		int sum = 0;	//记录总和
		for(int i = 0;i < arr.length;i++){
			for(int j = 0;j < arr[i].length;j++){
				sum += arr[i][j];
			}
		}
		System.out.println(sum);
	}
}

使用二维数组打印一个 10 行杨辉三角。

/*
 * 【提示】
 * 1. 第一行有 1 个元素, 第 n 行有 n 个元素
 * 2. 每一行的第一个元素和最后一个元素都是 1
 * 3. 从第三行开始, 对于非第一个元素和最后一个元素的元素。
 * 即:yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
 */
public class ArrayEver2 {
	public static void main(String[] args) {
		//1.声明并初始化二维数组
		int[][] arr = new int[10][];
		
		//2.给数组的元素赋值,遍历二维数组
		for(int i = 0;i < arr.length;i++){
			arr[i] = new int[i+1];
			
			//2.1 给首末元素赋值
			arr[i][0]=arr[i][i]=1;
			//2.2 给每行的非首末元素赋值
		//	if(i > 1){
			for(int j = 1;j < arr[i].length-1;j++){
					arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
				}
		//	}
	
		}
		
	//	3.遍历数组
		for(int i = 0;i < arr.length;i++){
			for(int j = 0;j <arr[i].length;j++){
				System.out.print(arr[i][j] + " ");
			}
			System.out.println();
		}
		
	}
}

3.5、面试题目

1、创建一个长度为 6 的 int 型数组,要求取值为 1-30,同时元素值各不相同

//此题只做了解,初学不必精通。
public class ArrayEver3 {
	public static void main(String[] args) {
		// 方式一:
//		int[] arr = new int[6];
//		for (int i = 0; i < arr.length; i++) {// [0,1) [0,30) [1,31)
//			arr[i] = (int) (Math.random() * 30) + 1;
//
//			boolean flag = false;
//			while (true) {
//				for (int j = 0; j < i; j++) {
//					if (arr[i] == arr[j]) {
//						flag = true;
//						break;
//					}
//				}
//				if (flag) {
//					arr[i] = (int) (Math.random() * 30) + 1;
//					flag = false;
//					continue;
//				}
//				break;
//			}
//		}
//
//		for (int i = 0; i < arr.length; i++) {
//			System.out.println(arr[i]);
//		}
		// 方式二:
		int[] arr2 = new int[6];
		for (int i = 0; i < arr2.length; i++) {// [0,1) [0,30) [1,31)
			arr2[i] = (int) (Math.random() * 30) + 1;

			for (int j = 0; j < i; j++) {
				if (arr2[i] == arr2[j]) {
					i--;
					break;
				}
			}
		}

		for (int i = 0; i < arr2.length; i++) {
			System.out.println(arr2[i]);
		}
	}
}    

四、数组常见异常

4.1.、数组越界异常

观察一下代码,运行后会出现什么结果?

public static void main(String[] args) {
 int[] arr = {1,2,3}; 
 System.out.println(arr[3])
 } 

创建数组,赋值3个元素,数组的索引就是0,1,2,没有3索引,因此我们不能访问数组中不存在的索引,程序运行后,将会抛出 ArrayIndexOutOfBoundsException 数组越界异常。在开发中,数组的越界异常是不能出现的,一 旦出现了,就必须要修改我们编写的代码。

4.2.、数组空指针异常

观察一下代码,运行后会出现什么结果。

public static void main(String[] args) { 
	int[] arr = {1,2,3};
	arr = null;
 	System.out.println(arr[0]);

arr = null 这行代码,意味着变量arr将不会在保存数组的内存地址,也就不允许再操作数组了,因此运行的时候 会抛出 NullPointerException 空指针异常。在开发中,数组的空指针异常是不能出现的,一旦出现了,就必须要修改我们编写的代码。
Java数组入门超详细-Java教程(尚硅谷笔记-数组这一篇就够了)_第4张图片

五、数组常见操作

5.1. 数组反转
数组的反转: 数组中的元素颠倒顺序,例如原始数组为1,2,3,4,5,反转后的数组为5,4,3,2,1

实现思想: 对称位置的元素交换

  • 实现反转,就需要将数组对称元素位置交换
  • 定义两个变量,保存数组的最小索引和最大索引
  • 两个索引上的元素交换位置 最小索引++,最大索引–,再次交换位置
  • 最小索引超过了最大索引,数组反转操作结束

实现思路:

  • 把数组最小索引元素和数组的最大索引元素交换

  • 把数组次小索引元素和数组索引次大索引元素交换

  • 定义两个索引,一个指向最小索引,一个指向最大索引
    int min = 0; int max = arr.length - 1;

  • 遍历数组,让两个索引变化
    min++,max–, 交换条件 min < max;

  • 交换最小索引元素 和最大索引元素
    需要定义三方变量
    int temp = arr[min];
    arr[min] = arr[max];
    arr[max] = temp;

代码实现:

public static void main(String[] args) { 
	int[] arr = { 1, 2, 3, 4, 5 }; 
	/*循环中定义变量min=0最小索引 max=arr.length‐1最大索引 
	min++,max‐‐ 
	*/ 
	for (int min = 0, max = arr.length ‐ 1; min <= max; min++, max‐‐) { 
		//利用第三方变量完成数组中的元素交换 
		int temp = arr[min]; 
		arr[min] = arr[max]; 
		arr[max] = temp; }// 反转后,遍历数组
	for (int i = 0; i < arr.length; i++) { 
		System.out.println(arr[i]);
 	} 
}

5.2、数组获取最大元素

最大值获取:从数组的所有元素中找出最大值。

实现思路:

  • 定义变量 max,保存数组0索引上的元素
  • 遍历数组,获取出数组中的每个元素
  • 将遍历到的元素和保存数组0索引上值的max变量进行比较
  • 如果数组元素的值大于了变量的值,变量记录住新的值
  • 数组循环遍历结束,变量保存的就是数组中的最大值

5.3、数组排序

  • 选择排序
    • 直接选择排序、堆排序
  • 交换排序
    • 冒泡排序、快速排序
  • 插入排序
    • 直接插入排序、折半插入排序、Shell 排序
  • 归并排序
  • 桶式排序
  • 基数排序
/**
  * 快速排序
  * 通过一趟排序将待排序记录分割成独立的两部分,其中一部分记录的关键字均比另一部分关键字小,
  * 则分别对这两部分继续进行排序,直到整个序列有序。
  *
 */
public class QuickSort {
	private static void swap(int[] data, int i, int j) {
		int temp = data[i];
		data[i] = data[j];
		data[j] = temp;
	}
	private static void subSort(int[] data, int start, int end) {
		if (start < end) {
			int base = data[start];
			int low = start;
			int high = end + 1;
			while (true) {
				while (low < end && data[++low] - base <= 0)
					;
				while (high > start && data[--high] - base >= 0)
					;
				if (low < high) {
					swap(data, low, high);
				} else {
					break;
				}
			}
			swap(data, start, high);
			
			subSort(data, start, high - 1);//递归调用
			subSort(data, high + 1, end);
		}
	}
	public static void quickSort(int[] data){
		subSort(data,0,data.length-1);
	}
	
	public static void main(String[] args) {
		int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
		System.out.println("排序之前:\n" + java.util.Arrays.toString(data));
		quickSort(data);
		System.out.println("排序之后:\n" + java.util.Arrays.toString(data));
	}
}

六、常用API

6.1. 输出数组 Arrays.toString()

 int[] array = { 1, 2, 3 };
 System.out.println(Arrays.toString(array));

6.2. 数组转List Arrays.asList()

	String[] array2 = {"a", "b", "c", "d"};
	System.out.println(array2);  // [Ljava.lang.String;@13b6d03
	List list = new ArrayList(Arrays.asList(array2));
	System.out.println(list);   // [a, b, c, d]
	list.add("GG");
	System.out.println(list);  // [a, b, c, d, GG]

6.3. 数组转Set Arrays.asList()

	String[] array = { "a", "b", "c", "d", "e" };
	Set set = new HashSet(Arrays.asList(array));
	System.out.println(set);

6.4. List转数组 toArray()

	List list = new ArrayList();
	list.add("a");
	list.add("b");
	list.add("c");
	String[] array = new String[list.size()];
	list.toArray(array);
	for (String s : array)
	System.out.println(s);

6.5. 数组中是否包含某个值

String[] array = { "a", "b", "c", "d", "e" };
boolean isEle = Arrays.asList(array).contains("a");
System.out.println(isEle);

6.6. 数组复制

int array[] = new int[] { 1, 2, 3, 4 };
int array1[] = new int[array.length];
System.arraycopy(array, 0, array1, 0, array.length);

6.7. 数组合并

int[] array1 = { 1, 2, 3, 4, 5 };
int[] array2 = { 6, 7, 8, 9, 10 };
int[] array = org.apache.commons.lang.ArrayUtils.addAll(array1, array2);
System.out.println(Arrays.toString(array));
String数组转字符串(使用指定字符拼接)
String[] array = { "a", "b", "c" };
String str = org.apache.commons.lang.StringUtils.join(array, ", ");
System.out.println(str);

6.8. 数组逆序

int[] array = { 1, 2, 3, 4, 5 };
org.apache.commons.lang.ArrayUtils.reverse(array);
System.out.println(Arrays.toString(array));

6.9. 数组元素移除

int[] array = { 1, 2, 3, 4, 5 };
int[] removed = org.apache.commons.lang.ArrayUtils.removeElement(array, 3);
System.out.println(Arrays.toString(removed));  

七、Arrays 工具类的使用

java.util.Arrays类即为操作数组的工具类,包含了用来操作数组(比如排序和搜索)的各种方法。

import java.util.Arrays;
/*
 * java.util.Arrays:作数组的工具类,包含了用来操作数组(比如排序和搜索)的各种方法。
 */
public class ArrayTest4 {
	public static void main(String[] args) {
		
		//1.boolean equals(int[] a,int[] b)判断两个数组是否相等。
		int[] arr1 = new int[]{1,2,3,4};
		int[] arr2 = new int[]{1,2,9,3};
		boolean isEquals = Arrays.equals(arr1, arr2);
		System.out.println(isEquals);
		
		//2.String toString(int[] a)输出数组信息。
		System.out.println(Arrays.toString(arr1));		
		
		//3.void fill(int[] a,int val)将指定值填充到数组之中。
		Arrays.fill(arr1, 10);
		System.out.println(Arrays.toString(arr1));		
		
		//4.void sort(int[] a)对数组进行排序。
		Arrays.sort(arr2);
		System.out.println(Arrays.toString(arr2));
		
		//5.int binarySearch(int[] a,int key)对排序后的数组进行二分法检索指定的值。
		int[] arr3 = new int[]{43,32,76,92,-65,85,71,-42}; 
		int index = Arrays.binarySearch(arr3, 210);
		if(index >= 0){
			System.out.println(index);
		}else{
			System.err.println("未找到。");
		}		
	}
}

你可能感兴趣的:(笔记,java,开发语言)