1.栈内存与堆内存
栈内存
特点:
1.所有函数在执行时都会进入栈内存(函数的入栈),
当函数执行完毕后会出栈被系统销毁。
2.先入栈后出栈 。入栈又叫压栈, 出栈又叫弹栈。
堆内存
特点
1.堆内存会分配内存地址
2.堆内存会分配初值,基本数据类型初值 0 ,
引用数据类型初值 null。
3.有垃圾回收机制(这块内存没人用 就是垃圾)。
2.数组
数组相当于一个容器,用来保存一组相同数据类型的元素。
声明方式:
数据类型[] 数组名 = 初值
注意:这里的数据类型表示的是数组中保存的元素的数据类型。
//声明一个数组 保存五个int元素
//注意:数组的长度一旦确定,就不能改变
//关键词new 表示会从堆内存中开辟一块空间
//数组会在堆内存中开辟一块连续的内存空间
int[] array = new int[5];
//如何给数组中的元素赋值
//使用下标来进行对数组元素的赋值和取值
//下标从0开始
//数组名[下标] = 值;
array[3] = 10;
//ArrayIndexOutOfBoundsException
//下标越界异常
//array[5] = 15;
System.out.println(array[3]);
//把array保存的地址指向空
array = null;
//NullPointerException(空指针异常)
//访问一块不属于你的内存区域
//array[3] = 3;
数组的遍历
遍历数组通俗点就是说把数组中的每个数都读一遍(部分有if条件+break的则可能不会完全遍历),你可以对于数组中的每个数进行处理,亦或者是找到数组中那个你需要的数。
//重点:打印数组中的每一个元素(遍历数组)
//循环遍历数组(for)
for (int i = 0; i < array1.length; i++) {
System.out.println(array1[i]);
}
数组的简单练习
1.根据下标查找对应的元素
2.根据元素查找对应的下标
public class Test {
//需求: 封装一个函数 传入数字1 返回 一
// 数字2 返回 二 ….. 数字5 返回 五
public static char findKeytToIndex(int n) {
//声明char类型的数组 保存一二三四五
char [] array = {'一','二','三','四'};
return array[n-1];
}
/* 需求: 封装一个函数
* 定义一个数组 数组值 分别 3,6,11,22
* 在数组中 查找 11的位置
*/
public static void main(String[] args) {
int[] array = new int[] {3, 6, 11, 22};
int key = 11;
int index = findIndexToKey(array, key);
if (index == -1) {
System.out.println("该数组没有元素");
}
System.out.println(index);
}
private static int findIndexToKey(int[] array,int key) {
//声明一个变量保存返回的下标
int index = 0;
for (int i = 0; i < array.length; i++) {
//查找相同的元素
if (array[i] == key) {
index =i;
}
}
return index;
}
}
数组的排序
1.元素的翻转
基本数据类型(int) 参数传递时是值的传递。
引用数据类型(数组) 参数传递时是地址的传递。
public static void reverse(int[] array) {
//计算交换次数
int num = array.length / 2;
//遍历数组
for (int i = 0; i < num; i++) {
//交换
//array[i]------array[length-1-i]
int temp = array[i];
array[i] = array[array.length-1-i];
array[array.length-1-i]=temp;
}
//System.out.println(Arrays.toString(array));
}
public static void main(String[] args) {
// int a = 10;
// int b = 15;
// //交换两个变量的值
// int temp = a;
// a = b;
// b = temp;
// System.out.println(a);
// System.out.println(b);
int[] array = {1, 2, 3, 6, 8};
reverse(array);
System.out.println(Arrays.toString(array));
}
2.冒泡排序
核心思想:交换两个相邻元素的位置。
public static void main(String[] args) {
int[] array = {3, 2, 5, 1};
//外层循环控制比较的趟数
//内层循环控制一趟计较的次数
//外层循环-1表示4个数比3趟
//内层循环-1表示防止角标越界
//内层循环-i表示每一趟比较确定一个数 就少一次比较
for (int i = 0; i < array.length-1; i++) {
for (int j = 0; j < array.length-1-i; j++) {
//交换相邻位置的元素比较大小
if (array[j] > array[j+1]) {
//j和j+1进行交换
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
System.out.println(Arrays.toString(array));
}
3.选择排序
核心思想:选择一个数(一般选第一个数)与其他的数进行比较交换。
public static void main(String[] args) {
int[] array = {3, 2, 5, 1};
//外循环-1 四个数比三趟
//内循环1+i表示每一趟确定的数不用再重复比较了
for (int i = 0; i < array.length-1; i++) {
for (int j = 1 +i; j < array.length; j++) {
if (array[i] > array[j]) {
int temp = array[i];
array[i] = array[j];
array[j] =temp;
}
}
}
System.out.println(Arrays.toString(array));
}
4.折半查找(在数组中根据元素查找对应的角标)
前提:必须在有序的数组中查找。
public static void main(String[] args) {
int[] array = {1, 11, 22, 33, 44, 55, 66, 77, 99};
//声明最大最小中间角标
int max =array.length-1 ;
int min = 0;
int mid = (min + max) / 2;
//声明要查找的值
int key = 1;
//循环查找
//明确的循环结束条件 中间角标对应的值和查找的值相等,停止循环)
while (array[mid] != key) {
//挪动角标
if (key > array[mid]) {
min = mid +1;
}
if (key < array[mid]) {
max = mid - 1;
}
//重新计算中间角标
mid = (min + max) / 2;
if (min > max) {
//确定数组中没这个值
mid = -1;
//停止循环
break;
}
}
System.out.println("要寻找的值得下标是" + mid);
}