java基础学习——Java数组

最新推荐文章于 2023-10-10 14:18:53 发布
最新推荐文章于 2023-10-10 14:18:53 发布
阅读量400 收藏
点赞数
文章标签： java 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SJ020821/article/details/125932460
版权

数组

【1】数组的定义
数组是相同类型数据的有序集合。数据描述的是相同类型的若干数据，按照一定的先后次序排列序组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标）来访问它们。数组的四个基本特点：
1.长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
2.其元素的类型必须是相同类型，不允许出现混合类型。
3.数组类型可以是任何数据类型，包括基本类型和引用类型。
4. 数组有索引的：索引从0开始，到数组。length-1结束
5.数组变量属于引用类型，数组也是对象。
PS：数组变量属于引用类型，数组也是对象。数组中的每个元素相当于该对象的成员变量。数组本身就是对象，java中对象是在堆中的，因此数组无论保留原始类型还是其他对象类型，数组对象本身是在堆中存储的。

（1）习题的引入：

import java.util.Scanner;
public class testArray01 {
    public static void main(String[] args){
        //功能：键盘录入十个学生的成绩，求和，求平均数：
        //定义一个求和的变量：
        int sum=0;
        Scanner sc = new Scanner(System.in);
        for(int i=1;i<=10;i++){//i:控制循环次数
            System.out.print("请录入第"+i+"个学生的成绩：");
            int score = sc.nextInt();
            sum +=score;
        }

        System.out.println("十个学生的成绩之和为："+sum);
        System.out.println("十个学生的成绩之和为："+sum/10);

        //本题的缺点：
        //求第6个学生的成绩：？？？？？---》不能


    }
}

缺点：就是不能求每个学生的具体成绩是多少
解决：将成绩进行存储 ----》引入：数组
感受到数组的作用：数组用来存储数据的，在程序设计中，为了处理方便，数组用来将相同类型的若干数据组织起来。这个若干数据的集合我们称之为数组

数组的学习

1.声明
2.创建
3.赋值
4.使用

public class testArray02 {
    public static void main(String[] args){
        //数组的作用：用来存储相同类型的数据
        //以int类型数据为案例：数组用来存储int类型数据

        //1.声明（定义数组）
        int[] arr;//定义一个int类型的数组，名字叫arr
        int arr2[];
        //如果数组只声明，没有后续操作，那么这个数组相当于没定义
        int[] arr3 = null;//空 辨别：数组赋值为null和什么都没有赋值   不一样的效果

        //2.创建
        arr= new int[4];//给数组开辟了一个长度为4的空间
        //编译期声明和创建会被合成一句话：int[] arr= new int[4];

        //3.赋值
        arr[0] = 12;
        arr[3] = 47;
        arr[2] = 98;
        arr[1] = 56;
        arr[2] = 66;
        /*
          arr[4] = 93;
          出现异常：Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4
          Array  数组
          Index  索引
          OutOf  超出
          Bounds   接线
          Exception   异常
          ----》数组索引越界异常
         */
        //4.使用
        System.out.println(arr[2]);
        System.out.println(arr[0]+100);
        //通过数组以个属性来获取  length 长度
        System.out.println("数组的长度是多少："+arr.length);
    }
}

内存分析
内存分析

数组习题完善—数组的遍历方式
【1】代码：

public class testArray03 {
    public static void main(String[] args){
        //功能：键盘录入十个学生的成绩，求和，求平均数：
        //定义一个int类型的数组，长度为10：
        int[] scores = new int[10];
        //定义一个求和的变量：
        int sum=0;
        Scanner sc = new Scanner(System.in);
        for(int i=1;i<=10;i++){//i:控制循环次数
            System.out.print("请录入第"+i+"个学生的成绩：");
            int score = sc.nextInt();
            scores[i-1]=score;
            sum +=score;
        }

        System.out.println("十个学生的成绩之和为："+sum);
        System.out.println("十个学生的成绩之和为："+sum/10);

        //求第6个学生的成绩：
        //System.out.println(scores[5]);
        /*
        System.out.println(scores[0]);
        System.out.println(scores[1]);
        System.out.println(scores[2]);
        System.out.println(scores[3]);
        //...
        System.out.println(scores[9]);
         */
        //将数组中的每个元素进行查看--》数组的遍历：
        //方式一：普通for循环
        for(int i=0;i<=9;i++){
            System.out.println("第"+(i+1)+"个学生的成绩为："+scores[i]);
        }
        //方法二：增强for循环：
        //对scores数组进行遍历，遍历出来每个元素都用int类型的num接收：
        for(int num:scores){
            //每次都将num在控制台输出
            System.out.println(num);

            /*
            增强for循环：
            优点：  代码简单
            缺点： 单纯的增强for循环不能涉及跟索引相关的操作
             */

            //方式三：利用普通for循环： 逆向遍历：
            for(int i=9;i>=0;i--){
                System.out.println("第"+(i+1)+"个学生的成绩为："+scores[i]);
            }
        }
    }
}

