Develop Reference

Java loop in a method asks for extra return statement [duplicate]

This question already has answers here:
This method must return a result of type boolean(Java)
(3 answers)
Closed 5 years ago.
I am trying to write a method that contains a for loop that loops through a string from the second digit to the end digit, checking to make sure that the characters in that part of the string are all digits.
public static boolean hasValidDigits (String nameAccount)
{
for (int i = 1; i < nameAccount.length(); i++)
{
if(Character.isDigit(nameAccount.charAt(i)))
{
return true;
}
else
{
return false;
}
}
(It keeps asking for an extra return statement here, I have no idea why)
}
I'm expecting the loop to run through the last 5 characters of a 6 character string check to make sure that they are digits and return true if they are, otherwise return false.
My problem is that the code keeps asking for an extra return statement that shouldn't be needed, also as far as results go when I add the extra return statement (just to get the code working) the boolean seems to work for only the starting digit in the string (changing the digit to another character returns false) but if I change any of the other digits further along the string it still returns true even though it should output false.
Any help on this or a push in the right direction would be a great help.

Consider rewriting the method so that there is only one return statement. In this case it's not difficult to debug but if you had 30 execution paths as Matheus mentioned, it could be pretty tricky. You could also consider using regex here. As your code currently is, not all digits will be checked.
You can try regex at https://regex101.com/
at that point your method body could be something like
return yourString.matches(".\\d{5}");

Your method actually behaves as expected. What a return statement does is to terminate a method immediately. What's happening is: your method is not being run completely, it's being terminated prematurely. Try and follow the flow of your method; immediately after the first iteration, the entire method is terminated (with the return statement); so it never actually checks for the remaining characters. A better approach would be to do this:
public static boolean hasValidDigits(String nameAccount){
for(int i = 0; i < nameAccount.length(); i++){
if(!(Character.isDigit(nameAccount.charAt(i)))){
return false;
}
}
return true;
}
This way, when looping, immediately the program encounters a character that is not a digit, the entire method is aborted and it returns false. However if no non-digit is detected, it means the String contains all digits and therefore, it returns true.
It's actually logical:
Check for non-digits...
immediately one is detected, abort and return false...
If the iteration is complete and there is still no non-digit, return true!
I hope this helps!
Merry coding!!!

Your method needs an extra return statement to cover all possible paths of execution. Let's say your user inputs an empty string as its username. Your loop body would not be executed.
That's the reason Java is requiring an extra return statement.

New to programming - ***Updated*** PracticeProblem throwing StringIndexOutOfBoundsException

I'm trying to teach myself Java and I've recently been doing online practice problems with a built in compiler. My code is working great for most of the conditions except for two in which the string length is less than two.
The URL to this specific practice problem is: http://codingbat.com/prob/p123384
Problem:
Given a string, return a new string where the first and last chars have been exchanged.
Example
frontBack("code") should be→ "eodc"
frontBack("a") should be→ "a"
frontBack("ab") should be→ "ba"
Here's my code:
public String frontBack(String str) {
char firstChar = str.charAt (0);
char lastChar = str.charAt (str.length()-1);
String middle = str.substring(1, str.length()-1);
if (str.length()>=3){
return lastChar + middle + firstChar;
}
else {
return new StringBuilder(str).reverse().toString();
}
}
These are the two conditions that error
frontBack("a") should be→ "a"
"Exception:java.lang.StringIndexOutOfBoundsException: String index out of range: -1 (line number:4)"
frontBack("") should be→ ""
"Exception:java.lang.StringIndexOutOfBoundsException: String index out of range: 0 (line number:2)"
Here's the solution, the code that works
public String frontBack(String str) {
if (str.length() <= 1) return str;
String mid = str.substring(1, str.length()-1);
// last + mid + first
return str.charAt(str.length()-1) + mid + str.charAt(0);
}
What's the difference between my code and the solution?
Any help would be great. I'm confused on this one since my else statement simply returns the original string. Why would any of the variables (frontChar, middle, lastChar) affect the original string I'm returning? Thanks in advance!
First I want to say thank you to everyone that helped me!*
I've reworked my code and narrowed it down to one simple difference. That difference is the placement of an explicit statement to account for strings equal to or less than one. This apparently can't be handled implicitly by a catch-all else statement. Still not exactly sure why? Here is the same code with one minor difference; Explicit vs Implicit
This code works... Explicitly return str if string length is less than or equal to 1.
public String frontBack(String str) {
// This line below is the only difference
if (str.length() <= 1) {
return str;
}
char firstChar = str.charAt (0);
char lastChar = str.charAt (str.length()-1);
String middle = str.substring(1, str.length()-1);
if (str.length()>=2){
return lastChar + middle + firstChar;
}
else {
return str;
}
}
This code doesn't work... Implicitly return str with an else statement if string length is less than or equal to 1.
public String frontBack(String str) {
char firstChar = str.charAt (0);
char lastChar = str.charAt (str.length()-1);
String middle = str.substring(1, str.length()-1);
if (str.length()>=2){
return lastChar + middle + firstChar;
}
else {
return str;
}
}

