群聊头像 - 取前五个用户头像生成一个新的头像

仿微信九宫格（从1-9个头像）

取前五个用户头像生成一个新的头像（从1-5个头像）

可自定义算法做头像拼接

效果图如下

package com.example.demo.util;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.geom.AffineTransform;
import java.awt.geom.Ellipse2D;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;

/**
 * @version 1.0
 * @className UpdateGroupLogoUtil
 * @description TODO
 */
public class UpdateGroupLogoUtil {
    /**
     * 图片格式：JPG
     */
    private static final String PICTRUE_FORMATE = "jpg";

    /**
     * 生成组合头像
     * 画布宽度和高度为166，图片间距为2
     *
     * @param paths   用户头像路径列表
     * @param outPath 生成后的头像保存路径
     * @throws IOException
     */
    public static void generate(List<String> paths, String outPath) throws IOException {
        generate(paths, 166, 4, outPath);
    }

    /**
     * 生成组合头像
     *
     * @param paths    用户头像路径列表
     * @param length   画板的宽高和高度
     * @param interval 画板中的图片间距
     * @param outPath  生成后的头像保存路径
     * @throws IOException
     */
    public static void generate(List<String> paths, int length, int interval, String outPath) throws IOException {
        //圆形五图
        int wh = (length - interval * 4) / 2; // 每个图片的宽高和高度：图片数>4
        //微信9宫格
        //int wh = (length - interval * 4) / 3; // 每个图片的宽高和高度：图片数>4
        if (paths.size() == 1) {
            wh = length - interval * 2; // 每个图片的宽高和高度：图片数=1
        }
        if (paths.size() > 1 && paths.size() < 5) {
            wh = (length - interval * 3) / 2; // 每个图片的宽高和高度：图片数>0并且<5
        }
        List<BufferedImage> bufferedImages = new ArrayList<BufferedImage>();
        for (int i = 0; i < paths.size(); i++) {
            bufferedImages.add(UpdateGroupLogoUtil.resize(paths.get(i), wh, wh, false));
        }
        // BufferedImage.TYPE_INT_RGB可以自己定义可查看API
        BufferedImage outImage = new BufferedImage(length, length, BufferedImage.TYPE_INT_RGB);
        // 生成画布
        Graphics g = outImage.getGraphics();
        Graphics2D g2d = (Graphics2D) g;
        // 设置背景色
        g2d.setBackground(new Color(255, 255, 255));
        // 通过使用当前绘图表面的背景色进行填充来清除指定的矩形。
        g2d.clearRect(0, 0, length, length);
        // 开始拼凑 根据图片的数量判断该生成那种样式的组合头像(仿微信群聊 9宫格)
        /*for (int i = 1; i <= bufferedImages.size(); i++) {
            int j = i % 3 + 1;
            if (bufferedImages.size() < 5) {
                j = i % 2 + 1;
            }
            int x = interval * j + wh * (j - 1); //95    5
            int split = (wh + interval) / 2;    //45.5  45.5
            if (bufferedImages.size() == 9) {
                if (i <= 3) {
                    g2d.drawImage(bufferedImages.get(i - 1), x, wh * 2 + interval * 3, null);
                } else if (i <= 6) {
                    g2d.drawImage(bufferedImages.get(i - 1), x, wh + interval * 2, null);
                } else {
                    g2d.drawImage(bufferedImages.get(i - 1), x, interval, null);
                }
            } else if (bufferedImages.size() == 8) {
                if (i <= 3) {
                    g2d.drawImage(bufferedImages.get(i - 1), x, wh * 2 + interval * 3, null);
                } else if (i <= 6) {
                    g2d.drawImage(bufferedImages.get(i - 1), x, wh + interval * 2, null);
                } else {
                    g2d.drawImage(bufferedImages.get(i - 1), x - split, interval, null);
                }
            } else if (bufferedImages.size() == 7) {
                if (i <= 3) {
                    g2d.drawImage(bufferedImages.get(i - 1), x, wh * 2 + interval * 3, null);
                } else if (i <= 6) {
                    g2d.drawImage(bufferedImages.get(i - 1), x, wh + interval * 2, null);
                } else {
                    g2d.drawImage(bufferedImages.get(i - 1), (length - wh) / 2, interval, null);
                }
            } else if (bufferedImages.size() == 6) {
                if (i <= 3) {
                    g2d.drawImage(bufferedImages.get(i - 1), x, wh * 2 + interval * 3 - split, null);
                } else if (i <= 6) {
                    g2d.drawImage(bufferedImages.get(i - 1), x, wh + interval * 2 - split, null);
                }
            } else if (bufferedImages.size() == 5) {
                if (i <= 3) {
                    g2d.drawImage(bufferedImages.get(i - 1), x, wh * 2 + interval * 3 - split, null);
                } else {
                    g2d.drawImage(bufferedImages.get(i - 1), x - split, wh + interval * 2 - split, null);
                }
            } else if (bufferedImages.size() == 4) {
                if (i <= 2) {
                    g2d.drawImage(bufferedImages.get(i - 1), x, wh + interval * 2, null);
                } else {
                    g2d.drawImage(bufferedImages.get(i - 1), x, interval, null);
                }
            } else if (bufferedImages.size() == 3) {
                if (i <= 2) {
                    g2d.drawImage(bufferedImages.get(i - 1), x, wh + interval * 2, null);
                } else {
                    g2d.drawImage(bufferedImages.get(i - 1), x - split, interval, null);
                }
            } else if (bufferedImages.size() == 2) {
                g2d.drawImage(bufferedImages.get(i - 1), x, wh + interval * 2 - split, null);
            } else if (bufferedImages.size() == 1) {
                g2d.drawImage(bufferedImages.get(i - 1), interval, interval, null);
            }
            // 需要改变颜色的话在这里绘上颜色。可能会用到AlphaComposite类
        }*/

        //圆形拼凑
        for (int i = 1; i <= bufferedImages.size(); i++) {
            int j = i % 3 + 1;
            if (bufferedImages.size() < 5) {
                j = i % 2 + 1;
            }
            int x = interval * j + wh * (j - 1); 
            int split = (wh + interval) / 2;    
            int y = wh + interval * 2 - split;
            if (bufferedImages.size() == 1) {
                g2d.drawImage(bufferedImages.get(i - 1), interval, interval, null);
            }else if (bufferedImages.size() == 2) {
                if(i == 1){
                    x = x - 15;
                    y = y + 10;
                }
                if(i == 2){
                    x = x + 15;
                }
                g2d.drawImage(bufferedImages.get(i - 1), x, y, null);
            }else if(bufferedImages.size() == 3){
                if(i == 1){
                    x = x - 15;
                    y = y + 15;
                }
                if(i == 2){
                    x = x + 15;
                    y = y + 15;
                }
                if(i == 3){
                    x = x - 40;
                    y = y - 25;
                }
                g2d.drawImage(bufferedImages.get(i - 1), x, y, null);
            }else if(bufferedImages.size() == 4){
                if(i == 1){
                    x = x - 15;
                    y = y + 25;
                }
                if(i == 2){
                    x = x + 15;
                    y = y + 25;
                }
                if(i == 3){
                    x = x - 15;
                    y = y - 25;
                }
                if(i == 4){
                    x = x + 15;
                    y = y - 25;
                }

                g2d.drawImage(bufferedImages.get(i - 1), x, y, null);
            }else if(bufferedImages.size() == 5){
                if(i == 1){
                    x = x - 40;
                    y = y + 40;
                }
                if(i == 2){
                    x = x - 80;
                    y = y + 15;
                }
                if(i == 3){
                    x = x + 70;
                    y = y - 30;
                }
                if(i == 4){
                    x = x - 55;
                    y = y - 35;
                }
                if(i == 5){
                    x = x - 155;
                    y = y + 10;
                }
                g2d.drawImage(bufferedImages.get(i - 1), x, y, null);
            }
            // 需要改变颜色的话在这里绘上颜色。可能会用到AlphaComposite类
        }

        ImageIO.write(outImage, PICTRUE_FORMATE, new File(outPath));
    }

