BigDecimal使用stream获取最大值 Java

转载

doscommand 2024-12-12 14:19:41

文章标签 数组执行环境作用域 文章分类 Java 后端开发

String

所有的API都无法修改原字符串，只能返回新字符串

API：

大小写转换
str.toUpperCase();
str.toLowerCase();
获取指定字符串位置
str.charAt(); 得到下标 str[i]
str.charCodeAt(i); 得到字符串编码
选取字符串
str.slice(start,end+1); 支出负数
str.substring(start,end+1); 不支持负数
str.substr(statr,n); 含头不含尾
查找关键字

查找关键字出现的位置
str.indexOf("关键字",from); 如果找不到返回-1
优点:可以指定开始位置，可以查找所有
缺点:不支持正则，一次只能找一个关键词
专门查找最后一个关键词的下标，str.lastIndexOf("关键词")
判断是否包含符合条件的关键词
str.search(/正则表达式/); 如果找不到就返回-1，不支持使用g
优点:支持正则
缺点:不支持设置开始位置，只能找第一个，不能找到所有
只能返回关键词位置，不能返回关键词内容
获取所有关键词内容
str.match(/正则表达式/g); 返回包含所有关键词内容的数组，如果找不到返回null
优点:返回所有关键词的内容
缺点:无法返回关键词的下标
既能获取下标，又能获取内容
regexp.exec(str)

替换
str.splice(/正则表达式/ig,"替换值"); 忽略大小写
切割
简单切割 str.split("分隔符")
复杂切割 str.split(/正则表达式/)

Number

极大极小的数值，可以用e表示

如果数值超出javaScript数值范围，会被自动转换为Infinity值（有正负之分）;infinity不能参与下次计算

确定一个数值是不是有穷的，可使用isFinite()函数

NaN表示一个本来要返回数值的操作数未返回数值的情况，这样不会抛出错误
特点:
1.任何涉及NaN操作 ( 如：NaN/10 ) 都会返回NaN
2.NaN与任何值都不相等，包括NaN本身，如：alert（NaN==NaN）//false
isNaN()；接受一个参数，判断这个参数是否“不是数值”

Boolean

Null&&Undefined

null
表示一个空指针，这也是使用typeof操作符检测null值时会返回object的原因
定义一个变量在将来保存对象，那么最好将改变量初始化为null
undefined
使用var声明变量但未对其加以初始化时，这个变量就是Undefined
比较
null===undefined //true
尽管两者有这样的关系，但是它们的用途完全不同，无论什么情况下都没有必要把一个变量显示的设置为Undefined，而null就应该明确的让该变量保存为null值，这样做不仅可以提现null空对象指针的惯例，还有助于进一步区分null和undefined

Object

1、Arrary

什么是
内存中连续存储多个数据的存储控件，再起一个名字
为什么
连续存储的一组数据，可大量提高操作速度
何时
只要存储多个数据都要用数组
如何

创建

创建空数组

var arr = []
var arr = new Array()

创建数组并初始化数组元素

var arr = [值1，只2，...]
var arr = new Array(值1，值2，...)

创建n个空元素数组

var arr = new Array(值1，值2，...)

访问
arr[i]
用法和单个变量完全一样
三个不限制：
不限制元素个数，可以随时添加元素；
不限制下标越界，取值：不报错，返回undefined；赋值：不报错，自动在指定位置添加元素
不限制元素数据类型
关联数组

什么是
可自定义下标名称的数组
为什么
索引数组没有意义，只能通过遍历查找指定的元素内容，查找速度受数组元素个数和元素位置影响
何时
希望快速查找某个元素时，不受元素个数和元素位置影响
如何

创建

var hash = [];
hash[“下标名称”]="值（value）"

访问

hash["下标名称"]

特点
length始终为0
无法使用索引数组API
遍历:

for(var key in hash){
	key //下标名
	hash[key] //元素值
}

固定套路，仅获取hash中所有key

数组API

转字符串

//将arr中每个元素转为字符串，用逗号连接
String(arr)

//自定义连接符连接
arr.join("连接符")

//无缝拼接
arr.join("")

//判断空数组
arr.join("")===""

拼接和选取

//拼接
//无权修改原数组，只能返回新数组，可自动打散数组类型的数值为单个元素，再拼接
arr.concat()


