协同过滤（CF）推荐算法实现

在网上看了CF算法的实现，自己也敲了敲，如下：有不懂的可以留言到评论区

import java.util.*;

public class CFDemo {
    private static String [] users = {"Mike","Shrry","Lena","Jane"};
    private static String [] movies = {"Babi","The King","The Queen","The PikaQiu","Pokemon"};
    private static int[][] allUserMovieScoreList = {
            {5,3,3,0,0},
            {1,4,4,2,0},
            {0,2,2,5,5},
            {4,0,0,3,4}};
    private static List<List<Object>> similarUsers = null;
    private static List<String> targetRecommendMovies = null;
    private static Integer targetUserIndex =null;
    private static List<String> commentedMovies = null;

    public static void main(String[] args) {
        System.out.println("请输入用户名：");
        Scanner sc = new Scanner(System.in);
        String user = sc.nextLine();
        while(user!=null && !"exit".equals(user)){
            targetUserIndex = getUserIndex(user);
            if (targetUserIndex==null){
                System.out.println("对不起，您输入的用户不存在！");
            }else {
    //            计算相似度得到最相近的两个用户
                calcUserSimilarity();
    //            推荐电影
                calcRecommendMovie();
    //            处理电影列表
                handleRecommendMovies();
                System.out.println("为其推荐的电影：");
                for (String item : targetRecommendMovies) {
                    if (!commentedMovies.contains(item)) {
                        System.out.print("《" + item + "》" );
                    }
                }
                System.out.println();
            }
            user = sc.nextLine();
            targetRecommendMovies = null;
        }
    }

    public static Integer getUserIndex(String user){
        if(user==null||" ".equals(user))
            return null;
        for (int i = 0; i < users.length; i++) {
            if(user.equals(users[i])){
                return i;
            }
        }
        return null;
    }

    public static void calcUserSimilarity(){
        similarUsers = new ArrayList<>();
        List<List<Object>> userSimilarities = new ArrayList<>();
        List<Object> userSimilarity =null;

        for (int i = 0; i < users.length; i++) {
            if(targetUserIndex == i){
                continue;
            }
            userSimilarity = new ArrayList<>();
            userSimilarity.add(i);
            userSimilarity.add(caclTwoUserSimilarity(allUserMovieScoreList[i],
                    allUserMovieScoreList[targetUserIndex]));
            userSimilarities.add(userSimilarity);

        }
        sortCollection(userSimilarities,1);
        similarUsers.add(userSimilarities.get(0));
        similarUsers.add(userSimilarities.get(1));
    }

    public static double caclTwoUserSimilarity(int[] user1score,int[] user2score){
        float sum = 0;
        for (int i = 0; i < movies.length; i++) {
            sum += Math.pow(user1score[i]+user2score[i],2);
        }
        return Math.sqrt(sum);
    }

    public static void sortCollection(List<List<Object>> us,int order){
        Collections.sort(us, new Comparator<List<Object>>() {
            @Override
            public int compare(List<Object> objects, List<Object> t1) {
                double one = Double.parseDouble(objects.get(1).toString());
                double two = Double.parseDouble(t1.get(1).toString());
                if(one > two){
                    return order;
                }else if(one < two){
                    return -order;
                }else {
                    return 0;
                }
            }
        });
    }

    public static void calcRecommendMovie(){
        targetRecommendMovies = new ArrayList<>();
        List<List<Object>> recommendedMovies = new ArrayList<>();
        List<Object> recommendedMovie = null;
        double recommendRate = 0,sumRate = 0;
                for (int i = 0; i < movies.length; i++) {
                    recommendedMovie = new ArrayList<>();
                    recommendedMovie.add(i);
                    recommendRate = allUserMovieScoreList[Integer.parseInt(similarUsers.get(0).get(0).toString())][i]
                            * Double.parseDouble(similarUsers.get(0).get(1).toString())
                            + allUserMovieScoreList[Integer.parseInt(similarUsers.get(1).get(0).toString())][i]
                            * Double.parseDouble(similarUsers.get(1).get(1).toString());
                    recommendedMovie.add(recommendRate);
                    recommendedMovies.add(recommendedMovie);
                    sumRate += recommendRate;
        }
                sortCollection(recommendedMovies,1);

        for (List<Object> item : recommendedMovies) {
            if (Double.parseDouble(item.get(1).toString()) > sumRate/movies.length){
                targetRecommendMovies.add(movies[Integer.parseInt(item.get(0).toString())]);
            }
        }
    }
    
    public static void handleRecommendMovies(){
        commentedMovies = new ArrayList<>();
        for (int i = 0; i < allUserMovieScoreList[targetUserIndex].length; i++) {
            if (allUserMovieScoreList[targetUserIndex][i] != 0){
                commentedMovies.add(movies[i]);
            }
        }
        
    }
}