java第三章Eclipse和数组笔记

准图灵奖得主

已于 2022-02-01 02:34:05 修改

阅读量230

点赞数

分类专栏： Java笔记文章标签： eclipse java ide

于 2022-01-16 14:09:31 首次发布

本文为博主原创文章，未经允许不得转载。如有问题，欢迎指正！

本文链接：https://blog.csdn.net/IAMLSL/article/details/122517991

版权

Java笔记专栏收录该内容

16 篇文章 4 订阅

订阅专栏

Eclipse使用和配置

转到>>第一章后半部分查看

3.1数组的概述

数组(Array),是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

数组的常见概念

数组名
下标（或索引）
元素
数组的长度

数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
数组的长度一旦确定，就不能修改。
我们可以直接通过下标（或索引）的方式调用指定位置的元素，速度很快。
数组的分类：

按照维度：一维数组、二维数组、三维数组、…
按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组（即对象数组)

3.2一维数组的使用

一维数组的声明和初始化

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[] arr4 = {1,2,3,4,5};//类型推断
总结： 数组一旦初始化完成，其长度就确定了。

调用数组的指定位置的元素:通过角标的方式调用。

String[] names = new String[5];
names[0] = “王铭”;
names[1] = “王赫”;
names[2] = “张学良”;
names[3] = “孙居龙”;
names[4] = “王宏志”;
System.out.println(names[i]); //0=<i=<4

获取数组的长度

String[] names = new String[5];
int len=names.length； //获取数组的长度

遍历数组

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

数组元素的默认初始化值

数组元素是整型：0
数组元素是浮点型：0.0
数组元素是char型：0或’\u0000’，而非’0’
数组元素是boolean型：false
数组元素是引用数据类型：null

数组的内存解析

栈(stack):存放局部变量
堆(heap): 存放new出来的结构：对象、数组
方法区(包含静态域、常量池等)：如static变量放在静态域、字符串放在常量池。

3.3多维数组的使用

Java语言里提供了支持多维数组的语法。
如果说可以把一维数组当成几何中的线性图形，那么二维数组就相当于是一个表格。
对于二维数组的理解，我们可以看成是一维数组 array1又作为另一个一维数组array2的元素而存在。其实，从数组底层的运行机制来看，其实没有多维数组。

二维数组的声明和初始化

int [][]arr = new int [][]{ {1,2,3},{4,5},{6,7,8}}; //静态初始化
String[][] arr2 = new String[3][2];//动态初始化2
错误的情况：
String[][] arr3 = new String[3][];
String[][] arr4 = new String[][4];
String[4][3] arr5 = new String[][];
int[][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}};
正确的写法：
int[][]arr4 = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
int[][] arr5 = {{1,2,3},{4,5},{6,7,8}};
int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};

如何调用数组的指定位置的元素

System.out.println(arr[0][1]);//2
System.out.println(arr2[1][1]);//null

获取数组的长度

int[][]arr4 = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
System.out.println(arr4.length);//3
System.out.println(arr4[0].length);//3
System.out.println(arr4[1].length);//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();
}

数组元素的默认初始化值
规定：二维数组分为外层数组的元素，内层数组的元素。

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
内层元素的初始化值为：不能调用，否则报错。

二维数组的内存解析

11.补充

一维数组： int[] x 或者 int x[]
二维数组： int[][] y 或者 int[] y[] 或者 int y[][]

3.4数组中涉及到的常见算法

1.数组元素的赋值（杨辉三角、回形数等）

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

2.求数值型数组中元素的最大值、最小值、平均数、总和等
3.数组的复制、反转、查找（线性查找、二分法查找）
4.数组元素的排序算法

//数组的冒泡排序的实现
public class BubbleSortTest {
	public static void main(String[] args) {
		
		int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
		
		//冒泡排序
		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;
				}
				
			}
			
		}
		
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + "\t");
		}
		
	}
}

/**
 * 快速排序
 * 通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，
 * 则分别对这两部分继续进行排序，直到整个序列有序。
 */
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));
	}
}

3.5 Arrays工具类的使用

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

方法	作用
boolean equals(int a,int b)	判断两个数组是否相等。
String toString(int a)	输出数组信息。
void fill(int a,int val)	将指定值填充到数组之中
int binarySearch(int[]a,int key)	对排序后的数组进行二分法检索指定的值

3.6 数组使用中常见的异常

数组角标越界的异常：ArrayIndexOutOfBoundsExcetion
空指针异常：NullPointerException

空指针异常：NullPointerException
//情形一：
int[] arr1 = new int[]{1,2,3};
arr1 = null;
System.out.println(arr1[0]);
//情形二：
int[][] arr2 = new int[4][];
System.out.println(arr2[0][0]);
//情形三：
String[] arr3 = new String[]{“AA”,“BB”,“CC”};
arr3[0] = null;
System.out.println(arr3[0].toString());