//选取
//无权修改原数组，只能返回新数组，含头不含尾
arr.slice(start,end+1)

修改数组

//删除元素
//直接修改原数组，返回值时被删除的元素组成的临时数组
arr.splice(start,end+1)

//插入数组
//在arr中插入新值原始位置及后的元素顺序后移
//不支持打散数组类型的数值，如果插入数组，会变成二维数组
arr.splice(start,0,值1,值2...)

//替换
//先删除start位置的n个元素，再在start位置插入新元素
//删除的个数跟插入的个数不一定要一致
arr.splice(start,n,值1,值2...)

//固定用法
//广告轮播
//移除开头的n个元素到结尾
imgs = imgs.concat(imgs.splice(0,n))

//移除结尾的n个元素到开头
imgs = imgs.splice(imgs.length-n,n).concat(imgs)

翻转

arr.reverse()

排序

//将arr中每个元素转为字符串，再按升序排序
arr.sort()

//问题：只能按字符串升序排序
//解决：自定义比较器
function　compare(a,b){
	return a-b 
};

arr.sort(compare);


//降序排列
//将比较器函数的正负号颠倒就好了
function　compare(a,b){
	return b-a
};

栈和队列
栈：一端封闭，只能另一端进出的数组

//强调：js中没有栈和队列的结构，都是用普通数组模拟
//结尾出入栈
//入栈
arr.push()
//出栈
arr.pop()

//开头出入栈
//入栈
arr.unshift()
//出栈
arr.shift()

队列：只能一端进入，另一端出的数组

//结尾入
arr.push()
//开头出
arr.shift()

二维数组
二维数组：数组中的元素内容，又是一个子数组

//创建
var arr = []
arr[i] = {值1,值2,值3...}


var arr = [
	{值1,值2,值3...},
	{值1,值2,值3...}
]

//访问
arr[r][c]

//遍历
for(var r=0;r<arr.length;r++){
	for(var c=0;c<arr[r].length;c++){
		arr[r][c] //当前元素
	}
}

2、Function

创建

//1.
function 函数名（参数列表）{
	函数体；
	return 返回值
}
//2.
var 函数名 = function（参数列表）{
	函数体；
	return 返回值
}
//3.
var 函数名 = new Function（“参数1”，“参数2”，...）{
	函数体；
	return 返回值
}

重载
函数名相同，函数的参数列表不同(包括参数个数和参数类型)，根据参数的不同去执行不同的操作。
我们举个例子看看

function overload(a){
    console.log('一个参数')
}

function overload(a,b){
    console.log('两个参数')
}

// 在支持重载的编程语言中，比如 java
overload(1);         //一个参数
overload(1,2);    //两个参数


// 在 JavaScript 中
overload(1);         //两个参数
overload(1,2);    //两个参数

在JavaScript中，同一个作用域，出现两个名字一样的函数，后面的会覆盖前面的，所以 JavaScript 没有真正意义的重载。

但是有各种办法，能在 JavaScript 中模拟实现重载的效果。

一、借助流程控制语句，通过 arguments 对象来实现

arguments 对象，是函数内部的一个类数组对象，它里面保存着调用函数时，传递给函数的所有参数。

function overload () {
  if (arguments.length === 1) {
    console.log('一个参数')
  }
  if (arguments.length === 2) {
    console.log('两个参数')
  }
}

overload(1);      //一个参数
overload(1, 2);  //两个参数

这个例子非常简单，就是通过判断 arguments 对象的 length 属性来确定有几个参数，然后执行什么操作。

但是参数少的情况下，还好，如果参数多一些，if 判断就需要写好多，就麻烦了。

二、巧用闭包特性

JQuery之父John Resig写的《secrets of the JavaScript ninja》找到了一个绝佳巧妙的方法！那种方法充分的利用了闭包的特性！

在介绍这个方法之前，我们先来看看外国人名字组成哈，比如，John Resig，John是first-name，Resig是last-name，就相当于我们的姓名由姓和名组成一样。

我们现在有这样的一个需求，有一个people对象，里面存着一些人名，如下：

var people = {
  values: ["Dean Edwards", "Sam Stephenson", "Alex Russell", "Dean Tom"]
};

