Java AI案例

wen java案例 2026-08-02 247

本文目录导读：

Java AI案例

图像识别案例 - 手写数字识别
自然语言处理案例 - 情感分析
智能推荐系统案例
实时预测系统案例
深度学习集成案例 - 图像分类与目标检测

我将为您提供几个Java AI应用的典型案例，涵盖不同的AI领域。

图像识别案例 - 手写数字识别

import org.deeplearning4j.datasets.iterator.impl.MnistDataSetIterator;
import org.deeplearning4j.nn.conf.MultiLayerConfiguration;
import org.deeplearning4j.nn.conf.NeuralNetConfiguration;
import org.deeplearning4j.nn.conf.layers.DenseLayer;
import org.deeplearning4j.nn.conf.layers.OutputLayer;
import org.deeplearning4j.nn.multilayer.MultiLayerNetwork;
import org.deeplearning4j.optimize.listeners.ScoreIterationListener;
import org.nd4j.linalg.activations.Activation;
import org.nd4j.linalg.api.ndarray.INDArray;
import org.nd4j.linalg.dataset.DataSet;
import org.nd4j.linalg.dataset.api.iterator.DataSetIterator;
import org.nd4j.linalg.learning.config.Adam;
import org.nd4j.linalg.lossfunctions.LossFunctions;
/**
 * 使用DL4J实现手写数字识别
 */
public class MnistClassifier {
    public static void main(String[] args) throws Exception {
        // 加载MNIST数据集
        DataSetIterator trainData = new MnistDataSetIterator(64, true, 12345);
        DataSetIterator testData = new MnistDataSetIterator(64, false, 12345);
        // 构建神经网络模型
        MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder()
            .updater(new Adam(0.001))
            .list()
            .layer(0, new DenseLayer.Builder()
                .nIn(28 * 28)
                .nOut(256)
                .activation(Activation.RELU)
                .build())
            .layer(1, new DenseLayer.Builder()
                .nIn(256)
                .nOut(128)
                .activation(Activation.RELU)
                .build())
            .layer(2, new OutputLayer.Builder()
                .nIn(128)
                .nOut(10)
                .activation(Activation.SOFTMAX)
                .lossFunction(LossFunctions.LossFunction.NEGATIVELOGLIKELIHOOD)
                .build())
            .build();
        // 创建模型
        MultiLayerNetwork model = new MultiLayerNetwork(conf);
        model.init();
        // 添加训练监听器
        model.setListeners(new ScoreIterationListener(100));
        // 训练模型
        System.out.println("开始训练模型...");
        int epochs = 10;
        for (int epoch = 0; epoch < epochs; epoch++) {
            model.fit(trainData);
            System.out.println("Epoch " + (epoch + 1) + " 完成");
        }
        // 评估模型
        Evaluation eval = new Evaluation(10);
        while (testData.hasNext()) {
            DataSet batch = testData.next();
            INDArray output = model.output(batch.getFeatures());
            eval.eval(batch.getLabels(), output);
        }
        System.out.println("模型准确率: " + eval.accuracy());
        System.out.println(eval.stats());
        // 保存模型
        model.save(new java.io.File("mnist_model.zip"));
        System.out.println("模型已保存");
    }
}

自然语言处理案例 - 情感分析

import edu.stanford.nlp.ling.CoreAnnotations;
import edu.stanford.nlp.neural.rnn.RNNCoreAnnotations;
import edu.stanford.nlp.pipeline.Annotation;
import edu.stanford.nlp.pipeline.StanfordCoreNLP;
import edu.stanford.nlp.sentiment.SentimentCoreAnnotations;
import edu.stanford.nlp.trees.Tree;
import edu.stanford.nlp.util.CoreMap;
import java.util.Properties;
/**
 * 使用Stanford CoreNLP进行情感分析
 */