【2】用IDEA验证数组的确将数据进行存储了：
在这里插入图片描述

数组的三种初始化方式
数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。

- 静态初始化

除了用new关键字来生产数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。
eg:
int[] arr = {12,23,45};
int[] arr = new int[]{12,23,45};
注意：
1.new int[3]{12,23,45};—>错误
2.int[] arr;
arr = {12,23.45};—>错误

- 动态初始化

数组定义与为数组元素分配空间并赋值的操作分开进行。
eg:
int[] arr ;
arr = new int[3]
arr[0] = 12;
arr[1] = 23;
arr[2] = 45;

- 默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照案例变量同样的方式被隐式初始化。
在这里插入图片描述

数组应用题

1. 最值问题

【1】实现一个功能：给定一个数组int[] arr = {12,3,7,4,8,125,9,45};,求出数组中最大的数。
在这里插入图片描述
代码：

public class testArray04 {
    public static void main(String[] args){
        //实现一个功能：给定一个数组int[] arr = {12,3,7,4,8,125,9,45};,求出数组中最大的数
        //1.给定一个数组
        int[] arr = {12,3,7,4,8,125,9,45,666,36};
        //2.求出数组中的最大值：
        //先找一个数上擂台，假定认为这个数最大：
        int maxNum = arr[0];
        for(int i=0;i<arr.length;i++){
           if(arr[i]>maxNum){
               maxNum = arr[i];
           }

        }
        System.out.println("当前数组中最大的数为："+maxNum);
    }
}

【2】将求最大值的方法提取出来：

public class testArray05 {
    public static void main(String[] args){
        //实现一个功能：给定一个数组int[] arr = {12,3,7,4,8,125,9,45};,求出数组中最大的数
        //1.给定一个数组
        int[] arr = {12,3,7,4,8,125,9,45,666,36};
        //2.求出数组中的最大值：
        //调用方法：
        int num = getMaxNum(arr);
        System.out.println("当前数组中最大的数为："+num);
    }


    /*
    想提取一个方法：求数组中的最大值
    求哪个数组中的最大值 ---》不确定因素：哪个数组 (形参)---》返回值：最大值
    */
    public static int getMaxNum(int[] arr){
        //先找一个数上擂台，假定认为这个数最大：
        int maxNum = arr[0];
        for(int i=0;i<arr.length;i++){
            if(arr[i]>maxNum){
                maxNum = arr[i];
            }
        }
        return maxNum;

    }
}

【3】画内存：
方法的实参传递给形参的时候一定要注意：一切都是值传递：
如果是基本数据类型，那么传递的就是字面值
如果是引用数据类型，那么传递的就是地址值
在这里插入图片描述查询问题
【1】查询指定位置的元素

public class testArray06 {
    public static void main(String[] args){
        //查询指定位置元素
        //给定一个数组：
        int[] arr = {12,34,56,7,3,10};
        //查找索引为2的位置上对应的元素是什么？
        System.out.println(arr[2]);
    }
}

上面代码体现了一个优点：
在按照位置查询的时候，直接一步到位，效率非常高

【2】查询指定元素的位置–》找出元素对应的索引

