JavaSE——数组

漫卿逍

已于 2023-05-11 21:47:30 修改

阅读量72

点赞数

分类专栏： JavaSE学习笔记文章标签：学习笔记 java

于 2023-04-25 19:49:00 首次发布

本文链接：https://blog.csdn.net/weixin_50650672/article/details/130372606

版权

JavaSE学习笔记专栏收录该内容

9 篇文章 0 订阅

订阅专栏

数组——数组也是对象

文章目录

- 数组——数组也是对象

1. 一维数组的概念

/*1.数组的定义、赋值*/
public class AaryDemo01 {
    public static void main(String[] args) {
        
        int[] array1;           // 声明一个数组
        array1 = new int[10];   // 创建一个数组
        int[] array2 = new int[10];
        // 给数组赋值
        int i = 0;
        for(;i<array1.length;i++){
            array1[i]=i+1;
        }
        for (i=0;i<array1.length;i++){
            System.out.println(array1[i]);
        }
    }
}

数组的四个特点
1. 其长度是确定的。数组一旦被创建它的大小就是不可以改变的。
2. 其元素必须是相同类型,不允许出现混合类型。
3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
4. 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型数组对象本身是在堆中的。

数组边界

下标的合法区间：[0, length-1]

//ArrayIndexOutOfBoundsException:数组下标越界报错

2. 数组的使用

1. 打印数组

package Aarry;

public class Demo02 {
    public static void main(String[] args) {
        int[] arrays ={1,2,3,4,5,6};
        // 1.普通遍历
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+"\t");
        }
        System.out.println();

        // 2.for-each遍历
        printArray(arrays);                 // 打印数组
        System.out.println();

        // 3.反向打印
        for (int i = arrays.length-1; i >= 0; i--) {
            System.out.print(arrays[i]+"\t");
        }
        System.out.println();

        int[] reverse = reverse(arrays);
        for(int i=0;i<reverse.length;i++){
            System.out.print(reverse[i]+"\t");
        }
    }

    // 打印数组
    public static void printArray(int[] arrays){
        for (int array : arrays) {
            System.out.print(array + "\t");
        }
    }

    // 打印反转数组
    public static int[] reverse(int[] arrays){
        int[] r_arrays = new int[arrays.length];
        for (int i=0,j=r_arrays.length-1;i<arrays.length;i++,j--){
            r_arrays[j]=arrays[i];
        }
        return r_arrays;
    }
}

2. 数组的拷贝

package Aarry;

import java.util.Arrays;

public class Demo03 {
    public static void main(String[] args) {
        int[] a={1,2,3,4,5,6};
        //打印数组
        System.out.println(Arrays.toString(a));

        // 1. 将 a 数组复制给 b数组
        int[] b = a.clone();
        System.out.println(Arrays.toString(b));

        // 2.a—>b,将数组a[begin_a]~a[begin_a+length-1]复制到数组c[begin_c]~c[begin_c+length-1]
        int[] c = new int[a.length+7];
        System.arraycopy(a,0,c,2,6);
        System.out.println(Arrays.toString(c));

        // 3.从a数组中复制 [0,length) 中的元素 (可用于截取数组)
        int[] d = Arrays.copyOf(a, 3);
        System.out.println(Arrays.toString(d));

        // 4.从a数组中复制 [begin,to) 中的元素 (可用于截取数组)
        int[] e = Arrays.copyOfRange(a,3,6);
        System.out.println(Arrays.toString(e));
    }
}

3. 产生随机数

Math.random
Random类

package Aarry;

import java.util.Random;

public class 产生随机数 {
    public static void main(String[] args) {
        // 1.Math.random,只能产生double类型
        for (int i = 0; i < 10; i++) {
            double a = Math.random();
            System.out.printf("%.0f",a*10);
            System.out.print("\t");
        }
        System.out.println();

        // 2.Random类
        Random r = new Random();
        double d = r.nextDouble();
        double d1 = r.nextDouble()*7;
        int i1 = r.nextInt();
        int i2 = r.nextInt(10);
        int i3 = r.nextInt(18)-3;
        long l = r.nextLong();
        float f = r.nextFloat();
        boolean b = r.nextBoolean();

        System.out.println("生成的[0,1.0]区间的小数是：" + d);
        System.out.println("生成的[0,7.0]区间的小数是：" + d1);
        System.out.println("生成的[0,2^32]区间的整数是：" + i1);
        System.out.println("生成的[0,10]区间的整数是：" + i2);
        System.out.println("生成的[-3,15]区间的整数是：" + i3);
        System.out.println("生成一个随机长整型值：" + l);
        System.out.println("生成一个随机布尔型值：" + b);
        System.out.println("生成一个随机浮点型值：" + f);
        System.out.print("下期七星彩开奖号码预测：");
        for (int i = 0; i < 8; i++) {
            System.out.print(r.nextInt(9));
        }
    }
}

