Блог

Мне нужно использовать цикл for для поиска и отображения определенных игроков в каждом списке, как бы я использовал цикл for для поиска «Ниа Рид», предполагая, что вы не знаете, в какой вид спорта играет Ниа. Любая помощь приветствуется.

Я пытался сделать это, чтобы отобразить Kat Asman из Soccer Names, но я не уверен, как это сделать без использования Soccer Names.

 ArrayList<String> nList = new ArrayList<String>();
     String findString = "Kat Asman";

    for(String s: SoccerNames){
        if(s.contains(findString)){
            nList.add(s);
        }
        System.out.println(nList);
    }  
  

Это полная программа

 import java.util.ArrayList;
public class ArraysPrep
{

ArrayList<String> FootballNames;
ArrayList<String> VolleyballNames;
ArrayList<String> SoccerNames;
ArrayList<ArrayList<String>> bigArray;

public ArraysPrep()
{
    FootballNames = new ArrayList<>();
    VolleyballNames = new ArrayList<>();
    SoccerNames = new ArrayList<>();
    bigArray = new ArrayList<>();

    fillInNames();
    fillInBigTable();
}

private void fillInNames()
{
    FootballNames.add("Marcus Allen");
    FootballNames.add("Kyle Alston");
    FootballNames.add("Troy Apke");
    FootballNames.add("Matthew Baney");
    FootballNames.add("Saquon Barkley");

    VolleyballNames.add("Kendall White");
    VolleyballNames.add("Kaitlyn Hord");
    VolleyballNames.add("Bryanna Weiskircher");
    VolleyballNames.add("Nia Reed");
    VolleyballNames.add("Serena Gray");
    VolleyballNames.add("Alli Frantti");

    SoccerNames.add("Amanda Dennis");
    SoccerNames.add("Emily Ogle");
    SoccerNames.add("Ellie Jean");
    SoccerNames.add("Kat Asman");
    SoccerNames.add("Laura Suero");

/** for (String s: SoccerNames){
System.out.println(s);
}
*/

ArrayList<String> nList = new ArrayList<String>();
     String findString = "Kat Asman";

    for(String s: SoccerNames){
        if(s.contains(findString)){
            nList.add(s);
        }
        System.out.println(nList);
    }
}

private void fillInBigTable()
{
    bigArray.add(SoccerNames);
    bigArray.add(VolleyballNames);
    bigArray.add(FootballNames);


}


}



''''''''
public class app
{

public static void main(String[] args)
{
    ArraysPrep ap = new ArraysPrep();
}

}
  

Я действительно не думаю, что вам нужно перебирать весь список массива, чтобы найти, содержится ли в нем элемент.

Это:

 for(String s: SoccerNames) {
    if(s.contains(findString)) {
        nList.add(s);
    }
}
  

Может быть заменено этим:

 if(nList.contains(findString)) {
    nList.add(s);
}
  

Затем вы можете выполнить цикл bigArray и сделать что-то подобное для каждого из списков массива, чтобы отобразить определенное имя.

В качестве дополнения, я думаю, вам следует использовать класс с несколькими полями для ваших спортсменов.

Это может быть что-то вроде этого:

 public class Athlete {

private String name;
private Sport sport;

public Athlete(String name, Sport sport) {
    this.name = name;
    this.sport = sport;
}

public String getName() {
    return name;
}

public Sport getSport() {
    return sport;
}
  

}

Или создать несколько реализаций интерфейса Athete, например:

 Volleyballist extends Atlete // or implements
  

Таким образом, вы могли бы использовать только один ArrayList и хранить там всех ваших спортсменов и выполнять поиск в нем.

С учетом того, как вы подходите к проблеме, я думаю, что лучшим решением является создание списка, в котором выбираются значения 3 других элементов, а затем поиск с помощью for .

 private void lookingFor(String player){
    ArrayList<String> all = new ArrayList<String>();
    all.addAll(SoccerNames);
    all.addAll(FootballNames);
    all.addAll(VolleyballNames);

    for(String a : all) {
        if(player == a) {
            bigList.add(a);
            break;
        }
    }


    }
  

