Java数组

于 2022-09-01 19:07:29 发布
阅读量220 收藏
点赞数
分类专栏： 狂神说java学习笔记 文章标签： java 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43521718/article/details/126649585
版权

Java数组

数组概述

数组是相同类型数据的有序集合。

数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。

其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。

数组声明创建

声明数组变量：

dataType[] arrayRefVar;//首选方法
dataType arrayRefVar[];//C和C++风格

使用new方法创建数组：

dataType[] arrayRefVar = new dataType[arraySize];

数组的元素是通过索引访问的，数组索引从0开始。
获取数组长度：

arrays.length

package com.star_line.array;

public class ArrayDemo01 {
    //变量的类型 变量名 = 变量的值
    //数组类型
    public static void main(String[] args) {
        int[] nums; // 1.声明一个数组
        nums = new int[10]; //2.创建一个数组，存放10个int类型的数字
        /*
        	int num2 = new int[10];
        */
        // 3。给数组元素中赋值。
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;
        nums[7] = 8;
        nums[8] = 9;
        nums[9] = 10;

        //计算所有元素的和
        //获取数组长度：arrays.length
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum = sum + nums[i];
        }

        System.out.println("总和为：" + sum);
    }
}

总和为：55

进程已结束,退出代码0

内存分析：

堆：存放new的对象和数组。可以被所有的线程共享，不会存放别的对象引用。

栈：存放基本变量类型（会包含这个基本类型的具体数值）。引用对象的变量（会存放这个引用在堆里的具体地址）

方法区：可以被所有的线程共享，包含了所有的class和static变量。

三种初始化

静态初始化：

int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)};

动态初始化：

int[] a = new int[2];
a[0] = 1;
a[1] = 2;

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

package com.star_line.array;

public class ArrayDemo02 {
    public static void main(String[] args) {
        //静态初始化：创建+赋值
        int[] a = {1,2,3,4,5,6,7,8,9};
        System.out.println(a[0]);
        Man[] mans = {new Man(),new Man()};//引用类型的数组

        //动态初始化：包含默认初始化
        int[] b = new int[10];
        b[0] = 10;
        System.out.println(b[0]);
        System.out.println(b[1]);
    }
}

Man.java

package com.star_line.array;

public class Man {
}

1
10
0

进程已结束,退出代码0

数组的四个基本特点

  • 其长度是确定的。数组一旦被创建，它的大小就是不可改变的。
  • 元素必须是相同类型，不允许出现混合类型。
  • 数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
  • 数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。 数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型， 数组对象本身是在堆中的。

下标的合法区间：[0,length-1]，如果越界就会报错：

package com.star_line.array;

public class ArrayDemo01 {
    //变量的类型 变量名 = 变量的值
    //数组类型
    public static void main(String[] args) {
        int[] nums; // 1.声明一个数组
        nums = new int[10]; //2.创建一个数组，存放10个int类型的数字
        /*
        	int num2 = new int[10];
        */
        // 3。给数组元素中赋值。
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;
        nums[7] = 8;
        nums[8] = 9;
        nums[9] = 10;
        
        System.out.println(nums[10]);
    }
}

Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException: 10
at com.star_line.array.ArrayDemo01.main(ArrayDemo01.java:27)

进程已结束,退出代码1

数组下标越界异常：ArrayIndexOutOfBoundsException

小结：数组是相同数据类型（数据类型可以是任意类型）的有序集合。

数组也是对象。数组元素相当于对象的成员变量。

数组长度确定而不可变。如果越界，报错：ArrayIndexOutOfBoundsException

数组使用*

package com.star_line.array;

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

        //打印所有元素
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println("。。。。。。。。。。。。。。。");
        //计算所有元素的和
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum = sum + array[i];
        }
        System.out.println("所有元素的和为：" + sum);
        System.out.println("。。。。。。。。。。。。。。。");
        //查找最大元素
        int max = array[0];

        for (int i = 1; i < array.length; i++) {
            if (max < array[i]){
                max = array[i];
            }
        }
        System.out.println("max = " + max);
    }

}

1 2 3 4 5 。。。。。。。。。。。。。。。
所有元素的和为：15
。。。。。。。。。。。。。。。
max = 5

普通的for循环

For-Each循环：加强for循环，用于遍历数组。快捷操作是array.for
操作简便，但是取不到下标。
数组作方法入参
数组作返回值

