Java笔记——数组

已于 2024-10-04 10:47:37 修改
阅读量761 收藏 14
点赞数 26
文章标签： 笔记 开发语言 java
于 2024-10-03 22:26:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72047169/article/details/142690308
版权

1.前言:

数组相当于程序中的容器，是一种重要的基础数据结构，用于存储一系列相同类型的数据。

1.1 数组(Array)概念

用于存储固定大小的同类型元素的集合。每个数组都有一个固定的长度 (一旦创建，长度不可更改)，并通过一个索引（从0开始）来访问数组中的元素。

1.2 构成

  • 数组名
  • 索引、index、下标（找到指定数组元素所使用的编号）
  • 元素
  • 数组长度（存储数组容器中的存储的元素的个数）

图解：

图源来自网络
图源来自网络

1.3 数组的特点

  • 数组本身是 引用数据类型 ，数组中的元素可以是 任何数据类型 。
  • 创建数组对象会在内存中开辟一整块“连续的空间”，占用内存空间大大小，取决于数组的长度和数组中元素的类型。
  • 数组中的元素在内存中是依次紧密排列的，有序的。
  • 数组的初始化完成，长度就确定，无法更改。 
  • 数组名中引用的是这块连续空间的首地址。

1.4 为什么要使用数组

  1. 存储多个值：数组能够在单一变量中存储多个数据值，简化了数据的管理和操作。

  2. 快速访问：通过索引访问数组中的元素非常快速，时间复杂度为O(1)。这使得数组特别适合需要频繁访问和操作数据的场景。

  3. 内存管理：数组允许在内存中连续存储数据，提高了内存的使用效率。

  4. 数据结构基础：数组是实现其他复杂数据结构（如列表、栈、队列等）和算法（如排序、查找等）的基础。

1.5 数组的分类

数组维数分类：

  • 一维数组：存储一系列同类型的元素，类似于线性列表。
  • 多维数组：由多个一维数组组成，通常用于表示矩阵或表格数据。最常用的是二维数组。

2.一维数组

2.1 声明和初始化，索引

/*数组的声明和初始化

声明数组*/
int[] numbers;
/*初始化数组：
使用 new 关键字：*/
// 创建一个长度为5的整数数组
numbers = new int[5];

//在声明时直接初始化：
int[] numbers = {1, 2, 3, 4, 5};

/*2. 调用数组的指定元素
要访问数组中的特定元素，可以使用索引，索引从0开始。例如：*/
int firstElement = numbers[0]; // 访问数组中的第一个元素
int secondElement = numbers[1]; // 访问数组中的第二个元素
//可以通过索引来修改数组的元素：
numbers[0] = 10; // 将第一个元素的值修改为10

2.2 长度与遍历

/*数组的长度，用来描述数组容器中容量的大小
使用length属性表示：
*/
System.out.printlt(数组名.length);

// 使用传统的 for 循环
int[] arr = {1, 2, 3, 4, 5};
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

// 使用增强的 for 循环
for (int item : arr) {
    System.out.println(item);
}

2.3 数组元素的默认初始化值

数组的元素在创建时会被自动初始化为其默认值。默认值取决于数据类型：

  • 对于整数类型（如 int, long, short, byte），默认值为 0。
  • 对于浮点类型（如 float, double），默认值为 0.0。
  • 对于字符类型（char），默认值为 '\u0000'（空字符）。
  • 对于布尔类型（boolean），默认值为 false。
  • 对于引用数据类型，默认值为 null。
public class Person {
    public static void main(String[] args) {
        //采用int类型
        int[] arr = new int[5];
        System.out.println("这是int类型的默认初始化值： " + arr[0]);

        short[] arr2 = new short[4];
        System.out.println("这是short类型的默认初始化值： " + arr2[0]);
        //采用浮点类型
        double[] arr3 = new double[3];
        System.out.println("这是double类型的默认初始化值： " + arr3[0]);
        //采用字符类型
        char[] arr4 = new char[3];
        System.out.println("这是char类型的默认初始化值： " + arr4[0]);
        //采用布尔类型
        boolean[] arr5 = new boolean[2];
        System.out.println("这是boolean类型的默认初始化值： " + arr5[0]);
        //采用引用数据类型
        String[] arr6 = new String[5];
        for (int i = 0; i < arr6.length; i++) {
            System.out.println("这是String类型的默认初始化值： " + arr6[i]);
        }

        }
    }

