欢迎您访问 最编程 本站为您分享编程语言代码，编程技术文章！

热门搜索/Hot Search

您现在的位置是： 首页

基础不牢，地动山摇。20 分钟取阵列。

最编程 2024-04-06 22:41:45
...

文章目录


数组


动态初始化1（直接声明和分配）


动态初始化2（先声明再分配）


静态初始化


数组细节(⭐⭐⭐)


数组赋值机制(⭐⭐⭐)


打印数组最大值的下标


数组拷贝


数组反转


数组添加/扩容


冒泡排序


顺序查找(⭐⭐⭐)


二维数组


动态初始化


静态初始化


细节


数组

引出数组

假设现在有6只佩奇，称出他们的体重，然后用变量记录，变求出总重量？


网络异常，图片无法展示
|


传统方法：


/**
 * @Author: liu sen
 * @Version: 1.0
 * @Date: 2021/08/31/14:02
 */
public class demo21 {
    public static void main(String[] args) {
        //假设现在有6只佩奇，称出他们的体重，然后用变量记录，变求出总重量？
        int a = 112;
        int b = 122;
        int c = 212;
        int d = 212;
        int e = 312;
        int f = 142;
        System.out.println("总重量是："+(a+b+c+d+e+f)+"kg");
    }
}


结果：总重量是：1112kg


思考：我们发现6只佩奇都是int类型的，而我们却要定义6个变量，有没有更好的处理方案呢–》引入数组


数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型


使用数组解决上面需求：


/**
 * @Author: liu sen
 * @Version: 1.0
 * @Date: 2021/08/31/14:02
 */
public class demo21 {
    public static void main(String[] args) {
        //假设现在有6只佩奇，称出他们的体重，然后用变量记录，变求出总重量？
        int[] pig = {112,122,212,212,312,142};
        int sum = 0;
        for (int i = 0; i < pig.length; i++) {
            sum += pig[i];
        }
        System.out.println("总重量是："+sum+"kg");
    }
}


动态初始化1（直接声明和分配）


数组的定义


数据类型 数组名[] = new 数据类型[大小];


int[] a = new int[5];


创建了一个数组，名字为a，存放5个int类型大小


数组的使用


数组名[下标名/索引/index]


访问数组a的第3个元素 a[2];


数组下标是从0开始计数的


import java.util.Scanner;
public class xunhuan {
    public static void main(String[] args) {
        //创建数组，double，大小5
        double[] scores = new double[5];
        //循环输入
        for (int i = 0; i < scores.length; i++) {
            System.out.println("请输入第"+(i+1)+"个数据的值");
            Scanner scanner = new Scanner(System.in);
            scores[i] = Double.parseDouble(scanner.nextLine());
        }
        int sum = 0;
        for (int i = 0; i < scores.length; i++) {
            sum+=scores[i];
        }
        System.out.println("综合为："+sum+"    平均分是:"+sum/5);
    }
}


动态初始化2（先声明再分配）


先声明数组


语法：数据类型[] 数组名； 或 数据类型 数组名[];


举例：int a[]; 或 int[] a;


创建数组


语法：数组名 = new 数据类型[大小];


举例：a = new int[10];


double scores[];//声明数组，这时scores是null
    scores = new double[5];//分配内存空间，可以存放数据


静态初始化


语法：数据类型 数组名[] = {元素值，元素值1，……};


举例：int a[] = {1,2,5,6,9,0};


如果知道数组有多少元素，具体的值就可以使用静态初始化


相当于：int a[] = new int[6];


a[0] = 1;


a[1] = 2;


a[2] = 5;


a[3] = 6;


a[4] = 9;


a[5] = 0;


数组细节(⭐⭐⭐)


数组是多种相同类型数据的组合，实现对这些数据的统一管理

数组中的元素可以创建任意的数据类型，包括基本类型和引用类型，但是不能混合使用

数组创建后，如果没有赋值，有默认值，int 0，short 0，byte 0，long 0，float 0.0，double 0.0，char \u0000, boolean flase,String null

使用数组的步骤，1，声明数组并开辟空间 2，给数组各元素赋值 3，使用

数组下标是从0开始的

数组下标必须在指定的范围内使用。否则就会出现 数组下标越界的异常

