拆箱与装箱
/*
自动装箱 把基本类型转换为包装类类型
相当于Integer.valueOf(99);
*/
Integer total = 99;
/*
自动拆箱 把包装类类型转换为基本类型
相当于total.intValue();
*/
int totalprim = total;
Integer缓冲池
Integer的数据直接赋值
如:Integer a = 99;
相当于Integer.valueOf(99)。
如果在-128到127之间，会直接从缓冲池里获取数据。
package com.itheima.zkDemo;
public class TestInteger {
public static void main(String[] args) {
Integer a = 1;
Integer b = 1;
System.out.println(a == b);
Integer a1 = new Integer(1);
Integer b1 = new Integer(1);
System.out.println(a1 == b1);
Integer a2 = Integer.valueOf(1);
Integer b2 = Integer.valueOf(1);
System.out.println(a2 == b2);
}
}
//true
//false
//true
package com.itheima.zkDemo;
public class TestInteger2 {
public static void main(String[] args) {
Integer a = 129;
Integer b = 129;
System.out.println(a == b);
Integer a1 = new Integer(129);
Integer b1 = new Integer(129);
System.out.println(a1 == b1);
Integer a2 = Integer.valueOf(129);
Integer b2 = Integer.valueOf(129);
System.out.println(a2 == b2);
}
}
//false
//false
//false
基本类型回收时机
我们要看你这个int a处于什么地方，如果是在方法内部中被执行到，也就是说是局部变量，就会在栈内存中分配内存，由于是int型，所以就是4字节，也就是32bit，long类型的才会是64bit。
而你说的表示地址我们称为堆内存。创建的对象以及对象中的方法和数据是存储在堆内存中的。JVM会在栈内存中建立对象的引用，然后当执行到new语句时，在堆内存中创建对象，这时就将这个对象的类型以及这块区域的内存地址值赋给引用，然后进行对象中数据的初始化。
也就是说，对象的引用存储在栈内存中，存放的是类型以及hash值，如Integer@0xff67。而对象里的内容实际上是存储在堆内存中的。 如果你这句int a只是在某个对象内作为成员变量，那么根本不会涉及到栈内存。a就存储在它所在的那个对象的堆内存中。明白了么？
对象数组
**数组既可以存储基本数据类型，也可以存储引用类型。**它存储引用类型的时候的数组就叫对象数组。
集合只能存储引用类型不能存储基本类型,具体表现为泛型为基本类型时编译期就会报错。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u44czF0r-1669712210994)(assets/1629514797676.png)]
排序算法
冒泡排序算法
相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处
N个元素外层需要比较N-1次。内层每次需要比较N-1-外层层数。
假设4个元素,外层需要比较3次,内层每次需要比较3-外层层数
package digitalwallet;
public class CompareSort {
public static void main(String[] args) {
//int[] values = {80, 10, 20, 5, 8, 4, 9, 19, 90};
int[] values = {80, 10, 20, 90};
//冒泡排序代码
bubbleSort(values);
printArray(values);
}
public static void bubbleSort(int[] arr){
boolean over = true;
//假设有4个元素 需要两两比较 x<3 取值范围是 0 1 2 外层需要比较3 次
for (int x = 0; x < arr.length - 1 && over; x++) {
over = false;
// y < 4 - 1 -x x取值范围是 0 1 2
// 即 y < 3 y < 2 y < 1 内层别需要比较 3 2 1
for (int y = 0; y < arr.length - 1 - x; y++) {
if (arr[y] > arr[y + 1]) {
int temp = arr[y];
arr[y] = arr[y + 1];
arr[y + 1] = temp;
over = true;
}
}
}
}
// 遍历功能
public static void printArray(int[] arr) {
System.out.print("[");
for (int x = 0; x < arr.length; x++) {
if (x == arr.length - 1) {
System.out.print(arr[x]);
} else {
System.out.print(arr[x] + ", ");
}
}
System.out.println("]");
}
}
package digitalwallet;
import sun.awt.SunHints;
public class CompareAndSort {
public static void main(String[] args) {
int[] values = {80, 10, 20, 90};
for (int i = 0; i < values.length-1; i++) {
for (int j = 0; j < values.length-1-i; j++) {
int prev = values[j];
int next = values[j+1];
if(prev>next){
int temp = prev;
//注意这里不能使用prev 和 next 因为不是引用类型
values[j] = values[j+1];
values[j+1] =temp;
}
}
}
for (int i = 0; i < values.length; i++) {
System.out.println(values[i]);
}
}
}
选择排序算法
从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处
N个元素外层需要比较N-1次。内层每次需要比较N-1-外层层数。
假设4个元素,外层需要比较3次,内层每次需要比较4-外层层数-1 次,第一个元素分别和第二三四个元素比较共比较3次
public class ChooseCompare {
public static void main(String[] args) {
int[] values = {80, 10, 20, 90};
//外层需要比较3次
for (int i = 0; i < values.length-1; i++) {
//内层需要比较 下标为0 的要和 下标为1的比较 和 下标为1 2 3的比较 总共 比较3次
for (int j = i+1; j < values.length; j++) {
if (values[i]>values[j]){
int temp = values[j];
values[j] =values[i];
values[i] = temp;
}
}
}
for (int value : values) {
System.out.println(value);
}
}
}
===