结果：

2.4 内存解析

一维数组的内存分配是动态的。当你使用 new 关键字创建数组时，Java虚拟机（JVM）在堆内存中分配相应大小的内存空间。数组的长度在创建时被固定，数组中的每个元素都会占用相同大小的内存块。

内存空间可以分为5个部分：程序计数器、虚拟机栈、本地方法栈、堆、方法区。

与目前数组相关的内存结构：

  • 虚拟机栈：用于存放方法中的声明的变量。如：arr。
  • 堆：用于存放数组的实体（数组中的所有元素）如：1.2.3

3.二维数组

理解：可以堪称是一维数组arr1又作为另一个一维数组arr2的元素而存在。即嵌套一维数组

3.1 声明和初始化，索引

public class TwoDimensionalArrayExample {
    public static void main(String[] args) {
        //静态声明并初始化二维数组
        int[][] array = new int[][]{
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        //动态初始化
        String[][] arr2 = new String[3][4]
        // 访问第二行第三列的元素，值为 6
        int value = array[1][2]; 
        /*对于内层元素的调用，要将元素的行列写清楚
          对于外层元素的调用，只要写清楚行*/
        System.out.println(array[0][1]);//内层元素
        System.out.println(array[0]);//外层元素
    }
}

3.2 长度与遍历

//通过 length 属性获取二维数组的行数和列数：
int rows = array.length; // 行数
int cols = array[0].length; // 列数（假设所有行列数相同）
//使用嵌套的 for 循环遍历二维数组：
for (int i = 0; i < array.length; i++) { // 遍历行
    for (int j = 0; j < array[i].length; j++) { // 遍历列
        System.out.print(array[i][j] + " ");
    }
    System.out.println(); // 换行
}

3.3 默认初始化值

二维数组的元素会被默认初始化为以下值：

外层：

  • 表示地址值
System.out.println(arr[3]);//@32674235

内层：

  • 对于 int 类型：0
  • 对于 boolean 类型：false
  • 对于 char 类型：'\u0000'（空字符）
  • 对于引用数据类型：null
System.out.println(arr3[0][1]);//值为null

3.4 二维内存解析

Java 中的二维数组实际上是一个数组的数组。在内存中，它的分配是非连续的，每个内层数组的内存地址可能不在同一位置。这种结构使得可以有不规则的数组（即每一行的列数可以不同）。

解释:

       先开辟了arr1的三行两列的空间，arr2的空间则是4行n列，arr2的第二行有5列，由于是int类型默认为0，再将arr2的第二行第二列从0变1。由于arr2的第三行没有说明列数，所以arr的第三行第三列不存在，报错。

解释：

       先给arr1的4行n列开辟空间，再给arr1的第一行开辟了三列的空间，int类型默认值为0。arr1的第二行也开辟了三列的空间，但有赋值1，2，3。将arr1的第一行第三列的值改为5。最后相当于初始化了一个新的arr1。

4.数组的常见算法操作

4.1 特征值计算

示例：

import java.util.Random;

public class ArrayTest {
    public static void main(String[] args) {
        // 创建一个大小为10的int型数组
        int[] numbers = new int[10];
        
        // 创建一个Random对象用于生成随机数
        Random random = new Random();
        
        // 使用循环为数组赋随机值
        for (int i = 0; i < numbers.length; i++) {
            // 生成0到100之间的随机整数
            numbers[i] = random.nextInt(101); // 包含0到100的随机数
        }

        // 初始化最大值、最小值和总和
        int max = numbers[0];
        int min = numbers[0];
        int sum = 0;

        // 遍历数组，计算最大值、最小值和总和
        for (int number : numbers) {
            if (number > max) {
                max = number; // 更新最大值
            }
            if (number < min) {
                min = number; // 更新最小值
            }
            sum += number; // 累加到总和
        }

        // 计算平均值
        double average = (double) sum / numbers.length;

        // 输出结果
        System.out.println("数组元素: ");
        for (int number : numbers) {
            System.out.print(number + " ");
        }
        System.out.println("\n最大值: " + max);
        System.out.println("最小值: " + min);
        System.out.println("总和: " + sum);
        System.out.println("平均值: " + average);
    }
}

结果：

4.2 数组元素的赋值与反转

赋值示例：杨辉三角，10行

public class YangHuiTriangle {
    public static void main(String[] args) {
        // 定义二维数组，用于存储杨辉三角的10行
        int[][] triangle = new int[10][];
        
        // 构造杨辉三角
        for (int i = 0; i < 10; i++) {
            // 每一行的长度为i + 1
            triangle[i] = new int[i + 1];
            
            // 第一列和最后一列的元素为1
            triangle[i][0] = 1;
            triangle[i][i] = 1;
            
            // 计算每一行的其他元素
            if (i > 1) {  // 从第三行开始
                for (int j = 1; j < i; j++) {
                    triangle[i][j] = triangle[i - 1][j - 1] + triangle[i - 1][j];
                }
            }
        }

        // 打印杨辉三角
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < triangle[i].length; j++) {
                System.out.print(triangle[i][j] + " ");
            }
            System.out.println(); // 每行输出后换行
        }
    }
}