You need to program to defend
1.
for one character String
String middle = str.substring(1, str.length()-1);
this would be
str.substring(1, 0)
which is invalid
2.
for empty string (length = 0 ) your code will attempt to look at index = -1 which is invalid, or even index = 0 is invalid
3.
what if str is null

You always have to think of boundary conditions:
str is null? str is empty("") str is 1 char?
also bear in mind that Java's substring is inclusive on start position but exclusive on the end.
public String frontBack(String str) {
if (str == null || str.length()<2){
//if str is null - return empty. else return the string itself
return str == null ? "" : str;
}else{
//do the actual first last swap
return str.charAt(str.length()-1)+ str.substring(1,str.length()-1) + str.charAt(0);
}
}

I've reworked my code and narrowed it down to one simple difference. That difference is the placement of an explicit statement to account for strings equal to or less than one. This apparently can't be handled implicitly by a catch-all else statement. Still not exactly sure why?
It has nothing to do with implicit or explicit. The problem is simply the sequence in which the lines are executed within the method, which is top to bottom.
By the time it gets to your if/else in the "implicit" case, the three lines above, such as char firstChar = str.charAt(0); have already happened (or already failed). For an empty string it will blow up with a StringIndexOutOfBounds exception immediately on that line (look at the line number of the exception), and the method will stop executing then as it throws the exception out of the method. (The technical term for this is abrupt completion.) If that exception is thrown, the below if/else won't happen, so it cannot retroactively prevent the exception afterwards. That code will work fine if you move the three string-using statements from the top of the method to inside the 'if' branch of the if/else, so that they are not executed when not wanted.
In the "explicit" case, you added if (str.length() <= 1) return str; at the top of the method, where it can prevent the lines below from executing, because the return statement will exit the method before the attempts to use the non-existent characters of the string. That statement wouldn't help if it was lower down in the method.
I just want to add something about 'null', since other answerers on this page have complained that your code doesn't defend against a null argument. It's good to think about how your method will cope with peculiar input, but here, your code already does correctly defend against a null argument, because when you try to call charAt or length or substring on null, it will throw a NullPointerException out of the method, as it should.
Sometimes null should be checked for and allowed, but here it should not. If called without a valid string, what might frontBack be expected to return? Some might say it should return null, some might say it should return the empty string, and some might say it should coerce it to a string and thus return "luln". There is no fully sensible or unambiguously correct way to handle it that will work for all callers. So, frontBack should take the stance that null is not an acceptable input. Then it is the caller's fault if they pass in null, and if the caller passes in garbage, it's correct that they should get the garbage thrown back at them (metaphorically, of course; you will actually throw an exception object, not the original input) so they are forced to deal with it properly. Tolerating and making excuses for bad callers by explicitly coercing garbage to valid input is the wrong thing to do because it hides errors and it makes the program's behavior more subtle.
If the method had side effects, such as modifying a data structure, writing to a file, or calling other methods with side effects, then null input could be dangerous, because the method might complete some of the side effects without using str. Then, trying to use str would at some point throw the exception, leaving things half-finished and in an invalid state. Ideally, the side effects should be observed to happen either entirely or not at all. In that case, it would be good to check for null and throw the exception yourself at the top of the method:
if (str == null) throw new NullPointerException();
That won't make a difference in this simple method because it has no side effects (it is purely functional) and because it already unconditionally calls methods on str, which will cause the same exception to be thrown anyway.

