day07 初识数组

最新推荐文章于 2024-08-11 20:00:32 发布
最新推荐文章于 2024-08-11 20:00:32 发布
阅读量125 收藏
点赞数
分类专栏： javase 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Libra_97/article/details/126752819
版权

数组

1. 数组的概念

数组：一块连续的内存空间，存储类型相同的数据，长度是固定的

2. 数组的定义方式

先声明、再分配空间：
数据类型[] 数组名;
数组名 = new 数据类型[长度];

声明并分配空间：
数据类型[] 数组名 = new 数据类型[长度];

声明并赋值（繁）：
数据类型[] 数组名 = new 数据类型[]{value1,value2,value3,…};

声明并赋值（简）：
数据类型[] 数组名 = {value1,value2,value3,…};

package com.atguigu.test1;

/**
 * 1.先声明 再开辟空间
 * 2.连声明 带开辟空间
 * 3.声明并且赋值(繁琐)
 * 4.声明并且赋值(简单)
 * */
public class Test1 {
    public static void main(String[] args) {
        // 方式1 先声明 再开辟空间
        int [] arr1;
        arr1 = new int[3];

        // 方式2 连声明带开辟空间
        int arr2[] = new int[5];


        // 方式3 声明并且赋值(繁琐)
        int [] arr3 = new int[]{1, 3, 5, 6, 99, 88};

        // 方式4 声明并且赋值(简单)
        int [] arr4 = {56, 89, 12, 34, 45};


    }
}

3. 数组的访问

数组的访问：数组的访问包括 赋值 以及 取值

数组的元素：数组中的每个数据，称之为元素

数组的下标:下标(角标，索引)属于自动生成，不需要人为设置，从0开始，往后依次加1

举例：长度为5的数组，下标范围是 0 ~ 4

访问数组的中的元素是通过下标来访问

访问方式：

赋值 数组名[下标] = 值;

取值 System.out.println(数组名[下标]);

注意：不能访问超过下标范围的内容 否则将报数组下标越界异常 ArrayIndexOutOfBoundsException

异常会中断正在执行的程序 未执行的代码将不再执行

package com.atguigu.test2;
/**
 * 数组的访问：数组的访问包括 赋值 以及 取值
 * 数组的元素：数组的每个数据，称之为元素
 * 数组的下标：下标(角标，索引)属于自动生成，不需要人为设置，从0开始，往后依次加1
 *      举例：长度为5的数组，下标范围是 0 ~ 4
 *
 * 访问数组的元素是通过下标来访问
 * 访问方式：
 *      赋值 数组名[下标] = 值;
 *      取值 System.out.println(数组名[下标]);
 *
 *  注意：不能访问超出下标范围的内容，否则将报数组下标越界异常 ArrayIndexOutOfBoundsException
 *  异常会中断正在执行的程序 未执行的代码将不再执行
 *
 * */
public class Test1 {
    public static void main(String[] args) {
        int [] arr1 = new int[5];

        // 赋值/存值
        arr1[0] = 56;
        arr1[1] = 78;
        arr1[2] = 234;
        arr1[3] = 345;
        arr1[4] = 12387;

//        arr1[5] = 123;  // 报错 ArrayIndexOutOfBoundsException

        // 取值
        System.out.println("arr1数组第1个元素值为：" + arr1[0]);  // arr1数组第1个元素值为：56
        System.out.println("arr1数组第2个元素值为：" + arr1[1]);  // arr1数组第2个元素值为：78
        System.out.println("arr1数组第3个元素值为：" + arr1[2]);  // arr1数组第3个元素值为：234
        System.out.println("arr1数组第4个元素值为：" + arr1[3]);  // arr1数组第4个元素值为：345
        System.out.println("arr1数组第5个元素值为：" + arr1[4]);  // arr1数组第5个元素值为：12387
    }
}

4.数组的遍历

数组的遍历：逐一对数组中的元素进行访问 这个过程称之为遍历

package com.atguigu.test3;

import java.util.Scanner;

