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


相关推荐

  • oracle9i如何卸载,教你怎么样卸载Oracle9i[通俗易懂]

    oracle9i如何卸载,教你怎么样卸载Oracle9i[通俗易懂]

    oracle9i如何卸载,教你怎么样卸载Oracle9i[通俗易懂]欢迎进入Oracle社区论坛，与200万技术人员互动交流>>进入在win2000企业版操作系统下，卸载Oracle9i：1、停止所有Oracle服务2、删除注册表中的所有关于Oracle项(1)在HKEY_LOCAL_MACHINE\SOFTWARE下，删除Oracle目录(2)在HKEY_LOCAL_MACHINE\SYSTE欢迎进入Oracle社区论坛，与200万技…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年10月20日
  • IntelliJ idea 必备 好用 优秀 插件 idea

    IntelliJ idea 必备 好用 优秀 插件

    IntelliJ idea 必备 好用 优秀 插件1、AtomMaterialICons这是一个icon图片插件，有一个特别牛的功能就是可以优化idea流畅度，不知道是什么原理，现在这个插件成为了我必备插件2、FileExpander有了这个插件，有些小伙伴平时用的Jad工具就可以扔了，它能在Idea里直接打开Jar包3、GitToolBox这款插件现在我几乎离不开它。他能在项目上提示你还有多少文件没提交，远程还有多少文件没更新下来。还能在每一行代码上提示上次提交的时间。查版本提交问题的时候尤其方便4、MavenHelper

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年10月9日
  • Java static修饰方法

    Java static修饰方法

    Java static修饰方法一、static修饰方法1、与静态变量一样，我们也可以使用static修饰方法，称为静态方法或类方法。其实之前我们一直写的main方法就是静态方法。调用静态方法可通过类名访问或者对象方法。例如：publicclassStaticMethod{//使用static关键字修饰静态方法publicstaticvoidprint(){System.out.println(

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年7月17日
  • windows10搭建nas详细(docker搭建开发环境)

    windows10搭建nas详细(docker搭建开发环境)

    Windows下ODrive固件开发环境搭建以下内容适用于希望修改ODrive固件的开发人员。因此，它假定您了解诸如如何使用Git，什么是编译器之类的知识。如果这听起来很陌生，以下内容对您来说可能不适合。文章目录Windows下ODrive固件开发环境搭建1准备要用到的开发工具2安装Python3安装ST-Link/V2Drivers4安装GitforWindo…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年4月17日
  • VS 环境使用MySQL Connector C 6.1 连接数据库

    VS 环境使用MySQL Connector C 6.1 连接数据库

    VS 环境使用MySQL Connector C 6.1 连接数据库下载MySQLConnector/C，根据你的系统版本选择下载ZIPARCHIVE，下载链接 配置附加目录和库目录 项目–>属性–>配置属性–>VC++目录-包含目录中加入mysqlConnectC文件的include目录(根据自己的目录设置，此处测试使用了绝对路径) C:\Users\kelvin\Downloads\mysql-connector-c-…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年7月15日
  • 2022年Web前端入门的自学路线[通俗易懂]

    2022年Web前端入门的自学路线[通俗易懂]

    2022年Web前端入门的自学路线[通俗易懂]新手入门前端，需要学习的基础内容有很多。

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年7月3日

发表回复

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

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