public class SentimentAnalyzer {
    private StanfordCoreNLP pipeline;
    public SentimentAnalyzer() {
        // 初始化NLP管道
        Properties props = new Properties();
        props.setProperty("annotators", "tokenize, ssplit, parse, sentiment");
        pipeline = new StanfordCoreNLP(props);
    }
    /**
     * 分析文本情感
     * @param text 要分析的文本
     * @return 情感得分 (0=非常消极, 1=消极, 2=中性, 3=积极, 4=非常积极)
     */
    public int analyzeSentiment(String text) {
        Annotation annotation = pipeline.process(text);
        int mainSentiment = 0;
        int longestSentence = 0;
        for (CoreMap sentence : annotation.get(CoreAnnotations.SentencesAnnotation.class)) {
            Tree tree = sentence.get(SentimentCoreAnnotations.SentimentAnnotatedTree.class);
            int sentiment = RNNCoreAnnotations.getPredictedClass(tree);
            String sentenceText = sentence.get(CoreAnnotations.TextAnnotation.class);
            if (sentenceText.length() > longestSentence) {
                mainSentiment = sentiment;
                longestSentence = sentenceText.length();
            }
        }
        return mainSentiment;
    }
    /**
     * 将情感得分转换为文本描述
     */
    public String getSentimentDescription(int sentiment) {
        switch (sentiment) {
            case 0: return "非常消极";
            case 1: return "消极";
            case 2: return "中性";
            case 3: return "积极";
            case 4: return "非常积极";
            default: return "未知";
        }
    }
    public static void main(String[] args) {
        SentimentAnalyzer analyzer = new SentimentAnalyzer();
        String[] texts = {
            "I love this product! It's amazing!",
            "The service was terrible and the staff was rude.",
            "The weather today is quite nice.",
            "This movie was disappointing and boring.",
            "Great experience, highly recommend!"
        };
        for (String text : texts) {
            int sentiment = analyzer.analyzeSentiment(text);
            System.out.println("文本: " + text);
            System.out.println("情感: " + analyzer.getSentimentDescription(sentiment));
            System.out.println("------------------------");
        }
    }
}

智能推荐系统案例

import org.apache.mahout.cf.taste.common.TasteException;
import org.apache.mahout.cf.taste.impl.model.file.FileDataModel;
import org.apache.mahout.cf.taste.impl.neighborhood.NearestNUserNeighborhood;
import org.apache.mahout.cf.taste.impl.recommender.GenericUserBasedRecommender;
import org.apache.mahout.cf.taste.impl.similarity.PearsonCorrelationSimilarity;
import org.apache.mahout.cf.taste.model.DataModel;
import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood;
import org.apache.mahout.cf.taste.recommender.RecommendedItem;
import org.apache.mahout.cf.taste.recommender.Recommender;
import org.apache.mahout.cf.taste.similarity.UserSimilarity;
import java.io.File;
import java.io.IOException;
import java.util.List;
/**
 * 使用Apache Mahout实现协同过滤推荐系统
 */