/**
 * 数组的遍历：逐一对数组中的元素进行访问 这个过程称之为遍历
 * */
public class Test1 {
    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);

        int [] arr1 = new int[5];
        
        for (int i = 0; i < 5;i++){
            System.out.print("请输入第" + (i + 1) + "个元素的值：");
            arr1[i] = input.nextInt();
        }
        System.out.println("---------------赋值完毕---------------");

        for (int i = 0; i < 5; i++){
            System.out.println("第" + (i + 1) + "个元素的值为：" + arr1[i]);
        }
        System.out.println("---------------取值完毕---------------");
    }
}

5. 数组的length属性

遍历数组，推荐使用数组的length属性，length属性表示数组的长度(元素的个数)，是一个int类型的整数数值

使用方式：数组名.length

package com.atguigu.test3;
/**
 * 遍历数组：推荐使用数组的length属性，length属性表示数组的长度(元素的个数)，是一个int类型的整数数值
 * 使用方式：数组名.length
 * */
public class Test2 {
    public static void main(String[] args) {
        int [] nums = {45, 55, 66, 77};

        System.out.println("当前nums数组的长度为：" + nums.length);

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

6.数组的默认值

数组元素的默认值：当我们给数组开辟空间，数组中即存在对应长度个数的默认值

整数：0

浮点：0.0

布尔：false

字符：\u0000

其他：null

package com.atguigu.test3;
/**
 * 数组元素的默认值：当我们给数组开辟空间，数组中即存在对应长度个数的默认值
 * 整数：0
 * 浮点数：0.0
 * 布尔：false
 * 字符：\u0000
 * 其他：null
 * */
public class Test3 {
    public static void main(String[] args) {

        byte [] nums1 = new byte[3];

        for (int i = 0; i < nums1.length; i++){
            System.out.print(nums1[i] + "\t");  // 0	0	0
        }
        System.out.println();
        System.out.println("--------------------------------------");

        short [] nums2 = new short[5];
        for (int i = 0; i < nums2.length; i++){
            System.out.print(nums2[i] + "\t");  // 0	0	0	0	0
        }
        System.out.println();
        System.out.println("--------------------------------------");

        int [] nums3 = new int[6];
        for (int i = 0; i < nums3.length;i++){
            System.out.print(nums3[i] + "\t");  // 0	0	0	0	0	0
        }
        System.out.println();
        System.out.println("--------------------------------------");

        long [] nums4 = new long[10];
        for (int i = 0; i < nums4.length; i++){
            System.out.print(nums4[i] + "\t");  // 0	0	0	0	0	0	0	0	0	0
        }
        System.out.println();
        System.out.println("--------------------------------------");

        float [] nums5 = new float[4];
        for (int i = 0; i < nums5.length; i++){
            System.out.print(nums5[i] + "\t");  // 0.0	0.0	0.0	0.0
        }
        System.out.println();
        System.out.println("--------------------------------------");

        double [] nums6 = new double[8];
        for (int i = 0; i < nums6.length; i++){
            System.out.print(nums6[i] + "\t");  // 0.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0
        }
        System.out.println();
        System.out.println("--------------------------------------");

        boolean [] bls = new boolean[4];
        for (int i = 0; i < bls.length; i++){
            System.out.print(bls[i] + "\t");  // false	false	false	false
        }
        System.out.println();
        System.out.println("--------------------------------------");

        char [] chs = new char[6];
        for (int i = 0; i < chs.length; i++){
            System.out.print(chs[i] + "-\t");  //  -	 -	 -	 -	 -	 -
        }
        System.out.println();
        System.out.println("--------------------------------------");

        String [] strings = new String[7];
        for (int i = 0; i < strings.length; i++){
            System.out.print(strings[i] + "\t");  // null	null	null	null	null	null	null
        }
        System.out.println();
        System.out.println("--------------------------------------");

    }
}

7.数组的扩容

1.创建大于原数组长度的新数组

2.将原数组中的元素依次复制到新数组中

3.将原数组的引用指向新的数组 完成扩容

数组作为引用数据类型 其数组名(引用)中存储的是指向堆中的地址

所以 直接将一个数组赋值给另外一个数组 赋值的是内存中的地址

数组赋值

package com.atguigu.test4;
/**
 * 数组的扩容：
 *      1.创建大于原数组长度的新数组
 *      2.将原数组的元素依次复制到新数组中
 *      3.将原数组的引用指向新的数组 完成扩容
 * */
public class Test1 {
    public static void main(String[] args) {

        int [] oldArr = {22, 33, 44, 55, 66};

        // 1.创建大于原数组长度的新数组
        int [] newArr = new int[oldArr.length * 2];

        // 2.将原数组中的元素依次复制到新数组中
        for (int i = 0;i < oldArr.length; i++){
            newArr[i] = oldArr[i];
        }

        System.out.println("-------------------遍历新数组------------------");

        for (int i = 0;i < newArr.length;i++){
            System.out.print(newArr[i] + "\t");  // 22	33	44	55	66	0	0	0	0	0
        }
        System.out.println();

        // 3.将原数组的引用指向新的数组 完成扩容
        // 数组作为引用数据类型 其数组名(引用)中存储的是指向堆中的地址
        // 所以 直接将一个数组赋值给另外一个数组 赋值的是内存中的地址

        oldArr = newArr;
        System.out.println(oldArr);  // [I@1540e19d
        System.out.println(newArr);  // [I@1540e19d
    }
}


package com.atguigu.test4;

public class Test2 {
    public static void main(String[] args) {

        int [] nums1 = {1, 2, 3, 4, 5};
        int [] nums2 = new int[10];

        System.out.println(nums1);  // [I@1540e19d
        System.out.println(nums2);  // [I@677327b6

        nums2 = nums1;

        System.out.println("------------地址赋值完毕---------------");

        System.out.println(nums1);  // [I@1540e19d
        System.out.println(nums2);  // [I@1540e19d

        System.out.println("------------遍历nums2数组---------------");

        for (int i = 0;i < nums2.length;i++){
            System.out.print(nums2[i] + "\t");  // 1	2	3	4	5
        }
        System.out.println();

        System.out.println("------------nums2数组对元素进行改变-------------");

        nums2[0] = 999;
        System.out.println(nums1[0]);  // 改变nums2[0]，nums[1]也同步发生变化 999
    }
}

8. 课堂练习

统计int类型数组中所有元素的总和、平均值。

package com.atguigu.test5;

/**
 * 统计int类型数组中所有元素的总和、平均值
 * */
public class Test1 {
    public static void main(String[] args) {
        int [] nums = {56, 66, 34, 54, 98, 23};

        int sum = 0;

        for (int i = 0; i < nums.length; i++){
            sum += nums[i];
        }
        System.out.println("nums数组元素总和为：" + sum);  // nums数组元素总和为：331
        System.out.println("nums数组元素平均值为：" + sum / nums.length);  // nums数组元素平均值为：55
    }
}

求一个数组中的最大值，或者最小值。

分析：我们可以假设数组中的某个元素作为最大值/最小值 然后依次与其他的元素比较

如果遇到更到/更小的 就交换’头衔’ 最终来确定 最大/最小值

package com.atguigu.test5;
/**
 * 求一个数组中的最大值，或者最小值
 *
 * 分析：我们可以假设数组中的某个元素作为最大值/最小值 然后依次与其他的元素比较
 * 如果遇到更大/更小的 就进行交换 最终来确定 最大/最小值
 * */

public class Test2 {
    public static void main(String[] args) {

        int [] nums = {23, 56, 34, 87, 45};

        int max = nums[0];  // 假设第一个元素为最大值

        int min = nums[0];  // 假设第一个元素为最小值

        for (int i = 1; i < nums.length;i++){
            if (nums[i] > max){
                max = nums[i];
            }

            if (nums[i] < min){
                min = nums[i];
            }
        }

        System.out.println("nums数组中最大的元素为：" + max);  // nums数组中最大的元素为：87

        System.out.println("nums数组中最小的元素为：" + min);  // nums数组中最小的元素为：23
    }
}

需求：

1.编写方法用于统计一组人的成绩 并且返回

2.编写方法用于打印一组人的成绩 使用数组作为参数

package com.atguigu.test6;

import java.util.Scanner;

/**
 * 数组类型的参数 数组类型的返回值
 *
 * 需求：
 *      1.编写方法用于统计一组人的成绩 并且返回
 *      2.编写方法用于打印一组人的成绩 使用数组作为参数
 * */
public class Test1 {

    public static double[] inputScore(){
        Scanner input = new Scanner(System.in);
        System.out.print("请输入有几个人：");
        int count = input.nextInt();

        double [] scores = new double[count];
        for (int i = 0;i < scores.length;i++){
            System.out.print("请输入第" + (i + 1) + "个人的成绩:");
            scores[i] = input.nextDouble();
        }
        return scores;
    }

    public static void printScore(double[] scores){
        for (int i = 0;i < scores.length;i++){
            System.out.println("第" + (i + 1) + "个人的成绩为：" + scores[i]);
        }
    }

    public static void main(String[] args) {
        double [] scores = inputScore();
        System.out.println();
        printScore(scores);
    }


}

9. 值传递和引用传递的区别？

面试题：Java中值传递和引用传递的区别？

Java官方明确指出：Java中只有值传递，引用传递传递的也是值，只不过这个值是一个地址

基本数据类型 属于值传递 传递的是值本身 在方法中对值的操作 不影响实参的取值

引用数据类型 属于引用传递 传递的是地址 在方法中根据地址所做的操作 影响指向这个地址的所有变量

String类型属于特殊的引用数据类型 作为参数 在方法中对参数的改变 不会影响原来的实参

package com.atguigu.test7;

/**
 * 面试题：Java中值传递和引用传递的区别?
 * Java官方明确提出：Java中只有值传递，引用传递的也是值，只不过这个值是一个地址
 * 基本数据类型 属于值传递 传递的是值本身 在方法中对值的操作 不影响实参的取值
 * 引用数据类型 属于引用传递 传递的是地址 在方法中根据地址所做的操作 影响指向这个地址的所有变量
 * String类型属于特殊的引用数据类型 作为参数 在方法中对参数的改变 不会影响原来的实参
 * */
public class Test1 {

    public static void m1(int num){
        num += 10;
        System.out.println("m1方法中，num的值为：" + num);  // m1方法中，num的值为：20
    }

    public static void main(String[] args) {
        int a = 10;
        m1(a);
        System.out.println("main方法中，a的值为：" + a);  // main方法中，a的值为：10

        int [] arr = {1, 2, 3};
        m2(arr);

        for (int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + "\t");  // 2	3	4
        }
    }

    public static void m2(int[] nums){
        for (int i = 0; i < nums.length; i++){
            nums[i]++;
        }
    }
}

10.可变长参数

可变长参数：可接收零个或者多个同类型的实参 个数不限 使用方式与数组相同

语法格式：数据类型 … 参数名称

要求：

1.整个形参列表中只能存在一个可变长参数

2.只能存在于形参列表的末尾

package com.atguigu.test8;

/**
 * 可变长参数：可接受零个或者多个同类型的实参 个数不限 使用方式与数组相同
 * 语法格式：数据类型 ... 参数名称
 *
 * 要求：
 *      1.整个形参列表中只能存在一个可变长参数
 *      2.只能存在于形参列表的末尾
 * */
public class Test1 {