数组属于引用类型。数据类型是对象（object）


数组赋值机制(⭐⭐⭐)


基本数据类型赋值，值传递


public class demo14 {
    public static void main(String[] args) {
        int n1 = 10;
        int n2 = n1;
       
        n2 = 80;
        System.out.println("n1="+n1);
        System.out.println("n2="+n2);
    }
}


值拷贝,n2不会影响n1


结果：


n1=10

n2=80


引用类型赋值传递的是地址


引用传递，是一个地址


public class demo14 {
    public static void main(String[] args) {
        int[] arr1 = {1,2,3};
        int[] arr2 = arr1;//把arr1赋值给arr2
        arr2[0] = 10;
        System.out.println(arr1[0]);
    }
}


这里改变的是arr2的值，发现arr1的值也被改变

输出：10


打印数组最大值的下标

重点学习下标的获取，学会随着需求的驱动去定义变量，从而解决问题，体现在int maxIndex = 0; //记录下标


/**
 * @Author: liu sen
 * @Version: 1.0
 * @Date: 2021/08/31/14:02
 */
public class demo21 {
    public static void main(String[] args) {
        //找出数组最大值的下标，并打印出来
        int[] arr = {1, 345, 45, 800, 666};
        int max = arr[0];//假定第一个元素是最大值
        int maxIndex = 0; //记录下标
        for (int i = 1; i < arr.length; i++) {//从下标 1 开始遍历 arr
            if (max < arr[i]) {//如果 max < 当前元素
                max = arr[i]; //把 max 设置成 当前元素
                maxIndex = i;
            }
        }
        System.out.println("最大值的下标为：" + maxIndex);
    }
}


数组拷贝


编写代码 实现数组拷贝(内容复制)


/**
 * @Author: liu sen
 * @Version: 1.0
 * @Date: 2021/08/31/15:28
 */
public class demo22 {
    //编写代码 实现数组拷贝(内容复制)
    public static void main(String[] args) {
        int arr1[] = {1,2,3,4,5};//原数组
        int arr2[] = new int[arr1.length];//新数组，赋值后的数组，长度为 arr1.length
        //这时的arr2数组，里有默认值0，通过循环把arr1中的每个元素赋值给arr2，即完成复制
        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }
        //输出两个数组
        System.out.println("arr1====复制====arr2\n");
        for (int i = 0; i < arr1.length; i++) {
            System.out.print("arr1: "+arr1[i]+"\t\t");
            System.out.println("arr2: "+arr2[i]);
        }
        //改变arr1中元素的值，再输出
        System.out.println("\narr1====改变arr1后======arr2\n");
        arr1[2] = 100;
        for (int i = 0; i < arr1.length; i++) {
            System.out.print("arr1:  "+arr1[i]+"\t\t");
            System.out.println("arr2:  "+arr2[i]);
        }
    }
}


数组反转


方案1：


/**
 * @Author: liu sen
 * @Version: 1.0
 * @Date: 2021/08/31/16:28
 */
public class demo23 {
    //要求：把数组的元素内容反转
    public static void main(String[] args) {
        int arr[] = {1,2,3,4,5};
        int temp = 0;
        int len = arr.length;
        for (int i = 0; i < len/2; i++) {
            temp = arr[len - 1 - i];
            arr[len - 1 - i] = arr[i];
            arr[i] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
    }
}


方案2：逆序赋值(⭐⭐⭐)


/**
 * @Author: liu sen
 * @Version: 1.0
 * @Date: 2021/08/31/17:32
 */
public class demo24 {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3, 4, 5};
        int[] arr2 = new int[arr1.length];
        for (int i = arr1.length - 1, j = 0; i >= 0; i--, j++) {
            arr2[j] = arr1[i];
        }
        System.out.println("前arr1："+arr1.hashCode());
        System.out.println("前arr2："+arr2.hashCode());
        arr1 = arr2;
        System.out.println("后arr1："+arr1.hashCode());
        System.out.println("后arr2："+arr2.hashCode());
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr1[i]);
        }
    }
}


输出：


上一篇： 如何使用 Java 反转文件内容的顺序（不允许使用第二个文件）

下一篇： 通过开发单例和多例之间区别的简单测试来实现 Spring 注释

推荐阅读