java数组知识点总结

·

数组知识点总结

1.数据结构

数组 栈 链表 散列 二叉树/红黑数

2.数组特性

多个相同数据的储存容器，可以同一管理，是引用数据类型
占两块空间，栈内存变量保存堆内存对象的引用

3.数组声明 3种

1.静态声明：

数组类型[] 变量 = {值，值，值}；

2.动态声明：

数组类型[] 变量 = new 数组类型[长度];
整数:0 浮点数:0.0 char:\u0000 boolean:false 引用类型:null

3.数组传递，静态声明

数据类型[] 变量 = new 数据类型[]{值，值，值};

4.获取数据（查）

长度 arr.length 索引/下标index arr[i] 尾元素arr[length-1]

5.设置数据（改）

数组[1]=1;

6.遍历

for（）{
sysout(arr[i]);
}
增强for循环：把arr数组元素依次取出并赋值给i
for（int i：arr）{
sysout（i);
}

一维数组美观友好输出方法：

public static void printArray(int[] arr) {
	 System.out.print("{");
        for (int i=0;i<= arr.length-1;i++){
            if (i == arr.length-1){
                System.out.print(arr[i]);
            }else {
                System.out.print(arr[i]+",");
            }
        }
        System.out.println("}");
}

二维数组美观友好输出方法：

public static void printArray2(int[][] arr) {
	System.out.print("{");
    for(int i=0;i<arr.length;i++) {
    	System.out.print("{");
    	for(int j=0;j<arr[i].length;j++) {
    		if(j == arr[i].length-1) {
    			System.out.print(arr[i][j]);
    		}else {
    		System.out.print(arr[i][j]+",");
    		}
    	}
    	System.out.print("}");
    	if(i!=arr.length-1) {
    		System.out.print(",");
    	}
    }
    System.out.print("}");
}

7.常见异常

1.下标越界异常
2.空指针异常

8.数组传递 搞清楚 成员变量、局部变量、引用、堆内存

传值
传引用

9.数组复制

System.arraycopy()；进行数组替换式复制
src:源数组 srcpos:源起始位 dest:目标数组 destpos：目标起始 length：长度

10.API

System.arraycopy()；
Arrays.sort（）；数组升序

11.二维数组 （难点）

注：首先需要动态初始化一维数组，才能赋值
否则报错-空指针异常

int[][] arr = {{},{},{}…};
int[][] arr = new int[3][2]; 有3个一维数组，每个一维数组3个
int[][] arr = new int[3][];

11.1获取第一个一维数组

int[] arr0 = arr[0] //arr二维数组 arr0 二维中的一维
int arr00 = arr0[0]; //arr00 一维中的第一位

12.Scanner 用户交互输入

Scanner sc = new Scanner(System.in);
int a = sc.nextInt();

12.1字符sc.next（）；分隔符是空格，1 2 3 只接收1
sc.nextLine（）；接收一行数据，没有分隔符
12.2整型sc.nextInt( ); 接收整数，纯数字
12.3小数sc.nextDouble（）； 同上，只能有一个小数点
…

13.排序 （难点）

13.1交换变量的值

1.中间变量 （实用）
int temp = x；
x = y；
y = temp；
2.位移运算 （面试）相同取0，不同取1
x = x^y; ^异或
y = x^y;
x = x^y;
3.加减运算 （少见）
x=x+y；
y=x-y；
x=x-y；

13.2冒泡排序（冒泡排序相比选择排序，少比较一轮）

1.比较相邻两元素，第一个大于第二个交换位置
2.每一对相邻重复以上，最后一位最大
3.再重复以上，除了最后一个元素（比较次数递减）
4.一直到没有任何一对元素，终止
-嵌套循环
外层循环决定比较多少轮
内存循环决定每轮比较多少次

13.3选择排序

1.每次把最小放到左边
先拿出第一个，假设最小，挨个和后面所有比较，找到最小的放最前

13.4数组升序
Arrays.sort（）；数组升序

13.5二分法查找
1.必须建立在已排序的基础上
2.一般没有重复的数据，如果有 只能是找到谁算谁
3.一般用于查找固定的有序的数据，因为二分法不利于添加和删除操作，因为还需要保持元素有序

public static int binarySearch(int[] arr, int target) {
		// 1 确定起始索引,结束索引,中间索引
		int startIndex = 0;
		int endIndex = arr.length;
		int m = (startIndex + endIndex) / 2;
		// 2 使用目标数据和中间数据进行比较
		// 终止条件 : 不存在该数据,当起始值大于中间数据时,说明不存在,可以相等,相等说明还有一个数据没有比较
		while (startIndex <= endIndex) {
			// 3 第一种 : 中间值就是目标数据,直接返回中间索引 m 即可
			if (arr[m] == target) {
				return m;
			}
			// 4 第二种 : 中间值小于目标数据,结束值不变,起始值=中间值+1
			if (arr[m]<target) {
				startIndex=m+1;
			}
			// 5 第三种 : 中间值大于目标数据,起始值不变,结束值=中间值-1
			if (arr[m]>target) {
				endIndex=m-1;
			}
			// 重新生成中间值
			m = (startIndex + endIndex) / 2;
		}
		// 能执行到这里
		// 说明不存在该数据,当起始值大于中间数据时,说明不存在,可以相等,相等说明还有一个数据没有比较
		return -1;
	}