1. 全栈程序员必看首页

LargeInteger

全栈程序员-用户IM • • 未分类

LargeInteger import java.math.BigInteger;/**   * 超大整数加减乘除：   * 题目要求：如果系统要使用超大整数（超过long的范围），请你设计一个数据结构来存储这种超大型数字以及设计一种算法来实现超大整数的加法运算   * @author Jason Huang   *   */ public class LargeIntege

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺
 

  1. import java.math.BigInteger;
  3. /**  
  4.  * 超大整数加减乘除：  
  5.  * 题目要求：如果系统要使用超大整数（超过long的范围），请你设计一个数据结构来存储这种超大型数字以及设计一种算法来实现超大整数的加法运算  
  6.  * @author Jason Huang  
  7.  *  
  8.  */ 
  9. public class LargeInteger {
  10.     // 第一位存储符号，第二位开始，从低位到高位存储数据，每个byte存储十进制数字两位，即该存储结构为100进制
  11.     private byte[] data = null;
  13.     private LargeInteger(byte[] data) {
  14.         if (data == null) {
  15.             throw new NumberFormatException();
  16.         }
  17.         this.data = copy(data, –1);
  18.     }
  20.     public LargeInteger(LargeInteger num) {
  21.         this(num.data);
  22.     }
  24.     public LargeInteger(String exp) {
  25.         // 转换成char array
  26.         char[] chars = exp.toCharArray();
  27.         // 获取第一个字母
  28.         char chr = chars[0];
  29.         // 获取左边第一个有效数字的位置
  30.         int left = (chr == ‘-‘ || chr == ‘+’) ? 1 : 0;
  31.         // 获取byte array的长度
  32.         int length = (chars.length – left + 3) / 2;
  33.         // 建立byte array
  34.         data = new byte[length];
  35.         // 存储正负符号
  36.         data[0] = (byte) (chr == ‘-‘ ? 0x1 : 0x0);
  38.         int index = 1;
  39.         // 从低位到高位处理数字
  40.         for (int i = chars.length – 1; i >= left;) {
  41.             // 个位数
  42.             int num1 = chars[i–] – ‘0’;
  43.             // 十位数
  44.             int num10 = i >= left ? chars[i–] – ‘0’ : 0;
  46.             // 含有非法字符时抛出错误
  47.             if (num1 < 0 || num1 > 9 || num10 < 0 || num10 > 9) {
  48.                 throw new NumberFormatException();
  49.             }
  51.             data[index++] = (byte) (num10 * 10 + num1);
  52.         }
  53.     }
  55.     private static byte[] copy(byte[] bytes, int append) {
  56.         if (bytes == null) {
  57.             throw new NumberFormatException();
  58.         }
  60.         if (bytes.length <= 1) {
  61.             return new byte[2];
  62.         }
  64.         //System.out.println(“copy1: ” + toString(bytes));
  65.         int length = bytes.length;
  66.         int right = length – 1;
  67.         if (append >= 0) {
  68.             length += append;
  69.         } else {
  70.             for (; right >= 2; right–) {
  71.                 if (bytes[right] > 0x0) {
  72.                     break;
  73.                 }
  74.             }
  75.             length = right + 1;
  76.         }
  78.         byte[] other = new byte[length];
  79.         for (int i = 0; i <= right; i++) {
  80.             other[i] = bytes[i];
  81.         }
  83.         if (isZero(other)) {
  84.             other[0] = 0x0;
  85.         }
  86.         //System.out.println(“copy2: ” + toString(other));
  87.         return other;
  88.     }
  90.     private static byte[] subarray(byte[] bytes, int beginIndex, int length) {
  91.         if (bytes == null || bytes.length <= 1) {
  92.             throw new NumberFormatException();
  93.         }
  95.         //System.out.println(“subarray: ” + toString(bytes));
  96.         //System.out.println(“beginIndex: ” + beginIndex);
  97.         //System.out.println(“length: ” + length);
  98.         if (beginIndex < 0 || length < 1) {
  99.             //System.out.println(“beginIndex: ” + beginIndex);
  100.             //System.out.println(“length: ” + length);
  101.             //System.out.println(“bytes.length: ” + bytes.length);
  102.             throw new IndexOutOfBoundsException();
  103.         }
  105.         byte[] other = new byte[length];
  106.         other[0] = bytes[0];
  107.         for (int i = 1; i < length && i + beginIndex < bytes.length; i++) {
  108.             //System.out.println(“i: ” + i);
  109.             //System.out.println(“beginIndex: ” + beginIndex);
  110.             //System.out.println(“length: ” + length);
  111.             //System.out.println(“bytes.length: ” + bytes.length);
  112.             other[i] = bytes[i + beginIndex];
  113.         }
  115.         //System.out.println(“other: ” + toString(other));
  116.         return other;
  117.     }
  119.     private static byte[] shift(byte[] bytes, int n) {
  120.         if (bytes == null || bytes.length <= 1) {
  121.             throw new NumberFormatException();
  122.         }
  124.         byte[] other = new byte[bytes.length + n];
  125.         other[0] = bytes[0];
  126.         for (int i = 1; i < bytes.length; i++) {
  127.             other[i + n] = bytes[i];
  128.         }
  130.         return other;
  131.     }
  133.     private static byte[] copy(int[] nums) {
  134.         if (nums == null) {
  135.             throw new NumberFormatException();
  136.         }
  138.         if (nums.length <= 1) {
  139.             return new byte[2];
  140.         }
  142.         //System.out.println(“copy1: ” + toString(nums));
  143.         byte[] other = new byte[nums.length];
  144.         other[0] = (byte) nums[0];
  145.         int over = 0;
  146.         int num = 0;
  147.         for (int i = 1; i < nums.length; i++) {
  148.             over += nums[i];
  149.             other[i] = (byte) (over % 100);
  150.             over /= 100;
  151.         }
  152.         return copy(other, –1);
  153.     }
  155.     public int signum() {
  156.         return compareTo(this.data, new byte[2]);
  157.     }
  159.     private static byte[] abs(byte[] bytes) {
  160.         byte[] other = copy(bytes, –1);
  161.         other[0] = 0x0;
  162.         return other;
  163.     }
  165.     public static LargeInteger abs(LargeInteger num) {
  166.         return new LargeInteger(abs(num.data));
  167.     }
  169.     public LargeInteger abs() {
  170.         return new LargeInteger(abs(this.data));
  171.     }
  173.     private static byte[] negate(byte[] bytes) {
  174.         byte[] other = copy(bytes, –1);
  175.         other[0] ^= 0x1;
  176.         return other;
  177.     }
  179.     public static LargeInteger negate(LargeInteger num) {
  180.         return new LargeInteger(negate(num.data));
  181.     }
  183.     public LargeInteger negate() {
  184.         return new LargeInteger(negate(this.data));
  185.     }
  187.     private static boolean isZero(byte[] bytes) {
  188.         if (bytes == null) {
  189.             throw new NumberFormatException();
  190.         }
  192.         for (int i = 1; i < bytes.length; i++) {
  193.             if (bytes[i] != 0x0) {
  194.                 return false;
  195.             }
  196.         }
  197.         return true;
  198.     }
  200.     private static int compareTo(byte[] bytes1, byte[] bytes2) {
  201.         if (bytes1 == null || bytes2 == null) {
  202.             throw new NumberFormatException();
  203.         }
  205.         if (isZero(bytes1) && isZero(bytes2)) {
  206.             return 0;
  207.         } else if (isZero(bytes1)) {
  208.             return bytes2[0] == 0x1 ? 1 : –1;
  209.         } else if (isZero(bytes2)) {
  210.             return bytes1[0] == 0x1 ? –1 : 1;
  211.         } else if (bytes1[0] > bytes2[0]) {
  212.             return –1;
  213.         } else if (bytes1[0] < bytes2[0]) {
  214.             return 1;
  215.         } else if (bytes1[0] == 0x1) {
  216.             return compareTo(abs(bytes2), abs(bytes1));
  217.         }
  219.         byte[] other1 = copy(bytes1, –1);
  220.         byte[] other2 = copy(bytes2, –1);
  222.         if (other1.length < other2.length) {
  223.             return –1;
  224.         } else if (other1.length > other2.length) {
  225.             return 1;
  226.         } else {
  227.             for (int i = other1.length – 1; i >= 1; i–) {
  228.                 if (other1[i] < other2[i]) {
  229.                     return –1;
  230.                 } else if (other1[i] > other2[i]) {
  231.                     return 1;
  232.                 }
  233.             }
  234.             return 0;
  235.         }
  236.     }
  238.     public static int compareTo(LargeInteger num1, LargeInteger num2) {
  239.         return compareTo(num1.data, num2.data);
  240.     }
  242.     public int compareTo(LargeInteger num) {
  243.         return compareTo(this.data, num.data);
  244.     }
  246.     private static byte[] add(byte[] data1, byte[] data2) {
  247.         if (data1 == null || data2 == null) {
  248.             throw new NumberFormatException();
  249.         }
  251.         if (data1[0] != data2[0]) {
  252.             // 如果正负号相异，则A+B = A-(-B)
  253.             return subtract(data1, negate(data2));
  254.         }
  256.         //System.out.println(“data1: ” + toString(data1));
  257.         //System.out.println(“data2: ” + toString(data2));
  258.         // 复制A，B，并加长一位，以保证进位
  259.         int length = data1.length > data2.length ? data1.length + 1 : data2.length + 1;
  260.         // byte1复制A，被加数，并作为结果
  261.         byte[] byte1 = copy(data1, length – data1.length);
  262.         // byte2复制B，加数
  263.         byte[] byte2 = copy(data2, length – data2.length);
  264.         // 因为AB同正负号，所以符号不变
  265.         byte1[0] = data1[0];
  266.         // 进位
  267.         int over = 0;
  268.         // 运算位
  269.         int num = 0;
  270.         // 从低位到高位相加计算
  271.         for (int i = 1; i < byte1.length; i++) {
  272.             // 相应位再加进位，相加
  273.             num = byte1[i] + byte2[i] + over;
  274.             //System.out.println(“num: ” + num);
  275.             if (num >= 100) {
  276.                 // 有进位
  277.                 over = 1;
  278.                 num -= 100;
  279.             } else {
  280.                 // 无进位
  281.                 over = 0;
  282.             }
  283.             byte1[i] = (byte) num;
  284.         }
  285.         return byte1;
  286.     }
  288.     public LargeInteger add(LargeInteger… nums) {
  289.         byte[] augend = this.data;
  290.         for (LargeInteger num : nums) {
  291.             augend = add(augend, num.data);
  292.         }
  293.         return new LargeInteger(augend);
  294.     }
  296.     private static byte[] subtract(byte[] data1, byte[] data2) {
  297.         if (data1 == null || data2 == null) {
  298.             throw new NumberFormatException();
  299.         }
  301.         //System.out.println(“data1: ” + toString(data1));
  302.         //System.out.println(“data2: ” + toString(data2));
  303.         if (data1[0] != data2[0]) {
  304.             // 如果正负号相异，则A-B = A+(-B)
  305.             return add(data1, negate(data2));
  306.         } else if (compareTo(abs(data1), abs(data2)) < 0) {
  307.             // 如果A的绝对值>B的绝对值，则A-B = -(B-A)，以保证结果与被减数同符号
  308.             return negate(subtract(data2, data1));
  309.         }
  311.         // data复制A，被减数，并作为结果
  312.         byte[] data = copy(data1, 0);
  313.         // 结果与被减数同符号
  314.         data[0] = data1[0];
  315.         // 退位
  316.         int over = 0;
  317.         // 运算位
  318.         int num = 0;
  319.         for (int i = 1; i < data.length; i++) {
  320.             // 相应位相减，再减退位
  321.             num = data[i] – (i >= data2.length ? 0 : data2[i]) – over;
  322.             //System.out.println(“num: ” + num);
  323.             if (num < 0) {
  324.                 // 有退位
  325.                 over = 1;
  326.                 num += 100;
  327.             } else {
  328.                 // 无退位
  329.                 over = 0;
  330.             }
  331.             data[i] = (byte) num;
  332.         }
  333.         return data;
  334.     }
  336.     public LargeInteger subtract(LargeInteger… nums) {
  337.         byte[] minuend = this.data;
  338.         for (LargeInteger num : nums) {
  339.             minuend = subtract(minuend, num.data);
  340.         }
  341.         return new LargeInteger(minuend);
  342.     }
  344.     private static byte[] multiply(byte[] data1, byte[] data2) {
  345.         if (data1 == null || data2 == null) {
  346.             throw new NumberFormatException();
  347.         }
  349.         //System.out.println(“data1: ” + toString(data1));
  350.         //System.out.println(“data2: ” + toString(data2));
  351.         int[] data = new int[data1.length + data2.length];
  352.         data[0] = data1[0] ^ data2[0];
  354.         int num = 0;
  355.         for (int i = 1; i < data1.length; i++) {
  356.             for (int j = 1; j < data2.length; j++) {
  357.                 num = data1[i] * data2[j];
  358.                 data[i + j – 1] += num;
  359.             }
  360.         }
  362.         return copy(data);
  363.     }
  365.     public LargeInteger multiply(LargeInteger… nums) {
  366.         byte[] multiplicand = this.data;
  367.         for (LargeInteger num : nums) {
  368.             multiplicand = multiply(multiplicand, num.data);
  369.         }
  370.         return new LargeInteger(multiplicand);
  371.     }
  373.     private static byte[][] divide(byte[] data1, byte[] data2) {
  374.         if (data1 == null || data2 == null) {
  375.             throw new NumberFormatException();
  376.         } else if (compareTo(data2, new byte[2]) == 0) {
  377.             //System.out.println(“data2: ” + toString(data2));
  378.             throw new ArithmeticException();
  379.         }
  381.         //System.out.println(“data1: ” + toString(data1));
  382.         //System.out.println(“data2: ” + toString(data2));
  383.         byte[] bytes1 = abs(copy(data1, –1));
  384.         byte[] bytes2 = abs(copy(data2, –1));
  385.         byte[][] result = new byte[bytes1.length – bytes2.length + 2][2];
  387.         if (bytes1.length < bytes2.length) {
  388.             result[0] = new byte[2];
  389.             result[1] = bytes1;
  390.             return result;
  391.         }
  393.         byte[] result1 = new byte[bytes1.length – bytes2.length + 2];
  394.         result1[0] = (byte) (data1[0] ^ data2[0]);
  396.         for (int i = result1.length – 1; i >= 1; i–) {
  397.             //System.out.println(“bytes1.length : ” + bytes1.length);
  398.             //System.out.println(“bytes2.length : ” + bytes2.length);
  399.             //System.out.println(“i: ” + i);
  400.             byte[] num2 = shift(bytes2, 1);
  401.             byte[] num1 = subarray(bytes1, i – 1, num2.length);
  402.             //System.out.println(“bytes1: ” + toString(bytes1));
  403.             //System.out.println(“num1  : ” + toString(num1));
  404.             //System.out.println(“num2  : ” + toString(num2));
  405.             for (int j = 99; j > 0; j–) {
  406.                 num2 = subtract(num2, bytes2);
  407.                 //System.out.println(“j: ” + j);
  408.                 //System.out.println(“num1: ” + toString(num1));
  409.                 //System.out.println(“num2: ” + toString(num2));
  410.                 if (compareTo(num1, num2) >= 0) {
  411.                     result1[i] = (byte) j;
  412.                     bytes1 = subtract(bytes1, shift(num2, i – 1));
  413.                     break;
  414.                 }
  415.             }
  416.         }
  418.         result[0] = result1;
  420.         bytes1[0] = data1[0];
  421.         result[1] = bytes1;
  423.         return result;
  424.     }
  426.     public LargeInteger divide(LargeInteger… nums) {
  427.         byte[] quotient = this.data;
  428.         for (LargeInteger num : nums) {
  429.             quotient = divide(quotient, num.data)[0];
  430.         }
  431.         return new LargeInteger(quotient);
  432.     }
  434.     public LargeInteger remainder(LargeInteger num) {
  435.         byte[] remainder = divide(this.data, num.data)[1];
  436.         return new LargeInteger(remainder);
  437.     }
  439.     public LargeInteger mod(LargeInteger num) {
  440.         if (num.data == null) {
  441.             throw new NumberFormatException();
  442.         } else if (compareTo(num.data, new byte[2]) <= 0) {
  443.             throw new ArithmeticException();
  444.         }
  446.         byte[] remainder = divide(this.data, num.data)[1];
  447.         //System.out.println(“remainder: ” + toString(remainder));
  448.         return new LargeInteger(remainder[0] == 0x0 ? remainder : add(num.data, remainder));
  449.     }
  451.     public String toString() {
  452.         return toString(data);
  453.     }
  455.     private static String toString(byte[] data) {
  456.         // 验证数据
  457.         if (data == null || data.length <= 1) {
  458.             return null;
  459.         }
  461.         byte[] bytes = copy(data, –1);
  463.         // 获得数据长度
  464.         int length = bytes.length;
  465.         // 设置输出char array及从低位到高位进行处理的索引
  466.         int index = length + length;
  467.         char[] chars = new char[index–];
  469.         for (int i = 1; i < length; i++) {
  470.             // 获得个位数
  471.             int num1 = bytes[i] % 10;
  472.             // 获得十位数
  473.             int num10 = bytes[i] / 10;
  474.             // 保存个位数的字符
  475.             chars[index–] = (char) (bytes[i] % 10 + ‘0’);
  476.             // 保存十位数的字符
  477.             chars[index–] = (char) (bytes[i] / 10 + ‘0’);
  478.         }
  480.         // 若最高位是’0’，截去
  481.         int left = chars[2] == ‘0’ ? 3 : 2;
  482.         // 设置正负符号
  483.         if (bytes[0] == 0x1) {
  484.             chars[–left] = ‘-‘;
  485.         }
  486.         // 返回字符串
  487.         return new String(chars, left, chars.length – left);
  488.     }
  490.     public static void main(String[] args) {
  491.         System.out.println(“题目要求：如果系统要使用超大整数（超过long的范围），请你设计一个数据结构来存储这种超大型数字以及设计一种算法来实现超大整数的加法运算”);
  492.         String str1 = “7363246083486034683046834068860303406834063467340660286027670238403508439035870357057037452750657194361385618374019364013560156019406349215631248654728652462263”;
  493.         String str2 = “-890450326502467843206225206846783926523485737101634543894739462923749016316021651061090106189734913864619057083749828964002176309116341493496”;
  494.         String str3 = “64068204572572309572305203498204327203957234853207432074230653057026723”;
  495.         LargeInteger num1 = new LargeInteger(str1);
  496.         LargeInteger num2 = new LargeInteger(str2);
  497.         LargeInteger num3 = new LargeInteger(str3);
  498.         BigInteger int1 = new BigInteger(str1);
  499.         BigInteger int2 = new BigInteger(str2);
  500.         BigInteger int3 = new BigInteger(str3);
  501.         //System.out.println(“num2 : ” + num2);
  502.         //System.out.println(“shift: ” + toString(shift(num2.data, 1)));
  503.         //System.out.println(“subarray: ” + toString(subarray(num2.data, 1, 5)));
  504.         System.out.println(“result1: “ + num1);
  505.         System.out.println(“result1: “ + int1);
  506.         System.out.println(“result2: “ + num2);
  507.         System.out.println(“result2: “ + int2);
  508.         System.out.println(“negate: “ + num1.negate());
  509.         System.out.println(“negate: “ + int1.negate());
  510.         System.out.println(“abs: “ + num2.abs());
  511.         System.out.println(“abs: “ + int2.abs());
  512.         System.out.println(“add1: “ + num1.add(num2));
  513.         System.out.println(“add1: “ + int1.add(int2));
  514.         System.out.println(“add2: “ + num1.add(num2, num2, num2));
  515.         System.out.println(“add2: “ + int1.add(int2).add(int2).add(int2));
  516.         System.out.println(“add3: “ + num2.add(num2.negate()));
  517.         System.out.println(“add3: “ + int2.add(int2.negate()));
  518.         System.out.println(“add4: “ + num2.add(num3.negate()));
  519.         System.out.println(“add4: “ + int2.add(int3.negate()));
  520.         System.out.println(“add5: “ + num2.add(num2));
  521.         System.out.println(“add5: “ + int2.add(int2));
  522.         System.out.println(“subtract4: “ + num2.subtract(num3));
  523.         System.out.println(“subtract4: “ + int2.subtract(int3));
  524.         System.out.println(“subtract5: “ + (new LargeInteger(“10000”)).subtract((new LargeInteger(“1”))));
  525.         System.out.println(“subtract5: “ + (new BigInteger(“10000”)).subtract((new BigInteger(“1”))));
  526.         System.out.println(“subtract6: “ + (new LargeInteger(“10000”)).subtract((new LargeInteger(“9999”))));
  527.         System.out.println(“subtract6: “ + (new BigInteger(“10000”)).subtract((new BigInteger(“9999”))));
  528.         System.out.println(“subtract7: “ + (new LargeInteger(“1”)).subtract((new LargeInteger(“10000”))));
  529.         System.out.println(“subtract7: “ + (new BigInteger(“1”)).subtract((new BigInteger(“10000”))));
  530.         System.out.println(“subtract8: “ + (new LargeInteger(“9999”)).subtract((new LargeInteger(“10000”))));
  531.         System.out.println(“subtract8: “ + (new BigInteger(“9999”)).subtract((new BigInteger(“10000”))));
  532.         System.out.println(“subtract9: “ + (new LargeInteger(“-9999”)).subtract((new LargeInteger(“10000”))));
  533.         System.out.println(“subtract9: “ + (new BigInteger(“-9999”)).subtract((new BigInteger(“10000”))));
  534.         System.out.println(“multiply1: “ + num1.multiply(num2));
  535.         System.out.println(“multiply1: “ + int1.multiply(int2));
  536.         System.out.println(“multiply2: “ + num1.multiply(num2, num3));
  537.         System.out.println(“multiply2: “ + int1.multiply(int2).multiply(int3));
  538.         System.out.println(“divide5: “ + (new LargeInteger(“130000”)).divide(new LargeInteger(“4”)));
  539.         System.out.println(“divide5: “ + (new BigInteger(“130000”)).divide(new BigInteger(“4”)));
  540.         System.out.println(“divide6: “ + (new LargeInteger(“-13”)).divide(new LargeInteger(“4”)));
  541.         System.out.println(“divide6: “ + (new BigInteger(“-13”)).divide(new BigInteger(“4”)));
  542.         System.out.println(“divide7: “ + (new LargeInteger(“13”)).divide(new LargeInteger(“-4”)));
  543.         System.out.println(“divide7: “ + (new BigInteger(“13”)).divide(new BigInteger(“-4”)));
  544.         System.out.println(“divide8: “ + (new LargeInteger(“-13”)).divide(new LargeInteger(“-4”)));
  545.         System.out.println(“divide8: “ + (new BigInteger(“-13”)).divide(new BigInteger(“-4”)));
  546.         System.out.println(“mod5: “ + (new LargeInteger(“13”)).mod(new LargeInteger(“4”)));
  547.         System.out.println(“mod5: “ + (new BigInteger(“13”)).mod(new BigInteger(“4”)));
  548.         System.out.println(“mod6: “ + (new LargeInteger(“-13”)).mod(new LargeInteger(“4”)));
  549.         System.out.println(“mod6: “ + (new BigInteger(“-13”)).mod(new BigInteger(“4”)));
  550.         System.out.println(“divide1: “ + num1.divide(num1));
  551.         System.out.println(“divide1: “ + int1.divide(int1));
  552.         System.out.println(“divide2: “ + int1.divide(int1.negate()));
  553.         System.out.println(“divide2: “ + num1.divide(num1.negate()));
  554.         System.out.println(“divide3: “ + num2.divide(num2.negate().add(num3)));
  555.         System.out.println(“divide3: “ + int2.divide(int2.negate().add(int3)));
  556.         System.out.println(“divide4: “ + num2.divide(num2.negate().subtract(num3)));
  557.         System.out.println(“divide4: “ + int2.divide(int2.negate().subtract(int3)));
  558.         System.out.println(“mod1: “ + num2.mod(num3));
  559.         System.out.println(“mod1: “ + int2.mod(int3));
  560.         System.out.println(“mod2: “ + num2.negate().mod(num3));
  561.         System.out.println(“mod2: “ + int2.negate().mod(int3));
  562.     }
  563. }
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/160065.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权 正版激活】： 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

赞 (0)
全栈程序员-用户IM全栈程序员-用户IM
0 0


相关推荐

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号