3. java.util.Array类用法

1. 排序

2. 数组全部打印

3. 数组比较

4. 数组拷贝

5. 二分查找法

6. 数组容量扩充

7. 数组fill赋值

8. 截取数组

package Aarry;

import java.util.Arrays;
import java.util.Collections;
import java.util.Random;

public class Arrays类 {
    public static void main(String[] args) {
        int[] a = new int[10];
        String[] b = {"a","h","t","m","w","q","j","A","p"};
        String[] c = {"a","h","t","m","w","q","j","A","p"};
        Random r = new Random();
        for (int i = 0; i < a.length; i++) {
            a[i] = r.nextInt(50);
        }
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.toString(b));
        
        /*排序*/
        // (1).选择数组指定位置排序
        Arrays.sort(a,1,5);
        System.out.println(Arrays.toString(a));
        // (2).数字排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        // (3).字母排序 (先大写后小写)
        Arrays.sort(b);
        System.out.println(Arrays.toString(b));
        // (4).严格按照字母表顺序排序，忽略大小写排序
        Arrays.sort(c,String.CASE_INSENSITIVE_ORDER);
        System.out.println(Arrays.toString(c));
        // (5).反向排序
        Arrays.sort(b, Collections.reverseOrder());
        System.out.println(Arrays.toString(b));
        // (6).忽略大小写反向排序
        Arrays.sort(c,String.CASE_INSENSITIVE_ORDER);
        Collections.reverse(Arrays.asList(c));
        System.out.println(Arrays.toString(c));
        
        /*比较相同位置的数组元素是否相等*/
        System.out.println(Arrays.equals(b,c));

        /*二分查找法找指定元素的索引值
        * 使用该方法要先把数组排好序！！！
        * binarySearch() 返回值：索引从0开始，若找不到元素，返回值从-1开始数
        */
        int i = Arrays.binarySearch(a, 18);
        System.out.println(i);
        int i1 = Arrays.binarySearch(a, 0, 10, 15);
        System.out.println(i1);

        /*数组容量扩充*/
        a = Arrays.copyOf(a,a.length+1);
        System.out.println(Arrays.toString(a));
        
        /*数组fill赋值*/
        Arrays.fill(a,1);
        System.out.println(Arrays.toString(a));
    }
}

4. 多维数组

多维数组的内存结构
多维数组的存储表格
Javabean和数组存储表格

5. 常见算法

冒泡排序基础算法
冒泡排序优先算法
二分法查找（折半查找）
稀疏数组

package Aarry;

public class Demo04 {
    public static void main(String[] args) {
        int[][] a=new int[11][11];
        a[1][2]=1;
        a[2][3]=2;
        System.out.println(a.length);
        //打印棋盘
        for (int[] ints : a) {
            for (int j = 0; j < a.length; j++) {
                System.out.print(ints[j] + "\t");
            }
            System.out.println();
        }
        //转换成稀疏数组保存
        //获取有效值个数
        int sum = 0;
        for(int i=0;i<11;i++){
            for (int j=0;j<11;j++){
                if(a[i][j]!=0){
                    sum++;
                }
            }
        }
        // 建立稀疏数组
        int[][] b = new int[sum+1][3];
        //赋值
        b[0][0]=11;
        b[0][1]=11;
        b[0][2]=sum;
        for(int i=0,count=0;i<11;i++){
            for(int j=0;j<11;j++){
                if (a[i][j]!=0){
                    count++;
                    b[count][0]=i;
                    b[count][1]=j;
                    b[count][2]=a[i][j];
                }
            }
        }
        // 打印稀疏数组
        for (int i=0;i<sum+1;i++){
            for (int j=0;j<3;j++){
                System.out.print(b[i][j]+"\t");
            }
            System.out.println();
        }

        // 还原稀疏数组
        int[][] c=new int[b[0][0]][b[0][1]];
        for(int i=1;i<=b[0][2];i++){
            c[b[i][0]][b[i][1]]=b[i][2];
        }
        // 打印还原数组
        for(int i=0;i<b[0][0];i++){
            for (int j=0;j<b[0][1];j++){
                System.out.print(c[i][j]+"\t");
            }
            System.out.println();
        }
    }
}