集合及数组小脚本

前言

处理集合或数组的一些小脚本。

一、集合

1.1分隔集合

/*** 按指定大小，分隔集合，将集合按规定个数分为n个部分
 * * @param list
 * @param len
 * @return*/                
public static List<List<?>> splitList(List<?> list, int len) {
    if (list == null || list.size() == 0 || len < 1) {
         return null;
     } 
    List<List<?>> result = new ArrayList<List<?>>();  
    int size = list.size();
    int count = (size + len - 1) / len;  
    for (int i = 0; i < count; i++) {
        List<?> subList = list.subList(i * len, ((i + 1) * len > size ? size : len * (i + 1)));
        result.add(subList);
    }
    return result;
}   

1.2集合根据某一字段分组

实体类
public class SkuVo {
    //实体类
    private Long skuId;
    private String productName;
    private Long brandStoreSn;

    public SkuVo(Long skuId, String productName, Long brandStoreSn) {
        super();
        this.skuId = skuId;
        this.productName = productName;
        this.brandStoreSn = brandStoreSn;
    }

    public Long getSkuId() {
        return skuId;
    }
    public void setSkuId(Long skuId) {
        this.skuId = skuId;
    }
    public String getProductName() {
        return productName;
    }
    public void setProductName(String productName) {
        this.productName = productName;
    }
    public Long getBrandStoreSn() {
        return brandStoreSn;
    }
    public void setBrandStoreSn(Long brandStoreSn) {
        this.brandStoreSn = brandStoreSn;
    }

    @Override
    public String toString() {
        return "SkuVo [skuId=" + skuId + ", productName=" + productName + ", brandStoreSn=" + brandStoreSn + "]";
    }
}

测试类：
public class OutStandingServiceImpl {

    public static void main(String[] args) {
        //将集合根据某一字段进行分组
        /*1、准备数据**/
        SkuVo sku1 = new SkuVo(1L,"p1",100L);
        SkuVo sku2 = new SkuVo(2L,"p2",101L);
        SkuVo sku3 = new SkuVo(3L,"p3",102L);
        SkuVo sku4 = new SkuVo(3L,"p4",103L);
        SkuVo sku5 = new SkuVo(2L,"p5",100L);
        SkuVo sku6 = new SkuVo(5L,"p6",100L);

        List<SkuVo> skuVoList = Arrays.asList(new SkuVo [] {sku1,sku2,sku3,sku4,sku5,sku6});

        /*2、分组算法**/
        Map<Long, List<SkuVo>> skuIdMap = new HashMap<>();
        for (SkuVo skuVo : skuVoList) {
            List<SkuVo> tempList = skuIdMap.get(skuVo.getSkuId());
            /**zs批注：
             * 【1】此处获取tempList时的条件应为多个字段，应放入集合或数组中，而不仅仅为一个id字段，map的key应为一个数组或是集合；
             * 【2】通过配置的工具类获取group by的分组数组的集合字段，---》这里应更加的通用，可以灵活增删字段，变化分组维度。
             * 【3】查询分组字段的值，放入一个数组或集合。
            */
            /*如果取不到数据,那么直接new一个空的ArrayList**/
            if (tempList == null) {
                tempList = new ArrayList<>();
                tempList.add(skuVo);
                skuIdMap.put(skuVo.getSkuId(), tempList);
            }
            else {
                /*某个sku之前已经存放过了,则直接追加数据到原来的List里**/
                tempList.add(skuVo);
            }
        }

        /*3、遍历map,验证结果**/
        for(Long skuId : skuIdMap.keySet()){
            System.out.println(skuIdMap.get(skuId));
        }
    }
}

1.3将集合按照某些字段进行分组并处理数据

实体类
package com.asd.modules.pojo.zsTest;

public class Bill {

    private String type;
    private String state;
    private Integer money;
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    public String getState() {
        return state;
    }
    public void setState(String state) {
        this.state = state;
    }
    public Integer getMoney() {
        return money;
    }
    public void setMoney(Integer money) {
        this.money = money;
    }
}
测试类package com.asd.modules.pojo.zsTest;

import java.util.ArrayList;
import java.util.List;

public class MergeList1 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        List<Bill> list = new ArrayList<Bill>();
        Bill b = new Bill();
        b.setType("A");
        b.setMoney(1);
        b.setState("中");
        list.add(b);
        b = new Bill();
        b.setType("B");
        b.setState("大");
        b.setMoney(2);
        list.add(b);
        b = new Bill();
        b.setType("C");
        b.setMoney(3);
        b.setState("大");
        list.add(b);
        b = new Bill();
        b.setType("A");
        b.setMoney(2);
        b.setState("大");
        list.add(b);
        b = new Bill();
        b.setType("B");
        b.setMoney(2);
        b.setState("中");
        list.add(b);
        b = new Bill();
        b.setType("C");
        b.setMoney(3);
        b.setState("大");
        list.add(b);

        b = new Bill();
        b.setType("A");
        b.setMoney(1);
        b.setState("中");
        list.add(b);
        b = new Bill();
        b.setType("B");
        b.setState("中");
        b.setMoney(2);
        list.add(b);
        b = new Bill();
        b.setType("C");
        b.setState("大");
        b.setMoney(3);
        list.add(b);
        b = new Bill();
        b.setType("C");
        b.setState("大");
        b.setMoney(1);
        list.add(b);

        List<Bill> bi = new ArrayList<Bill>();
        for (Bill bill : list) {
            boolean flag = false;
            String a1 = bill.getType()+","+bill.getState();
            for (Bill bills : bi) {
                String a2 = bills.getType()+","+bills.getState();
                if(a1.equals(a2)){
                    int money = bills.getMoney();
                    money += bill.getMoney();
                    bills.setMoney(money);
                    flag = true;
                }
            }
            if(!flag){
                bi.add(bill);
            }
        }

        for (Bill bill : bi) {
            System.out.println(bill.getType() +"    " +bill.getState()+"    "+bill.getMoney());
        }
    }
}

二、数组

2.1移除某一数组某一索引的值

package com.asd.modules.controller;

import java.util.*;
import java.lang.*;

public class Tests {

    public static void main(String args[]) throws Exception{

        int[] arr={1,2,3,4,5,6};
        arr=remove(arr,0);// 移除下标为2的元素
        for(int x:arr) System.out.println("x="+x);// 移除后数组剩下的元素

    }
    // 移除数组指定下标的元素 重载+1
    private static int[] remove(int[] array,int index){
        return (int[]) remove((Object) array, index);
    }

    // 移除数组指定下标的元素 重载+2
    private static Object remove(Object array,int index){

        int length = java.lang.reflect.Array.getLength(array);
        if (index < 0 || index >= length) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length);
        }

        Object result=java.lang.reflect.Array.newInstance(array.getClass().getComponentType(),length-1);
        // 截取被删除的前半部分
        System.arraycopy(array, 0, result, 0, index);

        if (index < length - 1) {
            // 截取被删除的后半部分
            System.arraycopy(array, index + 1, result, index, length - index - 1);
        }

        return result;
    }
}

2.2数组消除字符串空格

String[] trimmedArray = new String[array.length];
for (int i = 0; i < array.length; i++)
    trimmedArray[i] = array[i].trim();
现在trimmedArray包含与数组相同的字符串，但没有前导和尾随空格。或者，您可以在同一个数组中原位修改字符串：
for (int i = 0; i < array.length; i++)
    array[i] = array[i].trim();

三、其他