我们希望people对象拥有一个find方法，当不传任何参数时，就会把people.values里面的所有元素返回来；当传一个参数时,就把first-name跟这个参数匹配的元素返回来；当传两个参数时，则把first-name和last-name都匹配的才返回来。因为find方法是根据参数的个数不同而执行不同的操作的，所以，我们希望有一个addMethod方法，能够如下的为people添加find的重载：

addMethod(people, "find", function() {}); /*不传参*/
addMethod(people, "find", function(a) {}); /*传一个*/
addMethod(people, "find", function(a, b) {}); /*传两个*/

这时候问题来了，这个全局的addMethod方法该怎么实现呢？John Resig的实现方法如下，代码不长，但是非常的巧妙：

function addMethod(object, name, fn) {
　　var old = object[name]; //把前一次添加的方法存在一个临时变量old里面
　　object[name] = function() { // 重写了object[name]的方法
　　　　// 如果调用object[name]方法时，传入的参数个数跟预期的一致，则直接调用
　　　　if(fn.length === arguments.length) {
　　　　　　return fn.apply(this, arguments);
　　　　// 否则，判断old是否是函数，如果是，就调用old
　　　　} else if(typeof old === "function") {
　　　　　　return old.apply(this, arguments);
　　　　}
　　}
}

现在，我们一起来分析一个这个addMethod函数，它接收3个参数，第一个为要绑定方法的对象，第二个为绑定的方法名称，第三个为需要绑定的方法（一个匿名函数）。函数体的的分析已经在注释里面了。

OK，现在这个addMethod方法已经实现了，我们接下来就实现people.find的重载啦！全部代码如下：

//addMethod
function addMethod(object, name, fn) {
　　var old = object[name];
　　object[name] = function() {
　　　　if(fn.length === arguments.length) {
　　　　　　return fn.apply(this, arguments);
　　　　} else if(typeof old === "function") {
　　　　　　return old.apply(this, arguments);
　　　　}
　　}
}
 
 
var people = {
　　values: ["Dean Edwards", "Alex Russell", "Dean Tom"]
};
 
/* 下面开始通过addMethod来实现对people.find方法的重载 */
 
// 不传参数时，返回peopld.values里面的所有元素
addMethod(people, "find", function() {
　　return this.values;
});
 
// 传一个参数时，按first-name的匹配进行返回
addMethod(people, "find", function(firstName) {
　　var ret = [];
　　for(var i = 0; i < this.values.length; i++) {
　　　　if(this.values[i].indexOf(firstName) === 0) {
　　　　　　ret.push(this.values[i]);
　　　　}
　　}
　　return ret;
});
 
// 传两个参数时，返回first-name和last-name都匹配的元素
addMethod(people, "find", function(firstName, lastName) {
　　var ret = [];
　　for(var i = 0; i < this.values.length; i++) {
　　　　if(this.values[i] === (firstName + " " + lastName)) {
　　　　　　ret.push(this.values[i]);
　　　　}
　　}
　　return ret;
});
 
// 测试：
console.log(people.find()); //["Dean Edwards", "Alex Russell", "Dean Tom"]
console.log(people.find("Dean")); //["Dean Edwards", "Dean Tom"]
console.log(people.find("Dean Edwards")); //["Dean Edwards"]

三、巧用引用类型特性

核心思想：由于ECMAScript函数是一种引用类型对象，可扩展属性与方法。借此通过创建一个容器用于存储要重载的函数，并将容器挂载到代理函数上以便后续访问，而代理函数利用闭包特性访问容器。
重载顺序：首先查找参数类型匹配的函数，其次查找参数个数匹配的函数。
存储格式：键值对，键名由逗号与参数个数或参数类型组成，键值为要重载的函数，如下：

{
  ',0': function(){/* code */},
  ',1': function(a){/* code */},
  ',string,number': function(a,b){/* code */}
}

工具函数被调用时：

先判断是否已重载过，若有，直接将要重载的函数按格式存入容器；
若未重载过，则创建一个容器变量；
判断未重载前的值是否为一个函数，若是，则以逗号+参数个数的格式存入容器；
将要重载的函数存入容器；
代理原函数，并将容器挂载到代理函数上；
当代理函数被调用时，将依次查找容器中匹配的函数并调用。

