efficiently searching arrays without using index?

So I am making a text based rpg for a class. Currently the functionality is working for one room which is all I currently want. However I want a more efficient way of doing this. I want to do this without indexes. I want to print a list of elements from the text file from contains(3.a) to the point where end.3 is. Can any of you vets help me? . This is my first attempt at this type of project. The reason I am asking this early is because this is the intro into the project and the final project at the end of the semester will be a parsed 40 page text file.

The text file

1.a

Outside building
-------
WEST       2
UP         2
NORTH      3
IN         3

end.1

2.a

End of road
You are at the end of a road at the top of a small hill.
You can see a small building in the valley to the east.
------
EAST      1
DOWN      2

end.2

3.a

Inside building
You are inside a building, a well house for a large spring
-------
SOUTH    1
OUT      1

end.3

The code

public static void main(String[] args)throws FileNotFoundException{ 
	
	
	int direction = 0;
	Scanner s = new Scanner(new File("C:\\Users\\Basil Sheppard\\eclipse-workspace\\software practice\\src\\software\\rooms.txt"));
	Scanner choice = new Scanner(System.in);
	ArrayList<String> listS = new ArrayList<String>();
	

	while ( s.hasNextLine()) 
		listS.add(s.nextLine());
	
	
	System.out.println("please enter 3 for testing");
    direction = choice.nextInt();

	switch (direction){

//tests for room 3	
	case 3: {
	boolean found = listS.contains("3.a");
    if(found) {
    	for(int i = 22; i<27; i++) {
	        System.out.println(listS.get(i));
	    }
    }
   			 				
} 

Your approach looks entirely wrong.

What I would do:

1. Create a class MapLocation, with the following:
   1. Title, String
   2. Description, String[]
   3. Navigation, MapNavi[]
2. Create another class MapNavi, with the following:
   1. MapLoc, int
   2. Direction, String
3. Read and parse entire file into MapLocation[]
4. Process input and traverse MapLocation[]

The structure of the file seems to be:

(#.a
Title
Description Lines*
-------
MapNavi+
end.#)+

So you could either build a parser to process the file as above, which is quite trivial. You could also parse the entire file using purely RegEx.

Sample parser:

try (BufferedReader br = new BufferedReader(new InputStreamReader(getClass().getResourceAsStream(_FILE_NAME))))
{
String line;
int state = 0;
MapLocation currSegment = null;
while ((line = br.readLine()) != null)
{
switch (state)
{
case 0:
if (line.endsWith(".a"))
{
String segId = line.substring(0, line.indexOf(".a"));
currSegment = new MapLocation(Integer.parseInt(segId));
state++;
}
break;
case 1:
if (line.length() != 0)
{
currSegment.setTitle(line);
state++;
}
case 2:
if ("-------".equals(line))
{
state++;
} else if (line.length() > 0)
{
currSegment.addDescription(line);
}
case 3:
if (line.equals("end." + currSegment.getSegId()))
{
mapLocations.put(currSegment.getSegId(), currSegment);
currSegment = null;
state = 0;
} else if (line.length() > 0)
{
String[] nav = line.split("\t");
Integer mapLoc = Integer.parseInt(nav[1]);
currSegment.addNavi(mapLoc, nav[0]);
}
}
}
}

Once the file is parsed into the mapLocations container, you are ready to process input:

try (Scanner in = new Scanner(System.in))
{
MapLocation currLoc = // startLocation;
while (!quitSignal.equals(line = in.nextLine()))
{
int mapLoc = Integer.parseInt(line);
if (currLoc.validateNav(mapLoc))
{
currLoc = mapLocations.get(mapLoc);
System.out.println("You travel to " + currLoc.getTitle());
System.out.println(currLoc.toString());
}
else
{
System.out.println("You cannot travel to location '" + line + "' from here.  Please re-select your destination.");
}
}
}

You should look into storing your path as an xml file! Java has some cool ways to read them and it can understand elements in a list. You can even write to xml for easier constructing your game. Check this out for how to read in xml: https://stackoverflow.com/a/428091/9789673

Try this.

try (Scanner s = new Scanner(new File("C:\\Users\\Basil Sheppard\\eclipse-workspace\\software practice\\src\\software\\rooms.txt"))) {
Scanner choice = new Scanner(System.in);
ArrayList<String> listS = new ArrayList<String>();
while (s.hasNextLine())
listS.add(s.nextLine());
System.out.println("please enter 3 for testing");
int direction = choice.nextInt();
listS.stream()
.dropWhile(x -> !x.equals(direction + ".a"))
.takeWhile(x -> !x.equals("end." + direction))
.forEach(System.out::println);
System.out.println("end." + direction);
}

output

3.a
Inside building
You are inside a building, a well house for a large spring
-------
SOUTH    1
OUT      1
end.3

Note that .takeWhile(x -> !x.equals("end." + direction)) discards end.3 itself.

I think you need to think about two main things:

• Structure your file so that its lines have a fairly consistent structure that is easy to parse.
• Think about how you can organise your code so that you only scan through the file once, creating classes to store the data in memory in an organised way the first time you read through the file. (Yes, in a sense, this is an "index", but you can't have it both ways: either you store/index information from the file the first time you scan it, or you throw the information away and have to scan through it again on the next query, which is inherently inefficient.)

For example, you might structure your file something like this:

BEGIN:LOCATION:1
BEGIN:DESCRIPTION:
A house.
END:DESCRIPTION
BEGIN:DIRECTIONS
NORTH:3
SOUTH:4
END:DIRECTIONS
END:LOCATION

In other words, the lines generally consist of 'command':'subcommand', and given a line in the file, it is fairly easy to split this into its components (look at String.indexOf(), String.substring(). If you can, look at the regular expressions API: see the Pattern and Matcher classes. (Theoretically, this can bring some efficiencies when you are trying to scan the same line/text for a number of different patterns/substrings simultaneously, and is the approach you'd generally use if you were scanning large volumes of text for more complex patterns/commands. For your purposes, you would also be fine with the simple String methods-- indexOf(), substring() etc-- if you find these easier to get to grips with.)

Others have mentioned XML: this is one a structured format that you could also consider, and comes with the advantage of standard parsing routines built into the Java platform. But there's nothing inherently wrong with a plain old text file in a format that you've devised so long as it's consistent and it's easy to write a routine to parse it...