跳至主要內容
打印横排二维码
public class PrintQrCode3Test {

    public static void main(String[] args) throws Exception {

        // 最多3组
        List<KeyValue> list = new ArrayList<>();
        list.add(KeyValue.generator("80", getStr(28)));
        list.add(KeyValue.generator("80", getStr(44)));
        list.add(KeyValue.generator("80", getStr(74)));
        System.out.println(toHexString(qrCode3Map(list)));

    }

    public static String getStr(Integer len) {
        return StringUtil.leftPad("", len, "zxcvbnmasdfghjklqwertyuiop.:/.:/");
    }

    public static byte[] qrCode3Map(List<KeyValue> content) {
        byte[] byteMerger = new byte[0];
        //  byte[] init = new byte[]{0x1B, 0x1D, 0x1E, 0x00, 0x0C, 0x04, 0x1B, 0x1D, 0x1F, 0x1B, 0x40};
        byte[] init = new byte[]{0x1B, 0x40};
        byteMerger = byteMerger(byteMerger, init);

        int w = 880;
        int h = 380;
        int w_pL = w%256;
        int w_pH = w/256;
        int h_pL = h%256;
        int h_pH = h/256;
        byte[] start = new byte[]{0x1B,0x4C,0x1B,0x57,0x00,0x00,0x00,0x00,(byte) w_pL,(byte) w_pH,(byte)h_pL,(byte)h_pH,0x0A};
        byteMerger = byteMerger(byteMerger, start);

        for (int i = 0; i < content.size(); i++) {
            String text = content.get(i).getValue();
            int size = content.get(i).getKey();
            Integer pager = content.get(i).getPager();
            int x = (pager*8 / content.size()) * i + 20;
            // byte[] crtiPrintAnddot = new byte[]{0x1D, 0x24, 0x00, 0x00, 0x1B, 0x24, (byte) (x % 256), (byte) (x / 256)};
            byte[] crtiPrintAnddot = new byte[]{0x1B, 0x24, (byte) (x % 256), (byte) (x / 256)};

            byte[] qrcodeSize = new byte[]{29, 40, 107, 3, 0, 49, 67, (byte) size};
            byte[] qrcodeData = {29, 40, 107, (byte) ((text.getBytes().length + 3) % 256), (byte) ((text.getBytes().length + 3) / 256), 49, 80, 48};
            byte[] qrcodeText = text.getBytes();
            byte[] printQrcode = {29, 40, 107, 3, 0, 49, 81, 48};
            byteMerger = byteMerger(byteMerger, crtiPrintAnddot);
            byteMerger = byteMerger(byteMerger, qrcodeSize);
            byteMerger = byteMerger(byteMerger, qrcodeData);
            byteMerger = byteMerger(byteMerger, qrcodeText);
            byteMerger = byteMerger(byteMerger, printQrcode);
            System.out.println(String.format("%s - %s - %s", size, text.length(), text));
        }

        byte[] end = new byte[]{10, 12, 24, 13};
        byteMerger = byteMerger(byteMerger, end);
        byte[] oc = new byte[] {0x0A,0x0A,0x0A,0x0A,0x0A,0x0A};
        byteMerger = byteMerger(byteMerger, oc);
        return byteMerger;
    }

    public static byte[] byteMerger(byte[] bt1, byte[] bt2) {
        byte[] bt3 = new byte[bt1.length + bt2.length];
        System.arraycopy(bt1, 0, bt3, 0, bt1.length);
        System.arraycopy(bt2, 0, bt3, bt1.length, bt2.length);
        return bt3;
    }


    public static String toHexString(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for(byte b : bytes) {
            String hex = Integer.toHexString(b).toUpperCase();
            if(hex.length() == 1) {
                hex = "0" + hex;
            } else if(hex.length() > 2) {
                hex = hex.substring(hex.length() - 2);
            }
            sb.append(hex).append(" ");
        }
        return sb.toString();
    }