Java error: missing return statement?

Here is my method:
//usedLetters method to check if user's guess has already been guessed
private boolean usedLetters(char used[], char alphabet) throws IOException
{
for(int x=0; x<used.length; x++){
if(alphabet == used[x])
{
return true;
}
else
{
used[dataSize] = alphabet;
return false;
}
}
}//End of usedLetters method
IT checks to see if the alphabet that the user entered in an another method has already been guessed. If it has already been guessed, it returns true, and if has not been already guessed, it adds the alphabet into used, and returns false. But the error says that there are no return statements...I am not familiar with methods in general, so I am confused. Any help would be appreciated!

What if used.length==0? Then the for-loop is never entered.
Therefore you need a return statement after the loop.

What if the for is never entered? i.e. used.length == 0 (used is an empty array). In this case - nothing will be returned.
The compiler forbids a flow that can terminate without returning the value, and that's why it shows the error.
Also note, I believe even after fixing this issue - the program will yield a wrong result, it will only check the first element of used, without advancing to the next one.

You should move the return false; to just before the last }. Otherwise it will return in the first iteration of the loop.

/usedLetters method to check if user's guess has already been guessed
private boolean usedLetters(char used[], char alphabet) throws IOException
{
for(int x=0; x
if(alphabet == used[x])
{
return true;
}
else
{
used[dataSize] = alphabet;
return false;
}
}
}//End of usedLetters method
There should be return statement after for loop, currently there is no return statement that's why you are getting error.

As you have written your code, the method will always return on the first iteration of the cycle, while I doubt this is what you want.
I believe that you should return false outside the for. I am not sure what does to "guess an alphabet" mean but I think this is what you are trying to do.

Yep, all the above are correct. You would be better off defining the return variable at the top, setting it to values wherever you need to within the method body, breaking out of the 'for' loop and returning it once at the end.

Java - changing a method to a for/while loop

I want to change the first method to a while and for loop. I have added the code below. Is this correct?
public String extractWordFour(String text){
if(text.length()==0 || text.charAt(0) == ''){
return "";
} else {
return text.charAt(0) + extractWordFour(text.substring(1));
}
}
public String extractWordFour(String text){
int i=0;
while (i<=text.length){
return text.charAt(0) + extractWordFour(text.substring(i));
i++;
}
}
public String extractWordFour(String text){
for(int i=0;i<=text.length();i++){
return text.charAt(0) + text.substring(1);
}
}

I'm not going to answer this question because I think its a h.w. assignment but I'm putting it in an answer since I can't fit this in a comment, but I'm assuming you want to convert a recursive solution into a while or for loop solution.
Your while solution is wrong first of all because you are mixing recursion and while together. You should not be calling the function inside your while loop!
public String extractWordFour(String text){
int i=0;
while (i<=text.length){
return text.charAt(0) + extractWordFour(text.substring(i));
i++;
}
}
This one can't finish because you are returning it before its even looped more than once.
public String extractWordFour(String text){
for(int i=0;i<=text.length();i++){
return text.charAt(0) + text.substring(1);
}
}
Anyways hope that helps. The best thing to do would be to fully understand what the first function does, write it down and then think about how to make it do the exact same thing with a while or a for loop.

For a start, you can't have String.charAt(0) == '' because '' isn't a valid character, unlike "" for an empty String which is valid.
Your second method doesn't work because it should be text.length() instead of text.length which is the method when you're calling it on an array, as well as the i++ being unreachable because of the recursion. And failing that, the method signature claims it returns a String, but there is no return statement.
Your third method does have a return statement, but it still wouldn't work because it'll just return on the first iteration and therefore only give you the first 2 characters (and in fact your compiler won't even allow it because it won't realise this).
Aside from all these issues, if the method name of extractWordFour is an accurate representation of what they should do, none of them will because the logic makes no sense. I suggest you start by thinking about that: How can you tell when one word ends by examining the String, and what does your program need to know to remove everything before the fourth word, and everything after it?

