面试题：如何将任意一个 一维数组 转换成任意的 二维数组

最新推荐文章于 2023-05-10 16:24:36 发布
最新推荐文章于 2023-05-10 16:24:36 发布
阅读量272 收藏
点赞数
文章标签： java 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flagyili/article/details/117335710
版权

目录

代码如下：

说明：我这里写的代码的 限制条件是 一维数组中最多 有 26个 元素（以26个字母为基本）。当然，想测试更多，可以更改判断条件。

代码如下：

说明：输出二维数组的逻辑，参考JDK的源码。JDK有现成的API：Arrays.deepToString:

@SuppressWarnings("all")
public class ArrayTransform {
    private static final int
            ZERO = 0, ONE = 1, TWO = 2, THREE = 3, FOUR = 4,
            FIVE = 5, SEX = 6, SEVEN = 7, EIGHT = 8, NINE = 9,
            TEN = 10, ELEVEN = 11, TWELVE = 12, THIRTEEN = 13,
            FOURTEEN = 14, FIFTEEN = 15, SIXTEEN = 16, SEVENTEEN = 17,
            EIGHTEEN = 18, NINETEEN = 19, TWENTY = 20, TWENTY_ONE = 21,
            TWENTY_TWO = 22, TWENTY_THREE = 23, TWENTY_FOUR = 24, TWENTY_FIVE = 25,
            TWENTY_SIX = 26;


    public static Object[][] transformToTwoDimensionArray(Object[] srcArray, int howGap) throws Exception {
        if (srcArray.length > TWENTY_SIX) {
            throw new Exception("sorry, at most 26 element!!!");
        }
        if (howGap == ZERO){
            throw new Exception("sorry, how Gap cannot is zero !!!");
        }
        if (srcArray.length == ZERO){
            return new Object[ZERO][];
        }
        Object[][] objDimensionArr = null;
        int flag = ZERO;
        // 分配二维数组长度
        if ((howGap == srcArray.length)) {
            flag = ONE;
            objDimensionArr = new Object[ONE][];
        } else {
            objDimensionArr = allocationTwoDimensionArrayLength(srcArray, howGap, objDimensionArr);
        }

        int count = 0;
        for (int j = 0; j < objDimensionArr.length; j++) {
            // 为二维数组里面的一维数组分配长度
            if (flag == ONE) {
                objDimensionArr[j] = new Object[srcArray.length];
            } else {
                objDimensionArr[j] = new Object[howGap];
                if (j == objDimensionArr.length - 1) {
                    switch (srcArray.length % howGap) {
                        case ONE:
                            objDimensionArr[j] = new Object[ONE];
                            break;
                        case TWO:
                            objDimensionArr[j] = new Object[TWO];
                            break;
                        case THREE:
                            objDimensionArr[j] = new Object[THREE];
                            break;
                        case FOUR:
                            objDimensionArr[j] = new Object[FOUR];
                            break;
                        case FIVE:
                            objDimensionArr[j] = new Object[FIVE];
                            break;
                        case SEX:
                            objDimensionArr[j] = new Object[SEX];
                            break;
                        case SEVEN:
                            objDimensionArr[j] = new Object[SEVEN];
                            break;
                        case EIGHT:
                            objDimensionArr[j] = new Object[EIGHT];
                            break;
                        case NINE:
                            objDimensionArr[j] = new Object[NINE];
                            break;
                        case TEN:
                            objDimensionArr[j] = new Object[TEN];
                            break;
                        case ELEVEN:
                            objDimensionArr[j] = new Object[ELEVEN];
                            break;
                        case TWELVE:
                            objDimensionArr[j] = new Object[TWELVE];
                            break;
                    }
                }
            }

            // 给 每个二维数组里面的一位数组的元素 赋值
            to:
            for (int i = 0; i < srcArray.length; i++) {
                for (int d = 0; d < objDimensionArr[j].length; d++) {
                    objDimensionArr[j][d] = srcArray[count];
                    count++;
                    if (d == objDimensionArr[j].length - 1) {
                        break to;
                    }
                }
            }
        }
        return objDimensionArr;
    }

