一.一维数组
一维数组:保存一组相同数据类型的元素
1.声明方式:
数据类型[] 数组名 = 初值;数据类型表示的是数组中保存的元素的数据类型
注意:数组的长度一但确定就不能改变
2.创建数组的方法:
方法一:数据类型[] 数组名 = new 数据类型[数组长度];
方法二:数据类型[] 数组名 = new 数据类型[] {1,2,3,4,5};
方法三:数据类型[] 数组名 = {1,2,3,4,5};简化创建(语法糖)
//遍历打印数组:
/*for (int i = 0; i < arr1.length; i++) {
System.out.println(arr[i]);
}*/
//在循环外打印数组方法是:
/* 打印数组所有元素的方法:
* System.out.println(Arrays.toString(数组名));
* Arrays是数组工具类
*/
public class Kll {
public static void main(String[] args) {
//声明一个数组 保存5个int元素
//关键词 new 表示 会从堆内存[在下边会有解释]中开辟一块空间
//数组会在堆内存中开辟一块连续的堆内存空间
int[] arr = new int[5];
//如何给数组中的元素赋值呢?
// 是使用下标来进行对数据元素的赋值和取值
// 下标是从0开始,所以最后一个元素的下标就是长度减一
// 数组名[下标] = 值;
arr[3] = 10;
//下标越界异常
//ArrayIndexOutOfBoundsException
//arr[5] = 15;
System.out.println(arr[3]);
//把arr保存的地址指向空
arr = null;
//NullPointerException(空指针异常)
//访问了一块不属于你的内存区域
//arr[3] = 3;
System.out.println();
}
}
这是上述创建数组在内存中的部分实现过程
堆内存和栈内存下面会有讲到
3.找数组对应元素的下标或者是元素
public class Kll {
public static void main(String[] args) {
System.out.println(findKeyIndex(1));
int[] array = {3, 6, 11, 22};
int index = findKeyIndex(11, array);
if (index == -1) {
System.out.println("数组内不存在");
}
System.out.println(index);
}
//需求: 封装一个函数 传入数字1 返回 一
// 数字2 返回 二 ….. 数字5 返回 五
public static char findKeyIndex (int n) {
char[] arr = {'一','二','三','四','五'};
return arr[n - 1];
}
/* 需求:
* 定义一个数组 数组值 分别 3,6,11,22
* 在数组中 查找 11的位置
*/
public static int findKeyIndex(int key,int[] array) {
int index = -1;//声明一个变量保存返回的下标
//之所以index赋值不能是0是因为,当元素不存在数组时,也会返回一个0
for (int i = 0; i < array.length; i++) {
if (key == array[i]) {
index = i;
//return i;
}
}
return index;
//return -1;
}
}
二.栈内存
特点:
1.所有函数都会在栈内存中执行,函数执行完毕会自动出栈销毁
2.先入栈后出栈(只针对函数中调用函数时).
二.堆内存
1.堆内存的特点
1.堆内存会分配内存地址
2.堆内存分配初值:基本数据类型初值是0;引用数据类型初值是null
3.有垃圾回收机制(这块内存没人用就是垃圾)
2.Java数据类型:
基本类型(有八种):四种整数类型(int,short,byte,long),两种浮点数类型(float,double),一种字符类型(char),一种布尔类型(boolean)
引用数据类型:类,接口,数组.
3.注意:
基本数据类型(八个)参数传递时是值的传递
引用数据类型(数组) 参数传递时是地址的传递
//例子:
public class Kll {
public static void main(String[] args) {
int[] array = {1, 2, 3, 6, 8, 9, 18};
reverse(array);
System.out.println(Arrays.toString(array));
int a = 10;
int b = 15;
fun2(a, b);
System.out.println(a,b);
}
private static void fun2(int a, int b) {
int temp = a;//声明temp保存数据
a = b;
b = temp;
}
public static void reverse(int[] array) {
/*第一种 利用数组进行数组元素倒放
* int[] arr = new int[array.length];
for (int i = 0; i < array.length; i++) {
arr[i] = array[array.length - 1 - i];
}
System.out.println(Arrays.toString(arr));
*/
//第二种 利用变量进行倒放
for (int i = 0; i < (int)(array.length / 2); i++) {
int temp =array[i];
array[i] = array[array.length - 1 - i];
array[array.length - 1 - i] = temp;
}
//打印数组
System.out.println(Arrays.toString(array));
}
}
//上述代码打印出的数组是交换的是因为:在调用函数时,传参传的是地址
//而基本类型进行传参只穿数值,不是地址,所以打印出来的a和b数值不变
三.排序和查找
这次讲的排序和查找都是最基础的方法
1.数组排序:冒泡排序,选择排序
冒泡排序:
核心思想:交换两个相邻元素的位置
会依次把最大值(或最小值)一个一个找出来,从最后向前依次排序放好
例子:
public class Kll {
public static void main(String[] args) {
int[] arr = {3, 2, 5, 1};
fun1(arr);
}
private static void fun1(int[] arr) {
//外层循环控制比较的趟数(即数组的次数)
//外层循环减一:表示4个数比较3次
for (int i = 0; i < arr.length-1; i++) {
//内层循环控制比较每趟比较的次数(即数组内的元素的次数)
//内层循环减i是已经排好的数,再减1是为了不让角标越界(是为了减少程序执行次数)
for (int j = 0; j < arr.length - 1 - i; j++) {
int temp = arr[j];//声明变量保存元素
if (temp > arr[j + 1]) {
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}else {
arr[j] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
选择排序:
核心:选择一个数(一般选择第一个数)与其他的数进行比较
例子:
public class Kll {
public static void fun1(int[] array) {
int temp;
//外层循环array.length -1:4个数比较3趟
for (int i = 0; i < array.length - 1; i++) {
for (int j = i+1; j < array.length - 1; j++) {
//i+1:是已经确定的数就不用比较了.
//内层循环控制未进行排序的数与要比较的数进行比较
if (array[i] > array[j]) {
temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}
System.out.println(Arrays.toString(array));
}
public static void main(String[] args) {
int[] array = {2, 6, 5, 4, 1};
fun1(array);
}
}
2.数组查找:折半查找:
折半查找(在数组中根据元素查找对应的角标)
前提:必须是在有序数组中查找
例子:
public class Kll {
public static void main(String[] args) {
int[] arr = {1, 11, 22, 33, 44, 55, 66, 77, 99};
int index = findKeyIndex(arr, 0 );
System.out.println(index);
}
// 折半查找顾名思义就是对半找:1.先把数组(已排好序)的最大值下标和最小值下标用变量表示,把中间值的下标(最大值下标和最小值下标的一半)也用一个变量保存;2.比较查找元素和中间值的大小,然后更换最大值或最小值的值的角标,中间值也随之变化.
private static int findKeyIndex(int[] arr,int num) {//数组是升序
int min = 0;//最小值角标
int max = arr.length - 1;//最大值角标
int mid = (min + max) / 2;//中间值角标
while(num != arr[mid]) {
if (num > arr[mid]) {
min = mid + 1;//也可以不加1,加一是因为已经比较了不在范围内,可以
略掉
mid = (min + max) / 2;
}else if (num < arr[mid]) {
max = mid - 1;也可以不加1,同上加1
mid = (min + max) / 2;
}
if (min > max) {//判断不在数组元素内存在的情况
mid = -1;
break;
}
}
return mid;
}
}