结果：

数组反转的示例：反转这个一维数组

public class Person {
    public static void main(String[] args) {
        int[] fanzhuan = new int[]{1,2,3,4,5};
        //遍历原本的顺寻
        for (int i = 0; i < fanzhuan.length; i++) {
                System.out.print(fanzhuan[i]+ " ");
        }
        System.out.println(); // 每行输出后换行
        //反转操作
        for (int i = 0; i < fanzhuan.length/2; i++) {
            int temp = fanzhuan[i];
            fanzhuan[i] = fanzhuan[fanzhuan.length-1-i];
            fanzhuan[fanzhuan.length-1-i] = temp;
        }
        //
        for (int i = 0; i < fanzhuan.length; i++) {
            System.out.print(fanzhuan[i]+ " ");
        }
        System.out.println(); // 每行输出后换行

    }
}

结果：

4.3 数组的扩容和缩容

示例：int[] arr = new int[] {1,2,3,4,5};将数组扩容一倍，并插入6，7，8三个元素到数组中

public class Person {
    public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5};

        int[] newArr = new int[arr.length << 1];

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

        newArr[arr.length] = 6;
        newArr[arr.length+1] = 7;
        newArr[arr.length+2] = 8;

        arr = newArr;

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

结果：

示例：int[] arr = {1,2,3,4,5,6}，现需删除数组中索引为3的元素，也就是删除4，即缩容一列。 


public class Person {
    public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5,6,7};
        int index1 = 3;
        /*不使用新数组
        for (int i = index1; i < arr.length-1; i++) {
            arr[i] = arr[i+1];
        }
        arr[arr.length-1] = 0;
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
        */
        //使用新数组
        int[] newArr = new int[arr.length - 1];
        for (int i = 0; i < index1; i++) {
            newArr[i] = arr[i];
        }
        for (int i = index1; i < arr.length - 1; i++) {
            newArr[i] = arr[i+1];
        }
        for (int i = 0; i < newArr.length; i++) {
            System.out.print(newArr[i]);
        }

    }
}

结果：

4.4 查找数组元素

4.4.1 线性查找

示例：int[] arr1 = new int[]{55,66,77,1,2,3,4,5,76,34,12};查找元素77是否出现过，出现求索引值


public class Person {
    public static void main(String[] args) {
        int[] arr1 = new int[]{55,66,77,1,2,3,4,5,76,34,12};
        int target = 77;
        //线性查找
        boolean isFlag = true;
        for (int i = 0; i < arr1.length; i++) {
            if (target == arr1[i]){
                System.out.println("找到啦"+ target + "，对应位置为："+ i);
                isFlag = false;
                break;
            }
        }
        if (isFlag) {
            System.out.println("没找到");
        }
        
    }
}

结果：

4.4.2 二分法查找

说明：适用于在有序数组中查找特定元素。其基本思路是将数组分成两半，逐步缩小查找范围。

步骤：

  1. 初始化：设置两个指针，low指向数组的开始，high指向数组的结束。
  2. 查找：
    • 计算中间索引 mid = (low + high) / 2。
    • 比较 mid 位置的元素与目标值：
      • 如果相等，返回 mid（找到了目标值）。
      • 如果目标值小于 mid 位置的元素，则在左半部分继续查找，将 high 更新为 mid - 1。
      • 如果目标值大于 mid 位置的元素，则在右半部分继续查找，将 low 更新为 mid + 1。
  3. 结束：如果 low 大于 high，说明目标值不在数组中，返回一个表示未找到的值（例如 -1）。