    private static Object[][] allocationTwoDimensionArrayLength(Object[] srcArray, int howGap, Object[][] objDimensionArr) throws Exception {
//        if (srcArray.length / howGap == srcArray.length) {
//            objDimensionArr = new Object[srcArray.length][];
//        }
        if (srcArray.length / howGap == TWENTY_SIX) {
            objDimensionArr = new Object[TWENTY_SIX][];
        } else {
            if (srcArray.length % howGap == 0) {
                objDimensionArr = schema1(srcArray, howGap);
            } else {
                if (howGap > (srcArray.length / 2)) {
                    switch (srcArray.length / howGap) {
                        case ONE:
                            objDimensionArr = new Object[ONE + 1][];
                            break;
                        default:
                            objDimensionArr = schema2(srcArray, howGap);
                    }
                } else {
                    objDimensionArr = schema2(srcArray, howGap);
                }
            }
        }
        return objDimensionArr;
    }

    private static Object[][] schema2(Object[] srcArray, int howGap) throws Exception {
        Object[][] objDimensionArr = null;
        switch (srcArray.length / howGap) {
            case ONE:
                objDimensionArr = new Object[ONE + 1][];
                break;
            case TWO:
                objDimensionArr = new Object[TWO + 1][];
                break;
            case THREE:
                objDimensionArr = new Object[THREE + 1][];
                break;
            case FOUR:
                objDimensionArr = new Object[FOUR + 1][];
                break;
            case FIVE:
                objDimensionArr = new Object[FIVE + 1][];
                break;
            case SEX:
                objDimensionArr = new Object[SEX + 1][];
                break;
            case SEVEN:
                objDimensionArr = new Object[SEVEN + 1][];
                break;
            case EIGHT:
                objDimensionArr = new Object[EIGHT + 1][];
                break;
            case NINE:
                objDimensionArr = new Object[NINE + 1][];
                break;
            case TEN:
                objDimensionArr = new Object[TEN + 1][];
                break;
            case ELEVEN:
                objDimensionArr = new Object[ELEVEN + 1][];
                break;
            case TWELVE:
                objDimensionArr = new Object[TWELVE + 1][];
                break;
            default:
                if (howGap > srcArray.length) {
                    throw new Exception("sorry, gap cannot greater than resource array length!!! array length: " + srcArray.length);
                }
        }
        return objDimensionArr;
    }
    
    private static Object[][] schema1(Object[] srcArray, int howGap) {
        Object[][] objDimensionArr = null;
        switch (srcArray.length / howGap) {
            case ONE:
                objDimensionArr = new Object[ONE][];
                break;
            case TWO:
                objDimensionArr = new Object[TWO][];
                break;
            case THREE:
                objDimensionArr = new Object[THREE][];
                break;
            case FOUR:
                objDimensionArr = new Object[FOUR][];
                break;
            case FIVE:
                objDimensionArr = new Object[FIVE][];
                break;
            case SEX:
                objDimensionArr = new Object[SEX][];
                break;
            case SEVEN:
                objDimensionArr = new Object[SEVEN][];
                break;
            case EIGHT:
                objDimensionArr = new Object[EIGHT][];
                break;
            case NINE:
                objDimensionArr = new Object[NINE][];
                break;
            case TEN:
                objDimensionArr = new Object[TEN][];
                break;
            case ELEVEN:
                objDimensionArr = new Object[ELEVEN][];
                break;
            case TWELVE:
                objDimensionArr = new Object[TWELVE][];
                break;
            case THIRTEEN:
                objDimensionArr = new Object[THIRTEEN][];
                break;
        }
        return objDimensionArr;
    }

    public static String dimensionArrayToString(Object[] oArr) {
        if (oArr == null){return "null";}
        int bufLength = oArr.length * 20;
        if (oArr.length != 0 && bufLength <= 0){
            bufLength = Integer.MAX_VALUE;
        }
        StringBuilder sb = new StringBuilder(bufLength);
        toStr(oArr,sb);
        return sb.toString();
    }
    private static void toStr(Object[] oArr, StringBuilder sb){
        if (oArr == null){
            sb.append("null");
            return;
        }
        int maxIndex = oArr.length -1;
        if (maxIndex == -1){
            sb.append("[]");
            return;
        }

        sb.append('[');
        int i = 0;
        while (true){
            // 每个元素
            Object ele = oArr[i];
            if (ele == null ){
                sb.append("null");
            }else{
                final Class<?> clazz = ele.getClass();
                // 是否是数组，是就递归
                if (clazz.isArray()){

                    toStr((Object[]) ele,sb);
                }else{
                    // 数组的每个元素to str
                    sb.append(ele.toString());
                }
            }
            if (i == maxIndex){
                break;
            }
            sb.append(", ");
            i++;
        }
        sb.append(']');
//        for (int i=0;;i++){
//            // 每个元素
//            Object ele = oArr[i];
//            if (ele == null ){
//                sb.append("null");
//            }else{
//                final Class<?> clazz = ele.getClass();
//                // 是否是数组，是就递归
//                if (clazz.isArray()){
//                    // 递归
//                    to((Object[]) ele,sb);
//                }else{
//                    //
//                    sb.append(ele.toString());
//                }
//            }
//            if (i == maxIndex){
//                break;
//            }
//            sb.append(", ");
//        }

    }
}