    public static void printStr(byte[] decode) {
        try {
            System.out.println(new String(decode, "GB18030"));
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }


    static class KeyValue {
        private Integer key;
        private String value;
        private Integer pager;
        public KeyValue(Integer key, String value, Integer pager) {
            this.key = key;
            this.value = value;
            this.pager = pager;
        }

        public static KeyValue generator(String page, String value) {
            // 取正整数(9 - 取正整数(85 / 20))
            int pager  = Integer.parseInt(page);
            try {
                int x = 0;
                if ("58".equals(page)) {
                    x = 3;
                } else if ("80".equals(page)) {
                    x = 2;
                }
                int len = value.getBytes("GB2312").length;
                Integer key = Math.max((9 - Math.max(((len + x * 20 ) / 20), 0)), 0);
                if ("58".equals(page) && len >= 80) {
                    key = 3;
                }
                if ("80".equals(page) && len >= 80) {
                    key = 4;
                }
                if ("110".equals(page) && len >= 80) {
                    key = 5;
                }
                return new KeyValue(key, value, pager);
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
                return new KeyValue(5, value, pager);
            }
        }

        public Integer getPager() {
            return pager;
        }

        public void setPager(Integer pager) {
            this.pager = pager;
        }

        public Integer getKey() {
            return key;
        }

        public void setKey(Integer key) {
            this.key = key;
        }

        public String getValue() {
            return value;
        }

        public void setValue(String value) {
            this.value = value;
        }
    }

}
yuanmoc2021/8/17大约 2 分钟historyListSetStackMapArrayList
Esc图片预处理（先加载进打印机，再直接调用打印）

定义

/**
 * 定义位图
 */
public byte[] critDefineNV(ArrayList<BufferedImage> images) {
    int n = images.size();
    // 定义几个位图，执行会覆盖原来的
    byte[] header = new byte[]{28, 113, (byte)n};

    for(int i = 0; i < images.size(); ++i) {
        header = byteMerger(header, imageToByte((BufferedImage)images.get(i)));
    }

    return header;
}

/**
 * 合并字节数组
 */
public byte[] byteMerger(byte[] byte_1, byte[] byte_2) {
    byte[] byte_3 = new byte[byte_1.length + byte_2.length];
    System.arraycopy(byte_1, 0, byte_3, 0, byte_1.length);
    System.arraycopy(byte_2, 0, byte_3, byte_1.length, byte_2.length);
    return byte_3;
}

/**
 * 图片转字节
 */
public static byte[] imageToByte(BufferedImage bi) {
    int[] rgb = new int[3];
    int width = bi.getWidth();
    int height = bi.getHeight();
    StringBuilder res = new StringBuilder();

    int i;
    String y;
    for(int x = 0; x < width / 8 * 8; ++x) {
        for(int y = 0; y < height / 8 * 8; ++y) {
            i = bi.getRGB(x, y);
            rgb[0] = (i & 16711680) >> 16;
            rgb[1] = (i & '\uff00') >> 8;
            rgb[2] = i & 255;
            y = (rgb[0] + rgb[1] + rgb[2]) / 3 >= 200 ? "0" : "1";
            res.append(y);
        }
    }

    String x = res.toString();
    byte[] i1 = new byte[x.length() / 8];

    for(i = 0; i < x.length(); i += 8) {
        y = x.substring(i, i + 4);
        String z = x.substring(i + 4, i + 8);
        byte y1 = Byte.parseByte(y, 2);
        byte z1 = Byte.parseByte(z, 2);
        i1[i / 8] = (byte)((byte)(y1 << 4) | z1);
    }

    byte[] bytes = new byte[]{(byte)(width / 8 % 256), (byte)(width / 8 / 256), (byte)(height / 8 % 256), (byte)(height / 8 / 256)};
    bytes = byteMerger(bytes, i1);
    return bytes;
}
yuanmoc2021/4/10大约 1 分钟historyListArrayList
递归与回溯问题

汉诺塔问题

解题思路

1、假设有n个盘子需要移动
2、首先将最上面的n-1个盘子从A借助C移到B柱子
3、然后将最下面的一个盘子从A移到C柱子
4、最后将B当作A，A当作B，将n-1个盘子从B借助C移动到A柱子，再将B柱子最后一个移动到C上（实际重复了2-3步骤，只是把A、B参考对象对换）
5、当只剩下最后一个时，从A移动到C就可以了

Java代码

public class Hanota  {

    public static void main(String[] args) {
        List<Integer> a = new ArrayList<>();
        List<Integer> b = new ArrayList<>();
        List<Integer> c = new ArrayList<>();
        a.add(2);
        a.add(1);
        a.add(0);
        new Hanota().hanota(a,b,c);
        System.out.println(c);
    }

    public void hanota(List<Integer> A, List<Integer> B, List<Integer> C) {
        move(A.size(), A, B, C);
    }

    public void move(int n, List<Integer> A, List<Integer> B, List<Integer> C){
        if(n == 1){
            C.add(A.get(A.size() - 1));
            A.remove(A.size() - 1);
        }else{
            // 把A经过辅助C放到B上
            move(n - 1, A, C, B);
            // 把A放到C上
            C.add(A.get(A.size() - 1));
            A.remove(A.size() - 1);
            // 把B经过辅助A放到C上
            move(n - 1, B, A, C);
        }
    }
}
yuanmoc2020/7/24大约 5 分钟historyListArrayListORM解决方案
桶排序

计数排序

解题思路
1、取出数组中的最大值。
2、以（最大值 +1）作为辅助数组大小进行记录数组信息。
3、重新把辅助数组中的数据转回数组中。

Java代码

public void countSort(int[] arr) {
    // 设置最大值变量并找出
    int max = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (max < arr[i]) {
            max = arr[i];
        }
    }
    // 设置辅助数组
    int[] tmp = new int[max+1];
    // 将数据保存到辅助数组中
    for (int i = 0; i < arr.length; i++) {
        tmp[arr[i]]++;
    }
    // 从辅助数组中数据转到数组中
    int index = 0;
    for (int i = 0; i < tmp.length; ) {
        if (tmp[i] == 0) {
            i++;
        } else {
            arr[index] = i;
            tmp[i]--;
            index++;
        }
    }
}
yuanmoc2020/7/21大约 2 分钟historyListArrayList