package com.star_line.array;

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

        //JDK1.5,没有下标，For-Each循环
        for (int array : arrays) {//前面是遍历的每一个值，后面的是数组，取不到下标。
            System.out.println(array);
        }

        printArray(arrays);
    }

    //打印一个数组，此处数组入参
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
    }
}

1
2
3
4
5
1 2 3 4 5
进程已结束,退出代码0

package com.star_line.array;

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

        /*//JDK1.5,没有下标
        for (int array : arrays) {//前面是遍历的每一个值，后面的是数组，取不到下标。
            System.out.println(array);
        }

        printArray(arrays);*/

        int[] result = reverse(arrays);
        printArray(result);
    }

    //打印一个数组
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
    }

    //反转数组，数组是一个返回值，返回数组result。
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];

        for (int i = 0,j = result.length - 1; i < arrays.length; i++,j--) {
            result[j] = arrays[i];
        }
        return result;
    }
}

5 4 3 2 1
进程已结束,退出代码0

多维数组

多维数组可以看做数组的数组。二维数组是一个特殊的一位数组，其中每一个元素都是一个一维数组。

二维数组

int a[][] = new int[2][5];

解析：以上二维数组可以看做一个二行五列的数组。

思考：多维数组的使用？

num[1][0];

。

package com.star_line.array;

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

[I@1b6d3586

进程已结束,退出代码0

一个对象，数组。

package com.star_line.array;

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

        printArray(array[0]);
    }

    //打印一个数组
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
    }
}

[I@1b6d3586
1 2
进程已结束,退出代码0

package com.star_line.array;

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

        printArray(array[0]);*/
        System.out.println(array.length);
        System.out.println(array[0].length);
    }

4
2

进程已结束,退出代码0

package com.star_line.array;

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

        printArray(array[0]);
        System.out.println(array.length);
        System.out.println(array[0].length);*/
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);
            }

        }
    }

    //打印一个数组
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
    }
}

1
2
3
4
5
6
7
8

进程已结束,退出代码0

Arrays类

数组的工具类：java.util.Arrays

查看JDK帮助文档

[I@1b6d3586
1，2，3，4，9009，298，312343，21，3，23，
进程已结束,退出代码0

package com.star_line.array;

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,9009,298,312343,21,3,23};
        System.out.println(a);//[I@1b6d3586 HashCode
        //打印数组元素，Arrays.toString  System.out.println(Arrays.toString(a));

        printArray(a);
    }

    //不要重复造轮子
    public static void printArray(int[] a){
        for (int i = 0;i < a.length;i++){
            System.out.print(a[i] + "，");
        }
    }
}

[I@1b6d3586
[1, 2, 3, 4, 9009, 298, 312343, 21, 3, 23]
[1,2,3,4,9009,298,312343,21,3,23]
进程已结束,退出代码0

package com.star_line.array;

import java.util.Arrays;

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,9009,298,312343,21,3,23};
        System.out.println(a);//[I@1b6d3586 HashCode
        //打印数组元素，Arrays.toString
        System.out.println(Arrays.toString(a));

        printArray(a);
    }

    //不要重复造轮子
    public static void printArray(int[] a){
        for (int i = 0;i < a.length;i++){
            if (i == 0){
                System.out.print("[");
            }
            if (i == a.length-1){
                System.out.print(a[i] + "]");
            }else {
                System.out.print(a[i] + ",");
            }

        }
    }
}

[1, 2, 3, 3, 4, 21, 23, 298, 9009, 312343]

进程已结束,退出代码0

package com.star_line.array;

import java.util.Arrays;

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,9009,298,312343,21,3,23};

        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        //[I@1b6d3586 HashCode    System.out.println(a);
        //打印数组元素，Arrays.toString
        //System.out.println(Arrays.toString(a));

        //printArray(a);
    }

    //不要重复造轮子
    public static void printArray(int[] a){
        for (int i = 0;i < a.length;i++){
            if (i == 0){
                System.out.print("[");
            }
            if (i == a.length-1){
                System.out.print(a[i] + "]");
            }else {
                System.out.print(a[i] + ",");
            }

        }
    }
}

Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象进行调用。（是不用不是不能）

常用功能：

给数组赋值：fill

对数组排序：sort，升序排序

比较数组：equals，比较数组中元素值是否相等

查找数组元素：binarySearch能对排好序的数组进行二分查找法操作。

package com.star_line.array;

import java.util.Arrays;

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,9009,298,312343,21,3,23};

        Arrays.fill(a,0);//数组填充
        System.out.println(Arrays.toString(a));
        }
}

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

