数组:
数组是相同类型数据的有序集合。数组描述的是相同类型的若干数据,按照一定的先后次序排列组合而成。
基本特点:
不能同时静态初始化又动态初始化,即:
int[] arr = new int[2]{1,2};
会报错
数组特点
- 长度确定,一把被创建,大小就是不可改变的。
- 数组内元素必须是相同类型
- 数组类型可以是任何数据类型,包括基本类型和引用类型
- 数组变量属于引用类型,数组可以看成是对象,数组中的每个元素相当于该对象的成员变量。Java中对象时存储在堆中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身都是在堆中存储。
type[] arr_name; //(推荐使用这种方式)
type arr_name[];//部分语音已经不支持这种声明方式
int [] arr01 = new int[10];
数组的声明和初始化:数组的声明只在栈当中开辟一块内存数组变量,堆里面什么都没有。只有在初始化的时候才会在堆中开辟一块空间。
静态初始化
在定义数组同时就给数组元素分配空间并赋值。
int[] a = { 1, 2, 3 };// 静态初始化基本类型数组;
Man[] mans = { new Man(1, 1), new Man(2, 2) };// 静态初始化引用类型数组;
动态初始化
将数组的定义,为数组元素分配空间和赋值分开操作。
int[] a1 = new int[2];//动态初始化数组,先分配空间;
a1[0]=1;//给数组元素赋值;
a1[1]=2;//给数组元素赋值;
默认初始化
数组是引用类型,它的元素相当于类的实例变量,因此数组一经分配空间,其中的每个元素也被按照实例变量同样的方式被隐式初始化。
int a2[] = new int[2]; // 默认值:0,0
boolean[] b = new boolean[2]; // 默认值:false,false
String[] s = new String[2]; // 默认值:null, null
foreach循环
该循环仅用于读取数组元素的值,不能修改本数组内元素的值,每一个temp都是数组内元素的一个副本,并不是原来的数组元素。
temp只是一个临时变量,和原来的数组内的元素没有任何关联。输出的结果还是原数组
数组中的删除本质上还是拷贝。
public static String[] arrayDelete(String[] s, int index){
System.arraycopy(s,index+1,s,index,s.length-(index + 1));
s[s.length - 1] = null;
for(int i = 0; i<s.length; i++){
System.out.println(i + "--" + s[i]);
}
return s;
}
数组的扩容
本质上是先定义一个更大的数组,然后将原数组内容原封不动拷贝到新数组中
public static String[] arrayExtand(String [] s1,int length){
String [] s2 = new String [s1.length+10];
System.arraycopy(s1,0,s2,0,s1.length);
return s2;
}
数组的插入
本质上是先定一个更大的数组,然后将原数组内容分两段拷贝到新数组中,然后插入想要插入的元素
public static String[] arrayInsert(String [] s1, String s, int index){
String [] s2 = new String [s1.length+1];
System.arraycopy(s1,0,s2,0,index);
s2[index] = s;
System.arraycopy(s1,index,s2,index+1,s1.length - index);
return s2;
}
java.util.Array
导入java.util.Array包。
二维数组
int[][] a = new int[3][];
a[0] = new int[]{20,30};
a[1] = new int[]{10,15,80};
a[2] = new int[]{11,22,80};
int[][] b = {
{20,30,40},
{50,20},
{100,200,300,400}
};
System.out.println(b[2][3]);
输出结果是400.
二维数组的本质就是一维数组,数组中的元素指向另一个数组。注意下标是从0开始。
冒泡排序法
public static void bubbleSort(int[] arr){
for (int i = 0; i < arr.len - 1; i++) {//确定比较次数
for (int j = i; j < arr.length; j++) {//依次与后边的元素比较,最值上浮
if(arr[j] > arr[j + 1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
for (int i : arr) {
System.out.print(i + " ");
}
}
选择排序法
public static void selectSort(int[] arr){
for (int i = 0; i < arr.length-1; i++) {//确定每一次循环数组头都是最值
for (int j = i + 1; j < arr.length; j++) {//与后面的元素进行比较
if(arr[i] > arr[j]){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
for (int i : arr) {
System.out.print(i + " ");
}
}
插入排序法
public static void insertSort(int[] arr){
for (int i = 1; i < arr.length; i++) {
int pos = i; //记录要插入的位置
int curr = arr[i]; //记录该元素的值
for (int j = i-1; j >= 0; j--) {
if(curr >= arr[j]){
break;
}
if(curr < arr[j]){
arr[j + 1] = arr[j];
pos--;
}
}
if(pos != i){ //如果位置更改了就插入
arr[pos] = curr;
}
}
for (int i : arr) {
System.out.print(i + " ");
}
}
小总结:
冒泡排序算法是外层循环确定循环次数,内层循环依次与后一个元素进行比较,以类似于水中泡泡向上浮的形式进行排序。选择排序法是外层循环确定次数,以及确保该位置的元素是最值,内层循环依次进行元素比较,选择其中最值的放入位置。插入排序是最容易出错的排序算法,注意的是外层循环为要插入的元素,内层循环时已经排序好了的数组,外层元素依次往其中插入。声明变量pos记录要插入的位置,变量curr记录插入元素的值并且与排序好的元素进行比较,如果第一次比较就是失败的,可以直接退出,因为内层循环的都是已经排序好了的。注意循环条件是用curr进行比较。
二分法查找算法:
二分法是可以从中间开始比较的,我一开始碰到存在于数组中的数字它给我返回了-1,以为错误在于mid = (high + low)
认为是否是因为mid并非是中间数,例如(0+9)/2=4,那么这样一来从第四个数字开始比较是不够完美的(不明确中间数是哪个)。但是其实mid是用来作为数组的下标,也就是第五个数字,二分法是完整的二分,另外,因为mid
是int
型的变量,所以它的结果是去尾法的整型结果。实际上我碰到的错误是将while(low <= high)
中的等于号忘记了,这就导致了有存在的数值会漏掉,比如当数组中只有一个元素时,low = high 但是此时如果没有等号会直接返回-1;(ps:当碰到return语句时,会直接跳出函数,所以return下一行有如break语句不会被执行)
public static int BinarySearch(int[] arr, int value) {
int low = 0;
int high = arr.length - 1;
while (low <= high) {
int mid = (low + high) / 2;
if (value == arr[mid]) {
return mid;
}
if (value < arr[mid]) {
high = mid - 1;
}
if (value > arr[mid]) {
low = mid + 1;
}
}
return -1;
}