catan | Settlers of Catan map generator | Generator Utils library

It appears that the textio lib needs the jline library (https://mvnrepository.com/artifact/jline/jline/2.14.6).

Download the jar and add it to the dependencies of the project.

We had the same problem with the catan project ;)

New Answer based on comments and updated question:

The line ManyDice die = new ManyDice(); is wiping your dice list clean every loop through your program. It's replacing your variable with a new instance of the class, with a fresh list and all.

Simply move that line before the start of the loop:

before the line do {

and then every iteration will use the same instance of ManyDice, and will all share the variable die, without overwriting it.

OLD ANSWER: From what I can see, your program only runs once. And then you need to start it again to put in another dice. Your main function only asks for input once. Whenever you start the program again, all the memory used in the program gets cleared. Unless I’m missing something, that is why your list continues to be reset. You’re actually running a completely new program the next time you try to add dice. So it has no knowledge of the previous runs.

One solution is to say (pseudo code)

Did you mean to loop over items?

The question to ask here is what value you're getting out of the Singleton behavior. You've described this as "only if there is no sense to have more than one, and when there is a need to access them from all over the program". The nuance there is that even if it wouldn't be useful to have more than one, you might choose against Singleton: It might be fine to allow multiple instances to be created if that doesn't have any significant downsides.

Remember, if you implement Singleton well, that object cannot be destroyed throughout the lifetime of the application, and you'll need to synchronize the creation of the object so multiple threads can't create multiple instances. For heavy objects, or objects with heavy dependencies, that might actually lead to greater long-term memory usage because you cannot destroy or garbage-collect the object throughout your app's lifecycle. That leaves a gap between which objects can be Singleton and which objects should be Singleton. It'll require your judgment.

Some factors to consider:

1. Will your application be correct if more than one is created? For something like a DatabaseService or StorageService, the answer might be "no", in which case Singleton behavior is absolutely required.

2. Will your application have good performance if more than one is created? For something like a WebRequestService, there may be some additional value in having one object queue or manage the requests, and that might be a good motivation to make it Singleton.

3. If your object does not have to be Singleton, is it expensive to create, or will it be created often enough to want to reuse the object? In this case you have to weigh the expense of creation versus the expense of the Singleton. Imagine a Dictionary or SpellChecker where the results are correct even if you create a new one, but you want to minimize the number of times you have to read the dictionary file from disk. There are sometimes more options than Singleton, such as Dagger's @Reusable scope, which would give you some of the benefits with fewer costs.

For your Dice class:

• If a Dice class represents exactly one dice roll determined when the object is created, obviously it can't be Singleton, because then you could only roll the dice once and it would always return the same value. You probably don't want that.
• If your Dice class represents a pure (pseudo)random number generator, it generally won't have to be Singleton: It's probably cheap to create, and there's probably no advantage to asking the same object in sequence. You could plausibly make this "reusable" or keep the Dice objects in a pool to avoid recreating them, but if I were writing the code I think it'd be unlikely for that to be worthwhile.
• If you would like your games to be repeatable, such as to have predictable games in integration tests, it might make sense to have the Dice object be Singleton: In that case you might want the single object so it can be called in the same order and receive the same random-seeded results.
• If you're calling out to a random number service like https://www.random.org, it may be important to make the object Singleton so it can batch, cache, and reuse those requests.

For "Dice" I'd make that "scopeless", creating a new instance every time and allowing for its replacement in tests. In contrast, it probably makes sense for your Board, Game, or GameState object to be Singleton across the application.

One issue is you might get duplicates in your randomized gamespicked array. It might be better to shuffle the array (randomize it) and then just get the slice of X items, like this. Notice that I change the numOfGames value from a string to a number by prepending it with +

So here is the problem :

By slice I think you mean Array.

Regardless of whether you include the section or not, the

First you map to get the array of value from col2-5 for each object, then reduce it to find the max for the corresponding column