    public static BufferedImage resize(String filePath, int width, int height) {
        try {
            BufferedImage bi = ImageIO.read(new File(filePath));
            bi.getSubimage(0, 0, width, height);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 图片缩放
     *
     * @param filePath 图片路径
     * @param height   高度
     * @param width    宽度
     * @param bb       比例不对时是否需要补白
     */
    public static BufferedImage resize(String filePath, int height, int width, boolean bb) {
        try {
            double ratio = 0; // 缩放比例
            //读取本地图片
            /*File f = new File(filePath);
            BufferedImage bi = ImageIO.read(f);*/
            //读取网络图片
            URL url = new URL(filePath);
            InputStream inputStream = url.openStream();
            BufferedImage bi1 = ImageIO.read(inputStream);
            //裁剪成圆形
            BufferedImage bi = cutCircle(bi1);

            Image itemp = bi.getScaledInstance(width, height, Image.SCALE_SMOOTH);
            // 计算比例
            if ((bi.getHeight() > height) || (bi.getWidth() > width)) {
                if (bi.getHeight() > bi.getWidth()) {
                    ratio = (new Integer(height)).doubleValue() / bi.getHeight();
                } else {
                    ratio = (new Integer(width)).doubleValue() / bi.getWidth();
                }
                //等比例缩放
                AffineTransformOp op = new AffineTransformOp(AffineTransform.getScaleInstance(ratio, ratio), null);
                itemp = op.filter(bi, null);
            }
            if (bb) {
                BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
                Graphics2D g = image.createGraphics();
                g.setColor(Color.white);
                g.fillRect(0, 0, width, height);
                if (width == itemp.getWidth(null)) {
                    g.drawImage(itemp, 0, (height - itemp.getHeight(null)) / 2, itemp.getWidth(null), itemp.getHeight(null), Color.white, null);
                } else {
                    g.drawImage(itemp, (width - itemp.getWidth(null)) / 2, 0, itemp.getWidth(null), itemp.getHeight(null), Color.white, null);
                }
                g.dispose();
                itemp = image;
            }
            return (BufferedImage) itemp;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 裁剪 - 圆形
     * @param bi1
     * @return
     */
    public static BufferedImage cutCircle(BufferedImage bi1){
        BufferedImage image = new BufferedImage(bi1.getWidth(), bi1.getHeight(), BufferedImage.TYPE_INT_ARGB);
        Ellipse2D.Double shape = new Ellipse2D.Double(0, 0, bi1.getWidth(), bi1.getHeight());
        Graphics2D g2 = image.createGraphics();
        image = g2.getDeviceConfiguration().createCompatibleImage(bi1.getWidth(), bi1.getHeight(),
                Transparency.TRANSLUCENT);
        g2 = image.createGraphics();
        // 将背景设置为透明。如果注释该段代码，默认背景为白色.也可通过g2.setPaint(paint) 设置背景色
        g2.setComposite(AlphaComposite.Clear);
        g2.fill(new Rectangle(image.getWidth(), image.getHeight()));
        g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.9f));
        g2.setClip(shape);
        // 使用 setRenderingHint 设置抗锯齿
        g2.drawImage(bi1, 0, 0, null);
        g2.dispose();
        return image;
    }

    public static void main(String[] args) throws Exception {
        ArrayList<String> picUrls = new ArrayList<>();
        String pic = "F:\\zsl\\";
        picUrls.add(pic + "1.jpg");
        picUrls.add(pic + "2.jpg");
        picUrls.add(pic + "3.jpg");
        
        //2 调用工具类 生成九宫格 并保存在已有路径
        //UpdateGroupLogoUtil.generate(picUrls, "F:\\zsl\\33 .jpg");
        for (int i = 0; i < picUrls.size(); i++) {
            UpdateGroupLogoUtil.generate(picUrls.subList(0,i+1), "F:\\zsl\\100"+i+" .jpg");
        }
        /*long start = System.currentTimeMillis();
        UpdateGroupLogoUtil.generate(picUrls, "F:\\zsl\\101.jpg");
        long end = System.currentTimeMillis();
        System.out.println(end - start);*/

    }

}