内存分析
内存具体的有:堆、栈、方法区
堆:
1、存放new的对象和数组
2、可以被所有的线程共享,不会存放别的对象引用
栈:
1、存放基本变量类型(会包含这个基本类型的具体数据)
2、引用对象的变量(会存放这个引用在堆里面的具体地址)
方法区:
1、可以被所有的线程共享
2、包含了所有的class和static变量
这么说可能太模糊。上代码:
package array;
public class demo01 {
//变量的类型 变量名 = 变量的值;
public static void main(String[] args) {
int[] sum1; //1.定义
sum1 = new int[10]; //创建一个数组,这里面可以存放10个int类型的数字
sum1[0] = 1;
sum1[1] = 2;
sum1[2] = 3;
sum1[3] = 4;
sum1[4] = 5;
sum1[5] = 6;
sum1[6] = 7;
sum1[7] = 8;
sum1[8] = 9;
sum1[9] = 10;
int sum = 0;
// 数组的长度:array.length
for (int i = 0; i < sum1.length; i++) {
sum = sum + sum1[i];
}
System.out.println(sum);
}
}
我们来分析一下上面的代码:
1、int[] sum1;我们声明一个数组sum1,这时这个sum1会存在栈内存中。
2、sum1 = new int[10]; 这时我们new了对象,在堆内存中会存在一个长度为10的数组。
3、sum1[0] = 1; sum1[1] = 2; sum1[2] = 3; sum1[3] = 4; sum1[4] = 5; sum1[5] = 6; sum1[6] = 7; sum1[7] = 8; sum1[8] = 9; sum1[9] = 10;我们将其赋值,这时在堆内存中会存在值。
4、如果我们想要获取sum1[10],也就是第11个数,会报异常:ArrayIndexOutOfBoundsException(数组下标越界)。
上图:
数组的三种初始化
1、静态初始化
int[] a = {1, 2, 3}
Man[] mans = {new Man(1, 1), new Man(2, 2)}
2、动态初始化
int[] a = new int[2];
a[0] = 1;
a[1] = 2;
3、数组的默认初始化
数组是引用类型,它的元素相当于类的实例变量,因此数组一经分配空间,其中的每个元素也被按照实例变量同样的方式被隐式初始化。
代码:
package array;
public class Demo02 {
public static void main(String[] args) {
// 静态初始化:声明 + 赋值
int[] a = {1, 2, 3, 4, 5, 6, 32};
System.out.println(a[0]);
// 动态初始化,包含默认初始化
int[] b = new int[2];
b[0] = 10;
System.out.println(b[0]);
System.out.println(b[1]);
}
}
结果为:
我们可以发现,动态初始化后,数组的每个元素会有一个默认值。
数组的四个基本特点
1、其长度是确定的。数组一旦被创建,它的大小就是不可以被改变的。
2、其元素必须是相同类型,不允许出现相同类型。
3、数组中的元素可以是任意类型,包括基本类型和引用类型。
4、数组变量属于引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。数组本身就是对象,Java中对象是在堆内存中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆内存中的。
数组边界问题
下标的合法区间:[0, length-1],如果越界就会报错
代码:
package array;
public class Demo03 {
public static void main(String[] args) {
int[] a = {1,2,3,4,5,6,7,8};
for (int i = 0; i <= a.length; i++) {
System.out.println(a[i]);
}
}
}
结果:
该数组的长度为8,所以下标是从0到7,而for循环中,等于的数组a的长度,所以导致数组下标越界。报:ArrayIndexOutOfBoundsException下标越界异常。
小结:
1、数组是相同数据类型(数据类型可以为任意类型)的有序集合。
2、数组也是对象。数组元素相当于对象的成员变量。
3、数组的长度是确定的,不可变的。如果越界,则报异常:ArrayIndexOufOfBoundsException
数组的使用
代码:
package array;
public class Demo04 {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
//打印数组所有的元素
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]);
}
System.out.println("=========");
//计算数组中所有元素的总和
int sum = 0;
for (int i = 0; i < arrays.length; i++) {
sum += arrays[i];
}
System.out.println("sum = " + sum);
System.out.println("=========");
// 找到数组中最大的那个值
int max = arrays[0];
for (int i = 0; i < arrays.length; i++) {
if (arrays[i] > max) {
max = arrays[i];
}
}
System.out.println("max = " + max);
}
}
结果为:
我们再来一个。
for — each循环
代码:
package array;
public class Demo05 {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
// JDK1.5开始有的,没有下标,适合打印输出,如果要用到下标,则没那么实用
for (int array : arrays) {
System.out.println(array);
}
}
}
结果:
数组作方法入参
代码:
package array;
public class Demo06 {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
printArray(arrays);
}
public static void printArray(int[] arrays) {
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]);
}
}
}
结果:
数组作返回值
代码:
package array;
public class Demo07 {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
int[] reverse = reverse(arrays);
printArrays(reverse);
}
// 反转数组
public static int[] reverse(int[] arrays) {
int[] result = new int[arrays.length];
//反转操作
for (int i = 0,j = result.length-1; i < arrays.length; i++,j--) {
result[j] = arrays[i];
}
return result;
}
// 打印数组中所有的元素
public static void printArrays(int[] arrays) {
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i] + " ");
}
}
}
结果为:
多维数组
多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每个元素都是一个一维数组。
二维数组:
int a[][] = new int[2][5];
以上二维数组a可以看成一个两行五列的数组
代码:
package array;
public class Demo08 {
public static void main(String[] args) {
// 相当于4行2列的数组
/**
* 1,2 array[0]
* 2,3 array[1]
* 3,4 array[2]
* 4,5 array[3]
*/
int[][] array = {{1,2},{2,3},{3,4},{4,5}};
// 取出1,2
printArrays(array[0]);
}
// 打印数组中所有的元素
public static void printArrays(int[] arrays) {
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]);
}
}
}
结果:
我们取出二维数组中的数字1:
代码:
package array;
public class Demo08 {
public static void main(String[] args) {
// 相当于4行2列的数组
/**
* 1,2 array[0]
* 2,3 array[1]
* 3,4 array[2]
* 4,5 array[3]
*/
int[][] array = {{1,2},{2,3},{3,4},{4,5}};
// 取出1
System.out.println(array[0][0]);
}
// 打印数组中所有的元素
public static void printArrays(int[] arrays) {
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]);
}
}
}
结果:
我们要将二维数组中的所有元素都打印出来
代码:
package array;
public class Demo09 {
public static void main(String[] args) {
int array[][] = {{1,2},{2,3},{3,4},{4,5}};
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j] + " ");
}
}
}
}
结果:
在此说明一下:本人不是托,我的这些总结都是根据哔哩哔哩的up主:遇见狂神说,我是看他的视频学习的,真心推荐这位up主,有兴趣的小伙伴可以去看看!!!