Mark Ii

Hi! Mr. Ritchie how about the following code? What do you think? Please feel free to let me know.



package isAlphaOrNumber; import java.util.regex.Pattern; public class IsAlphaOrNumber { private static Pattern pattern = Pattern.compile("-?\\d+(\\.\\d+)?"); public static boolean isNumeric(String strNum) {    if (strNum == null) {        return false;    }    return pattern.matcher(strNum).matches(); } public static void main(String[] args) { String aString = "0123456789"; //aString = "1234.555"; //aString = "aaaannnffff,.?"; System.out.println(isNumeric(aString) ? "Is numeric." : "Is alphabetical and/or punctuational."); } }

From Runestone's Interactive Python Tutorial there is a section where you can use Turtle to draw fun graphics. You can try to introduce them to graphics first so they see how cool programming can be.

Here is a chapter and URL of second chapter from that website. It's very fun. It's interactive also. You can code yourself if you want to.

Runestone Interactive Python Turtle Graphics: Our first Turtle Program

Python is a very simple programming language. I enjoyed the tutorial. And loved the programming language.

You can try the following code to do the same thing.


import java.util.Arrays; public class ReturnArr { public static int[] retArr() { return new int[] {1,2,3,4,5}; } public static void main(String[] args) { int[] anArray = retArr(); System.out.println(Arrays.toString(anArray)); } }

Sorry I posted too quickly. But this is one of the methods you can use. I know you don't want this way but if you do then this is the way. Sorry.

package isNumOrAlpha; public class isNumOrAlpha { public static boolean isDoubleNumberOrString(String aString) { try { double aNum2 = Double.parseDouble(aString); return true; }catch(NumberFormatException e) { return false; } } public static void main(String[] args) { String aString = "0123456789"; //aString = "mdmdmdmd,.?"; if(isDoubleNumberOrString(aString)) { System.out.println("Is numeric: " + true); }else { System.out.println("Is a String: " + true); } } }

Campbell Ritchie wrote:

Mark Ii wrote:. . . postfix increment operator is used. b is assigned the current value of n first which is 1 then n is incremented. . . .

Afraid that is incorrect. The increment to n occurs first. But the value of n++ is not incremented, i.e. n++ has the old value of n.

Thank you for the correction.

Tomhmas Smith wrote:I am trying to create a code that would populate an array with prime numbers. However, when executing, the answer I get is 12345 instead of  2357 and I cant understand where did I miss the connection between methods.
public class Primearr { public static boolean isPrime(int num) { for (int i =2; i<num/2; i++){ if(num%i ==0) return false; } return true; } public static int[] fillArray(int a){ int[] arr = new int[a]; int m = 0; for (int i = 1; m < arr.length; i++){ if (isPrime(i)){ arr[m] = i; m++; } } return arr; }    public static void main(String[] args) {     int a = Integer.parseInt("5");     int[] arr = fillArray(a);     for(int val:arr){     System.out.print((val+","));     }    } }

public class Primearr {    public static boolean isPrime(int num) {     if(num < 2) return false;     //I have declared i as long because Math.sqrt() and     // return double type. I didn't want to     // lose the precision. What if a number larger than     // integer is passed. That's why i did that.        for (long i =2; i <= (long)(Math.sqrt(num)); i++){                     if((num%i) == 0) {                            return false;                            }        }                return true;    }    public static int[] fillArray(int a){        int[] ArrPrime = new int[a];        int m = 0;        int index  = 0;        boolean isArrFull = false;        while(!isArrFull) {            if (isPrime(m)){                ArrPrime[index] = m;                              index++;            }            if(index >= ArrPrime.length) {             isArrFull = true;            }        m++;        }        return ArrPrime;    }    public static void main(String[] args) {      int a = Integer.parseInt("5");      int[] arr = fillArray(a);      for(int val:arr){          System.out.print((val+","));      }          } }

Annet Rose wrote:My 12 years old child is interested in programming and would like to learn it. How can I teach him coding?

Below you will find a link.

Tutorials and Apps for Children's coding


Hope it helps.

Jonathan Barry wrote: Hi, I'm a complete newbie attempting to learn Java.  This is a task from codegym that I've solved
   but I don't understand why the answers are what they are.  I'm sure I'm missing something obvious,
   but I would like some help understanding how this has an output of 12 and 2?  X is equal to 10 if I
   am deserving of graduated first grade.  What am I missing?

public class JavaClass3 { public static void main(String[] args) { int x = 2; int y = 12; y = x + y; // 14 right? x = y - x; // 10 right? y = y - x; // 10 right? System.out.println(x); System.out.println(y); } }
Thanks for your help.

John

public class JavaClass3 {    public static void main(String[] args) {        int x = 2;        int y = 12;        // here x is 2 and y is 12        // So y = x + y = 2 + 12 = 14        y = x + y;        System.out.println(y);                // Here y is y's current value which is 14 as y is modified        // x is 2 as x is not modified        // x = y - x = 14 - 2 = 12        x = y - x;        System.out.println(x);                // y is 14        // x is modified now. x = 12        // y = y - x = 14 - 12 = 2        y = y - x;        System.out.println(y);            } }

Cosmid Constantine wrote:Hi,

Sample program:
 n = 0;
 a = ++n;
 b = n++;

If the post-increment or post-decrement operator has higher precedence than the pre-increment or pre-decrement operator, then why b didn't get a value of 2? I mean, it would make more logical sense if a = 0 and b = 2 with the precedence of the two.

I guess my question is, if n++ has higher precedence, why didn't it apply the ++ effect sooner than the ++ on the ++n? Is this just a special case in Java?

Thanks

Here n = 0; that's clear. n is given the value 0. Okay then a = ++n; which means prefix increment operator is used. Here a is assigned the value after n has been incremented by 1. So a is equal to 1 now. Then b = n++; postfix increment operator is used. b is assigned the current value of n first which is 1 then n is incremented. Now n is equal to 2 and b is equal to 1

And if you do like this:

public class PrePostIncrement { public static void main(String[] args) { int n = 0; int a = ++n; int b = n++; System.out.println("b equals = " + b); System.out.println("n equals = " + n); } }


You can see the result now.
But if you had

n++; //or ++n;

All by itself it doesn't matter. n will be incremented anyways.
But for n++; it is expensive for huge numbers.

n is evaluated first then n is incremented.
But if you had

++n;

It is little bit less expensive for huge numbers.

Why you should avoid postfix operator?

I hope it helps.

Jesse Silverman wrote:I feel like I know a lot of true statements that have remained true about the "String Literal Pool" or the "String Constant Pool", as I see it variously called in different posts and articles, even within this forum.  If I understand correctly, the behavior has zero dependence on what you compile with, and solely on which JVM is running the code, what's more, I suspect that this all changed ten years ago and is only confusing people because there is so much stale information about SCP out there in old tutorials and archived discussions and old mock exam questions.

My current belief is that the following statements from the certainly great-at-the-time but possibly no longer quite true tutorial on this site may have become inoperative:

When a .java file is compiled into a .class file, any String literals are noted in a special way, just as all constants are. When a class is loaded (note that loading happens prior to initialization), the JVM goes through the code for the class and looks for String literals. When it finds one, it checks to see if an equivalent String is already referenced from the heap. If not, it creates a String instance on the heap and stores a reference to that object in the constant table. Once a reference is made to that String object, any references to that String literal throughout your program are simply replaced with the reference to the object referenced from the String Literal Pool.

A downstream conclusion from this fundamental explication that I believe is no longer applicable now is:
Strings created at run-time will always be distinct from those created from String Literals.

It is my current belief that the String Constant Pool seems to now be built up during code execution, so that if a String Literal that the JVM is considering adding or looking up in the pool has already been added to the heap and then the SCP by executing user code, it will choose that very one as the reference to add to the String Literal Pool.  In the old days, as this was done before a single line of user code executed, at class loading time, that would never ever happen.

The reason this matters so much (or at all) is that the simple downstream conclusion mentioned both in that article and many other places that exam-preparers are reading is no longer operative.  Instead, it instead now depends on whether the code creating the string that is only created at runtime executes before the line that references the string constant!

I never loved these questions about "how many String objects get created?  Where?" which I see from some sources are indicated to be much more common in preparatory materials and mock exams than on real exams.

class SCPTest { public static void main( String... args) { String sub1 = "Du"; String sub2 = "de!"; String sameOrDifferent = sub1.concat(sub2); String somethingElse = sameOrDifferent.intern(); String myConstant = "Dude!"; // Loadtime or Execution time? if (sameOrDifferent == myConstant) { System.out.println("String Constant at commented line: "); System.out.println("Not added to Pool at loading but at runtime!!"); System.out.println("Therefore uses value of sameOrDifferent..."); System.out.println("Which didn't exist until runtime!!"); } if (somethingElse == myConstant) { System.out.println("Well this reference explicitly gets value from intern(): "); System.out.println("So no surprise here."); System.out.println("Same as it ever was!!"); } } }

Referenced "Was-Great-At-The-Time-But-Confusing-To-New-Exam-Takers-Now" article from this site:
https://javaranch.com/journal/200409/ScjpTipLine-StringsLiterally.html

I second Jesse Silverman. What he said makes much more sense to me. Thank you.

Hanna Roberts wrote:

Mark Ii wrote:. . .

Thank you, This code almost worked as well. The last two in my book fails though I'm not sure why. Thanks for your help though I appreciate it.

You are welcome. You said my code almost works. Can you kindly please give situations where it does not work so that I can write you a better version of the code?

Try this instead. I saw your effort in figuring out the code. So thought why not just help you. I am more into helping a person in need. Extremely sorry for my attitude. That is why I am posting the code. Let me know if you wanted this code this way. Or otherwise, you could use the StringBuilder class from Java built-in library and print the string like the other kind and generous forum member showed in the posting.

import java.util.Scanner; public class NumberTrianglePattern {        public static void strPattern(int num1, int num2)    {     int row = num2 - num1;              for(int i = 0; i <= row && num1 <= num2;i++)        {            for(int j = 0; j<= i;j++ )            {                System.out.print(num1);            }             ++num1;                System.out.println("");        }              }// End of your method           public static void main(String[] args)   {            Scanner scnr = new Scanner(System.in);            int num1 = scnr.nextInt();      int num2 = scnr.nextInt();           //it's better to use the class method with the class name for a maintenance issue.     //You will know it's a class method. You don't have to but it's a good     //practice     NumberTrianglePattern.strPattern(num1, num2);         }       }


Input:

2 8

Output:

2 33 444 5555 66666 777777 8888888

Carey Brown wrote:NEVER EVER close a Scanner object that has been created from System.in. This will cause System.in to get closed which is a bad thing. Some IDEs complain if you don't close all Scanner objects but in this case you don't want to do it.

To tell you the truth I never in my life closed System.in Scanner object. This is the first time doing it.

My eclipse IDE latest version of Java 13 sdk was giving a warning. So had to close it. Thank you for clearing that out.

I need some good recommendations here.

Where can I find a good Java 8 SDK Certification training course with the duration of one semester in Scarborough, Ontario (Canada)?

Summer is at the doorstep. Does Centennial College or Trios College have any dedicated one-semester course starting from the summer of 2020? Are they any good?

Can anyone have any experience with this in Scarborough?

My main criteria are that I will get the best value for my money, have hands-on experience, and have to write regular tests and quizzes to better grasp Java SDK 8.

Also, I would like to know what are the different Java 8 SDK certification exam types and their designations? Moreover, what's the easiest and basic exam for Java SDK 8? What version of SDK is covered for that exam? Where can I find more information about that particular exam?


Thank you.

How about this one? I created a class method.


import java.util.Scanner; public class SimonSays { public static int countScore() { //initialize the Scanner object and userScore //that reads from command prompt and keep //keep track of matched alphabets before //termination Scanner scnr = new Scanner(System.in); int userScore = 0; //with try-catch-finally clause if there is any //error in input it would be caught and finally //Scanner object would be closed try{ //Initialize two variables to store the inputs //and an index String simonPattern; String userPattern; int i; //REad the inputs by printing out a nice description System.out.print("Simon Pattern Input: "); simonPattern = scnr.next(); System.out.print("User Pattern Input: "); userPattern  = scnr.next(); //as two String pattern are told to be of same length //we can take any of them. It's a contract between user //and the programmer. Then increment the userScore by one //if matches and returns and terminate the method if doesn't for ( i = 0; i< simonPattern.length(); ++i) {   if(simonPattern.charAt(i)==userPattern.charAt(i)) { ++userScore; }else { return userScore; }   } }catch(Exception e) { e.printStackTrace(); }finally { scnr.close(); } //return the final userScore return userScore; } public static void main (String [] args) { //print the UserScore System.out.println("UserScore: " + SimonSays.countScore());         } }