/**
 * 重载工具函数
 * @param {Object} ctx - 上下文
 * @param {String} name - 函数名
 * @param {Function} fn - 函数体
 * @param {String} type - 参数类型
 * @author 范围兄 <ambit_tsai@qq.com>
 * @example 不指定参数类型
 *  overload(obj, 'do', function(){...});
 *  overload(obj, 'do', function(a){...});
 * @example 指定参数类型
 *  overload(obj, 'do', function(a,b){...}, 'string,number');
 */
function overload(ctx, name, fn, type){
  type = type? type.trim().toLowerCase(): fn.length;
  // 已重载过
  if(typeof ctx[name]==='function' && typeof ctx[name]._$fnMap==='object'){
    ctx[name]._$fnMap[','+type] = fn;	// 将fn存入_$fnMap
    return;
  }
  // 未重载过
  var fnMap = {};   // 容器
  if(typeof ctx[name] === 'function'){
    // 若ctx[name]是一个函数，则存入容器
    fnMap[','+ctx[name].length] = ctx[name];
  }
  fnMap[','+type] = fn;
  ctx[name] = function overloading(){   // 代理
    var args = arguments, 
        len = args.length, 
        type, i;
    for(i=0, type=''; i<len; ++i){  // 计算参数类型
      type += ',' + typeof args[i];
    }
    // 依次匹配：参数类型->参数个数
    if(fnMap[type]) return fnMap[type].apply(this, args);
    if(fnMap[','+len]) return fnMap[','+len].apply(this, args);
    throw 'Overload: no matched function';
  };
  ctx[name]._$fnMap = fnMap;   // 将fnMap挂载到代理上
}

匿名函数
没有实际名字的函数

//自调函数
//自己调用自己，调完后立即释放
(function (str){
	console.log(str)
})(str)

//函数表达式
let fn = function(str){
	console.log(str)
}
fn(str)

//模仿块级作用域
function fn(){
    (function(){
        var la="啦啦啦！";
    })();
    console.log(la);//报错---la is not defined
}
fn();

匿名函数的作用：

1、通过匿名函数可以实现闭包，关于闭包在后面的文章中会重点讲解。在这里简单介绍一下：闭包是可以访问在函数作用域内定义的变量的函数。若要创建一个闭包，往往都需要用到匿名函数。

2、模拟块级作用域，减少全局变量。执行完匿名函数，存储在内存中相对应的变量会被销毁，从而节省内存。再者，在大型多人开发的项目中，使用块级作用域，会大大降低命名冲突的问题，从而避免产生灾难性的后果。自此开发者再也不必担心搞乱全局作用域了。

作用域（scope）与作用域链（scope chain）

函数生命周期

开始执行前:
创建执行环境栈(数组): 临时保存正在执行的函数的执行环境
向执行环境栈中压入第一个默认函数main()

创建全局作用域对象window

定义函数时:
创建函数对象，封装函数定义
声明函数名变量，引用函数对象
函数对象的scope属性引用回创建函数时的作用域
调用函数时:
ECS（执行环境栈）中压入一个新的元素(执行环境)记录新函数的调用
创建一个活动对象，保存本次函数调用用到的局部变量
ECS（执行环境栈）中的新执行环境元素，引用活动对象
活动对象中的parent属性引用函数的scope指向的父级作用域对象
执行过程中: 优先使用活动对象中的局部变量
局部没有，才延parent向父级作用域找
函数调用后:
执行环境栈中本次函数的执行环境出栈
导致活动对象被释放
导致局部变量一同释放

图示：

前三步

作用域
作用域就是代码的执行环境，全局执行环境就是全局作用域，函数的执行环境就是私有作用域，它们都是栈内存。
执行环境定义了变量或函数有权访问的其他数据，决定了它们各自的行为。每个执行环境都有一个与之关联的变量对象，环境中定义的所有变量和函数都保存在这个对象中。虽然我们编写的代码无法访问这个对象，但解析器在处理数据时会在后台使用它。
全局执行环境是最外围的一个执行环境。根据 ECMAScript 实现所在的宿主环境不同，表示的执行环境的对象也不一样。

在 Web 浏览器中，全局执行环境被认为是 window 对象，因此所有全局变量和函数都是作为 window 对象的属性和方法创建的。
在 NODE 环境中，全局执行环境是 global 对象。