图解：

示例：int[] arr2 = new int[]{55,66,77,1,98,45,69,2,3,4,5,76,34,12};查找元素55是否出现过，出现求索引值


public class Person {
    public static void main(String[] args) {
        int[] arr2 = new int[]{55,66,77,1,98,45,69,2,3,4,5,76,34,12};
        int target = 77;
        int low = 0;//首索引
        int high = arr2.length - 1;//默认的尾索引
        int mid;
        boolean isFlag = false;
        while(low <= high) {
            mid = (high + low) / 2;

            if (target == arr2[mid]) {
                System.out.println("找到了 " + target + ",对应位置为：" + mid);
                isFlag = true;
                break;
            }else if(target > arr2[mid]){
                high = mid +1;
            }else {
                low = mid - 1;
            }
        }
        if (!isFlag){
            System.out.println("没找到");
        }

    }
}

结果：

4.4.3 优缺点

线性查找：

  • 优点：算法简单
  • 缺点：执行效率低，执行的时间复杂度0(N)

二分法查找：

  • 优点：执行效率高，执行时间复杂度0(logN)
  • 缺点：偏难，前提：数组必须有序

4.5 数组元素排序

算法概述：用于将一组数据按照特定顺序排列。

目的;为了快速查找；

衡量排序算法的优劣:

  • 时间复杂度：关键字的比较次数和记录的移动次数。
  • 空间复杂度：分析排序算法中需要多少辅助内存。
  • 稳定性：若A与B的关键字值相等，但排序后A、B的先后次序保持不变。

4.5.1 冒泡排序

说明：它通过重复遍历待排序的数列，比较相邻的元素，并在顺序错误的情况下交换它们。这个过程持续进行，直到没有需要交换的元素为止，即数列已经有序。因为每次比较后，较大的元素会“冒泡”到数列的末尾。

冒泡排序的工作原理

  1. 比较相邻元素：从数组的第一个元素开始，比较当前元素与下一个元素的大小。
  2. 交换：如果当前元素大于下一个元素，则交换它们。
  3. 重复过程：对每一对相邻元素重复以上过程，直到数组的末尾。
  4. 缩小范围：每一趟结束后，最后一个元素是当前的最大值，下次比较时可以忽略它。
  5. 终止条件：如果在某一趟中没有进行任何交换，表示数组已经有序，可以提前终止算法。

示例：

public class BubbleSort {
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        boolean swapped;

        // 外层循环控制趟数
        for (int i = 0; i < n - 1; i++) {
            swapped = false; // 每趟开始前重置交换标志

            // 内层循环进行相邻元素比较
            for (int j = 0; j < n - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换 arr[j] 和 arr[j + 1]
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    swapped = true; // 标记发生了交换
                }
            }

            // 如果没有发生任何交换，提前结束
            if (!swapped) {
                break;
            }
        }
    }

    // 测试冒泡排序
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        System.out.println("原始数组:");
        printArray(arr);

        bubbleSort(arr);

        System.out.println("排序后的数组:");
        printArray(arr);
    }

    // 辅助方法，打印数组
    public static void printArray(int[] arr) {
        for (int value : arr) {
            System.out.print(value + " ");
        }
        System.out.println();
    }
}

结果：

4.5.2 快速排序

说明：通过选择一个“基准”元素（pivot），将数组分成两个子数组，其中一个子数组的所有元素都小于基准元素，另一个子数组的所有元素都大于基准元素。然后，递归地对这两个子数组进行排序，最终实现整个数组的排序。

快速排序的基本步骤

  1. 选择基准元素：从数组中选择一个元素作为基准。
  2. 分区操作：重排数组，将比基准元素小的元素放在其左边，比基准元素大的元素放在其右边。此时，基准元素的最终位置已确定。
  3. 递归排序：对基准元素左边和右边的子数组分别进行快速排序。

示例：

public class QuickSort {
    
    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            // 获取分区索引
            int pi = partition(arr, low, high);
            
