盘点前端、后端工具包

Bertha 。 2022-11-29 12:39 130阅读 0赞

**1、视频API或者播放器API**

API地址：[https://h5player.bytedance.com/api/][https_h5player.bytedance.com_api]

开源地址：[https://github.com/bytedance/xgplayer][https_github.com_bytedance_xgplayer]

安装: `npm install xgplayer`  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDQ3MzAx_size_16_color_FFFFFF_t_70_pic_center]  
**2、位运算工具类**

import java.math.BigDecimal;
 import java.math.RoundingMode;
 
 public class BitUtils { 
 
 /** * 获取运算数指定位置的值 * 例如： 0000 1011 获取其第 0 位的值为 1, 第 2 位 的值为 0 * * @param source 需要运算的数 * @param pos 指定位置 (0<=pos<=7) * @return 指定位置的值(0 or 1) */
 public static byte getBitValue(byte source, int pos) { 
 return (byte) ((source >> pos) & 1);
 }
 
 /** * 将运算数指定位置的值置为指定值 * 例: 0000 1011 需要更新为 0000 1111, 即第 2 位的值需要置为 1 * * @param source 需要运算的数 * @param pos 指定位置 (0<=pos<=7) * @param value 只能取值为 0, 或 1, 所有大于0的值作为1处理, 所有小于0的值作为0处理 * @return 运算后的结果数 */
 public static byte setBitValue(byte source, int pos, byte value) { 
 byte mask = (byte) (1 << pos);
 if (value > 0) { 
 source |= mask;
 } else { 
 source &= (~mask);
 }
 return source;
 }
 
 /** * 将运算数指定位置取反值 * 例： 0000 1011 指定第 3 位取反, 结果为 0000 0011; 指定第2位取反, 结果为 0000 1111 * * @param source 指定位置 (0<=pos<=7) * @param pos * @return 运算后的结果数 */
 public static byte reverseBitValue(byte source, int pos) { 
 byte mask = (byte) (1 << pos);
 return (byte) (source ^ mask);
 }
 
 /** * 检查运算数的指定位置是否为1 * * @param source 需要运算的数 * @param pos 指定位置 (0<=pos<=7) * @return true 表示指定位置值为1, false 表示指定位置值为 0 */
 public static boolean checkBitValue(byte source, int pos) { 
 source = (byte) (source >>> pos);
 return (source & 1) == 1;
 }
 
 
 public static int turnOffRightmost1(final int input) { 
 return input & (input - 1);
 }
 
 public static int turnOnRightmost0(final int input) { 
 return input | (input + 1);
 }
 
 public static int turnOffTrailing1s(final int input) { 
 return input & (input + 1);
 }
 
 public static int turnOnTrailing0s(final int input) { 
 return input | (input - 1);
 }
 
 public static int markPositionOfRightmost0With1(final int input) { 
 return ~input & (input + 1);
 }
 
 public static int markPositionOfRightmost1With0(final int input) { 
 return ~input | (input - 1);
 }
 
 public static int createWordWith1sAtPositionsOfTrailing0s(final int input) { 
 return ~input & (input - 1);
 }
 
 public static int createWordWith0sAtPositionsOfTrailing1s(final int input) { 
 return ~input | (input + 1);
 }
 
 public static int markPositionOfRightmost1BitWith1(final int input) { 
 return input & (input * -1);
 }
 
 public static int markRightmost1WithContiguous1s(final int input) { 
 return input ^ (input - 1);
 }
 
 public static int markRightmost0WithContiguous1s(final int input) { 
 return input ^ (input + 1);
 }
 
 public static int clearRightmostContiguousStringOf1s(final int input) { 
 return (markPositionOfRightmost1BitWith1(input) + input) & input;
 }
 
 public static boolean isBaseTwoAMultipleOfBaseTwo(final int baseTwoB, final int baseTwoA) { 
 if (baseTwoB < baseTwoA) { 
 throw new IllegalArgumentException();
 }
 if (baseTwoA < 0) { 
 throw new IllegalArgumentException();
 }
 if ((clearRightmostContiguousStringOf1s(baseTwoB) | clearRightmostContiguousStringOf1s(baseTwoA)) == 0){ 
 return true;
 }
 
 return false;
 }
 
 public static int abs(final int input) { 
 int y = input >> 31;
 return (input ^ y) - y;
 }
 
 public static int nabs(final int input) { 
 int y = input >> 31;
 return y - (input ^ y);
 }
 
 
 /** * 计算两个无符号整数的四舍五入平均值 */
 public static int floorAvg(final int x, final int y) { 
 return ((x & y) + ((x ^ y) >>> 1));
 }
 
 /** * 计算两个无符号整数的四舍五入平均值 */
 public static int ceilingAvg(final int x, final int y) { 
 return ((x | y) - ((x ^ y) >>> 1));
 }
 
 public static int threeValueCompare(final int x, final int y) { 
 return (lt(y, x) - lt(x, y));
 }
 
 public static int eq(final int x, final int y) { 
 return (abs(x - y) - 1) >>> 31;
 }
 
 public static int ne(final int x, final int y) { 
 return nabs(x - y) >>> 31;
 }
 
 public static int lt(final int x, final int y) { 
 return ((x - y) ^ ((x ^ y) & ((x - y) ^ x))) >>> 31;
 }
 
 public static int gt(final int x, final int y) { 
 return lt(y, x);
 }
 
 public static int le(final int x, final int y) { 
 return ((x | ~y) & ((x ^ y) | (~(y - x)))) >>> 31;
 }
 
 public static int ge(final int x, final int y) { 
 return le(y, x);
 }
 
 public static int doz(final int x, final int y) { 
 if (x >= y ) { 
 return x - y;
 }
 return 0;
 }
 
 /** * 正负数都包含在里面，不用分开处理 * @param a * @param b * @return */
 private static int binaryAdd(int a, int b) { 
 // 不考虑进位的和
 int s = a ^ b;
 // 进位
 int jw = a & b;
 // 下面是 s + (jw<<1) 的计算
 while (jw != 0) { 
 // 保存s + (jw<<1)的进位
 int jw_temp = s & (jw << 1);
 // 保存s + (jw<<1)的和，不包含进位
 s = s ^ (jw << 1);
 // 赋值之后，还是计算s+(jw<<1)，依旧是计算：进位以及不进位的和，当进位为0时，不进位的和就是最终的计算结果
 jw = jw_temp;
 }
 return s;
 }
 
 /** * 计算a*b * @param a * @param b * @return */
 private static int binaryMulti(int a, int b) { 
 if (a == 0 || b == 0) { 
 return 0;
 }
 int res = 0;
 int base = a;
 while (b != 0) { 
 if ((b & 1) != 0) { 
 res = binaryAdd(res, base);
 }
 b >>= 1;
 base <<= 1;
 }
 
 return res;
 }
 
 /** * 计算a*b * @param a * @param b * @return */
 private static int binaryMulti2(int a, int b) { 
 if (a == 0 || b == 0) { 
 return 0;
 }
 if(b>a) { 
 int tmp = a;
 a = b;
 b = tmp;
 }
 int res = 0;
 int shift = 0;
 while(b!=0) { 
 if((b&1)!=0) { 
 res += (a<<shift);
 }
 shift += 1;
 b >>= 1;
 }
 return res;
 }
 
 /** * 计算a/b * @param a * @param b * @return * @throws Exception */
 private static int binaryDiv(int a, int b) throws Exception { 
 if (b == 0) { 
 throw new Exception("分母不能为0");
 }
 boolean flag = false;
 if ((a ^ b) < 0) { 
 // 表示a,b异号；
 flag = true;
 }
 a = a >= 0 ? a : -a;
 b = b >= 0 ? b : -b;
 
 int res = 0;
 //依次获取a的最高位
 int aux = 0;
 // 用来依次获取分母的最高位bit
 int mask = 0x40_00_00_00;
 while (mask != 0) { 
 // 这里注意处理，尤其是后半部分表达式，很容易写成aux
 aux = (aux << 1) | ((a & mask) == 0 ? 0 : 1);
 // = (aux<<1) |
 // (a&mask);
 if (aux >= b) { 
 res = (res << 1) | 1;
 aux -= b;
 } else { 
 res = (res << 1) | 0;
 }
 mask >>= 1;
 }
 return flag ? -res : res;
 }
 
 /** * 加 * @param a * @param b * @return */
 public static int add(int a, int b) { 
 if (b == 0) { 
 return a;
 } else { 
 return add(a ^ b, (a & b) << 1);
 }
 }
 
 /** * 加 * @param a * @param b * @return */
 public static int add2(int a, int b) { 
 int sum = a;
 while (b != 0) { 
 sum = a ^ b;
 b = (a & b) << 1;
 a = sum;
 }
 return sum;
 }
 
 /** * 加 * @param a * @param b * @return */
 public int add3(int a, int b) { 
 while (b != 0) { 
 int j = a ^ b;
 int k = (a & b) << 1;
 a = j;
 b = k;
 }
 return a;
 }
 /** * 减 * @param a * @param b * @return */
 public static int minus(int a, int b) { 
 return add(a, add(~b, 1));
 }
 
 /** * 乘 * @param a * @param b * @return */
 public static int multiply(int a, int b) { 
 //将乘数和被乘数都取绝对值
 int A = a < 0 ? add(~a, 1) : a;
 int B = b < 0 ? add(~b, 1) : b;
 //计算绝对值的乘积
 int P = 0;
 while (B != 0) { 
 //取乘数的二进制的最后一位，0 or 1
 if ((B & 1) != 0) { 
 P = add(P, A);
 }
 A = A << 1;
 B = B >> 1;
 }
 //计算乘积的符号
 if ((a ^ b) < 0) { 
 P = add(~P, 1);
 }
 return P;
 }
 
 /** * 除 * @param a * @param b * @return */
 public static int[] divide(int a, int b) { 
 //对被除数和除数取绝对值
 int A = a < 0 ? add(~a, 1) : a;
 int B = b < 0 ? add(~b, 1) : b;
 //对被除数和除数的绝对值求商
 // 余数C
 int C = A;
 // 商N
 int N = 0;
 while (C >= B) { 
 // C-B
 C = minus(C, B);
 // N+1
 N = add(N, 1);
 }
 // 求商的符号
 if ((a ^ b) < 0) { 
 N = add(~N, 1);
 }
 // 求余数的符合
 if (a < 0) { 
 C = add(~C, 1);
 }
 return new int[]{ N, C};
 }
 
 /** * 除 * @param a * @param b * @return */
 public static int[] divide2(int a, int b) { 
 // 对被除数和除数取绝对值
 int A = a < 0 ? add(~a, 1) : a;
 int B = b < 0 ? add(~b, 1) : b;
 // 商 N
 int N = 0;
 for (int i = 31; i >= 0; i--) { 
 // 未使用A>=(B<<i)进行判断，因为只有左移B时舍弃的高位不包含1，才相当于该数乘以2的i次方.
 // A ÷ 2^i >= B
 if ((A >> i) >= B) { 
 // N = N + 2^i
 N += (1 << i);
 // A = A - B*2^i
 A -= (B << i);
 }
 }
 // 余数C
 int C = A;
 // 求商的符号
 if ((a ^ b) < 0) { 
 N = add(~N, 1);
 }
 // 求余数的符号
 if (a < 0) { 
 C = add(~C, 1);
 }
 return new int[]{ N, C};
 }
 
 
 /** * 除法计算 * * @param x 被除数 * @param y 除数 * @return 结果，保留两位小数 */
 public static BigDecimal divide(long x, long y) { 
 if (y == 0) { 
 return BigDecimal.ZERO;
 }
 return BigDecimal.valueOf(x).divide(BigDecimal.valueOf(y), 2, RoundingMode.HALF_UP);
 }
 
 /** * 除法计算 * * @param x 被除数 * @param y 除数 * @param scale 精确位数 * @return 结果，保留两位小数 */
 public static BigDecimal divide(long x, long y, int scale) { 
 if (y == 0) { 
 return BigDecimal.ZERO;
 }
 return BigDecimal.valueOf(x).divide(BigDecimal.valueOf(y), scale, RoundingMode.HALF_UP);
 }
 
 /** * 除法计算 * * @param x 被除数 * @param y 除数 * @param scale 精确位数 * @return 结果，保留两位小数 */
 public static BigDecimal divide(BigDecimal x, BigDecimal y, int scale) { 
 if (y.intValue() == 0) { 
 return BigDecimal.ZERO;
 }
 return x.divide(y, scale, RoundingMode.HALF_UP);
 }
 
 /** * 毫秒数转换成秒 * * @param val 毫秒数 * @return 对应的秒 */
 public static BigDecimal millis2Seconds(BigDecimal val) { 
 return val.divide(BigDecimal.valueOf(1000), 2, RoundingMode.HALF_UP);
 }
 
 /** * 获取百分比值 * * @param val 值 * @return 乘以100后的值 */
 public static BigDecimal getPercent(BigDecimal val) { 
 if (val == null) { 
 return BigDecimal.ZERO;
 }
 return val.multiply(BigDecimal.valueOf(100));
 }
 
 }

**3、封装了大多数nlp项目中常用工具**

开源地址：[https://github.com/NLPchina/nlp-lang][https_github.com_NLPchina_nlp-lang]

依赖：

<dependency>
 <groupId>org.nlpcn</groupId>
 <artifactId>nlp-lang</artifactId>
 <version>1.7.6</version>
 </dependency>

4、待续。。。

[https_h5player.bytedance.com_api]: https://h5player.bytedance.com/api/
[https_github.com_bytedance_xgplayer]: https://github.com/bytedance/xgplayer
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDQ3MzAx_size_16_color_FFFFFF_t_70_pic_center]: /images/20221124/0d56817c202447fdb609b1b90aa2d29f.png
[https_github.com_NLPchina_nlp-lang]: https://github.com/NLPchina/nlp-lang