public class testArray07 {
    public static void main(String[] args){
        //查询指定元素的位置--》找出元素对应的索引
        //给定一个数组：
        int[] arr = {12,34,56,7,3,10};
        //            0  1  2 3 4 5

        //功能：查询元素56对应的索引：
        int index = -1;//这个初始值只要不是数组的索引即可
        for(int i=0;i<arr.length;i++){
            if(arr[i]==56){
                index = i;//只要找到元素，那么index就变成i
                break;//只要找到这个元素，循环就会停止
            }
        }
        if(index!=-1){
            System.out.println("元素对应的索引："+index);
        }else{//index==-1
            System.out.println("查无次数！");
        }
    }
}

【3】将查指定元素对应的索引的功能提取为方法：

public class testArray07 {
    public static void main(String[] args) {
        //查询指定元素的位置--》找出元素对应的索引
        //给定一个数组：
        int[] arr = {12, 34, 56, 7, 3, 10};
        //            0  1  2 3 4 5

        //功能：查询元素56对应的索引：
        //调用方法：
        int index = getIndex(arr,999);
        //int index = -1;//这个初始值只要不是数组的索引即可
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == 56) {
                index = i;//只要找到元素，那么index就变成i
                break;//只要找到这个元素，循环就会停止
            }
        }
        if (index != -1) {
            System.out.println("元素对应的索引：" + index);
        } else {//index==-1
            System.out.println("查无次数！");
        }
    }

    /*
    定义一个方法：查询数组中指定的元素对应的索引：
    不确定因素：那个数组，那个指定元素   （形参）
    返回值： 索引
    */
    public static int getIndex(int[] arr, int ele) {
        int index = -1;//这个初始值只要不是数组的索引即可
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == ele) {
                index = i;//只要找到元素，那么index就变成i
                break;//只要找到这个元素，循环就会停止
            }
        }
        return index;
    }

}

添加元素
【1】实现一个功能：
添加逻辑：
添加逻辑图

public class testArray08 {
    public static void main(String[] args){
        //功能：给定一个数组,在数组下标为2的位置上添加一个元素91

        //1.给定一个数组：
        int[] arr = {12,34,56,7,3,10,55,66,77,88,999,89};
        //           0  1   2 3 4 5
        //2.输出增加元素前的数组：
        System.out.print("增加元素前的数组：");
        for(int i=0;i<arr.length;i++){
            if (i!=arr.length-1){
                System.out.print(arr[i]+",");
            }else{//i==arr.length-1 最后一个元素后不用加逗号
                System.out.println(arr[i]);
            }
        }
        //3.增加元素
        /*
        arr[5]=arr[4];
        arr[4]=arr[3];
        arr[3]=arr[2];
         */
        int index = 1;
        for (int i=arr.length-1;i>=(index+1);i--){
            arr[i] = arr[i-1];
        }
        arr[index]=666;

        //4.输出增加元素后的数组：
        System.out.print("增加元素后的数组：");
        for(int i=0;i<arr.length;i++){
            if (i!=arr.length-1){
                System.out.print(arr[i]+",");
            }else{//i==arr.length-1 最后一个元素后不用加逗号
                System.out.println(arr[i]);
            }
        }
    }
}

【2】将添加功能提取一个方法：

import java.util.Scanner;
public class testArray08 {
    public static void main(String[] args){
        //功能：给定一个数组,在数组下标为2的位置上添加一个元素91

        //1.给定一个数组：
        int[] arr = {12,34,56,7,3,10,55,66,77,88,999,89};
        //           0  1   2 3 4 5
        //2.输出增加元素前的数组：
        System.out.print("增加元素前的数组：");
        for(int i=0;i<arr.length;i++){
            if (i!=arr.length-1){
                System.out.print(arr[i]+",");
            }else{//i==arr.length-1 最后一个元素后不用加逗号
                System.out.println(arr[i]);
            }
        }

        //从键盘接收数据
        Scanner sc= new Scanner(System.in);
        System.out.print("请录入你要添加元素的指定下标：");
        int index = sc.nextInt();
        System.out.print("请录入你要添加的元素：");
        int ele = sc.nextInt();

        //3.增加元素
        //调用方法
        insertEle(arr,index,ele);
        /*
        arr[5]=arr[4];
        arr[4]=arr[3];
        arr[3]=arr[2];
         */
        /*
        int index = 1;
        for (int i=arr.length-1;i>=(index+1);i--){
            arr[i] = arr[i-1];
        }
        arr[index]=666;

         */

        //4.输出增加元素后的数组：
        System.out.print("增加元素后的数组：");
        for(int i=0;i<arr.length;i++){
            if (i!=arr.length-1){
                System.out.print(arr[i]+",");
            }else{//i==arr.length-1 最后一个元素后不用加逗号
                System.out.println(arr[i]);
            }
        }
    }
    /*
    提取一个添加元素的方法：
    在数组的指定位置上添加一个指定的元素。
    在那个数组的那个位置添加那个元素！
    不确定因素：形参：那个数组，那个位置，那个元素
    返回值： 无
     */
    public static void insertEle(int[] arr,int index,int ele){
        for (int i=arr.length-1;i>=(index+1);i--){
            arr[i] = arr[i-1];
        }
        arr[index]=ele;
    }
}