Я это не тестировал. Но я думаю, вам следует создать класс игроков с его именем, идентификатором и видом спорта, в который он играет, и выбрать вместо этого этот атрибут. Таким образом, вы даже можете создать один список вместо четырех.

 public class Player {
    private Integer id;
    private String name;
    private String sport;

    public Player() {
        // TODO Auto-generated constructor stub
    }

    public Player(Integer id, String name, String sport) {
        super();
        this.id = id;
        this.name = name;
        this.sport = sport;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSport() {
        return sport;
    }

    public void setSport(String sport) {
        this.sport = sport;
    }


}
  

И затем:

 ArrayList<Player> players;
ArrayList<Player> bigList;

private void filterPlayer(String name){
for(Player p : players){
if(p.getName() == name){
bigList.add(p);
break;
}
}
}
  

Прежде всего, не используйте списки. Используйте наборы — они не допускают повторения, и я уверен, что вам не нужна возможность дважды включать player в один и тот же список (бьюсь об заклад, в вашем домене это не имеет смысла).

У Set есть метод contains , который сразу сообщит вам, содержится элемент в наборе или нет — без каких-либо циклов вообще.

Затем, если вы хотите иметь возможность определить, в каком из наборов содержится игрок (например, играл ли он в футбол или волейболе), не повторяя этот конкретный вид спорта — вы могли бы поместить эти наборы в a, Map где a String с названием вида спорта было бы ключом, а Set<String> было бы значением.

И да, не давайте локальным переменным имен полей, начинающихся с символа верхнего регистра — это противоречит соглашениям о коде Java.

Пример кода:

 import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;

public class Test {

    Map<String, Set<String>> sportsToPlayers = new LinkedHashMap<>();

    public void populatePlayers() {
        Set<String> footballPlayers = new LinkedHashSet<>();
        Set<String> volleyballPlayers = new LinkedHashSet<>();
        Set<String> soccerPlayers = new LinkedHashSet<>();

        footballPlayers.add("Marcus Allen");
        footballPlayers.add("Kyle Alston");
        footballPlayers.add("Troy Apke");
        footballPlayers.add("Matthew Baney");
        footballPlayers.add("Saquon Barkley");

        volleyballPlayers.add("Kendall White");
        volleyballPlayers.add("Kaitlyn Hord");
        volleyballPlayers.add("Bryanna Weiskircher");
        volleyballPlayers.add("Nia Reed");
        volleyballPlayers.add("Serena Gray");
        volleyballPlayers.add("Alli Frantti");
        // Added to test for multiple sports for 1 player
        volleyballPlayers.add("Kat Asman");

        soccerPlayers.add("Amanda Dennis");
        soccerPlayers.add("Emily Ogle");
        soccerPlayers.add("Ellie Jean");
        soccerPlayers.add("Kat Asman");
        soccerPlayers.add("Laura Suero");

        sportsToPlayers.put("Football", footballPlayers);
        sportsToPlayers.put("Volleyball", volleyballPlayers);
        sportsToPlayers.put("Soccer", soccerPlayers);
    }

    private Set<String> findPlayerSports(String playerName) {
        Set<String> result = new LinkedHashSet<>();
        for (Map.Entry<String, Set<String>> sportsToPlayersEntry : sportsToPlayers.entrySet()) {
            String sportName = sportsToPlayersEntry.getKey();
            Set<String> playerNames = sportsToPlayersEntry.getValue();
            if (playerNames.contains(playerName)) {
                result.add(sportName);
            }
        }
        return resu<
    }

    private String findPlayerSport(String playerName) {
        for (Map.Entry<String, Set<String>> sportsToPlayersEntry : sportsToPlayers.entrySet()) {
            String sportName = sportsToPlayersEntry.getKey();
            Set<String> playerNames = sportsToPlayersEntry.getValue();
            if (playerNames.contains(playerName)) {
                return sportName;
            }
        }
        return null;
    }

    public Test() {
        populatePlayers();
    }

    public static void main(String[] args) throws Exception {
        Test test = new Test();
        // Find all sports for player
        System.out.println(test.findPlayerSports("Kat Asman"));

        // Find one sport for player
        System.out.println(test.findPlayerSport("Kat Asman"));

    }
}
  

 ArrayList<String> nList = new ArrayList<String>();
     String findString = "Kat Asman";
     List<String> lst = new ArrayList(Arrays.asList(SoccerNames));
     lst.addAll(Arrays.asList(FootballNames));
     lst.addAll(Arrays.asList(VolleyballNames));

    for(String s: lst){
        if(s.contains(findString)){
            nList.add(s);
        }
        System.out.println(nList);
    }  
  

Вы можете использовать метод объединения нескольких массивов в один массив / список, чтобы вы могли выполнять итерации по всем трем массивам всего за один цикл.

Надеюсь, это сработает.