public class RecommendationSystem {
    /**
     * 构建基于用户协同过滤的推荐器
     */
    public static Recommender buildUserBasedRecommender(File dataFile) throws IOException, TasteException {
        // 加载数据模型
        DataModel model = new FileDataModel(dataFile);
        // 计算用户相似度（基于皮尔逊相关系数）
        UserSimilarity similarity = new PearsonCorrelationSimilarity(model);
        // 定义用户邻域（取最近的100个用户）
        UserNeighborhood neighborhood = new NearestNUserNeighborhood(100, similarity, model);
        // 构建推荐器
        return new GenericUserBasedRecommender(model, neighborhood, similarity);
    }
    /**
     * 为指定用户生成推荐
     */
    public static void recommendForUser(Recommender recommender, long userId, int numRecommendations) 
            throws TasteException {
        List<RecommendedItem> recommendations = recommender.recommend(userId, numRecommendations);
        System.out.println("为用户 " + userId + " 推荐 " + numRecommendations + " 个项目:");
        for (RecommendedItem recommendation : recommendations) {
            System.out.println("  项目 " + recommendation.getItemID() + 
                             " (评分: " + recommendation.getValue() + ")");
        }
    }
    /**
     * 创建示例数据文件
     */
    public static File createSampleData() throws IOException {
        // 创建临时文件存储评分数据
        File dataFile = File.createTempFile("ratings", ".csv");
        dataFile.deleteOnExit();
        StringBuilder sb = new StringBuilder();
        // 格式: 用户ID,项目ID,评分
        sb.append("1,101,5.0\n");
        sb.append("1,102,4.0\n");
        sb.append("1,103,3.0\n");
        sb.append("2,101,4.0\n");
        sb.append("2,102,5.0\n");
        sb.append("2,104,2.0\n");
        sb.append("3,101,3.0\n");
        sb.append("3,104,4.0\n");
        sb.append("3,105,5.0\n");
        sb.append("4,103,5.0\n");
        sb.append("4,105,4.0\n");
        sb.append("4,106,3.0\n");
        java.nio.file.Files.write(dataFile.toPath(), sb.toString().getBytes());
        return dataFile;
    }
    public static void main(String[] args) {
        try {
            // 创建示例数据
            File dataFile = createSampleData();
            // 构建推荐系统
            Recommender recommender = buildUserBasedRecommender(dataFile);
            // 为用户1生成推荐
            recommendForUser(recommender, 1, 3);
            // 为用户3生成推荐
            recommendForUser(recommender, 3, 3);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

实时预测系统案例

import com.github.pemistahl.lingua.api.Language;
import com.github.pemistahl.lingua.api.LanguageDetector;
import com.github.pemistahl.lingua.api.LanguageDetectorBuilder;
import org.knowm.xchart.*;
import org.nd4j.linalg.api.ndarray.INDArray;
import org.nd4j.linalg.factory.Nd4j;
import java.util.*;
import java.util.stream.Collectors;
/**
 * 智能文本分类和语言检测系统
 */
public class IntelligentTextSystem {
    // 语言检测器
    private LanguageDetector languageDetector;
    public IntelligentTextSystem() {
        // 初始化语言检测器
        languageDetector = LanguageDetectorBuilder.fromAllLanguages().build();
    }
    /**
     * 检测文本语言
     */
    public Language detectLanguage(String text) {
        return languageDetector.detectLanguageOf(text);
    }
    /**
     * 简单的关键词分类器
     */
    public String categorizeText(String text) {
        String lowerText = text.toLowerCase();
        Map<String, Double> scores = new HashMap<>();
        // 定义分类关键词
        scores.put("技术", calcScore(lowerText, 
            Arrays.asList("java", "python", "code", "programming", "software", "algorithm")));
        scores.put("金融", calcScore(lowerText,
            Arrays.asList("money", "bank", "finance", "stock", "investment", "loan")));
        scores.put("医疗", calcScore(lowerText,
            Arrays.asList("health", "doctor", "hospital", "medicine", "patient", "disease")));
        scores.put("教育", calcScore(lowerText,
            Arrays.asList("school", "teacher", "student", "education", "course", "learning")));
        // 返回得分最高的分类
        return scores.entrySet().stream()
            .max(Map.Entry.comparingByValue())
            .get().getKey();
    }
    private double calcScore(String text, List<String> keywords) {
        return keywords.stream()
            .filter(text::contains)
            .count() * 1.0;
    }
    /**
     * 生成简易数据可视化
     */
    public void visualizeData() {
        // 创建示例数据
        String[] categories = {"技术", "金融", "医疗", "教育"};
        int[] counts = {352, 214, 178, 265};
        // 创建柱状图
        CategoryChart chart = new CategoryChartBuilder()
            .width(800)
            .height(600)
            .title("文本分类统计")
            .xAxisTitle("分类")
            .yAxisTitle("数量")
            .build();
        // 添加数据
        chart.addSeries("文本数量", Arrays.asList(categories), 
                       Arrays.stream(counts).boxed().collect(Collectors.toList()));
        // 保存图表
        try {
            new SwingWrapper<>(chart).displayChart();
        } catch (Exception e) {
            System.out.println("图表显示失败: " + e.getMessage());
        }
    }
    public static void main(String[] args) {
        IntelligentTextSystem system = new IntelligentTextSystem();
        // 测试文本
        String[] texts = {
            "Java is a powerful programming language for enterprise applications",
            "The stock market showed significant growth this quarter",
            "Patients with chronic diseases need regular medical checkups",
            "University students are preparing for their final examinations"
        };
        for (String text : texts) {
            // 语言检测
            Language lang = system.detectLanguage(text);
            // 文本分类
            String category = system.categorizeText(text);
            // 输出结果
            System.out.println("文本内容: " + text);
            System.out.println("检测语言: " + lang);
            System.out.println("文本分类: " + category);
            System.out.println("------------------------");
        }
        // 生成可视化
        system.visualizeData();
    }
    /**
     * 辅助类：用于处理中文文本的简单关键词分类
     */
    public static class ChineseTextCategorizer {
        private Map<String, List<String>> rules;
        public ChineseTextCategorizer() {
            rules = new HashMap<>();
            rules.put("科技", Arrays.asList("人工智能", "大数据", "云计算", "区块链", "互联网"));
            rules.put("体育", Arrays.asList("足球", "篮球", "比赛", "运动员", "奥运会"));
            rules.put("娱乐", Arrays.asList("电影", "音乐", "明星", "综艺", "演唱会"));
        }
        public String categorize(String text) {
            for (Map.Entry<String, List<String>> entry : rules.entrySet()) {
                if (entry.getValue().stream().anyMatch(text::contains)) {
                    return entry.getKey();
                }
            }
            return "其他";
        }
    }
}

深度学习集成案例 - 图像分类与目标检测

import org.deeplearning4j.nn.api.Model;
import org.nd4j.linalg.api.ndarray.INDArray;
import java.util.concurrent.*;
/**
 * AI模型管理平台
 */
public class AIModelManager {
    private Map<String, Model> models = new ConcurrentHashMap<>();
    private ExecutorService executor = Executors.newFixedThreadPool(4);
    /**
     * 注册模型
     */
    public void registerModel(String name, Model model) {
        models.put(name, model);
        System.out.println("模型 " + name + " 已注册");
    }
    /**
     * 异步执行预测
     */
    public CompletableFuture<INDArray> predictAsync(String modelName, INDArray input) {
        return CompletableFuture.supplyAsync(() -> {
            try {
                Model model = models.get(modelName);
                if (model == null) {
                    throw new IllegalArgumentException("模型不存在: " + modelName);
                }
                // 这里是示例代码，实际需要根据模型类型调用相应的预测方法
                // 假设模型是MultiLayerNetwork
                if (model instanceof org.deeplearning4j.nn.multilayer.MultiLayerNetwork) {
                    org.deeplearning4j.nn.multilayer.MultiLayerNetwork net = 
                        (org.deeplearning4j.nn.multilayer.MultiLayerNetwork) model;
                    return net.output(input);
                }
                throw new IllegalArgumentException("不支持的模型类型");
            } catch (Exception e) {
                System.err.println("预测失败: " + e.getMessage());
                throw new CompletionException(e);
            }
        }, executor);
    }
    /**
     * 模型热更新
     */
    public void updateModel(String modelName, Model newModel) {
        models.put(modelName, newModel);
        System.out.println("模型 " + modelName + " 已更新");
    }
    /**
     * 获取所有模型信息
     */
    public Map<String, String> getModelInfo() {
        return models.entrySet().stream()
            .collect(Collectors.toMap(
                Map.Entry::getKey,
                e -> e.getValue().getClass().getSimpleName()
            ));
    }
    /**
     * 关闭资源
     */
    public void shutdown() {
        executor.shutdown();
        try {
            if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}