Check abecedarian in recursive way (Not a homework, part of my learning)

I have created this function to check abecedarian with while loop (A word is said to be "abecedarian" if the letters in the word appear in alphabetical order, such as "abdest")-
public static boolean isAbecedarian(String s) {
int index = 0;
char c = 'a';
while (index < s.length()) {
if (c > s.charAt(index)) {
return false;
}
c = s.charAt(index);
index = index + 1;
}
return true;
}
I want to change this function to a recursive function and I have written this function -
public static boolean isAbecedarianrec(String s){
char first = s.charAt(0);
char second = first ++;
if (first<second){
return isAbecedarianrec(s);
}
return false;
}
recursive function is not working as it should and I am not getting the expected result. Please check and help me to pin point the issue with this function.
Note - As I mentioned this is not a homework question and it is part of my self Java learning.

Two issues:
The following code char second = first++ should be char second = s.charAt(1);
The recursive call should be return isAbecedarianrec(s.substring(1));
Finally, you need length checks where appropriate. On method entry, ensure the string has at least 2 characters if not, return true.
When using recursion, you need to keep two things in mind. First, the input to the recursive should in some way be different than the previous input. Second, there must be a valid stopping point so that you don't recurse infinitely and thereby run out of memory.

Typically with recursion you need two things:
A base case (e.g. empty string, zero, etc.)
A way to check part of the more complex case, and then reduce it to a simpler recursive call.
The empty string does form a good base case here - it's trivially abecedarian. So the first part of your recursive method should be to check for the empty string and return true. This forms the base case that will be the termination of your recursive method in the "happy path" case.
Otherwise, you know you have a non-empty string. The recursive decomposition can be achieved by checking its first character, then recursively calling with the rest of the string. However, in order to perform the check, you'll need to remember what the previous character of the string was (just like c in the iterative method), so you'll need an additional argument to the recursive call to act as a sort of variable.
This is not uncommon with recursion - often the majority of the work is done in a "helper" method, and the public method just calls this with initial/dummy values.
Putting these together then, a solution would look something like the following:
// s must not be null
public boolean isAbecedarianrec(String s) {
return isAbecedarianRecImpl(s, (char)0);
}
private boolean isAbecedarianRecImpl(String s, char c) {
if (s.isEmpty())
return true;
else {
if (c > s.charAt(0))
return false;
else
return isAbecedarianRecImpl(s.substring(1), s.charAt(0));
}
}

Java does not have pointer arithmetics (it seems you are trying to do something like that). You code will take the first char (always the first char of the String), and afterwards it will increment the char (turning 'a' into 'b' etc) and furthermore store the value to second also. This means that first and second will always contain the same value.
A simple (but not very efficient solution could be:
public static boolean isAbecedarianrec(String s, char c){
if (s.equals("")) return true;
char first = s.charAt(0);
if (first>=c){
return isAbecedarianrec(s.subString(1), first);
}
return false;
}
(Notice that I have also flipped the equality. That seemed to be wrong).
Call the function with the value of the lowest character. E.g.: isAbecedarianrec(s, 'a').
Notice that this solution (like yours) requires that the code points of the letters have the same numerical order as the alphabetical order of the letters. That is not generally correct, for example you will see strange results if the string contains both capital and small letters.

To create a recursive function, you need two things: an end case that stops execution, and some way to modify the successive calls to the recursive function.
In your case, you have one end case covered (the case where the string is not abecedarian), but not the other. For your function to ever return true, it needs to contain a return true statement or a return statement with a boolean comparison in it. The condition in this case would probably be finding the end of the string (being called with an empty string).
You are also missing a modification of successive calls: every call to isAbecedarian is made with the same string. Depending on what works best in Java, you could either shorten the string by 1 character on every call, or pass the index as an argument to the function and increment it on each call.