一天一个变成了几天一个,最近接受的新东西太多、太快,有好多需要blog的但没有时间,这些基础知识应该是要深挖并好好研究的,不应该每次都草草了事,只看个皮毛。
数组:
JVM将数组存储在一个称为堆(heap)的内存区域中,堆用于动态内存分配,在堆中内存块可以按随意的顺序分配和释放
1.int[] a; ——表示声明一个数组(也可写为 int a[];)
声明一个数组变量时并不在内存中给数组分配任何空间,只是创建一个对数组的引用的存储位置
如果变量不包含对数组的引用,那么这个变量的值为null
通过new操作符创建数组
使用数组初始化语法时,必须将声明、创建和初始化数组都放在一条语句中,如下面代码是错误的:
double[] myList;
myList = {1, 2, 3};
2.数组在方法中的传递
public static void main(String[] args) {
int x = 1;
int[] y = new int[10];
m(x,y);
syso("x is " + x);
syso("y[0] is" + y[0]);
}
public void m(int number, int[] numbers) {
number = 10;
numbers[0] = 10;
}
//output:
x is 1
y[0] is 10
这是因为:
对于基本数据类型参数,传递的是实参的值
对于数组类型参数,参数值是数组的引用,给方法传递的是这个引用
3.查询
线性查询与二分查询
package Test;
public class Test2 {
/**
* 二分查找:
* 使用二分查找法的前提条件是数组中的元素必须已经排好序
* 二分查找法首先将关键字与数组的中间元素进行比较,有下面3种情况
* 1.如果关键字小于中间元素,只需要在数组的前一半元素中继续查找
* 2.如果关键字大于中间元素,只需要在数组的后一半元素中继续查找
* 3.如果关键字与中间元素相等,那么就找到了,查找结束
* 如一个有1024(2^10)个元素的数组,最好情况下只需要比较11次,最坏情况下要比较1023次
*/
public static void main(String[] args) {
int[] list = {1, 4, 4, 2, 5, -3, 6, 2};
int i = lineraSearch(list, 4);
System.out.println(i);
int j = lineraSearch(list, -4);
System.out.println(j);
int k = lineraSearch(list, -3);
System.out.println(k);
int[] list1 = {2, 4, 7, 10, 11, 45, 50, 59, 60, 66, 69, 70, 79};
int i1 = binarySearch(list1, 2);
System.out.println(i1);
int j1 = binarySearch(list1, 11);
System.out.println(j1);
int k1 = binarySearch(list1, 79);
System.out.println(k1);
//output:
/*
1
-1
5
0
4
12
*/
}
/**
* 线性查找法——最简单、最low
* @param list
* @param key
* @return
*/
public static int lineraSearch(int[] list, int key) {
for (int i = 0; i < list.length; i++) {
if (key == list[i]){
return i;
}
}
return -1;
}
/**
* 二分查找法
* @param list
* @param key
* @return
*/
public static int binarySearch(int[] list, int key) {
int low = 0;
int high = list.length - 1;
while (high >= low) {
int mid = (high + low) / 2;
if (key < list[mid]) {
high = mid - 1;
} else if (key == list[mid]) {
return mid;
} else {
low = mid + 1;
}
}
return -1;
}
}
4.排序
选择排序
1 /*
2 * 选择排序
3 * 1.选择排序法先找到数列中最小的数
4 * 2.然后将它放在数列的最前面
5 * 3.在剩下的数中,循环1、2操作
6 */
7 public static void selectionSort(int[] array) {
8 for (int i = 0; i < array.length - 1; i++) {
9 int minValue = array[i];
10 int minIndex = i;
11 for (int j = i + 1;j < array.length;j++) {
12 if (array[j] < minValue) {
13 minValue = array[j];
14 minIndex = j;
15 }
16 }
17 if (minIndex != i) {
18 array[minIndex] = array[i];
19 array[i] = minValue;
20 }
21 }
22 }
插入排序
1 /*
2 * 插入排序
3 * 1.外层循环(循环控制变量i)的迭代是为了获取已排好序的子数列
4 * 2.内层循环(循环控制变量k)将list[i]插入到从list[0]到list[i-1]的子数列中
5 */
6 public static void insertionSort(int[] array) {
7 for (int i = 1; i < array.length; i++) {
8 int minValue = array[i];
9 int k;
10 for (k = i - 1;k >= 0 && minValue < array[k]; k--) {
11 array[k + 1] = array[k];
12 }
13 array[k + 1] = minValue;
14 }
15 }
冒泡排序
快速排序