删除元素
【1】实现一个功能：
逻辑：
删除元素

public class testArray09 {
    public static void main(String[] args){
        //功能：给定一个数组,删除下标为2元素

        //1.给定一个数组：
        int[] arr = {12,34,56,7,3,10};
        //           0  1   2 3 4 5

        //2.输出删除前的数组
        System.out.println("删除元素前的数组："+Arrays.toString(arr));

        //3.删除
        /*
        arr[2] = arr[3];
        arr[3] = arr[4];
        arr[4] = arr[5];
         */
        int index =1;
        for(int i=index;i<=arr.length-2;i++){
            arr[i] = arr[i+1];
        }
        arr[arr.length-1] = 0;

        //4.输出删除后的数组
        System.out.println("删除元素后的数组："+Arrays.toString(arr));
    }
}

【2】实现一个功能：删除指定元素

    public static void main(String[] args){
        //功能：给定一个数组,删除下标为2元素

        //1.给定一个数组：
        int[] arr = {12,34,56,7,3,10,34,45,56,7,666};
        //           0  1   2 3 4 5

        //2.输出删除前的数组
        System.out.println("删除元素前的数组："+Arrays.toString(arr));

        //找到要删除的索引即可：
        int index = 0;
        for(int i=0;i<arr.length;i++){
            if(arr[i]==3){
                index = i;
                break;
            }
        }

        //3.删除
        /*
        arr[2] = arr[3];
        arr[3] = arr[4];
        arr[4] = arr[5];
         */
        if (index!=-1) {
            for (int i = index; i <= arr.length - 2; i++) {
                arr[i] = arr[i + 1];
            }
            arr[arr.length - 1] = 0;
        }else{//index==-1
            System.out.println("根本没有你要删除的元素！");
        }

        //4.输出删除后的数组
        System.out.println("删除元素后的数组："+Arrays.toString(arr));

    }
}

讲述main方法

【1】main方法：程序的入口，在同一个类中，如果有多个方法，那么虚拟机就会识别main方法，从这个方法作为程序的入口
【2】main方法格式严格要求：
public static void main(String[] args){}

public static—》修饰符，暂时用这个—》面向对象一章
void—》代表方法没有返回值 对应的类型void
main—》见名知意名字
String[] args —》形参—》不确定因素

【3】问题：程序中是否可以有其他的方法也叫main方法？
可以，构成了方法的重载。

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

        }
}

【4】形参为String[] 那么实参到低是什么？

public class testArray10 {
    public static void main(String[] args) {
        //从侧面验证：
        //int[] arr1; //如果对数组只声明，没有后续操作，那么相当于 白定义了。
        //int[] arr2 = null;
        //System.out.println(arr2.length);//Exception in thread "main" java.lang.NullPointerException
        //int[] arr3 = new int[0];
        //System.out.println(arr3.length);
        //int[] arr4 = new int[4];
        //System.out.println(arr4.length);
        //System.out.println(args.length);//0
        //从这个结果证据，参数是String[]，实参是  new String[0]
        //默认情况下，虚拟机在调用main方法的时候就是传入了一个长度为0的数组

        System.out.println(args.length);
        for(String str:args){
            System.out.println(str);
        }

    }
}

手动传入实参：
有特殊符号的时候可以加上 " "
在这里插入图片描述
没有特殊符号用空格隔开即可：
在这里插入图片描述

可变参数