某个执行环境中所有的代码执行完毕后，该环境被销毁，保存在其中的所有变量和函数定义也随之销毁（全局执行环境直到应用程序退出时，如关闭浏览器或网页，才会被销毁）

每个函数都有自己的执行环境。当执行流进入一个函数时，函数的环境就会被推入一个环境栈中。而在函数执行之后，栈将被环境弹出，把控制权返回给之前的执行环境。ECMAScript 程序中的执行流正是由这个方便的机制控制着。

概括来说：
作用域就是代码执行开辟栈内存

私有作用域 ----> 函数执行都会形成一个私有作用域
全局作用域 ----> 页面一打开就会形成一个全局的作用域
私有变量 ----> 在私有作用域里边形成的变量 (通过 var 声明；形参)
全局变量 ----> 在全局作用域形成的变量（var a = 12 或者函数内没有声明，直接赋值的变量）

作用域链
当代码在一个环境中执行时，会创建变量对象的一个作用域链（作用域形成的链条）

作用域链的前端，始终都是当前执行的代码所在环境的变量对象
作用域链中的下一个对象来自于外部环境，而在下一个变量对象则来自下一个外部环境，一直到全局执行环境
全局执行环境的变量对象始终都是作用域链上的最后一个对象

内部环境可以通过作用域链访问所有外部环境，但外部环境不能访问内部环境的任何变量和函数。

var n = 10;
function outer(){
  function inner(){
    function center(){
      console.log(n);
    }
    center();
  }
  inner();
  var n = 15;
}
outer(); //=> undefined

如函数的执行，形成一个私有作用域，形参和当前私有作用域中声明的变量都是私有变量，保存在内部的一个变量对象中，其下一个外部环境可能是函数，也就包含了函数的内部变量对象，直到全局作用域。

当在内部函数中，需要访问一个变量的时候，首先会访问函数本身的变量对象，是否有这个变量，如果没有，那么会继续沿作用域链往上查找，直到全局作用域。如果在某个变量对象中找到则使用该变量对象中的变量值。

由于变量的查找是沿着作用域链来实现的，所以也称作用域链为变量查找的机制。

这个机制也说明了访问局部变量要比访问全局变量更快，因为中间的查找过程更短。但是 JavaScript 引擎在优化标识符查询方面做得很好，因此这个差别可以忽略不计。

闭包
闭包（Closure）：闭包就是指有权访问另一个函数作用域中的变量的函数。
理解关键：外部函数调用之后其变量对象本应该被销毁，但闭包的存在使我们仍然可以访问外部函数的变量对象，这就是闭包的重要概念。

3、OOP(面向对象)

封装
创建一个对象，集中存储一个事物的属性和功能
继承
父对象的成员，子对象无需创建可直接使用
原型对象、原型链
多态
同一事物，在不同情况下，表现出不同的状态

Symbol

概述

ES6引入的一种新的原始数据类型Symbol，表示独一无二的值，最大的用法是用来定义对象的唯一属性名

基本用法

Symbol 函数栈不能用 new 命令，因为 Symbol 是原始数据类型，不是对象。可以接受一个字符串作为参数，为新创建的 Symbol 提供描述，用来显示在控制台或者作为字符串的时候使用，便于区分。

let sy = Symbol("KK");
console.log(sy);   // Symbol(KK)
typeof(sy);        // "symbol"
 
// 相同参数 Symbol() 返回的值不相等
let sy1 = Symbol("kk"); 
sy === sy1;       // false

BigInt

在 ES10 增加了新的原始数据类型：BigInt，表示一个任意精度的整数，可以表示超长数据，可以超出2的53次方。

Js 中 Number类型只能安全的表示-(2^53-1)至 2^53-1 范的值

console.log(2 ** 53) // es7 幂运算符
console.log(Number.MAX_SAFE_INTEGER) // 最大值-1

使用 BigInt 有两种方式：

方式一：数字后面增加n

const bigInt = 9007199254740993n
console.log(bigInt)
console.log(typeof bigInt) // bigint

console.log(1n == 1) // true
console.log(1n === 1) // false

方式二：使用 BigInt 函数

const bigIntNum = BigInt(9007199254740993n)
console.log(bigIntNum)

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：springboot bean 创建顺序第一

下一篇：java类中全局变量需要考虑多线程吗

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