            // 递归排序分区
            quickSort(arr, low, pi - 1);  // 左子数组
            quickSort(arr, pi + 1, high); // 右子数组
        }
    }

    private static int partition(int[] arr, int low, int high) {
        // 选择最后一个元素作为基准
        int pivot = arr[high];
        int i = (low - 1); // 小于基准的元素索引
        
        for (int j = low; j < high; j++) {
            // 如果当前元素小于或等于基准
            if (arr[j] <= pivot) {
                i++; // 增加小于基准的元素索引
                swap(arr, i, j); // 交换元素
            }
        }
        
        // 将基准元素放到正确的位置
        swap(arr, i + 1, high);
        return i + 1; // 返回基准元素的索引
    }

    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void main(String[] args) {
        int[] arr = {10, 7, 8, 9, 1, 5};
        int n = arr.length;
        
        quickSort(arr, 0, n - 1);
        
        System.out.println("排序后的数组: ");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

结果：

4.5.3 小结

排序的分类：内部排序（内存中排序），外部排序（外部存储设备+内存）

关注：

  • 冒泡排序：最简单，要求会敲。
  • 快速排序：最快的，开发中的默认排序方式，要掌握其实现思路。

编程的幸
关注
学习笔记（JAVA）——数组
qq_50233116的博客
05-15 378
数组
Java学习笔记——数组
大奖状的博客
11-28 252
java
java学习笔记——数组
Small__明的博客
11-17 338
java学习笔记——数组 文章目录java学习笔记——数组一、数组定义数组默认值内存分配静态初始化数组遍历数组 一、数组 定义数组 int [] arr = new int[3]; // int是数据类型， []代表数组， arr是数组名, new是为数组申请空间。 默认值 整数：0 浮点：0.0 布尔：false 字符：空字符 引用数据类型：null 内存分配 多个数组指向同一个内存，arr和arr2指向的是同一个地址。 静态初始化数组 int [] arr = {1,2,3}; 遍历数组 for
JAVA学习笔记——数组
weixin_45303372的博客
06-01 164
2021.5.25 1.数组的特点： 1.数组是有序的； 2.数组属于引用数据类型的变量； 3.数组在内存中是连续的； 4.数组的长度一旦确定不能修改。 2.数组的分类： 1.按照维数 2.按照数组元素的类型：基本数据类型数组，引用数据类型数组。 3.一维数组的使用 1.一维数组的声明和初始化 2.如何调用指定位置元素 3.获取数组长度 4.如何遍历数组 5.数组元素的默认初始化值 6.数组的内存解析 1.一维数组的声明和初始化 int[] ids;//声明 //静态初始化:
【Java学习笔记——数组】
zeng_q_yan的博客
11-24 416
Java学习笔记——数组2021.11.24数组其他知识补充 数组 常见概念： 数组名 下标（或索引）从0开始 元素 数组的长度 数组是有序排列的。 数组属于引用数据类型的变量。数组的元素可以是任何数据类型，既可以是基本数据类型，也可以是4引用数据类型。 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。 数组的长度一旦确定，不能修改。 数组的分类 按照维数：一维数组、二维数组… 按照数组元素类型：基本数据类型的数组、引用数据类型的数组 一维数组的使用
小白Java笔记——数组
Lunatic_fei的博客
12-20 311
一、数组类型数组是编程语言常见的一种数据结构，可以储存多个数据，每个数组元素存放一个数据，通常通过数组元素的引索来访问数组元素。 （一）数组也是一种类型 在一个数组中，数组元素的类型是唯一的，即一个数组只能存储一种数组类型的数据。 通俗理解：类之间可以继承，比如一个水果数组，数组元素可以是苹果、梨，表面上是另一种类型，其实只是水果的特殊类型，他们继承了水果组，仍然是水果类型。 数组初始化完成以后，
Java小白学习笔记——数组
tyomg的博客
12-20 243
1.1 数组1 数组存储相同类型值的序列。 1.2 声明 通过指出数组元素的数据类型和数组变量的名字来声明一个数组： int[] a; 现在拥有了一个数组的引用a，但是这只是一个引用，并没有给数组对象本身分配存储空间，为了创建这样的存储空间，需要进行初始化操作。 1.3 初始化 可以通过使用new来创建一个数组 int[] a = new int[n]; 每个数组都有一个“固有成员”length来表示数组的长度。 []内的值表示了数组的长度，创建时n不一定是一个常量，也可以是一个变量，但是一旦创建完成，
疯狂java笔记——数组
IMAlex233博客
07-24 163
java语言支持两种方法定义数组 type[ ] Name; type Name[ ];   例如 int a[ ]; int[ ] a; 建议使用第一种，第二种容易将Name[]当成一个变量； 定义数组不能指定长度   初始化 1.静态初始化 Name = new type[ ]{ a1,a2,a3.....} type是数组类型   如下： // 定义一个int数组类...
Java程序设计基础学习笔记——数组
Raider1的博客
01-07 172
数组的长度可以通过数组名.length得到数组的大小/长度数组练习创建一个char类型的26个元素的数组，分别放置'A'~'Z'，使用for循环访问所有的元素并打印出来。数组赋值机制 基本数据类型赋值，赋值方式为值拷贝数组在默认情况下是引用传递，赋的值是地址值传递和引用传递的区别二维数组内存布局二维数组的使用动态初始化——列数不确定（一维数组的个数可以不相同）对比C语言定义数组时对第一维的长度可以不定义，但必须定义第二维的长度例：int a [] [3] = {1， 2， 3， 4， 5， 6}；系统会根据
《Java数据结构和算法》学习笔记(1)——数组 二分法 大O表示法
03-14
本文将深入探讨《Java数据结构和算法》学习笔记的第一部分，主要聚焦于数组、二分法以及大O表示法。这些基础知识对于提升代码性能和优化解决方案具有决定性的作用。 **数组**是编程中最基本的数据结构之一，它在...
Java笔记06——数组的定义和使用
m0_61608447的博客
04-10 4271
包含 Java数组相关的知识点 + 解析 + 内存运转的简单了解 + 练习题
【笔记】Java学习——数组
AI_LYF1987的博客
08-11 174
Java数组学习
Java基础——数组（基础）学习笔记
weixin_43571269的博客
12-11 176
数组 1、数组的概念： 1)数组相当于是个容器,存相同类型的若干数据 2)数组也是一种基本的数据结构 3)数组属于引用数据类型 2、数组的定义： 数组的定义: 声明 + 初始化(需要注意：数组一旦确定数组的长度, 数组长度不可变) ...
AIGC学习笔记—minimind详解+训练+推理
m0_56569131的博客
09-27 298
这个开源项目是带我的一个导师，推荐我看的，记录一下整个过程，总结一下收获。这个项目的slogan是“大道至简”，确实很简。作者说是这个项目为了帮助初学者快速入门大语言模型（LLM），通过从零开始训练一个仅26MB的微型语言模型MiniMind，最快可在3小时内完成。降低学习LLM的门槛，让更多人能够轻松上手。MiniMind极其轻量，约为GPT-3的1/7000，适合普通个人GPU进行快速推理和训练。
（笔记）第三期书生·浦语大模型实战营（十一卷王场）--书生入门岛通关第2关Python 基础知识
haidizym的博客
10-02 394
学员闯关手册：https://aicarrier.feishu.cn/wiki/ZcgkwqteZi9s4ZkYr0Gcayg1n1g?课程视频：https://www.bilibili.com/video/BV1mS421X7h4/课程文档：https://github.com/InternLM/Tutorial/tree/camp3/docs/L0/Python。
江科大笔记—LED闪烁& LED流水灯& 蜂鸣器
m0_62005595的博客
09-28 475
LED闪烁& LED流水灯& 蜂鸣器
【韩顺平Java笔记】第6章：数组、排序和查找
随手写写
10-02 629
排序是将多个数据，依指定的顺序进行排列的过程。
大模型笔记05--coze经典案例分析
最新发布
脚步不能达到的地方，眼光可以达到；眼光不能达到的地方，精神可以飞到
10-03 621
扣子是新一代 AI 应用开发平台，具备完善的生态系统，是国内最出色的AI平台之一。用好coze平台，不仅可以让我们做出很多有意思的AI产品，还能让我们在AI时代走得更远。本文依托coze平台强大的工作流和图像流能力，分析当前知名的流程搭建方式，让我们能快速搭建有趣的工作流和图像流应用，定制有特色的AI智能体。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值