public class testArray11{
        /*
        1.可变参数：作用提供了一个方法，参数的个数是可变的 ,解决了部分方法的重载问题
        int...num
        double...num
        boolean...num
        
        3.方法的内部对可变参数的处理跟数组是一样
        4.可变参数和其他数据一起作为形参的时候，可变参数一定要放在最后
        5.我们自己在写代码的时候，建议不要使用可变参数。
        */
    public static void main(String[] args){
                //method01(10);
                //method01();
                //method01(20,30,40);
                method01(30,40,50,60,70);
                //method01(new int[]{11,22,33,44});
        }
        public static void method01(int num2,int...num){
                System.out.println("-----1");
                for(int i:num){
                        System.out.print(i+"\t");
                }
                System.out.println();
                
                System.out.println(num2);
        }
}
        
        2.可变参数在JDK1.5之后加入的新特性

Arrays工具类

为了方便我们对数组进行操作，系统提供一个类Arrays，我们将它当做工具类来使用

import java.util.Arrays;
public class testArray12{
        public static void main(String[] args){
                //给定一个数组：
                int[] arr = {1,3,7,2,4,8};
                //toString:对数组进行遍历查看的，返回的是一个字符串，这个字符串比较好看
                System.out.println(Arrays.toString(arr));
                
                //binarySearch:二分法查找：找出指定数组中的指定元素对应的索引：
                //这个方法的使用前提：一定要查看的是一个有序的数组：
                //sort：排序 -->升序
                Arrays.sort(arr);
                System.out.println(Arrays.toString(arr));
                System.out.println(Arrays.binarySearch(arr,4));
                
                int[] arr2 = {1,3,7,2,4,8};
                //copyOf:完成数组的复制：
                int[] newArr = Arrays.copyOf(arr2,4);
                System.out.println(Arrays.toString(newArr));
                
                //copyOfRange:区间复制：
                int[] newArr2 = Arrays.copyOfRange(arr2,1,4);//[1,4)-->1,2,3位置
                System.out.println(Arrays.toString(newArr2));
                
                //equals:比较两个数组的值是否一样：
                int[] arr3 = {1,3,7,2,4,8};
                int[] arr4 = {1,3,7,2,4,8};
                System.out.println(Arrays.equals(arr3,arr4));//true
                System.out.println(arr3==arr4);//false ==比较左右两侧的值是否相等，比较的是左右的地址值，返回结果一定是false
                
                //fill：数组的填充：
                int[] arr5 = {1,3,7,2,4,8};
                Arrays.fill(arr5,10);
                System.out.println(Arrays.toString(arr5));
        }
}

数组的复制操

在这里插入图片描述
在这里插入图片描述在这里插入图片描述

public class testArray13 {
    public static void main(String[] args){
        //给一个源数组：
        int[] srcArr = {11,22,33,44,55,66,77,88};
        //给一个目标数组：
        int[] destArr = new int[10];

        //复制：
        System.arraycopy(srcArr,1,destArr,3,3);
        //遍历查看目标数组：
        System.out.println(Arrays.toString(destArr));

    }
}

结果：

[0, 0, 0, 22, 33, 44, 0, 0, 0, 0]

二维数组

【1】引入：本质上全部都是一堆数组：
在这里插入图片描述
【2】基本代码：

public class testArray14 {
    public static void main(String[] args){
        //定义一个二维数组：
        int[][] arr = new int[3][];//本质上定义了一个一维数组，长度为3

        int[] a1 = {1,2,3};
        arr[0] = a1;

        arr[1] = new int[]{4,5,6,7};

        arr[2] = new int[]{9,10};

    }
}

对应内存：
在这里插入图片描述【3】四种遍历方式：

public class testArray15 {
    public static void main(String[] args){
        //定义一个二维数组：
        int[][] arr = new int[3][];//本质上定义了一个一维数组，长度为3

        int[] a1 = {1,2,3};
        arr[0] = a1;

        arr[1] = new int[]{4,5,6,7};

        arr[2] = new int[]{9,10};

        //读取6这个元素：
        //System.out.println(arr[1][2]);

        //对二维数组遍历：
        //方式1：外层普通for循环+内层普通for循环：
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr[i].length;j++){
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }

        //方式2：外层普通for循环+内层增强for循环：
        for(int i=0;i<arr.length;i++){
            for(int num:arr[i]){
                System.out.print(num+"\t");
            }
            System.out.println();
        }

