Non-static field 'peopleList' cannot be referenced from a static context

在Java中，非静态字段（non-static field）是属于类的实例（对象）的，而静态上下文（static context）是属于类本身的。因此，在静态上下文中无法直接引用非静态字段。

如果你在静态方法或静态代码块中尝试引用非静态字段，编译器会报错并提示"Non-static field 'peopleList' cannot be referenced from a static context"。

要解决这个问题，你可以通过以下两种方式之一来访问非静态字段：
1. 创建类的实例，并通过实例来访问非静态字段。
2. 将非静态字段改为静态字段，或者将访问该字段的方法改为静态方法。

相关问题

def login(): print("*" * 30) print("##登录界面：") account = input("**账号：") password = input("**密码：") print("*" * 30) file = open("用户表.txt", 'r', encoding='utf-8') peoplelist=file.read() print(peoplelist) for key,val in peoplelist: if key==account and val==password: print("登录成功") print(peoplelist)

这段代码是一个简单的登录函数，但是有几个问题：

1. `peoplelist` 变量的值是一个字符串，而不是一个列表，因此在 `for` 循环中使用 `key` 和 `val` 不会按照你期望的方式工作。你需要将 `peoplelist` 转换为一个列表，例如使用 `split()` 方法。

2. 如果用户输入的账号和密码匹配，则会输出 "登录成功"，但是没有做任何其他操作，比如返回一个表示登录成功的值或者跳转到其他页面。你需要在登录成功时添加相应的操作。

下面是修改后的代码：

def login():
    print("*" * 30)
    print("##登录界面：")
    account = input("**账号：")
    password = input("**密码：")
    print("*" * 30)
    
    with open("用户表.txt", 'r', encoding='utf-8') as file:
        peoplelist = file.read().split('\n')
        
    for people in peoplelist:
        key, val = people.split(',')
        if key == account and val == password:
            print("登录成功")
            # 在此添加登录成功后的操作
            return True
    
    print("账号或密码错误")
    return False

这里使用了 `with` 语句来打开文件，这样可以自动关闭文件并且更加安全。同时，将读取到的字符串使用 `split('\n')` 方法转换为了一个列表，列表中的每个元素代表一个用户的账号和密码，使用 `,` 分隔开。在 `for` 循环中，使用 `split()` 方法将每个元素拆分为账号和密码，然后比较输入的账号和密码是否和列表中的某个元素匹配。如果匹配成功，输出 "登录成功" 并返回 `True`，否则输出 "账号或密码错误" 并返回 `False`。这样在调用 `login()` 函数时，可以根据返回的值来判断登录是否成功。

把下面这段js代码转换成java代码/** * * @param {array} peopleList 选手列表 * @param {number} round_num 每人打的场数，默认选手人数-1 */ function getTempMatchList(peopleList,round_num) { let p_num = peopleList.length; let partner_group_list = []; //所有有可能搭档的组 let partner_group_list_real = []; //出场的搭档数组 let p_should_round_num = {}; //记录每人上场的次数对象 let ground_num = 0; for (let i = 0; i < peopleList.length; i++) { p_should_round_num[peopleList[i]] = peopleList.length-1; //预先定下前面的搭档池数 } if((p_num*round_num)%4==0){ //整除 ground_num = Math.floor(peopleList.length*round_num/2); for (let i = 0; i < peopleList.length; i++) { const e = peopleList[i]; for (let j = i+1; j < peopleList.length; j++) { const e1 = peopleList[j]; partner_group_list.push([e,e1]); //准确的搭档池 } } partner_group_list_real = [...partner_group_list]; if(round_num>peopleList.length-1){ //必须每人多打几场 let temp_partner_group_list = [...partner_group_list]; let flag = true; while (flag) { //随机拿一组出来 let index = Math.floor(Math.random()*temp_partner_group_list.length); let partner_group_list_real_one = temp_partner_group_list.splice(index,1); let p1 = partner_group_list_real_one[0][0]; let p2 = partner_group_list_real_one[0][1]; if(p_should_round_num[p1]<round_num&&p_should_round_num[p2]<round_num){ partner_group_list_real.push(partner_group_list_real_one[0]); p_should_round_num[p1] +=1; p_should_round_num[p2] +=1; } if(partner_group_list_real.length==ground_num){ flag = false; } } } return partner_group_list_real; }else{ return []; } }

以下是将 JavaScript 代码转换为 Java 代码的尝试：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;

public class Main {
    public static void main(String[] args) {
        List<String> peopleList = new ArrayList<>();
        peopleList.add("A");
        peopleList.add("B");
        peopleList.add("C");
        peopleList.add("D");
        int round_num = 3;
        List<List<String>> partner_group_list_real = getTempMatchList(peopleList, round_num);
        System.out.println(partner_group_list_real);
    }

    public static List<List<String>> getTempMatchList(List<String> peopleList, int round_num) {
        int p_num = peopleList.size();
        List<List<String>> partner_group_list = new ArrayList<>(); // 所有有可能搭档的组
        List<List<String>> partner_group_list_real = new ArrayList<>(); // 出场的搭档数组
        Map<String, Integer> p_should_round_num = new HashMap<>(); // 记录每人上场的次数对象
        int ground_num = 0;
        for (int i = 0; i < peopleList.size(); i++) {
            p_should_round_num.put(peopleList.get(i), peopleList.size() - 1); // 预先定下前面的搭档池数
        }
        if ((p_num * round_num) % 4 == 0) { // 整除
            ground_num = (int) Math.floor(peopleList.size() * round_num / 2);
            for (int i = 0; i < peopleList.size(); i++) {
                String e = peopleList.get(i);
                for (int j = i + 1; j < peopleList.size(); j++) {
                    String e1 = peopleList.get(j);
                    List<String> partner_group = new ArrayList<>();
                    partner_group.add(e);
                    partner_group.add(e1);
                    partner_group_list.add(partner_group); // 准确的搭档池
                }
            }
            partner_group_list_real.addAll(partner_group_list);
            if (round_num > peopleList.size() - 1) { // 必须每人多打几场
                List<List<String>> temp_partner_group_list = new ArrayList<>(partner_group_list);
                boolean flag = true;
                Random rand = new Random();
                while (flag) {
                    // 随机拿一组出来
                    int index = rand.nextInt(temp_partner_group_list.size());
                    List<String> partner_group_list_real_one = temp_partner_group_list.remove(index);
                    String p1 = partner_group_list_real_one.get(0);
                    String p2 = partner_group_list_real_one.get(1);
                    if (p_should_round_num.get(p1) < round_num && p_should_round_num.get(p2) < round_num) {
                        partner_group_list_real.add(partner_group_list_real_one);
                        p_should_round_num.put(p1, p_should_round_num.get(p1) + 1);
                        p_should_round_num.put(p2, p_should_round_num.get(p2) + 1);
                    }
                    if (partner_group_list_real.size() == ground_num) {
                        flag = false;
                    }
                }
            }
            return partner_group_list_real;
        } else {
            return new ArrayList<>();
        }
    }
}

需要注意的是，在 Java 中，数组是固定长度的，而 List 是可变长度的，所以需要使用 List 来替代数组，并且需要使用泛型来指定 List 中存储的数据类型。此外，Java 中的 Map 是类似于 JavaScript 中的对象的数据结构，也需要注意使用。