进程已结束,退出代码0

package com.star_line.array;

import java.util.Arrays;

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,9009,298,312343,21,3,23};

        Arrays.fill(a,2,4,0);//数组填充，从2~4填充0
        System.out.println(Arrays.toString(a));
    }
}

[1, 2, 0, 0, 9009, 298, 312343, 21, 3, 23]

进程已结束,退出代码0

package com.star_line.array;

import java.util.Arrays;

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,9009,298,312343,21,3,23};
        int[] b = {1,2,3,4,9009,298,312343,21,3,23};
        int[] c = {1,2,3,5,9009,298,312343,21,3,23};
        boolean flag1 = Arrays.equals(a,b);
        boolean flag2 = Arrays.equals(a,c);
        String str1 = new Boolean(flag1).toString();//将Boolean转化为String
        String str2 = new Boolean(flag2).toString();
        System.out.println(str1 + " " + str2);
            }
}

true false

进程已结束,退出代码0

equals最终输出结果是布尔值，两数组完全一致输出true，两数组数值不一致输出false。

二分查找

在进行此调用之前，使用必须排序的数组（如通过sort（int[]）方法）在指定的整数数组中搜索指定值。如果未排序，则结果未定义。如果数组包含多个具有指定值的元素，则无法保证找到哪个元素。
形参:
a–要搜索的数组
key–要搜索的值
返回值:
搜索关键字的索引，如果它包含在数组中；否则，（（插入点）-1）。插入点定义为将键插入到数组中的点：第一个元素的索引大于键，如果数组中的所有元素都小于指定键，则为a.length。请注意，这保证了当且仅当找到键时，返回值将>=0。

这个二分查找为（数组，要搜索的值），如果搜索的值存在，输出该值的索引；否则返回一个<0的数。

package com.star_line.array;

import java.util.Arrays;
import java.util.Scanner;

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,9009,298,312343,21,3,23};

        //二分查找 binarySearch
        Arrays.sort(a);
        System.out.println("请输入查找元素：");
        Scanner scanner = new Scanner(System.in);
        int input = scanner.nextInt();
        int index = Arrays.binarySearch(a,input);
        System.out.println(index < 0  ? "该元素不存在" : ("该元素的索引为：" + index));
        scanner.close();
    }
    
}

请输入查找元素：
6
该元素不存在

进程已结束,退出代码0
请输入查找元素：
15
该元素不存在

进程已结束,退出代码0
请输入查找元素：
0
该元素不存在

进程已结束,退出代码0
请输入查找元素：
3
该元素的索引为：2

进程已结束,退出代码0

冒泡排序

最出名的排序算法之一，总共有八大排序。

package com.star_line.array;

import java.util.Arrays;

public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] a = {2,5,7,2,6,245457,47893,9};
        //调用自己写的排序方法后，返回一个排序后的数组。
        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));
    }

    /*冒泡排序
     *1、比较数组中两个相邻的元素。如果第一个数比第二个数大，交换位置。
     *2、每一次比较都会产生一个最大或最小的数字。
     *3、下一轮可以少一次排序
     *4、依次循环，直到结束。
     */
    public static int[] sort(int[] array){
        //外层循环，判断要走多少次
        for (int j = 0; j < array.length - 1; j++) {
            //内层循环，第一个数比第二个数大，交换位置。
            for (int i = 0; i < array.length-1-j; i++) {//遍历之后-1-j
                 int change = 0;
                 if (array[i] > array[i+1]){
                     change = array[i+1];
                     array[i+1] = array[i];
                     array[i] = change;
                 }
            }
        }
        return array;
    }


}

[2, 2, 5, 6, 7, 9, 47893, 245457]

进程已结束,退出代码0

代码较为简单，两层循环，外层冒泡轮数，内层依次比较。

嵌套循环，时间复杂度O(N^2)

思考：如何优化？

 /*冒泡排序
     *1、比较数组中两个相邻的元素。如果第一个数比第二个数大，交换位置。
     *2、每一次比较都会产生一个最大或最小的数字。
     *3、下一轮可以少一次排序
     *4、依次循环，直到结束。
     */
    public static int[] sort(int[] array){
        int change = 0;
        //外层循环，判断要走多少次
        for (int i = 0; i < array.length - 1; i++) {
            boolean flag = false;//通过flag标识位减少没有意义的比较
            //内层循环，第一个数比第二个数大，交换位置。
            for (int j = 0; j < array.length-1-i; j++) {//遍历之后-1-j
                 if (array[j+1] <array[j]){
                     change = array[j];
                     array[j] = array[j+1];
                     array[j+1] = change;
                     flag = true;
                 }

                 if (flag == false){
                     continue;
                 }
            }
        }
        return array;
    }


}

