Piet Souris

Well, I always use doubles, that is not a problem. What I sometimes find a problem around here, is that personal opinions are being sold as if they were the truth, the whole truth and nothing but the truth.

Besides, if you use Processing (see Processing.org) then you notice that floats are standard, and I've seen no example whatsoever where that leads to any problem at all.

@Carey,

as I wrote to Tangara in one of my replies:

"No, all this is not necessary, your way is as good as mine, but I find my way more comfortable."

As I said, I hate nested index loops, like I hate incomprehensible cli-commands, so I was only showing a way that I find easy.

And your comment about optimizing made me have another think. Indeed I do some redundant checking. I have in my Matrix-class a method 'Matrix getMinorMatrix(int[][] a, int skipRow, int skipCol), and so to eliminate unnecessary checking, I could have this method:
public static boolean isSymmetric2(int[][] a) {    if (!isSquare(a)) throw new RuntimeException("array is not square!");    return Arrays.equals(a[0], getColumn(a, 0)) && isSymmetric2(minorMatrix(a, 0, 0)); }
But admitted, that tends to pure hobbyism!

@Jesse
I've never been involved as a professional programmer, albeit I used things like Basic, C and Java at home, and Excel, VBA and R in my job. So I am not hindered by any professional standard there may be, I am as free as a bird to follow any convention I like, even self-made conventions!

Carey Brown wrote:

Piet Souris wrote:for me the advantage of using Streams is that is makes things much more comprehensible.

Not comprehensible if you don't know what getColumn() is.

Does a person exist who is working with matrices and has no clue what the method 'getColumn' means?

Carey Brown wrote:Can this be refactored to take advantage of the optimization I mentioned?

I stick to
.allMatch(i -> Arrays.equals(a[i], getColumn(a, i)))
But my point was to give an alternative to nasty nested index loops. Perhaps I was not clear enough in my writing.