    public static void m1(int[] a, int... nums){
        for (int i = 0;i < nums.length;i++){
            System.out.print(nums[i] + "\t");  // 1	2	3	4	5	6	7	m1方法执行完毕
        }
        System.out.println("m1方法执行完毕");
    }

    public static void main(String[] args){
        int[] arr1 = {1, 2, 3, 4};
        m1(arr1,1, 2, 3, 4, 5, 6, 7);
    }
}

11.复制数组

循环将原数组中所有元素逐一赋值给新数组。

System.arraycopy(原数组,原数组起始,新数组,新数组起始,长度);

java.util.Arrays.copyOf(原数组, 新长度);//返回带有原值的新数组。

复制数组方式1：编写循环实现元素的复制

package com.atguigu.test9;

/**
 * 复制数组方式1：编写循环实现元素的复制
 * */
public class Test1 {
    public static void main(String[] args) {
        int[] oldArr = {1, 2, 3, 4, 5, 6, 7};

        int[] newArr = new int[oldArr.length];

        for (int i = 0;i < oldArr.length;i++){
            newArr[i] = oldArr[i];
        }

        System.out.println("-----------元素复制完毕---------------");

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

制数组方式2：System.arraycopy(原数组,原数组起始,新数组,新数组起始,长度);

长度必须小于等于剩余元素的个数 否则报下标越界异常

package com.atguigu.test9;
/**
 * 复制数组方式2：System.arraycopy(原数组, 原数组起始, 新数组, 新数组起始, 长度);
 *
 * 长度必循小于等于剩余元素的个数 否则报下标越界异常
 * */
public class Test2 {
    public static void main(String[] args) {
        int[] oldArr = {1, 2, 3, 4, 5};

        int[] newArr = new int[10];

        System.arraycopy(oldArr, 2, newArr, 6, 1);  // 原数组, 原数组下标起始位, 新数组, 新数组下标起始位, 复制多少位

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

        System.out.println();
    }
}

复制数组方式3：java.util.Arrays.copyOf(原数组, 新长度);//返回带有原值的新数组。

package com.atguigu.test9;

import java.util.Arrays;

/**
 * 复制数组方式3：java.util.Arrays.copyOf(原数组, 新数组的长度);  // 返回复制后的新数组
 * */
public class Test3 {
    public static void main(String[] args) {
        int[] oldArr = {11, 22, 33, 44, 55};

        int[] newArr = Arrays.copyOf(oldArr, 10);

        for (int i = 0;i < newArr.length;i++){
            System.out.print(newArr[i] + "\t");
        }
        System.out.println();  // 11	22	33	44	55	0	0	0	0	0
    }
}

12.练习

package com.atguigu.test10;

import java.util.Scanner;

/**
 * 数组练习
 * */
public class Test1 {
    public static void main(String[] args) {
        // 1.下列数组的声明有哪些是对的？错的应该怎么修改？
        // A. int[] a;
        // B. int a[] = new int[3];
            // c. int[] a;
            // a = {1, 2, 3, 4, 5};
        // D. int[] a = new int[3]{1, 2, 3};

        getAvg();

        isExist();

        getMaxMin();

        reverseOrder();
    }


    // 2.写一个函数，计算一个整数数组的平均值
    public static void getAvg(){
        int sum = 0;
        int[] nums = {11, 22, 33, 44, 55};
        for (int i = 0; i < nums.length; i++){
            sum += nums[i];
        }
        System.out.println("平均值为：" + sum / nums.length);  // 平均值为：33

    }

    // 3.自定义一个整数数组a, 读入一个整数n, 如果n在数组中存在, 则输出n的下标;如果不存在,输出-1。
    public static void isExist(){
        int[] a = {11, 22, 33, 44, 55};
        Scanner input = new Scanner(System.in);
        System.out.print("请输入整数：");
        int num = input.nextInt();
        for (int i = 0;i < a.length;i++){
            if (a[i] == num){
                System.out.println("下标为：" + i);
                break;
            }
        }
        System.out.println(-1);
    }

    // 4.给定一个数组，输出数组中的最大值和最小值
    public static void getMaxMin(){
        int[] nums = {34, 65, 12, 98, 45};
        int max = nums[0];
        int min = nums[0];

        for (int i = 0; i < nums.length;i++){
            // 求最大值
            if (nums[i] > max){
                max = nums[i];
            }
            // 求最小值
            if (nums[i] < min){
                min = nums[i];
            }
        }
        System.out.println("数组中的最大值为：" + max);  // 数组中的最大值为：98
        System.out.println("数组中的最小值为：" + min);  // 数组中的最小值为：12
    }

    // 5.给定一个数组，把这个数组中所有元素顺序进行颠倒
    public static void reverseOrder(){
        int[] nums = {34, 65, 12, 98, 45};
        for (int i = 0; i < nums.length / 2;i++){
            int temp = nums[i];
            nums[i] = nums[nums.length - i - 1];
            nums[nums.length - i - 1] = temp;
        }

        for (int i = 0; i < nums.length;i++){
            System.out.print(nums[i] + "\t");  // 45	98	12	65	34
        }
    }
}
Libra_97
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
day04-数组
qq_48076562的博客
04-27 298
学习目标 能够知道数组的定义格式 动态初始化:指定数组的长度,有默认初始化值 静态初始化:创建数组并附初始化值 能够使用两种方式完成数组元素的初始化 动态初始化:int[] arr = new int[10]; 静态初始化:int[] arr = new int[]{1,2,3,4,5,6,7,8,9,10}; 静态初始化:int[] arr = {1,2,3,4,5,6,7,8,9,10}; 能够知道数组在内存中的初始化过程 栈:运行方法(main方法入栈执行),在方法中
【day10】初识二维数组
qq_45727761的博客
07-14 97
初识二维数组
初识数组、指针、结构体、文件
m0_54720446的博客
04-10 299
数组、指针、结构体、文件1、数组1.1定义1.2运算符1.2.1 C语言运算符优先级表1.2.2运算符举例2、指针2.1定义2.2主存示意图2.3指针的大小2.4 *的三种意义2.5地址的输出2.6 ASCII码表3.结构体3.1定义3.2一个简单的结构体4.文件4.1读写文件图示4.2文件类型4.3 C语言提供给的三个标准文件 1、数组 1.1定义 数组是包含给定类型的一组数据，即一组相同类型元素的集合。 1.2运算符 1.2.1 C语言运算符优先级表 1.2.2运算符举例 1.%（余数）取模 辗转相除
Java SE - 数组初识
qq_39752387的博客
04-26 151
Day9 ：方法总结和数组初识 1. 方法总结 1.1 方法三要素 1. 返回值： 方法执行完之后，所给的反馈 2. 方法名： 简单来说，就是这段代码的名字 3. 形参列表： 需要传给方法的数据 1.1.1 方法名 命定规定： 1. 只能用英文字母，数字，下划线 2. 见名知意，【不要用拼音】【不要用拼音】【不要用拼音】【用拼音剁手剁手剁手】 3. 小驼峰命名（首个单词字母小写，其他单词首字...
一起来学Java！！！ day010 方法总结与初识数组
bandersnatch的博客
04-23 103
Java day010 方法总结与初识数组*** 方法三要素J 方法名 只能用大写英文字母‘A’-‘Z’，小写字母‘a’-‘z’，数字0-9，以及下划线‘-’。 命名应采用小驼峰命名法。如arrayList，add，update。 最好做到见名知意。 返回值类型 根据需求决定需不需要返回值。 返回值的数据类型与数据含义。 返回值有且只能有一个。 形式参数列表 根据实际情况来决定...
初识C语言 DAY5 【初识函数，数组】
Xjb200512的博客
01-09 488
本文章总结于此视频。
初识C语言 DAY11 【二维数组】
Xjb200512的博客
01-21 1013
一维数组只有一个下标，称为一维数组，其数组元素也称为单下标变量。顾名思义，二维数组有两个下标。也可以理解为二维数组代表着两个维度，横轴和纵轴，像一个矩阵。i代表行，j代表列比如说写一个成绩单，就可以使用二维数组。类型说明符 数组名 [常量表达式 1] [常量表达式 2]；// 6*6 6行6列// 5*4 5行4列// 8*6 8行6列在 C语言中，二维数组是按行排列的，即按行顺序存放，先存放 a[0] 行，再存放 a[1] 行，接着存放 a[2] 行。
软件漏洞分析入门_初级栈溢出_初识数组越界(1)
个人笔记
07-07 182
软件漏洞分析入门_初级栈溢出A_初识数组越界前言目的环境实验参考 前言 系列内容基于failwest的：<0day安全第二版> 电子资料： 链接：https://pan.baidu.com/s/17wYc7GRLWb1YaNVb3RSpsQ 提取码：572l 资料解压缩密码：0day2 目的 写这系列完全出于查漏补缺的目的，虽然知识早已掌握，但就像做试卷和出试卷的区别，从根源上去刨析知识结构，才能更加完善掌握。 环境 VS6.0 实验 存在数组越界漏洞的代码 #include <stdio
Day6数组
Syntactic_tang的博客
12-29 136
Day6 数组 第一节：数组的概念 一组连续的存储空间，存储多个相同数据类型的值 1.1数组的特点： 1、长度固定。 当创建的数组分配长度后，则该数组长度固定不变 2、类型相同 数组在创建初给定的类型，则数组当中存放的数据一定是该类型、统一 1.2数组的创建 一、声明并分配空间 1.2.1先声明、再分配空间 ​ 例： int[] a； a = new int[5]; /...
（javaweb）请求响应postman
2301_79144798的博客
08-08 483
1.Tomcat又称为servlet容器前端浏览器发起请求携带http请求数据，web服务器负责请求协议的解析，Tomcat接收请求数据，并对请求数据进行解析。Tomcat将解析后所有的信息封装到一个对象当中：HttpServletRequest（请求对象）---应用程序从中获取请求数据。HttpServletResponse--通过这个对象设置要响应的数据 --响应信息给浏览器浏览器--服务器：：BS架构（通过浏览器能访问到的网站：京东 淘宝 天猫 唯品会都是BS架构）
SpringBoot快速入门（手动创建）
最新发布
m0_74124657的博客
08-11 269
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 235
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
Spring事务
c1tenj2的博客
08-07 452
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
Spring Boot 3.x Rest API最佳实践之API设计
felix_alone2012的博客
08-08 902
本系列教程将会以企业中API基础功能封装为目标，用最新的Spring Boot 3.x版本来逐步搭建和完善Rest API项目基础架构，并结合实际电商项目中API的实现需求来进行最佳实践。如果觉得对你有帮助，记得点赞收藏，关注小卷，后续更精彩！
反射和注解
supercool7的博客
08-08 266
反射的基本步骤包括获取Class对象、获取类的信息（构造函数、方法、字段等），然后通过Constructor、Method、Field等类的实例进行具体的操作。注解以@符号开头，通常紧跟着一个标识符，后面可以跟一些参数，用于给类、方法、字段等添加元数据信息，这些信息可以在编译时、运行时被读取和处理。通过Class类，可以获取类的构造函数、方法、字段等信息，而不需要在编译时确定这些信息。Spring、SpringBoot、Mybatis等框架中都大量使用了反射机制。此外，开发者还可以定义自己的注解，通过。
安卓Android & JAVA校招/实习面试合集:多线程、强软弱虚引用、进程、内存管理、Activity、Fragment......
qq_41915623的博客
08-10 405
安卓Android、java面试资料合集：内存管理、多线程、进程、强软弱虚应用、Activity
Java：继承，this，super
m0_75257168的博客
08-10 347
可以同名，但参数列表不能相同（有参无参构造）
Spring一个强大便捷的代理工厂类
330553352的专栏
08-10 269
但如果你需要一种更加灵活和可配置性，那么Spring还提供了一个非常方便强大的ProxyFactoryBean类，该类特别适合那些需要更多自定义和控制的场景，例如当你需要为特定的Bean创建代理，或者需要在不修改原始代码的情况下为现有类添加额外的功能时。在Spring框架中，AOP（面向切面编程）是一种强大的编程范式，它允许开发者在不修改原有代码的情况下，为程序添加额外的功能，如日志记录、事务管理、安全控制等。在上面配置拦截器时，我们都是指定的具体拦截器，其实我们还可以使用通配符，指定拦截器。
log4j反序列化-流程分析
无
08-06 1188
JDK8u141依赖</</</</</</</</</
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值