android集合按某个字段分组,怎么对一组数据按照某个特定字段进行分组？

步骤

*第一步：排序，时间从近到远

*第二步：分割，将数组分成5个一组，返回新数组

*第三步：抽离，将相同时间抽离出来组成要求上的数据格式

代码

第一步：排序

var compare = function (prop) {

return function (obj1, obj2) {

var val1 = obj1[prop];

var val2 = obj2[prop];

if (!isNaN(Number(val1)) && !isNaN(Number(val2))) {

val1 = Number(val1);

val2 = Number(val2);

}

if (val1 < val2) {

return 1;

} else if (val1 > val2) {

return -1;

} else {

return 0;

}

}

}

//用法

arr.sort(compare("time"))

第二步：分割

//分割

Array.prototype.chunk = function(size) {

var array = this;

const length = array.length

if (!length || !size || size < 1) {

return []

}

let index = 0

let resIndex = 0

let result = new Array(Math.ceil(length / size))

while (index < length) {

result[resIndex++] = array.slice(index, (index += size))

}

return result

}

//用法

arr.chunk(5)

第三步：抽离

//抽离

function sortArr(arr, str) {

var _arr = [],

_t = [],

// 临时的变量

_tmp;

// 按照特定的参数将数组排序将具有相同值得排在一起

arr = arr.sort(function(a, b) {

var s = a[str],

t = b[str];

return s < t ? -1 : 1;

});

if ( arr.length ){

// _tmp = arr[0][str];

_tmp = new Date(arr[0][str]).getFullYear()

}

// 将相同类别的对象添加到统一个数组

for (let i=0;i

if(new Date(arr[i][str]).getFullYear()===_tmp){

// if ( arr[i][str] === _tmp ){

_t.push( arr[i] );

} else {

_tmp = new Date(arr[i][str]).getFullYear();

_arr.push( _t );

_t = [arr[i]];

}

}

// 将最后的内容推出新数组

_arr.push(_t);

return _arr;

}

//用法，这里仅对一维数组使用

sortArr( arr, 'time')

//我将数据一二步处理后开始二叉数循环

var cc = arr.sort(compare("time")).chunk(5)

var _cc = []

for(let i=0;i

//抽离

var _datas=sortArr( cc[i], 'time')

//根据所给数据结构进行赋值

_cc.push({section:i+1, sectionDatas:[]})

for(let o=0;o<_datas.length>

_cc[i].sectionDatas.push({

data:new Date(_datas[o][0].time).getFullYear(),

datas:[]

})

}

for(let p=0;p<_cc>

_cc[i].sectionDatas[p].datas=sortArr(cc[i], 'time')[p]

}

}

最近刚研究的函数式编程

功力不够，谨慎使用

class Functor {

constructor(data){

this.data = data

}

map(data){

return new Functor(data)

}

//排序

compare(prop) {

var result = this.data.sort(function (obj1, obj2) {

var val1 = obj1[prop];

var val2 = obj2[prop];

if (!isNaN(Number(val1)) && !isNaN(Number(val2))) {

val1 = Number(val1);

val2 = Number(val2);

}

if (val1 < val2) {

return 1;

} else if (val1 > val2) {

return -1;

} else {

return 0;

}

})

return this.map(result)

}

//分割

chunk(size) {

var array = this.data;

//获取数组的长度，如果你传入的不是数组，那么获取到的就是undefined

const length = array.length

//判断不是数组，或者size没有设置，size小于1，就返回空数组

if (!length || !size || size < 1) {

return []

}

//核心部分

let index = 0 //用来表示切割元素的范围start

let resIndex = 0 //用来递增表示输出数组的下标

//根据length和size算出输出数组的长度，并且创建它。

let result = new Array(Math.ceil(length / size))

//进行循环

while (index < length) {

//循环过程中设置result[0]和result[1]的值。该值根据array.slice切割得到。

result[resIndex++] = array.slice(index, (index += size))

}

//输出新数组

// return result

return this.map(result)

}

//抽离

sortArr(arr, str) {

var _arr = [],

_t = [],

// 临时的变量

_tmp;

// 按照特定的参数将数组排序将具有相同值得排在一起

arr = arr.sort(function(a, b) {

var s = a[str],

t = b[str];

return s < t ? -1 : 1;

});

if ( arr.length ){

// _tmp = arr[0][str];

_tmp = new Date(arr[0][str]).getFullYear()

}

// 将相同类别的对象添加到统一个数组

for (let i=0;i

if(new Date(arr[i][str]).getFullYear()===_tmp){

// if ( arr[i][str] === _tmp ){

_t.push( arr[i] );

} else {

_tmp = new Date(arr[i][str]).getFullYear();

_arr.push( _t );

_t = [arr[i]];

}

}

// 将最后的内容推出新数组

_arr.push(_t);

return _arr;

}

//转指定json格式

dataToJSON(){

var _json = []

var _this = this;

this.data.forEach(function(item,i){

var _datas=_this.sortArr( item, 'time')

_json.push({section:i+1, sectionDatas:[]})

for(let o=0;o<_datas.length>

_json[i].sectionDatas.push({

data:new Date(_datas[o][0].time).getFullYear(),

datas:[]

})

}

for(let p=0;p<_json>

_json[i].sectionDatas[p].datas=_datas[p]

}

})

return _json

}

}

Functor.of = function(data){

return new Functor(data)

}

使用方法

Functor.of(a).compare("time").chunk(5).dataToJSON() //返回一个新的值，不改变原来数据