Java——数组，小白到精通，收藏这篇就够了

目录

一、认识数组

1、数组的概念

2、数组的类型

3、数组在JVM是如何存储

二、一维数组

1、一维数组的定义

1、动态初始化：

2、静态初始化：

2、一维数组的使用

    [1、数组中元素的使用](about:blank#%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A01%E3%80%81%E6%95%B0%E7%BB%84%E4%B8%AD%E5%85%83%E7%B4%A0%E7%9A%84%E4%BD%BF%E7%94%A8)

            [1、通过下标使用](about:blank#%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A01%E3%80%81%E9%80%9A%E8%BF%87%E4%B8%8B%E6%A0%87%E4%BD%BF%E7%94%A8)

            [2、遍历快速访问数组中的每一个元素](about:blank#%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A0%C2%A02%E3%80%81%E9%81%8D%E5%8E%86%E5%BF%AB%E9%80%9F%E8%AE%BF%E9%97%AE%E6%95%B0%E7%BB%84%E4%B8%AD%E7%9A%84%E6%AF%8F%E4%B8%80%E4%B8%AA%E5%85%83%E7%B4%A0)

    [1、通过循环实现遍历访问每一位元素（打印了数组中的每一个元素）：](about:blank#%C2%A0%20%C2%A0%20%C2%A0%20%C2%A0%201%E3%80%81%E9%80%9A%E8%BF%87%E5%BE%AA%E7%8E%AF%E5%AE%9E%E7%8E%B0%E9%81%8D%E5%8E%86%E8%AE%BF%E9%97%AE%E6%AF%8F%E4%B8%80%E4%BD%8D%E5%85%83%E7%B4%A0%EF%BC%88%E6%89%93%E5%8D%B0%E4%BA%86%E6%95%B0%E7%BB%84%E4%B8%AD%E7%9A%84%E6%AF%8F%E4%B8%80%E4%B8%AA%E5%85%83%E7%B4%A0%EF%BC%89%EF%BC%9A)

    [2、直接使用Java中遍历数组的工具](about:blank#%C2%A0%20%C2%A0%20%C2%A0%20%C2%A0%202%E3%80%81%E7%9B%B4%E6%8E%A5%E4%BD%BF%E7%94%A8Java%E4%B8%AD%E9%81%8D%E5%8E%86%E6%95%B0%E7%BB%84%E7%9A%84%E5%B7%A5%E5%85%B7)

2、数组的运用场景

1、保存数据

2、作为函数的参数

3、作为函数的返回值

三、二维数组

1、二维数组的定义

1、普通二维数组的定义

2、不规则二维数组的定义

2、二维数组中的使用

1、二维数组中元素的使用

2、二维数组遍历元素中的每一位

四、Arrays中的常用的方法

1、数组转字符串

1、自定义实现to String方法

2、直接使用Arrays中的to String方法

2、拷贝（拷贝数组时也可以实现扩容）

1、Arrays中的copyOf方法

2、Arrays中的copyOfRange方法

3、System.arraycopy方法

3、查找

1、遍历查找

2、二分查找（二分查找只能在顺序排序的数组中使用）

1、自定义实现二分查找

2、使用Arrays中的二分查找

4、排序

1、自定义实现冒泡排序功能

2、使用Arrays中的sort()方法实现排序

3、实现逆序排序

---

一、认识数组

1、数组的概念

假设现在你要将一个班的成绩全部进行储存，此时若一个一个定义：

double score1=90.5;
double score2=94.12;
double score3=87.56;
double score4=94.5;
double score5=88.75;
//……

此时，可以看出一个一个定义过于复杂，而且这一组数的数据类型都是一样的，此时就可以通过数组来进行定义这一组数据：

double [] scores={90.5,94.12,87.56,94.5,88.75};

用数据便于定义数据类型都一致的大量数据

数组的定义：数组可以看作是相同类型元素的一个集合，在定义大量数据类型一致的数据时可以使用数组进行定义

2、数组的类型

数组变量是引用类型数据，数组变量储存的是第一个数组元素在堆上的地址（实际上就是一个16进制的数字）

3、数组在JVM是如何存储

数组变量是存储在栈中的一个十六进制的一个数字，这个数字是数组元素中第一个元素的地址，数组名和数组元素的关系如下图所示：

二、一维数组

1、一维数组的定义

1、动态初始化：

先表明在内存空间中存储的元素个数，先开辟一部分空间，再对这部分的空间进行使用，开辟空间的大小由数组中存储的元素个数和定义的数组是什么元素类型所共同决定的

int [] array=new int[5];//表明在内存空间中申请了一个长度为5的空间（20个字节）
String [] array1= new String[3]; //一个可以容纳三个字符串的数组

2、静态初始化：

在为这个数组开辟空间的同时对其中的空间进行赋值

int [] array={1,2,3,4,5,6};
//或者是：int [] array=new int[]{1,2,3,4,5,6};
//注：在生成数组对应的空间时如果对其进行了赋值，则不能在等号右端指定元素的个数
//电脑会自动查询元素个数
String[] array="hello";

2、一维数组的使用

1、数组中元素的使用

1、通过下标使用

数组中的元素在堆中的存储空间是连续的，此时若要访问数组中的某一个元素可以通过下标进行访问（数组中的元素对应的下标都是从0开始的）如上图中使用的scores数组对应的下标：

此时可以通过下标访问数组中的每一个元素，对其进行更改或者赋值等操作，如：

scores[0]=96.5;//将数组中为0下标的元素赋值（更改）成了96.5
System.out.println(scores[0]);//打印了数组中下标为0的元素
//……

2、遍历快速访问数组中的每一个元素

遍历数组——即对数组中的每一位元素进行某种操作（例如打印等）

1、通过循环实现遍历访问每一位元素（打印了数组中的每一个元素）：

 int[] scores=new int[]{1,2,3,4,5,};
        int len=arr.length;//可以运用数组名.lence的形式计算数组长度，类似于C语言中的strlen,计算其中的元素个数
        System.out.println("数组的长度"+len);
        for (int i = 0; i < len; i++) {
            System.out.print(arr[i]+" ");
        }

2、直接使用Java中遍历数组的工具

int []arr=new int[]{1,2,3,4,5,}; 
//这个循环遍历数组，将数组中的每一个元素都放到y中去
for (int y:arr){
    System.out.print(y+" ");
 }

注意：数组元素的访问不能超过数组的访问界限，即有n个元素则只能访问到以n-1为下标的元素，否则编译器会报下标越界异常（ArrayIndexOutOfBoundsException）

2、数组的运用场景

1、保存数据

数组在Java中可以用于保存数据类型一样的大量数据

（例如上述的用于保存一个班的成绩）

double [] scores={90.5,94.12,87.56,94.5,88.75};

2、作为函数的参数

在Java中数组也可以作为函数的参数进行传递，本质上是对数组中首元素的地址进行传递

例如：写一个arrayPrint方法实现打印数组中的所有元素的功能

public static void arrayPrint(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
    public static void main(String[] args) {
        int[] array=new int[]{1,2,3,4,5};
        arrayPrint(array);//数组传参是传的是堆中存放元素的地址
//但在本质上还是传的数组中所指向的对象（数组中的元素）
    }

注：也可以使用上述的遍历的方法实现打印：

public static void arrayPrint(int[] arr){
        for (int i ：arr) {
            System.out.println(i+"  ");
        }
    }
    public static void main(String[] args) {
        int[] array=new int[]{1,2,3,4,5};
        arrayPrint(array);//数组传参是传的是堆中存放元素的地址，但在本质上还是传的数组中所指向的对象（数组中的元素）
    }

3、作为函数的返回值

在Java中可以直接将一个数组作为函数的返回值

 //返回一个数组,在C语言中不能返回多个数，但在Java中可以通过返回一个数组，来返回多个返回值
    public static  int[] fun1(){
        int a=10;
        int b=20;
        int[] arr=new int[]{a,b};
        return arr;
    }
    public static void main(String[] args) {
    int[] arr=fun1();
        String s = Arrays.toString(arr);
        System.out.println(s);

    }

三、二维数组

1、二维数组的定义

1、普通二维数组的定义

普通二维数组的定义方法和一维数组的类似

也有动态初始化和静态初始化，也可以在定义时直接赋值2

//二维数组定义
    public static void main(String[] args) {
        int[][] array={{1,2,3},{4,5,6}};
        // 行列
        int[][] array1=new int[2][3];
        int[][] array2=new int[][]{{1,2,3},{4,5,6}};
        System.out.println(array);
        System.out.println(array.length);
        // array存放的是地址，地址指向的是两个一维数组的地址
        System.out.println(array[0]);
        System.out.println(array[0].length);
        //System.out.println(Arrays.toString(array[0]));
    }

注：1、二维数组中可以通过行和列来理解，例如上述举例的array1中int[2][3]表示定义了一个两行三列的数组，一共是6个整数储存在这个数组中

2、二维数组的本质也是一维数组，只不过每一个二维数组的元素都算作是一个一维数组

例如：定义了一个二维数组array1，其中存储了两行三列的数据（{1，2，3}，{4，5，6}）

（举例中的地址是随便编的，实际地址格式并不是这样的）

2、数组名.length 可以用来计算数组的行数，例如array.length计算的是数组名为array的数组的行数

public static void main(String[] args) {
        int[][] array={{1,2,3},{4,5,6}};
        System.out.println(array.length);
    }

例如上述代码定义了一个两行三列的数组，其array.length打印出来的结果是2

3、数组名[a].length （假设定义了一个m行n列的数组，则计算列数时,a可以取从0到m-1的任意整数值） 可以用来计算二维数组的列数

2、不规则二维数组的定义

    不规则二维数组指的是那些没有在定义时没有确定列的二维数组（可以理解为可以确定一个二维数组中有多少个一维数组，但是每一个一维数组中的元素个数可以不同或者说不知道是多少）

例如：

//不规则二维数组的定义
    //二维数组在定义时可以省略列但是不能省略行（与C语言恰好相反）
    public static void main13(String[] args) {
        int[][] array=new int[2][];
        array[0]=new int[3];
        array[1]=new int[5];
        //定义了一个两行的不规则数组，第一行有3列，第二行有5列

    }

注：不规则二维数组定义时只能省略数组的列不能省略数组的行（与C语言的恰好是相反的）

且要定义不规则的二维数组只能是先定义一个二维数组中所包含的一维数组的个数，然后再分别规定一维数组中的元素个数

例如：一个两行，第一行三列，第二行五列的二维数组的空间分布

2、二维数组中的使用

1、二维数组中元素的使用

二维数组中元素的使用和一维数组类似，都是通过下标进行访问数组中的元素的值

 public static void main(String[] args) {
        int[][] array1=new int[][]{{1,2,3},{4,5,6,7,8}};
        System.out.println(array1[1][4]);
        System.out.println(array1[0][2]);
    }

特别注意：在对不规则的二维数组进行访问其中的元素时，一定要特别注意不要越界访问

如不关注每一行的列数然后直接进行访问可能就会导致越界访问错误

  public static void main(String[] args) {
        int[][] array1=new int[][]{{1,2,3},{4,5,6,7,8}};
        System.out.println(array1[1][4]);
        System.out.println(array1[0][4]);
    }

![](https://i-blog.csdnimg.cn/direct/dc4b527449584e9d8cf6dba7002b4b5f.png)

此处的第二个打印是打印第一行中的第五列的元素，但是第一行中只有三列，此时进行访问第五列就会出现越界访问的错误

2、二维数组遍历元素中的每一位

1、使用双循环法遍历数组中的每一位

注：第一层循环是指的是二维数组的行数，第二层循环是指的是二维数组的列数

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

        for (int j = 0; j < array1.length; j++) {
//循环行
            for (int i = 0; i < array1[j].length; i++) {
//循环列
                System.out.print(array1[j][i]+"  ");

            }
            System.out.println();
        }

    }

注：不能直接使用一层循环打印二维数组中的元素，因为二维数组中的元素是地址（一维数组中首个元素的地址）

2、使用循环法加Java中的遍历工具

注：在第一层的循环仍然是二维数组的行数，第二层的for each循环是打印的存在二维数组中一维数组中的元素

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

        for (int i = 0; i < array1.length; i++) {
            //行数
            for (int y:array1[i]) {
                System.out.print(y+"   ");

            }
            System.out.println();
        }


    }

注：同样不能直接使用for each循环来遍历二维数组，如

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


        for (int[] y:array1) {
            System.out.println(y);

        }

    }

不然会直接遍历二维数组中的元素，而二维数组中的元素是一维数组（即是一维数组中首个元素的地址）

四、Arrays中的常用的方法

1、数组转字符串

1、自定义实现to String方法

1、一维数组

可以通过访问一维数组的下标遍历打印一维数组从而实现和to String类似的效果

如（使用for循环实现打印一个一维数组arrays1中的元素（仿造to String方法的效果））：

public static void main(String[] args) {
        int[] array1=new int[]{4,5,6,7,8};
        System.out.print("[");
        for (int i = 0; i < array1.length-1; i++) {
            System.out.print(array1[i]+","+" ");

        }
        System.out.print(array1[array1.length-1]);
        System.out.println("]");
    }

2、二维数组

同理，二维数组也可以通过访问下标的方法实现和to String类似的效果

public static void main(String[] args) {
        int[][] array1=new int[][]{{1,2,3},{4,5,6,7,8}};
        System.out.print("[");
        for (int i = 0; i < array1.length; i++) {
            //行
            System.out.print("[");
            for (int j = 0; j < array1[i].length-1; j++) {

                System.out.print(array1[i][j]+","+" ");
            }
            System.out.print(array1[i][array1[i].length-1]);
            System.out.print("]");
        }
        System.out.println("]");


    }

注：实现遍历时注意最后一个元素的打印不同之前的格式（之前的元素打印都是打印完这个元素之后再在其后加一个逗号和一个空格）

2、直接使用Arrays中的to String方法

1、一维数组

在Arrays包中会有将数组直接转化为字符串的方法，可以使用Arrays中的方法直接将数组转化为字符串

注意：但是在使用Arrays中的方法前需要导入Arrays包（在代码的最前方写上import java.util.Arrays;）

如图：

 public static void main(String[] args) {
        int[] array=new int[]{1,2,3,4,5,6};
        System.out.println(Arrays.toString(array));
    }

2、二维数组

二维数组中存的是一维数组的数组名，而一维数组名表示的是一维数组首个元素的地址，二维数组本质上存的是地址，所以不能直接使用，不然to String方法会将二维数组中的元素变成变成字符串（将那些地址变成字符串）如：

public static void main(String[] args) {
        int[][] array1=new int[][]{{1,2,3},{4,5,6,7,8}};
        System.out.println(Arrays.toString(array1));
    }

此时需要深度to String（在toString方法前加上一个deep）如：

public static void main(String[] args) {
        int[][] array1=new int[][]{{1,2,3},{4,5,6,7,8}};
        System.out.println(Arrays.deepToString(array1));
    }

2、拷贝（拷贝数组时也可以实现扩容）

1、Arrays中的copyOf方法

public static void main(String[] args) {
        int[] array={1,2,3,4,5};
        int[] newArray=Arrays.copyOf(array,3);
        //                           拷贝的数组，新数组的长度
        System.out.println(Arrays.toString(newArray));
    }

注意：1、copyOf中的长度是从左往右进行计算的，如上面拷贝的array只拷贝了前三个元素

2、如果长度超过被拷贝的数组的个数，其会自动在后边补0（实现了扩容的功能）

public static void main(String[] args) {
        int[] array={1,2,3,4,5};
        int[] newArray=Arrays.copyOf(array,8);
        //                           拷贝的数组，新数组的长度
        System.out.println(Arrays.toString(newArray));
    }

![](https://i-blog.csdnimg.cn/direct/ac72c05c143f4cdcbc11d0ba0664f73d.png)

2、Arrays中的copyOfRange方法

1、起始和结束时的范围是左开右闭的，如（下面的例子的下标范围就是[2,4)）

public static void main(String[] args) {
        int[] array={1,2,3,4,5};
        int[] newArray=Arrays.copyOfRange(array,1,3);
        //                           拷贝的数组 ，起始拷贝的下标，结束拷贝的下标（注：下标范围是[2,4)）
        System.out.println(Arrays.toString(newArray));
    }

2、如果超过了原数组的范围，其会自动添0替代

public static void main(String[] args) {
        int[] array={1,2,3,4,5};
        int[] newArray=Arrays.copyOfRange(array,4,8);
        //                           拷贝的数组 ，起始拷贝的下标，结束拷贝的下标（注：下标范围是[4,8)）
        System.out.println(Arrays.toString(newArray));
    }

3、System.arraycopy方法

 public static void main(String[] args) {
        int[] array={1,2,3,4,5};
        int[] newArray = new int[array.length];
        System.arraycopy(array,2,newArray,1,2);
        //         拷贝的数组   ，起始拷贝下标，拷贝到哪一个数组，放在新数组的哪一个下标位置开始，拷贝原数组的长度
        System.out.println(Arrays.toString(newArray));
    }

注意：1、System.arraycopy方法所包含的参数相对较多，在使用时要先得知每一个参数的作用再使用

2、System.arraycopy方法在使用时应当先创建一个新的数组才能将原数组拷贝到这个新的数组中去

3、新数组没有定义的内容会自动补0

3、查找

1、遍历查找

遍历数组中的每一个元素进行查找向要的值，优点是逻辑简单，缺点是不够效率

public static int Find(int[] array1,int key){
        for (int i = 0; i < array1.length; i++) {
            if (array1[i]==key)
                return i;
        }
        return -1;
    }
    public static void main(String[] args) {
        int[] array={1,2,3,4,5};
        int key=4;
        int n=Find(array,key);
        if(n==-1)
            System.out.println(key+"不在数组中");
        else
            System.out.println(key+"在数组中的下标为"+n);
    }

2、二分查找（二分查找只能在顺序排序的数组中使用）

1、自定义实现二分查找

自定义实现二分查找的关键在于判断需要查找的值和顺序排序的数组中的中间值的大小关系，一次刷掉一半的值，如此循环这个过程直到找出所需查找的值，大大提升了代码的效率

public static int binarySearch(int[] array, int key){
       int i=0;
       int j=array.length-1;
//循环判断所需查找的值和数组中位数的大小关系
//一次筛选了一半的值
        while(i<=j){
            int mid=(i+j)/2;
        if(key>array[mid])
            i=mid+1;
        else if (key<array[mid])
            j=mid-1;
        else
            return mid;
      }
       return -1;
    }
    public static void main(String[] args) {
        int[] array={1,2,3,4,5};
        int key=4;
        int n=binarySearch(array,key);
        if (n==-1)
            System.out.println(key+"不在数组中");
        else
            System.out.println(key+"在数组中的下标是"+n);

    }

2、使用Arrays中的二分查找

同时，在Arrays中提供了实现二分查找的方法——binarySearch（）方法；

其实现的功能是在binarySearch（）方法中输入两个参数，第一个参数指定在哪一个数组中进行查找，第二个参数指定所需要查找的关键词，binarySearch（）方法会返回其在数组中对应的下标

注意：如果所需要查找的数在数组中不存在，则返回的是-（所需查找的数在数组中对应的排序位）

 public static void main(String[] args) {
        int[] array={1,2,5,7,8};
        int key=5;
        int n=Arrays.binarySearch(array,key);
        //                   要查找的数组，元素的下标(注：若该数不在数组中返回的是-(将key放入数组的排序位))
        System.out.println(n);
    }

4、排序

1、自定义实现冒泡排序功能

冒泡排序的核心在于每次比较数组中的两个数的大小，如果大于（或小于）则交换位置，按照这样的方法可以确定参与比较的数中的最大值（或最小值），按照这个方法，可以依次确定数组中的第一大，第二大，第三大……，从而实现排序的功能

而这样的方法相当于每次冒出了一个最大值或者最小值，冒n-1次（假设这个数组中有n个元素）后这个数组就变得有序了

public static void bubbleSort(int[] array){
        for (int i = 0; i < array.length - 1; i++) {
//总共需要冒泡的次数
            boolean n=true;
            //起始的n置为true
            for (int j = 0; j < array.length - 1 - i; j++) {
//单次冒泡时遍历还没有确定位置的数据
                if(array[j+1]<array[j]){
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                    n=false;
            //如果发生了任何一次交换，则将n置为false
                }
            }
            if(n==true)
            //如果n在某一次冒泡时没有发生过一次交换数据，说明剩下的数都已经有序了
            //此时就不需要再接着进行冒泡排序了
                break;
        }
    }
    public static void main(String[] args) {
        int[] array={2,1,5,7,8};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }

注意：n-1次是一个数组中最多需要经历n-1次冒泡排序,而不是所有的数组都要经历n-1次冒泡排序，当数组中剩下的数都已经有序时，此时就已经没有要再进行冒泡排序的必要了，因此，可以直接打破循环（例如示例）

2、使用Arrays中的sort()方法实现排序

注：在Arrays也有实现排序的方法sort()方法，其只需要一个参数——需要排序的数组，sort()方法默认的是实现从小到大排序，没有返回值

使用实例：

public static void main(String[] args) {
        int[] array=new int[]{7,2,8,4,5};
        Arrays.sort(array);
        //从小到大排序没有返回值
        System.out.println(Arrays.toString(array));
    }

3、实现逆序排序

逆序排序就是将第一个元素放在最后，第二个元素放在倒数第二，以此类推

实现逆序排序的方法使用的是“双指针”的方法，记录最左边和最右边的数组下标，并且交换最做左边和最右边的值，再让左边的下标向右移动一位，右边的下标移动一位，当两个下标相等时（或者左边的下标大于右边的下标时），此时便实现了逆序排序

 //数组逆序（将第一个元素放在最后，第二个元素放在倒数第二，以此类推
    public static void reverse(int[] array){
        int i=0,j=array.length-1;
        while(i<j){
            int temp=array[i];
            array[i]=array[j];
            array[j]=temp;
            i++;
            j--;
        }
    }
    public static void main(String[] args) {
    int[] array={1,2,3,4,5};
    reverse(array);
        System.out.println(Arrays.toString(array));
    }

---

说真的，这两年看着身边一个个搞Java、C++、前端、数据、架构的开始卷大模型，挺唏嘘的。大家最开始都是写接口、搞Spring Boot、连数据库、配Redis，稳稳当当过日子。

结果GPT、DeepSeek火了之后，整条线上的人都开始有点慌了，大家都在想：“我是不是要学大模型，不然这饭碗还能保多久？”

先给出最直接的答案：一定要把现有的技术和大模型结合起来，而不是抛弃你们现有技术！掌握AI能力的Java工程师比纯Java岗要吃香的多。

即使现在裁员、降薪、团队解散的比比皆是……但后续的趋势一定是AI应用落地！大模型方向才是实现职业升级、提升薪资待遇的绝佳机遇！

Java与大模型结合的技术优势

• 推理环节的核心地位
  大模型训练依赖Python生态的高性能计算资源，而Java在推理阶段（模型部署、性能优化、系统集成）具有独特优势。其“编写一次，处处运行”的特性，使其能无缝集成到微服务、分布式系统等企业级架构中，高效处理高并发请求。例如，某电商平台通过Java构建的大模型API网关，支撑每日千万级请求的稳定运行，响应时间缩短50%。

• 生态成熟与性能稳定
  Java拥有Spring Boot、Spring Cloud等成熟框架，可快速实现服务注册、负载均衡、熔断降级等生产级能力。JVM的垃圾回收机制和即时编译技术，使其在长连接、高并发场景下表现优于脚本语言。例如，某金融系统采用Java实现大模型推理服务，系统可用率长期保持99.99%以上。

• 兼容性与工程化能力
  Java与现有业务系统的兼容性极强，可降低大模型落地的集成成本。例如，某制造企业通过Java将大模型与ERP系统对接，实现生产流程的智能优化，故障率降低30%。同时，Java在代码规范、测试流程、版本管理等方面的积累，能大幅降低大模型项目的研发成本和维护难度。

因此捕获AI，掌握技术是关键，让AI成为我们最便利的工具.

一定要把现有的技术和大模型结合起来，而不是抛弃你们现有技术！掌握AI能力的Java工程师比纯Java岗要吃香的多。

即使现在裁员、降薪、团队解散的比比皆是……但后续的趋势一定是AI应用落地！大模型方向才是实现职业升级、提升薪资待遇的绝佳机遇！

如何学习AGI大模型？

作为一名热心肠的互联网老兵，我决定把宝贵的AI知识分享给大家。 至于能学习到多少就看你的学习毅力和能力了 。我已将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

因篇幅有限，仅展示部分资料，需要点击下方链接即可前往获取

2025最新版优快云大礼包：《AGI大模型学习资源包》免费分享**

一、2025最新大模型学习路线

一个明确的学习路线可以帮助新人了解从哪里开始，按照什么顺序学习，以及需要掌握哪些知识点。大模型领域涉及的知识点非常广泛，没有明确的学习路线可能会导致新人感到迷茫，不知道应该专注于哪些内容。

我们把学习路线分成L1到L4四个阶段，一步步带你从入门到进阶，从理论到实战。

L1级别:AI大模型时代的华丽登场

L1阶段：我们会去了解大模型的基础知识，以及大模型在各个行业的应用和分析；学习理解大模型的核心原理，关键技术，以及大模型应用场景；通过理论原理结合多个项目实战，从提示工程基础到提示工程进阶，掌握Prompt提示工程。

L2级别：AI大模型RAG应用开发工程

L2阶段是我们的AI大模型RAG应用开发工程，我们会去学习RAG检索增强生成：包括Naive RAG、Advanced-RAG以及RAG性能评估，还有GraphRAG在内的多个RAG热门项目的分析。

L3级别：大模型Agent应用架构进阶实践

L3阶段：大模型Agent应用架构进阶实现，我们会去学习LangChain、 LIamaIndex框架，也会学习到AutoGPT、 MetaGPT等多Agent系统，打造我们自己的Agent智能体；同时还可以学习到包括Coze、Dify在内的可视化工具的使用。

L4级别：大模型微调与私有化部署

L4阶段：大模型的微调和私有化部署，我们会更加深入的探讨Transformer架构，学习大模型的微调技术，利用DeepSpeed、Lamam Factory等工具快速进行模型微调；并通过Ollama、vLLM等推理部署框架，实现模型的快速部署。

整个大模型学习路线L1主要是对大模型的理论基础、生态以及提示词他的一个学习掌握；而L3 L4更多的是通过项目实战来掌握大模型的应用开发，针对以上大模型的学习路线我们也整理了对应的学习视频教程，和配套的学习资料。

二、大模型经典PDF书籍

书籍和学习文档资料是学习大模型过程中必不可少的，我们精选了一系列深入探讨大模型技术的书籍和学习文档，它们由领域内的顶尖专家撰写，内容全面、深入、详尽，为你学习大模型提供坚实的理论基础。（书籍含电子版PDF）

三、大模型视频教程

对于很多自学或者没有基础的同学来说，书籍这些纯文字类的学习教材会觉得比较晦涩难以理解，因此，我们提供了丰富的大模型视频教程，以动态、形象的方式展示技术概念，帮助你更快、更轻松地掌握核心知识。

四、大模型项目实战

学以致用 ，当你的理论知识积累到一定程度，就需要通过项目实战，在实际操作中检验和巩固你所学到的知识，同时为你找工作和职业发展打下坚实的基础。

五、大模型面试题

面试不仅是技术的较量，更需要充分的准备。

在你已经掌握了大模型技术之后，就需要开始准备面试，我们将提供精心整理的大模型面试题库，涵盖当前面试中可能遇到的各种技术问题，让你在面试中游刃有余。

因篇幅有限，仅展示部分资料，需要点击下方链接即可前往获取

2025最新版优快云大礼包：《AGI大模型学习资源包》免费分享