        //方式3：外层增强for循环+内层增强for循环：
        for(int[] a:arr){
            for(int num:a){
                System.out.print(num+"\t");
            }
            System.out.println();
        }

        //方式4：外层增强for循环+内层普通for循环：
        for(int[] a:arr){
            for(int i=0;i<a.length;i++){
                System.out.print(a[i]+"\t");
            }
            System.out.println();
        }

    }
}

二维数组的初始化工具

数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化

  • 静态初始化

除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。
eg:
int[][] arr = {{1,2},{4,5,6},{4,5,6,7,8,9,9}};
int[][] arr = new int[][]{{1,2},{4,5,6},{4,5,6,7,8,9,9}};

  • 动态初始化

数组定义为与为数组元素分配空间并赋值的操作分开进行
eg：
int[][] arr = new int[3][];//本质上定义了一堆数组长度为3，每个“格子”中放入一个数组
arr[0] = new int[]{1,2};
arr[1] = new int[]{3,4,5,6};
arr[2] = new int[]{34,45,56};

eg:
int[][] arr = new int[3][2];
| |
|-public class testArray16 {
public static void main(String args){
int[][] arr = new int[3][2];
//本质上：定义一堆数组，长度为3，每个数组“格子”中，有一个默认的长度为2的数组：

    arr[1] = new int[]{1,2,3,4};

    //数组遍历：
    for(int[] a:arr) {
        for (int num:a) {
            System.out.print(num + "\t");
        }
        System.out.println();
    }
}
}
  • 默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐试初始化。

