Java数组查找数组，同意识的时空搜索对象

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * 数组模拟 计算‘面’是否在‘面’里面
 * 
 *
 * @author xiong
 * @email 731139982@qq.com
 * @date 2021年12月2日
 */
public class PlaneAlgorithm {
    public static void main(String[] args) {
        s1();
        s2();
        s3();
        s4();
        s5();
        s6();
//      s7();
    }
    
    /**
     * 同意识领域下
     * 体在时空位置
     */
    private static void s6() {
        //时空对象
        int[][][][] dateObj = new int[999][5][5][5];//意识领域下，999个瞬间的5x5x5范围
        for (int d = 0; d < dateObj.length; d++) {//时间坐标
            //时间点的空间对象
            int [][][] obj = dateObj[d];//对象所在时间坐标的空间坐标
            for (int x = 0; x < obj.length; x++) {//横坐标
                for (int y = 0; y < obj[x].length; y++) {//纵坐标
                    for (int z = 0; z < obj[x][y].length; z++) {//垂直坐标
                        
                    }
                }
            }
        }
    }

    /**
     * 体在体的位置
     */
    private static void s5() {
        //体
        int[][][] obj = new int[5][5][5];
        for (int x = 0; x < obj.length; x++) {//横坐标
            for (int y = 0; y < obj[x].length; y++) {//纵坐标
                for (int z = 0; z < obj[x][y].length; z++) {//垂直坐标
                    
                }
            }
        }
    }


    /**
     * 面在面的位置
     */
    private static void s4() {
        int[][] bigPlane = { 
                { 1, 5, 2, 1, 5, 3, 5 }, 
                { 5, 1, 5, 5, 1, 1, 8 }, 
                { 9, 1, 5, 5, 5, 7, 3 },
                { 9, 5, 1, 6, 8, 7, 3 } };
        System.out.println("bigPlane: " + Arrays.deepToString(bigPlane));
        int[][] plane = { { 1, 5 }, { 5, 1 } };
//      int[][] plane = { { 7, 3 }, { 7, 3 } };
        System.out.println("plane: " + Arrays.deepToString(plane));
        for (int i = 0; i < bigPlane.length; i++) {
            //面的第一行线，去大面每行线去比对，同一行需要发现多次
//          int idx = strFmt(Arrays.toString(bigPlane[i])).indexOf(strFmt(Arrays.toString(plane[0])));
            List<Integer> idxList = indexOfAll(strFmt(Arrays.toString(bigPlane[i])), strFmt(Arrays.toString(plane[0])));
            for (Integer idx : idxList) {
                Boolean isEq = true;
                //如果发现存在，就把面的第j行和发现的行+j行进行比对  如果有一次不对直接排除
                for (int j = 1; j < plane.length; j++) {
                    String nrow = strFmt(Arrays.toString(plane[j]));
                    //如果下标越界 直接排除
                    if((i + j) >=bigPlane.length  || (idx+nrow.length()) > strFmt(Arrays.toString(bigPlane[i + j])).length() ) {
                        isEq = false;
                        break;
                    }
                    String bnrow = strFmt(Arrays.toString(bigPlane[i + j])).substring(idx, idx+nrow.length());
                    if(!nrow.equals(bnrow)) {
                        isEq = false;//排除
                        break;
                    }
                }
                if(isEq) {
                    //如果每行比对都ok 则存在
                    System.out.println("row "+(i+1)+" - col "+(idx / (1 + 1)+1));
                }
            }
        }

    }

    /**
     * 线在面的位置
     */
    private static void s3() {
        int[][] plane = { { 6, 3, 2, 1, 5, 3, 5 }, { 3, 5, 5, 5, 1, 1, 8 }, { 9, 6, 5, 5, 5, 7, 3 },
                { 9, 6, 5, 6, 8, 7, 3 } };
        System.out.println("plane: " + Arrays.deepToString(plane));
        int[] line = { 5, 5, 5 };
        System.out.println("line: " + Arrays.toString(line));
        // 遍历横向
        for (int i = 0; i < plane.length; i++) {
            //todo 需要发现多次
            int idx = strFmt(Arrays.toString(plane[i])).indexOf(strFmt(Arrays.toString(line)));
            int result = idx == -1 ? -1 : (idx / (1 + 1));// (1+1)表示1位数字+1位逗号
            System.out.println("line" + i + " index: " + result);
        }
        System.out.println("--------------------------------------------------------");
    }

    /**
     * 线在线的位置
     */
    private static void s2() {
        int[] longLine = { 3, 5, 5, 5, 1, 1, 8 };
        System.out.println("longLine: " + Arrays.toString(longLine));
        int[] line = { 5, 5, 5 };
        System.out.println("line: " + Arrays.toString(line));
        //todo 需要发现多次
        int i = strFmt(Arrays.toString(longLine)).indexOf(strFmt(Arrays.toString(line)));
        System.out.println("line index: " + (i / (1 + 1)));// (1+1)表示1位数字+1位逗号
        System.out.println("--------------------------------------------------------");
    }

    /**
     * 点在线的位置
     */
    private static void s1() {
        int[] line = { 1, 1, 3, 5, 4, 6, 8 };
        System.out.println("line: " + Arrays.toString(line));
        String point = "5";
        System.out.println("point: " + point);
        //todo 需要发现多次
        int i = strFmt(Arrays.toString(line)).indexOf(strFmt(point));
        System.out.println("point index: " + (i / (1 + 1)));// (1+1)表示1位数字+1位逗号
        System.out.println("--------------------------------------------------------");
    }

    /**
     * 将[1,2,3,5]转换为,1,2,3,5, 将 1转换为,1, 方便查找值在值的位置
     * 方便数组里面去搜索数组
     * @param s
     * @return
     */
    private static String strFmt(String s) {
        if (s.indexOf("[") != -1) {
            s = s.replace(" ", "");
            s = s.substring(1, s.length() - 1);
            return strFmt(s);
        } else {
            return "," + s + ",";
        }
    }
    /**
     * 搜索文字出现的下标集合
     * @param all 长文字
     * @param value 值
     * @param isExist 是否保留-1
     * @return
     */
    private static List<Integer> indexOfAll(String all,String value) {
        List<Integer> idxall= new ArrayList<Integer>();
        indexOf(all, value, -1,idxall);
        return idxall;
    }
    /**
     * 递归查询
     * @param all 长文字
     * @param value 查找的值
     * @param fromIndex 开始索引
     * @param idxall 出现的下标
     */
    private static void indexOf(String all,String value,int fromIndex, List<Integer> idxall) {
        int i = all.indexOf(value,fromIndex+1);
        if(i!=-1) {
            idxall.add(i);
            indexOf(all, value, i, idxall);
        }
    }

}