Java狂神说基础51-59课

最新推荐文章于 2023-06-10 15:35:32 发布

weixin_42022326

最新推荐文章于 2023-06-10 15:35:32 发布

阅读量53

点赞数

文章标签： javase

原文链接：https://space.bilibili.com/95256449?spm_id_from=333.788.b_765f7570696e666f.1

版权

这篇博客详细介绍了Java中的数组声明、初始化、内存分配以及常见的数组操作，如数组反转和冒泡排序。同时，文章还讲解了稀疏数组的概念及其在内存优化中的应用。通过示例代码，展示了如何实现数组的动态声明、静态创建、反转和冒泡排序算法，以及稀疏数组的压缩和还原。此外，博客还讨论了数组在内存中的存储位置，包括堆、栈和方法区的作用。

摘要由CSDN通过智能技术生成

数组

2数组声明：

int[] a;
a = new int[10];//动态声明分开写
注意声明时不要写成int[10] a，不允许。

int[] a = new int[];//动态声明一起写

int[] b = {1,2,3};静态创建

int [] nums;//首选

int nums[];//不推荐，这种写法存在原因是：这是C、C++风格，早期为了让大众更容易接收Java

3数组下标默认从0开始，创建新对象时，int[10]是长度，初始化过后，nums[9]才是最后一位元素。

public class arrayDemo01 {
    public static void main(String[] args) {
        int[] nums;//声明数组，但并不开辟存储空间
        nums = new int[10];//这里定义长度，开辟存储空间
        System.out.println(nums.length);//输出10
        nums[9] = 1;
        System.out.println(nums[nums.length-1]);//输出1
        System.out.println(nums[nums.length]);//会报错，溢出
    }
}

4Java内存

堆：存放new的对象和数组

可以被所有的线程共享，不会存放别的对象引用

栈：存放基本变量类型

引用对象的变量（存放这个引用在堆里的具体地址）

方法区：可以被所有线程共享

包含了所有的class和static变量

5数组一旦被创建，它的大小就是不可改变的。

6数组本身是对象，Java中对象也是在堆中的，所以数组无论保存原始类型还是其它对象类型，数组对象本身存储在堆中。数组对象它的引用，是在栈里的。

//没问题
for (int i = 0; i < nums.length; i++) {
    
}
//报错，越界
for (int i = 0; i <= nums.length; i++) {
    
}

7数组反转

数组反转，原始数组1，2，3，4，5输出5，4，3，2，1

public class arrayDemo02 {
    public static void main(String[] args) {
        int[] nums = {1,2,3,4,5};
        nums = reversal(nums);
        for (int i = 0; i < nums.length; i++) {
            System.out.println(nums[i]);
        }
    }
    public static int[] reversal(int[] array){
        int[] result = new int[array.length];

        for(int i = 0;i<array.length;i++){
            result[result.length-1-i]=array[i];
        }

        return result;
    }
}

8输出数组元素，自己写的话

