java查找难点_（易忘篇）java基础编程难点2

本博客随笔主要记录本人学习过程中的知识，欢迎大家一同学习，有不对的地方很高兴读者能详细指出，感激不尽！

1、不同类型的一维数组元素的默认初始化值

整型元素 : 0

boolean型元素 : false

浮点型元素 : 0.0

char型元素 : 0或'\u0000'，而非'0'

引用类型元素 : null

2、一维数组的内存解析

方法中局部变量都会存在栈里面

new出来的对象都要放在堆空间中

数组中的元素为引用类型变量时，要么为null，要么存储的是地址值，指向字符串常量池中的值

关于数组：

数组一旦初始化，其长度就是确定的，

数组长度一旦确定，就不可修改。

3、二维数组的声明与初始化

正确的方式：

// 静态初始化

int[][] arr1 = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};

int[] arr2[] = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};

int[] arr3[] = {{1, 2, 3}, {4, 5}, {6, 7, 8}}; // 类型推断

// 动态初始化1

String[][] arr4 = new String[3][2];

// 动态初始化2

String[][] arr5 = new String[3][];

4、二维数组元素的默认初始化值

针对于初始化方式一：比如：int[][] arr = new int[4][3];

外层元素的初始化值为：地址值，

内存元素的初始化值为：与一维数组初始化情况相同。

针对于初始化方式二：比如：int[][] arr = new int[4][];

外层元素的初始化值为：null，

内存元素的初始化值为：不能调用，否则报错。

5、二维数组的内存解析

6、(冒泡和快速)排序算法及优化

冒泡排序及优化

/**

* 冒泡排序

* 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

* 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

* 针对所有的元素重复以上的步骤，除了最后一个。

* 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

*

*/

public class BubbleSort {

public static void bubbleSort(int[] data) {

System.out.println("开始排序");

int arrayLength = data.length;

for (int i = 0; i < arrayLength - 1; i++) {

for (int j = 0; j < arrayLength - 1 - i; j++) {

if (data[j] > data[j + 1]) {

int temp = data[j + 1];

data[j + 1] = data[j];

data[j] = temp;

}

}

System.out.println(java.util.Arrays.toString(data));

}

}

//优化1

public static void bubbleSort1(int[] data) {

System.out.println("开始排序");

int arrayLength = data.length;

for (int i = 0; i < arrayLength - 1; i++) {

boolean flag = false;

for (int j = 0; j < arrayLength - 1 - i; j++) {

if (data[j] > data[j + 1]) {

int temp = data[j + 1];

data[j + 1] = data[j];

data[j] = temp;

flag = true;

}

}

System.out.println(java.util.Arrays.toString(data));

if (!flag)

break;

}

}

public static void main(String[] args) {

int[] data = { 9, -16, 21, 23, -30, -49, 21, 30, 30 };

System.out.println("排序之前：\n" + java.util.Arrays.toString(data));

bubbleSort(data);

System.out.println("排序之后：\n" + java.util.Arrays.toString(data));

}

}

快速排序

/**

* 快速排序

* 通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，

* 则分别对这两部分继续进行排序，直到整个序列有序。

*/

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));

}

}

排序算法性能对比

7、查找(或搜索)

//线性查找：

String dest = "BB";

dest = "CC";

boolean isFlag = true;

for(int i = 0;i < arr.length;i++){

if(dest.equals(arr[i])){

System.out.println("找到了指定的元素，位置为：" + i);

isFlag = false;

break;

}

}

if(isFlag){

System.out.println("很遗憾，没有找到的啦！");

}

//二分法查找：(熟悉)

//前提：所要查找的数组必须有序。

int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};

int dest1 = -34;

dest1 = 35;

int head = 0;//初始的首索引

int end = arr2.length - 1;//初始的末索引

boolean isFlag1 = true;

while(head <= end){

int middle = (head + end)/2;

if(dest1 == arr2[middle]){

System.out.println("找到了指定的元素，位置为：" + middle);

isFlag1 = false;

break;

}else if(arr2[middle] > dest1){

end = middle - 1;

}else{//arr2[middle] < dest1

head = middle + 1;

}

}

if(isFlag1){

System.out.println("很遗憾，没有找到的啦！");

}

8、Arrays工具类的使用

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