[2, 2, 5, 6, 7, 9, 47893, 245457]

进程已结束,退出代码0

稀疏数组

需求：编写五子棋游戏中，有存盘退出和续上盘的功能。

使用二维数组记录棋盘

分析问题：因为该二维数组的很多默认值都是0，因此记录了很多没有用的数据。

解决：稀疏数组（一种数据结构）

当一个数组中大部分元素为0或相同时，可以使用稀疏数组保存该数组。

稀疏数组处理方式：记录数组一共几行几列，有多少个不同值。把具有不同值的元素和行列记录在一个小规模的数组中，从而缩小程序的规模。

package com.star_line.array;

public class ArrayDemo08 {
    public static void main(String[] args) {
        //创建一个二维数组 11*11 0无字，1黑棋，2白旗
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始的数组
        System.out.println("输出原始的数组");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }

            System.out.println();
        }
        System.out.println("。。。。。。。。。。。。。。");
        //转换为稀疏数组
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j] != 0){
                    sum++;
                }
            }
        }
        System.out.println("获取有效值的个数：" + sum);
        //创建一个稀疏数组对应的数组,前行后列
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //遍历二维数组，将非零的值存放在稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0){
                    count++;//从第二行开始存数，第一行是表头
                    array2[count][0] = i;//在第几行的第一个数字存横坐标
                    array2[count][1] = j;//在第几行的第一个数字存纵坐标
                    array2[count][2] = array1[i][j];
                }
            }
        }

        //输出稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0] + "\t"
                    + array2[i][1]+"\t"
                    + array2[i][2]+"\t");
        }
        System.out.println("。。。。。。。。。。。。。。");
        System.out.println("还原稀疏数组");
        //还原稀疏数组。
        // 读取稀疏数组的值
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //给其中的元素还原它的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //打印
        System.out.println("输出还原的数组");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }

            System.out.println();
        }
    }
}

输出原始的数组
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
。。。。。。。。。。。。。。
获取有效值的个数：2
稀疏数组
11 11 2
1 2 1
2 3 2
。。。。。。。。。。。。。。
还原稀疏数组
输出还原的数组
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0

进程已结束,退出代码0

稀疏数组表头不用再还原，循环从1开始。

