(i) Write a method called isYorN that takes a String as a parameter and returns true
if the parameter is the letter Y or the letter N, in either upper or lower case, or
false otherwise.
my code
// This is method (i)
publicstaticboolean isYorN ( String letter )
{
boolean result;
if ( letter =="Y" || letter =="N" || letter =="y" || letter=="n" )
{ result =true;}
else
{ result =false;}
return result;
}
Don't use == to compare Strings.
If you use == it will compare addresses.
You want to compare the actual string's themselves so you'll use the
String s1;
String s2;
if (s1.equals(s2))
return true;
Since you posted an attempt I'll post the way I would do it.
public static boolean isYorN(String in)
{
final String YN = "yYnN" ;
if(YN.indexOf(in) > -1){
return true ;
}
return false ;
}
PS.
Message was edited by:
puckstopper31
> Since you posted an attempt I'll post the way I would
> do it.
>
> [code]
>public static boolean isYorN(String in)
> {
> final String YN = "yYnN" ;
> if(YN.indexOf(in) > -1){
> return true ;
>
> return false ;
> /code]
>
> PS.
>
> Message was edited by:
> puckstopper31
Except:
1) return YN.indexOf(in) > -1; is more concise.
2) This allows yY, yYn, yYnN, Yn, YnN, and nN, which I believe goes against the requirements.
> Since you posted an attempt I'll post the way I would
> do it.
>
>public static boolean isYorN(String in)
> {
> final String YN = "yYnN" ;
> if(YN.indexOf(in) > -1){
> return true ;
>
> return false ;
isYorN("Yn') is true
isYorN("yn') is false
Hmmm...
> > 1) return YN.indexOf(in) > -1; is more concise.
>
> I agree, unless he needs to debug. Easier to - later
> on - insert a print statement after the "work" but
> before the return, if he assigns to a boolean
> "result".
Agreed.
I'd still forgo the if though.
boolean result = YN.indexOf(in) > -1;
return result;
or..
public static boolean charIsYN(char c)
{
boolean ret=false;
if (c=='Y' || c=='y' || c=='N' || c=='n') {ret=true;}
return ret;
}
public static boolean stringIsYN(String s)
{
boolean ret=false;
if (s!= null && s.length>=1) {
ret=charIsYN(s.charAt(0);
}
return ret;
}
> or..
> > public static boolean charIsYN(char c)
> {
> boolean ret=false;
> if (c=='Y' || c=='y' || c=='N' || c=='n')
> {ret=true;}
>
> return ret;
>
> }
>
>
> public static boolean stringIsYN(String s)
> {
>
> boolean ret=false;
> if (s.length>=1) {
>ret=charIsYN(s.charAt(0);
> return ret;
> }
>
>
>
Why declare a variable for the result? I would just return when I know what to return.
Kaj
Actually, second method should be this:
public static boolean stringIsYN(String s)
{
boolean ret=false;
if (s!= null && s.length()>=1) {
ret=charIsYN(s.charAt(0));
}
return ret;
}
variable for the result? I would just
> return when I know what to return.
>
> Kaj
such as
public static boolean charIsYN(char c)
{
if (c=='Y' || c=='y' || c=='N' || c=='n')
{
return true;
}
return false;
}
I was trying to adhere to the "1 return from a method" principle that I hear so often..
Even shorter... with null checking as a bonus!
public static boolean IsYOrN(String yn) {
return (yn != null && yn.length() == 1 && ("YyNn").indexOf(yn) >= 0 );
}
Message was edited by:
kevjava [Edit: Reply 15 beat me to the whole null-chekcing thing...]
> As long as we're pounding the krap out of this, I'd
> prefer contains over indexOf -- more to the point of
> what's required.
But still alows for more than just the single char, unless you have a separate length==1 test.
I'd say it's better to just equals() or equalsIgnoreCase().
> I was trying to adhere to the "1 return from a
> method" principle that I hear so often..
I'm still trying to tell people to stop listening to that.
I don't know why people are doing that, but I think that it is an inheritance from C/C++ where you don't have a finally clause.
I always follow the princible of returning as soon as possible. Why read more code than you need to? It does also lead to less nesting.
Kaj
> Even shorter... with null checking as a bonus!
>
> [code]
>public static boolean IsYOrN(String yn) {
> return (yn != null && yn.length() == 1 &&
> ("YyNn").indexOf(yn) >= 0 );
>}
> ode]
>
> Message was edited by:
> kevjava [Edit: Reply 15 beat me to the whole
> null-chekcing thing...]
Allthough I personally prefer this to what I wrote. I have run into teams that considered terniary operations to be anathema. Don't ask me why I never did get the straight of it. I think they just couldn't make sense out of it so of course it's bad. I will concede that it can be harder to read than a block if.
PS.
> Allthough I personally prefer this to what I wrote. I
> have run into teams that considered terniary
> operations to be anathema. Don't ask me why I never
> did get the straight of it. I think they just
> couldn't make sense out of it so of course it's bad.
> I will concede that it can be harder to read than a
> block if.
I certainly wouldn't use the ternary here.
boolean result = a ? b : !b;
can always simply be
boolean result = a;
or
boolean result = !a;
depending on the "sign" of b.
> I'm rather of the mindset, "Whatever works" here. I
> am a fan of graceful readable code. Which is a fairly
> ambiguous criteria largely dependent on the taste of
> the person evaluating for graceful/readable.
>
> PS.
I agree. I just happen to think that using a more complex structure that adds nothing functionally had a negative impact on readability.
I would functionally agree with that. The only caveat is that what is readable and makes sense to me might be incomprehensible to you through no deficiency on either of our parts just a difference in coding dialect.
As an example, the team I'm with these days has two conventions that are very difficult for me to adhere to.
public class MyClass
{
.... stufff
public void myMethod()
{
....
}
}
opening braces on the line following the scope declaration. To me
public class MyClass{
... suff
public void myMethod(){
.... stuff
}
}
is much more readable. Which is right? Both it's just a difference in coding dialect.
The other one is they like underscores at the beginning of private members.
private String _myString
Just remembering to underscore things requires braincells and I don't have that many to spare.
PS.
}
Was something like this mentioned yet...
public static boolean isYN(String toEval){
return ("Y".equalsIgnoreCase(toEval)||"N".equalsIgnoreCase(toEval));
}
Null testing included no charge.
public class Test{
public static boolean isYN(String toEval){
return ("Y".equalsIgnoreCase(toEval)||"N".equalsIgnoreCase(toEval));
}
public static void main(String[] args){
String[] samples = {"y","n","Y","y","YN","a",null};
for(int i=0;i<samples.length;i++){
System.out.println("Testing '"+samples[i]+"' result = "+Test.isYN(samples[i]));
}
}
}
">
> Was something like this mentioned yet...
>
> public static boolean isYN(String toEval){
> return
> ("Y".equalsIgnoreCase(toEval)||"N".equalsIgnoreCase(t
> Eval));
>}
Hinted at but code not provided, I believe.
This is probably how I'd do it.
> Hinted at but code not provided, I believe.
>
Yeah I saw equalsIgnoreCase mentioned but then someone else mentioned nulls.
I guess for comparison sake (not for you obviously but perhaps the OP or other later readers).
public class Test{
public static boolean isYN(String toEval){
return ("Y".equalsIgnoreCase(toEval)||"N".equalsIgnoreCase(toEval));
}
public static boolean notSoGoodIsYN(String toEval){
return (toEval.equalsIgnoreCase("Y")||toEval.equalsIgnoreCase("N"));
}
public static void main(String[] args){
String[] samples = {"y","n","Y","y","YN","a",null};
for(int i=0;i<samples.length;i++){
System.out.println("Testing '"+samples[i]+"' result = "+Test.isYN(samples[i]));
}
System.out.println("testing with not so good");
for(int i=0;i<samples.length;i++){
System.out.println("Testing '"+samples[i]+"' result = "+Test.notSoGoodIsYN(samples[i]));
}
}
}
Note the difference in output.
> This is probably how I'd do it.
Well that's because you're a smart guy. ;)">
> variable for the result? I would just
> > return when I know what to return.
> >
> > Kaj
>
> such as
>
> > public static boolean charIsYN(char c)
> {
>
> if (c=='Y' || c=='y' || c=='N' || c=='n')
>{
> return true;
> }
>
> return false;
> }
>
>
> I was trying to adhere to the "1 return from a
> method" principle that I hear so often..
or rather
public static boolean charIsYN(char c){
return c=='Y' || c=='y' || c=='N' || c=='n';
}