And to add to all previous repliers: a way to get both 'in Pooler" and "in Threader" printed is to override the run-method in Pooler as follows:
class Threader extends Thread {    @Override    public void run() {        System.out.println("In Threader");    } } class Pooler extends Thread {        public Pooler(Runnable r) {        super(r);  //1    }        @Override    public void run() {        super.run();        System.out.println("In Pooler");    } } class TestClass2 {    public static void main(String[] args) {        Threader t = new Threader();        Thread h = new Pooler(t);  //2        h.start(); //3    } }

hi Tangara,

for me the advantage of using Streams is that is makes things much more comprehensible. If there is anything I hate then it is using nasty nested index-loops.

Now, if you have a 2D array 'a' in java, then it is very easy to acces the rows of a. For instance, a[2] will give you the third row. Unfortunately, there is no equivalent easy way to acces the columns. To acces the columns, it is required that matrix a is rectangular. i.e. all rows have the same length. I have a method in my library called 'int[] getColumn(int[][] a, int index)'
and it goes:
public static int[] getColumn(int[][] a, int index) {    if (!a.isRectangular()) throw new RuntimeException("...");    return Arrays.stream(a)   // gives all the rows of a, one by one                 .mapToInt(row -> row[index])   // map each row to the int row[index]                 .toArray()   // and make an int[] array of all these ints    ; }
and so I avoid that nasty index juggling as much as possible, and I do not need to worry about the dimensions of my result-array. And as far as symmetric concerns, a Matrix is symmetric if row 1 equals column 1, row 2 equals column 2, et cetera.

No, all this is not necessary, your way is as good as mine, but I find my way more comfortable.

A Matrix can only be symmetric if that Matrix is square. And in that case you can avoid all those nested ifs with:
public static boolean isSymmetric(int[][] a) {    // a supposed to be square    return IntStream.range(0, a[0].length)        .allMatch(i -> Arrays.equals(a[i], getColumn(a, i)))    ; }

Carey is right, you will have a resizing problem.

But you can use this.getWidth() and this.getHeight() in your menubar-class For instance:
class MyMenuBar extends JMenuBar {        @Override        protected void paintComponent(Graphics g) {           // no need for a call to super, since the fill overwrites the background anyway           var g2d = (Graphics2D) g.create();           g2d.setPaint(determinePaint());           g2d.fill(new Rectangle2D.Double(0, 0, getWidth(), getHeight()));           g2d.dispose();        }                private Paint determinePaint() {            return new LinearGradientPaint(new Point2D.Double(), new Point2D.Double(getWidth(), getHeight()),                                           new float[]{0.1F, 0.5f, 1.0F},                                           new Color[]{Color.GREEN,Color.yellow, Color.pink},                                           CycleMethod.NO_CYCLE                                          )            ;        }        MyMenuBar() {        super();        add(new JMenu("File"));        add(new JMenu("Utilities"));    } }
and to get this working from the start, use for instance:
public class HopeSpartan {    public static void main(String... args) {        SwingUtilities.invokeLater(HopeSpartan::new);    }        HopeSpartan() {        var panel = new JPanel();        panel.setPreferredSize(new Dimension(300, 300));        panel.setBackground(Color.CYAN);        var f = new JFrame();        f.setContentPane(panel);        var menuBar = new MyMenuBar();        f.setJMenuBar(menuBar);        f.pack();        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);        f.setLocationRelativeTo(null);        f.setVisible(true);        menuBar.repaint();    } }

According to your Comparator, "c" and "d" are considered the same, since their lengths are 1. So it finds "c" at location 0.

Hi Jesse,

The method name is 'isCharacterPresentInAllNames'

I would put the addGenre method in the Genre enum.
Make a static Map<Character, Genre> in Genre, and initialize it.
Add a static method
getGenre(char c) {return map.get(c);}
and then you can find your enum by using
Genre.getGenre('e');

Since Einstein we know that almost everything is relative. So they may have seen 'earth from above', we've seen a 'rocket from below', and that free of charge.

I did, PAUL, but still the lines do not line up at the end. In my IDE, the output lines up as it should.

Confusing topic. Op's code in his opening post is almost correct. Instead of the line (68)
emps.sort();  ///[b]How can I call sort method?[/b]
it sould either be
emps.sort(EmployeeInfo.SortMethod.BYNAME);
or
emps.sort(EmployeeInfo.SortMethod.BYSALARY);
and for your latest question:how about
entities.stream().allMatch(???????);

A strategy could be:

let the String 'word' be "######", the number of repeats 100, the separator 'sep' "  " (two spaces) and the linelength 90.

Now, form a String 'longString' containing 100 times the word, and in between two consecutive words the sep. That makes longString 798 characters long.

Now, the string 'word' + 'sep' has length 8 and fits 11 times in the given linelength of 90. So we could as our first line, print the first 88 characters of longString. But then that line would end in two spaces, which is undesirable. So, from 88 we subtract the lenght of 'sep', giving 86.

And finally, we split our longString into substrings of length 86, and eventually a rest substring. In effect, I am adjusting the given linelength from 90 to 86.

For the given values, you would get this output (unfortunately, I cannot choose a monospaced font, so the lines look ragged)

######  ######  ######  ######  ######  ######  ######  ######  ######  ######  ######
 ######  ######  ######  ######  ######  ######  ######  ######  ######  ######  ####
##  ######  ######  ######  ######  ######  ######  ######  ######  ######  ######  ##
####  ######  ######  ######  ######  ######  ######  ######  ######  ######  ######  
######  ######  ######  ######  ######  ######  ######  ######  ######  ######  ######
 ######  ######  ######  ######  ######  ######  ######  ######  ######  ######  ####
##  ######  ######  ######  ######  ######  ######  ######  ######  ######  ######  ##
####  ######  ######  ######  ######  ######  ######  ######  ######  ######  ######  
######  ######  ######  ######  ######  ######  ######  ######  ######  ######  ######
 ######  ######  ######

I made these methods:
public static String makeLongString(String word, int wordRepeat, String separator) {    // to do } and
public static List<String> makeRivers(String word, int wordRepeat, int lineLength, String sep) {    // todo }