SJ020821
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
JAVA基础知识学习——方法与数组
03-30
自我学习的总结
求数组最小值
lzj_love_wx的博客
03-04 2496
定义一个含有五个元素的数组,并为每个元素赋值,求数组中所有元素的最小值 package day04.work; import java.util.Scanner; public class Test01 { public static void main(String[] args) { //定义含5个元素的数组，并赋值，求最小值 Scanner sc = new Scanner(System.in); int arr[] = new int[
java数组学习
qq_75141367的博客
05-11 118
Java初学者对数组的知识分析总结
Java数组是什么类型？
weixin_45943597的博客
07-13 1552
我们使用Java编程时时，经常会使用到数组，最常见的莫过于整形数组，对象数组，那数组到底是什么，今天我也是花了功夫查阅资料研究了一下。 1.数组是什么？ 现有下面一段代码: int[] arr = {1,2,3,4,5}; System.out.println(arr.getClass()); System.out.println(arr.getClass().getSuperclass()); System.out.println(arr instanc
Java数组，超详细整理，适合新手入门
久绊A的博客
02-21 2546
Java数组，超详细整理，适合新手入门、什么是Java中的数组？、数组有哪些常见的操作？、数组的五种赋值方法和使用方法声明数组、声明数组并且分配空间、声明数组同时赋值(1)声明数组同时赋值(2)从控制台输入向数组赋值、求总和平均、求数组中最大值最小值、对数组进行升序排序、不调用方法进行数组排序、Arrays 类常用方法
java快速寻找一个数组的最大值或最小值， min， max，三种方法
weixin_30394669的博客
09-19 7869
java 中 寻找一个数组中的最大值或最小，除了自己专门编写一个 min 或 max 函数外，还有几种方式方便使用。 1. 使用 stream 将一个数组放进 stream 里面，然后直接调用 stream 里的 min 或 max 函数得到最大值或最小值。 2. 使用 collection 将数组转化为对象数组，即 int 转化为 Integer （需要使用 toO...
java——数组.xmind
07-10
一维数组概念：一组连续的存储空间，存储多个相同数据类型的值。数组的创建。数组的组成。数组的遍历。数组的默认值。
学习Java，你需要知道这些——Java数组
01-21
目录数组的概念数组的创建数组的引用数组的创建数组元素的初始化数组的使用使用数组数组的复制多维数组 数组的概念 数组由同一类型的对象或者基本数据组成,并封装在同一一个标识符(数组名称)下。 数组是对象 动态...
Java基础Note——流程语句及方法和数组
12-22
java5和7后支持枚举和String类。注意：只要进入一个case后其它的case都会忽略，所以如果没有break则会一直向下执行（穿透）。case后面不能有{} 循环 for循环中，循环迭代变量一般起名为：i,j,k,m,n for循环的优化...
动力节点老杜Java基础入门学习教程分享——数组
09-16
动力节点老杜Java基础入门学习教程分享——数组
Java基础——数组学习
it14193的博客
02-26 132
数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。即：数组就是一组数据。
Java入门篇--数组（一）
luoyuhhh的博客
11-11 462
Java数组基础知识
Java基础——数组
D_ar_ker的博客
02-18 1162
Java基础中数组的学习，包含数组的定义及使用还有数组的存储结构
Java中数组的学习
yan130726的博客
07-07 46
定义：一个数组是由多个相同的数据类型元素组成的集合，这些元素在内存中顺序排列，是一段连续的空间，空间被所有元素平均分成多个小空间一一占用，每个小空间都有自己的标号（下标），由第一个小空间下标为0开始往后加1。格式：格式1：数据类型[] 变量名；示例：int [] array;格式2：数据类型 变量名 [];示例：int array [];示例：数组的特点数组是有序排列的数组属于变量数组的元素，既可以是基本数据类型，也可以是引用数据类型。
java学习之数组（超详细——看完不会你来打我）
最新发布
qq_73752061的博客
10-10 141
深入浅出之java数组学习 深入理解引用变量
Java--数组学习
aeiou123123123的博客
07-15 202
数组类型[][]数组名=new数组类型[一维数组的个数][每一个一维数组中元素的个数];遍历toString()将数组的元素以字符串的形式返回排序sort()将数组按照升序排列查找binarySearch()在指定数组中查找指定元素，返回元素的索引，如果没有找到返回-1注意使用查找的功能的时候，数组一定要先排序。...
JAVA数组学习总结
Syllll_的博客
12-03 700
JAVA数组学习总结
java数组的学习
weixin_65905274的博客
07-29 245
插入排序原理①获得新元素应该要插入的位置，方法是将新元素所在位置的值与原数组的所有元素从头开始一一比较，一旦发现新元素的/小于某个元素值，则这个元素所在位置就是新元素要插入的位置。静态初始值和动态初始值的区别静态初始化数组元素初始值由程序员指定，长度由系统的数算给定动态初始化数组的元素初始值由系统决定，长度由程序员决定。静态初始化指在声明数组的同时指定每个元素的初始值，由系统决定数组的长度，在编译的时候就初始化好了。数据类型[][]数组名=new数据类型[长度][长度]；例如int[]a;...
java中数组是什么类型_Java中的数组类型是什么？
weixin_32287563的博客
02-16 2770
Java中有两种类型的数组，它们是-一维数组-Java的一维数组是普通数组，其中该数组包含(相同类型的)连续元素-int[]myArray={10,20,30,40}示例publicclassTestArray{publicstaticvoidmain(String[]args){double[]myList={1.9,2.9,3.4,3.5};//打印所有...
Java基础教程——List（列表）
06-02
好的，下面是Java基础教程中有关List（列表）的内容： List是Java中最常用的数据结构之一，它是一个有序的集合，可以存储重复的元素。 常见的List实现类有ArrayList和LinkedList，其中ArrayList是基于数组实现的，而LinkedList是基于链表实现的。 下面是一些常用的List操作： 1. 创建List对象： ``` List<String> list = new ArrayList<>(); // 创建一个ArrayList对象 ``` 2. 添加元素： ``` list.add("apple"); // 在列表末尾添加元素 list.add(1, "banana"); // 在指定位置添加元素 ``` 3. 获取元素： ``` String fruit = list.get(0); // 获取列表中的第一个元素 ``` 4. 删除元素： ``` list.remove("apple"); // 删除指定元素 list.remove(0); // 删除指定位置的元素 ``` 5. 修改元素： ``` list.set(1, "orange"); // 修改指定位置的元素 ``` 6. 判断元素是否存在： ``` boolean contains = list.contains("apple"); // 判断列表中是否包含指定元素 ``` 7. 获取列表长度： ``` int size = list.size(); // 获取列表长度 ``` 以上就是Java基础教程中关于List的简单介绍，希望对你有所帮助！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值