test: 

public static void main(String[] args) throws Exception {
        Character[] srcArray = {'a', 'b', 'c', 'd', 'e', 'f',
                'g', 'h', 'i', 'j', 'k', 'l',
                'm', 'n', 'o', 'p', 'q', 'r',
                's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
        final Object[][] resultArr = ArrayTransform.transformToTwoDimensionArray(srcArray, 3);
        final String s = ArrayTransform.dimensionArrayToString(resultArr);
        System.out.println(s);
    }

result:

 

Jonny Z
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2024年Unity 面试题 |五萬字 二佰道| Unity面试题大全，面试题总结【全网最全，收藏一篇足够面试】
努力前行，总会成为自己心中的那道光
02-23 11万+
正所谓 金三银四 ，又到了找工作的大好时机了，不知道大家有没有意向找一份更好的工作呢~ 之前写了很多Unity的学习和实例文章，但是面试题部分还没有一个系统的整理。 那本篇文章就来整理一下Unity中一些常见的面试题，说不准就会面试的时候就会遇到！ 本篇文章会将Unity所有方面的面试资料都融会贯通，绝对是2022年Unity面试领域最实用的文章啦！
第 1-7 课：数组和排序算法 + 面试题
磊哥聊Java
10-28 244
数组的定义与使用 数组是 Java 编程中最重要的数据结构之一，也是最基本的数据结构，Java 中的常用集合 ArrayList、HashMap 等内部的实现都使用到了数组结构。数组是只能用来存储一种类型的集合，可以通过下标访问数值中的所有元素。 数组的声明方式有以下两种，如整数型数组，请参考下面代码： 方式一：int[] arr; 方式二：int arr[]; 大部分情况下，我们会使用第一种...
JavaScript实现一维数组转化为二维数组
09-20
下面小编就为大家分享一篇JavaScript实现一维数组转化为二维数组，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Leetcode刷题100天—2022. 将一维数组转变成二维数组(数组)—day55
智的博客
12-02 2802
前言： 作者：神的孩子在歌唱 大家好，我叫运智 2022. 将一维数组转变成二维数组 难度简单0 给你一个下标从 0 开始的一维整数数组 original 和两个整数 m 和 n 。你需要使用 original 中 所有 元素创建一个 m 行 n 列的二维数组。 original 中下标从 0 到 n - 1 （都 包含 ）的元素构成二维数组的第一行，下标从 n 到 2 * n - 1 （都 包含 ）的元素构成二维数组的第二行，依此类推。 请你根据上述过程返回一个 m x n 的二维数组。如果无法构成
面试题（数组去重，排序，转换）
Kylincsg的博客
07-28 108
var arr = [ 15, [1, new Number(10), 2], { a: 3, b: [4, 7, 8] }, [6, 7, 8, 9, [11, 12, [12, 13, [14]]]], ]; // 输出：[1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
Java编程一维数组转换成二维数组实例代码
08-28
主要介绍了Java编程一维数组转换成二维数组，分享了相关代码示例，小编觉得还是挺不错的，具有一定借鉴价值，需要的朋友可以参考下
二维数组转一维数组
04-13
将labview内二维数组方便的转化为一维数组使用
经验分享：java定义二维数组初始化
m0_57081368的博客
05-31 327
前言 Spring 是一个非常流行和成功的 Java 应用开发框架。Spring Security 是 Spring 家族中的一个安全管理框架，提供了一套 Web 应用安全性的完整解决方案。在用户认证方面，Spring Security 框架支持主流的认证方式，包括 HTTP 基本认证、HTTP 表单验证、HTTP 摘要认证、OpenID 和 LDAP 等。在用户授权方面，Spring Security 提供了基于角色的访问控制和访问控制列表（Access
JavaScript 基础 （4）{数组API、二维数组、字符串对象、Math对象、Date对象、Number对象、Boolean对象、错误处理、ES6}
weixin_59684494的博客
12-06 617
一、数组API API: js中预定义好的一些函数或者方法 toString() 将数组转为字符串,元素之间用逗号隔开 join() 将数组转为字符串,可以指定元素之间的分隔符 concat(arr2,arr3.....) 拼接多个数组arr2,arr3.....表示要拼接的数组 slice(start,end) 截取数组元素,start开始的下标,end结束的下标,不包括enf的本身,end为空截取到最后,下标为负数倒数,返回截取到的元素 splice(start,cou...
C语言面试题总结汇总经典.pdf
最新发布
03-29
- **问题描述**：给定一个二维数组，每行有十个数字，要求计算出下一行中每个数字代表的是上一行中该数字出现的次数。 - **解决方案**： - 对于每一行，统计其中每个数字出现的次数。 - 将统计的结果作为下一行的...
PHP二维数组（或任意维数组）转换成一维数组的方法
一个入门程序猿的博客
03-28 2703
$arr = [ 'a' =&gt; [ 1, 2, ], 'b' =&gt; [ '3', '4'=&gt;[ '5' ] ], 'b' ]; print_r(iterator_to_array( new RecursiveIterato...
创建numpy数组的不同方式
Gordennizaicunzai的博客
01-05 759
Numpy库的核心是数组对象或ndarray对象（n维数组）。你将使用Numpy数组执行逻辑，统计和傅里叶变换等运算。作为使用Numpy的一部分，你要做的第一件事就是创建Numpy数组。本指南的主要目的是帮助数据科学爱好者了解可用于创建Numpy数组的不同方式。 创建Numpy数组有三种不同的方法： 使用Numpy内部功能函数 从列表等其他Python的结构进行转换 使用特殊的库函数 #使...
一维数组转二维数组
weixin_45289656的博客
05-10 527
将一维数组根据某一个相同的属性变成二维数组，有两种转换的数据结构。以上两种方式想要哪种都可以转换。第二种：数据格式转换成这样。
数据结构之数组与经典面试题（二）
zhouhengzhe的博客
12-23 1488
1、定义 所谓数组，是有序的元素序列。 若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按无序的形式组织起来的一种形式。这些无序排列的同类数据元素的集合称为数组。int 的数组你就不能存float 也不能存double。数组是用于储存多个相同类型数据的集合。通常用Array表示，也称之为线性表，画图演示 2、特点 (1
一维数组转化为二维数组
weixin_49154058的博客
07-25 6016
一维数组的转换
c++ 一维数组转二维数组
xiangxianghehe的博客
09-12 8046
const int a[10] = { 1, 2, 3, 4, 5,6,7,8 }; int b[2][4]={0}; int i=0; int j=0; for (int m=0;m<10;m++) { i=m/4; j=m%4; b[i][j]=a[m]; } for (int i=0;i<2;i++) { for (int j=0;j<...
更简易的将一维数组转化为二维数组
weixin_54902466的博客
04-21 4176
提示：本章技术分享为将一维数组转化为二维数组 文章目录前言一、详细代码步骤二、代码优化总结 前言 提示：超简单的转化方法,灵活运用数组方法,通俗易懂 提示：以下是本篇文章正文内容，下面案例可供参考 一、详细代码步骤 示例：本步骤主要是中心思想,代码略微有些复杂,具体可用第二步中的优化代码. 代码如下（示例）： <!DOCTYPE html> <html lang="zh-CN"> <head> <meta charset="UTF-8">
将一维数组转变成二维数组
qq_43806430的博客
01-23 1728
将一维数组转变成二维数组 class Solution { public int[][] construct2DArray(int[] original, int m, int n) { if (original.length != m * n) return new int[0][]; //结果 int[][] ans = new int[m][n]; for (int i = 0; i < origi...
一维数组与二维数组互相转换
qq_20765533的博客
02-07 7932
一维数组与二维数组互相转换 一、二维数组转一维数组 1.1 使用 reduce 实现 vararr1=[[1,2],[3,4],[5,6],[7]]; functiontoArrayOne(pre,value,index,array){ returnpre.concat(value); } var arr2 = arr1.reduce(toArrayOne); console.log(arr2 ); reduce 还可以实现数组求和，求数组最大值/...
算法面试题：排序、链表操作与二维数组查找
在这些算法面试题中，首先提到了一个链表操作的问题，即如何从尾到头反向打印链表节点的值。这要求对链表结构有深入理解，可以通过迭代或递归的方式实现，通常会用到栈来辅助实现。 接下来，问题涉及到了二叉树的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值