star_line！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
关于各种排列组合java算法实现方法
09-05
介绍了几种用JAVA实现的排列组合算法，有需要的朋友可以参考一下
JAVA实现全排列和组合排列
最新发布
qq_43527397的博客
06-21 2406
JAVA通过递归实现全排列和组合排列
java排列组合算法
mm_bit的博客
07-13 6252
一.利用二进制状态法求排列组合，此种方法比较容易懂，但是运行效率不高，小数据排列组合可以使用 二.用递归的思想来求排列跟组合，代码量比较大 三.利用动态规划的思想求排列和组合 下面是求排列
排列组合 - Java代码实现
To be a great coder
06-18 1万+
最近发现求排列组合在大公司的笔试算法题中经常作为比较重要的一步出现，所以写篇文章好好整理一下。 首先，回顾一下高中知识。。。排列组合的公式。 接下来对排列、组合分别给出 Java 代码的实现，而且每个部分都会给出两个方面的实现。 排列会先给出求全排列数量的代码实现，然后给出求全排列结果的代码实现。 组合会先给出求所有组合数量的代码实现，然后给出求所有组合结果的代码实现。   排列 &n...
Java 全排列与组合
风口IT猪的成长录
05-19 1723
Permutation全排列概念分析代码展示组合概念枚举1-n所有组合，随机选取任意多个分析代码展示枚举1-n所有组合，随机选取m个数代码展示 排列组合是组合学最基本的概念。 所谓排列，就是指从给定个数的元素中取出指定个数的元素进行排序。 组合则是指从给定个数的元素中仅仅取出指定个数的元素，不考虑排序。 ----- 百度百科 全排列 概念 一般地说，从n个不同元素中，任取m(m≤n)个元素，按照一定的顺序排成一列，这就叫做从n个元素中取出m个元素的一个排列。 公式： 当 m=n 时，便称为全排列 此
java数组排序
09-04
java数组排序的思想，过程和代码实现。多种数组排序的方法，主要有冒泡排序，堆排序，插入排序， 归并操作(merge)， 归并操作(merge)，选择排序，希尔排序。
java数组结构图
11-15
对数组的总结和分析，通过这个结构记住它，在开发的过程中使用
java数组遍历 删除remove(示例代码)
09-04
java数组遍历 删除remove。需要的朋友可以过来参考下，希望对大家有所帮助
Java数组讲解
06-02
//在定义数组时,如果确定数组的各个元素,可以进行静态初始化 ,在创建数组时,给数组元素赋初值 int [] data2 = new int[] {34,56,765,78}; //注意静态初始化时,不需要指定数组的长度 //通过foreach循环遍历, 增强的...
java数组自定义排序
10-31
java中数组的自定义排序，种类繁多，简单实现，可自由操控。
排列组合算法总结（含Java实现）
Wendy0719的博客
06-06 1万+
一. 排列组合1. 排列（1）排列：（2）全排列：2. 组合：从n个元素中选择m个元素（不考虑顺序）
java 字符串排列组合_Java 程序计算列出字符串的所有排列组合
weixin_32943417的博客
02-12 2173
Java 程序计算列出字符串的所有排列组合在此示例中，我们将学习计算Java中字符串的所有排列组合。要理解此示例，您应该了解以下Java编程主题：字符串的排列是指可以通过互换字符串字符的位置来形成的所有可能的新字符串。例如，字符串ABC具有的排列组合 [ABC，ACB，BAC，BCA，CAB，CBA]。示例：Java 程序获取字符串的所有排列组合示例importjava.util.HashSet...
排列组合算法
qq_41250455的博客
09-14 390
import java.io.*; import java.util.Arrays; class test { /** * 计算阶乘数，即n! = n * (n-1) * ... * 2 * 1 */ private static long factorial(int n) { long sum = 1; while( n > 0 ) { sum = sum * n--; }
Java 实现m个数全排列组合以及从M中选取N个数（有序）
热门推荐
leixingbang的专栏
08-18 2万+
（1）全排列组合的递归规律： 集合s的全排列组合 all(s)=n+all(s-n);其中n为已经取出的集合 以集合 s={1,2,3}为例,则s的全排列组合为all(s)={1}+all({2,3});其中n={1},s-n={2,3} 通过以上例子，我们可以知道上述算法可以用递归来解决。 我们取极端情况，如果集合s为空，那么说明不需要再进行递归。 全排列组合，如果集合有4个元素，则全
java排列组合（递归算法）
qq_29039705的博客
05-26 1万+
一、排列 1、计算公式如下： 2、使用方法，例如在1，2，3，4，5中取3个数排列： 3、全排列 当m=n时，结果为全排列。例如1，2，3，4的全排列如下： 4、代码实现求无重复数组的全排列 /** * 循环递归获取给定数组元素(无重复)的全排列 * * @param oriList 原始数组 * @param oriLen 原始数组size * @param arrayCombResult 数组排列结果集，可传null或空Set * @param preList 记录排列参数
java实现全排列
m0_51212267的博客
02-11 2894
给一个数组返回其所有可能的排列组合情况。 例如 1，2，3的全排列有 1，2，3 1，3，2 2，1，3 2，3，1 3，1，2 3，2，1 如图，基于递归与回溯实现。在排列1，2，3的时候，先由3向上回溯到2发现没有其他可能的情况，再回溯到1，排列为1，3，2再向上回溯到存在其他情况时，即根节点然后再排列以2为第一位的情况，重复上述过程将所有可能结果全部放入res中。 import java.util.ArrayDeque; import java.util.ArrayList; imp.
java写出一个序列的所有排列组合
weixin_34302561的博客
02-21 458
排列组合其实具体概念我记得好像是不能有重复，每次组合中每个数都必须全部用到而且只能用一次。看见有很多人都把问题简单化了，今天为了完成任务，写了一个能正确运行的“算法”，“算法”之所以打引号那是因为我觉得好的算法要求是效率高，开销低，这个下次再考虑吧。 packagecom.pbj.mail;importjava.util.HashSet;importjava...
Java 对元素进行排列组合
weixin_42176639的博客
03-02 1142
Java 对元素进行排列组合
java 数组
05-30
Java 数组是一种用于存储同一类型数据的集合。它们是基本数据结构之一，非常重要，被广泛应用于各种算法和数据处理场景中。 Java 数组可以存储基本类型数据（如 int、float、double 等）以及对象类型（如 String、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值