注意这一句：for (int i = 0; ; i++) {

并没有写for语句的结束条件，而是在for里面加了if和return组合，实现了结束效果

public class arrayDemo03 {
    public static void main(String[] args) {
        int[] a = {};
        System.out.println(test1(a));
    }
    public static String test1(int[] a ){
        if (a == null){
            return  null;
        }
        int iMax = a.length-1;
        if(iMax==-1){
            return "[]";
        }
        StringBuilder arr = new StringBuilder();
        arr.append("[");
        for (int i = 0; ; i++) {
            arr.append(a[i]);
            if(i==iMax){
                return arr.append("]").toString();
            }
            arr.append(", ");
        }

    }
}

上面后半段for也可以，中规中矩一点

for (int i = 0;i<a.length ; i++) {
    arr.append(a[i]);
    if(i!=a.length-1){
        arr.append(", ");
    }
}
arr.append("]");
return arr.toString();

9冒泡排序时间复杂度O（n2）

要点：顺序是从右往左，第一次排序找到最小的，放到最左边。第二次排序找到第二小的，放到第二位。注意两次for循环的循环逻辑。

这个程序创新点：设立flag标记，若一次完整的内循环并没有改变flag值，说明本次循环作用内的元素已经排号序了，直接break节省了资源。

import java.util.Arrays;

public class arrayDemo05 {
    public static void main(String[] args) {
        int[] array = {9,8,7,6,5};
        System.out.println(Arrays.toString(sortBubble(array)));
    }
    public static int[] sortBubble(int[] array){
        for (int i = 0; i < array.length; i++) {
            boolean flag = false;
            for (int j = array.length-1; j >i; j--) {
                int temp;
                if(array[j-1]>array[j]){
                    flag = true;
                    System.out.print("本次冒泡，当前i为"+i+" 当前j为"+j+" 交换位数为"+(j)+" "+(j+1));
                    System.out.print(" 变更前结果为 "+Arrays.toString(array));
                    temp = array[j-1];
                    array[j-1]=array[j];
                    array[j]=temp;
                    System.out.println("变更结果为 "+Arrays.toString(array));
                }else{
                    System.out.println("本次不冒泡，当前i为"+i+" 当前j为"+j);
                }
            }
            if(flag==true){
                break;
            }
        }
        return array;
    }
}

10稀松数组

稀松数组，是为了节约存储空间，用计算时间成本换取内存存储的物理成本。

稀松数组一共3列，第一行记录原始数据多少行多少列多少有效数据；

从第二行开始记录有效数据在第几行第几列，具体数值多少。

下面代码将

1 0 0 0 0 0 0 0 0 0
0 2 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0

压缩为

10 10 2
0 0 1
1 1 2

再转为原始数据。
import java.util.Arrays;
//稀松数组
public class arrayDemo06 {
public static void main(String[] args) {
int[][] array = new int[10][10];
array[0][0] = 1;
array[1][1] = 2;
System.out.println(“打印原始数据”);
for (int[] ints :array){
for (int anInt : ints){
System.out.print(anInt+"\t");
}
System.out.println();
}

    int[][] compressSparseArray = new int[array.length][array[1].length];
    compressSparseArray=compressSparseArray(array);
    System.out.println("打印稀松数据");
    for (int[] ints :compressSparseArray){
        for (int anInt : ints){
            System.out.print(anInt+"\t");
        }
        System.out.println();
    }

    int[][] restoreSparseArray = new int[array.length][array[1].length];
    restoreSparseArray = restoreSparseArray(compressSparseArray);
    System.out.println("打印还原数据");
    for (int[] ints :restoreSparseArray){
        for (int anInt : ints){
            System.out.print(anInt+"\t");
        }
        System.out.println();
    }

}
public static int[][] compressSparseArray(int[][] array){
    int count = 0;
    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array[i].length; j++) {
            if(array[i][j]!=0){
                count+=1;
            }
        }
    }
    int[][] compressSparseArray = new int[count+1][3];
    compressSparseArray[0][0] = array.length;
    compressSparseArray[0][1] = array[1].length;
    compressSparseArray[0][2] = count;

    int row = 1;
    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array[i].length; j++) {
            if(array[i][j]!=0){
                compressSparseArray[row][0] = i;
                compressSparseArray[row][1] = j;
                compressSparseArray[row][2] = array[i][j];
            }
        }
        row++;
    }
    return compressSparseArray;

}
public static int[][] restoreSparseArray(int[][] array){
    int[][] restoreSparseArray = new int[array[0][0]][array[0][1]];
    //根据有效数据个数for循环，第一行记录总体情况，所以从第二行，也就是i=0开始
    for (int i = 1; i <= array[0][2]; i++) {
        restoreSparseArray[array[i][0]][array[i][1]] = array[i][2];
    }
    return  restoreSparseArray;
}

}