When a coding assessment is approaching and you are unsure what to practise first, the top Java coding interview questions to prioritise are string reversal, factorial, Fibonacci, largest and second largest values, array sums, and quicksort. You should also prepare palindrome checks, frequency counting, greatest common divisor, permutations, reverse order, and swapping two values because these exercises reveal how clearly you handle logic, data structures, and edge cases.
For freshers, the goal is not to memorise a perfect block of code. It is to understand each problem well enough to explain a simple approach, improve it when necessary, write valid Java, test it, and discuss its limits without becoming flustered.
Main points
- Start with strings, loops, arrays, and basic number logic before moving to recursion and sorting.
- Explain your approach before writing code so the interviewer can follow your reasoning.
- Use Java library methods when appropriate, but also understand the underlying algorithm.
- Test empty input, duplicate values, negative values, and unusually large input where relevant.
- Practise discussing efficiency, readability, and alternative solutions after your program works.
See which exercises test each core skill
Different questions reveal different parts of your programming ability. The following comparison helps you choose exercises based on the skill you need to strengthen rather than practising them in a random order.
| Exercise | Main skill tested | Typical approach | Important limit to discuss |
|---|---|---|---|
| Check whether text is a palindrome | String traversal | Compare characters from both ends | Spaces, punctuation, and letter case |
| Count character occurrences | Maps and iteration | Store each character with its frequency | Unicode and normalisation |
| Find factorial | Loops or recursion | Multiply values up to the input | Overflow and invalid input |
| Generate Fibonacci values | State management | Update previous and current values | Overflow and repeated recursive work |
| Find the greatest common divisor | Mathematical reasoning | Use the Euclidean algorithm | Zero and negative input |
| Find largest and second largest values | Array scanning | Track candidates in one pass | Duplicates and short arrays |
| Find an array sum | Basic accumulation | Add each element to a running total | Overflow and empty input |
| Generate permutations | Recursion and backtracking | Choose, recurse, and restore | Rapid growth in output |
| Implement quicksort | Sorting and partitioning | Place a pivot and divide the range | Poor pivot choices |
| Reverse values or text | Indexes and mutation | Swap values moving inward | Null or immutable input |
| Swap two values | Assignment and state | Use a temporary variable | Arithmetic alternatives can overflow |
Core string and counting problems
Check whether a string is a palindrome
What it is: You write a program to check if a word, phrase, or sequence reads the same from both directions. A clear solution places one index at the beginning and another at the end, compares the characters, and moves both indexes inward until they meet or a mismatch appears.
Who it suits: This is an excellent starting problem for students and freshers because it tests loops, character access, conditions, and edge case awareness without requiring an advanced data structure.
Pros: The direct approach is easy to explain and does not require creating a reversed copy. It also gives you an opportunity to clarify whether case, spaces, and punctuation should be ignored.
Limits: The definition of a palindrome can change with the requirements. A simple character comparison may treat uppercase and lowercase letters as different. Before coding, ask whether the interviewer expects input cleaning and whether null input should return false or cause an error.
Reverse a string
What it is: This task asks you to write a program to reverse a string. In Java, you can use StringBuilder and its reverse method, build the result manually, or convert the text to a character array and swap values from the outside toward the centre.
Who it suits: It suits beginners learning that String objects are immutable. It is also useful for candidates who need to compare a concise library solution with a manual algorithm.
Pros: The library approach is readable and appropriate in normal application code. The manual approach shows that you understand indexes, character arrays, and in place mutation.
Limits: Repeatedly adding characters to a plain String inside a loop can create unnecessary intermediate objects. You should also clarify how null and empty input are handled.
Count characters, vowels, words, or digits
What it is: An interviewer may ask you to write a program to count the number of vowels, words, digits, or occurrences of every character. For category counting, a loop and a set of conditions may be enough. For frequency counting, a HashMap is usually clearer.
Who it suits: This problem suits anyone practising collections, conditions, and input normalisation. It often appears among basic internship interview questions because the initial version is approachable while follow up questions can make it more demanding.
Pros: A frequency map works in a single traversal and can be adapted for characters, words, or numbers. It also lets you demonstrate useful Java methods such as getOrDefault.
Limits: Counting human language accurately can involve punctuation, combined characters, and different definitions of a word. State your assumptions rather than pretending the input is simpler than it is.
Number exercises that reveal your reasoning
Find a factorial
What it is: To write a program to find factorial, multiply each positive integer up to the supplied value. You can solve it iteratively or recursively. The iterative version is generally easier to trace and avoids adding recursive calls to the stack.
Who it suits: This is useful for freshers learning loops, methods, validation, and recursion. It also helps you practise explaining a mathematical definition in programming terms.
Pros: The logic is compact, and it is easy to compare iterative and recursive solutions. A strong answer mentions that the factorial of zero is defined as one.
Limits: Factorials grow quickly, so standard numeric types eventually overflow. Negative values need a defined response. If an interviewer asks for very large results, discuss BigInteger rather than silently returning an incorrect value.
Generate Fibonacci values
What it is: To write a program to find Fibonacci values, maintain the previous and current values and repeatedly calculate the next one. A simple recursive definition is easy to read, but the direct recursive implementation repeats work.
Who it suits: It suits candidates learning iteration, recursion, memoisation, and the difference between an elegant definition and an efficient implementation.
Pros: An iterative solution uses little additional memory and is easy to test. A memoised recursive solution provides a useful discussion about caching repeated results.
Limits: You must clarify whether the request is to produce a sequence or return the value at a particular position. Numeric overflow remains relevant, and a naive recursive solution becomes impractical as the input grows.
Find the greatest common divisor
What it is: To write a program to find GCD, repeatedly replace the larger problem with the remainder of a division until the remainder becomes zero. This is the Euclidean algorithm and is more effective than testing every possible divisor.
Who it suits: This exercise suits candidates who want to show that they can translate a mathematical process into a compact loop. It is also good practice for updating multiple variables correctly.
Pros: The algorithm is concise, efficient, and easy to justify with examples. It demonstrates that you can improve on a brute force search.
Limits: Discuss how your method treats negative input and zero. Converting values to their absolute form can simplify the implementation, but special input still deserves an explicit decision.
Find the sum of array values
What it is: To write a program to find the sum, initialise a running total and add each array element. A Java stream can express the operation concisely, while a loop makes the control flow visible.
Who it suits: This is suitable for beginners and for candidates revising arrays, enhanced loops, streams, and numeric types.
Pros: The solution is straightforward and provides a good setting for discussing readability. It can be extended to conditional sums, averages, or totals grouped by category.
Limits: A sum can overflow if the chosen type is too small. For an empty array, a total of zero may be sensible, while null input should be handled according to the agreed method contract.
Array selection and ordering challenges
Find the largest value
What it is: To write a program to find the largest element, initialise the current maximum from a real array element and update it whenever a larger value appears. Initialising the maximum to zero is a common mistake because an array may contain only negative values.
Who it suits: This question is ideal for freshers practising array traversal and careful initialisation. Recruiters may use it to see whether a candidate tests assumptions rather than merely completing the loop.
Pros: One pass is enough, and no sorting is needed. The solution remains readable while demonstrating correct state tracking.
Limits: An empty or null array has no largest element. Decide whether the method should throw an exception, return an optional result, or follow another stated contract.
Find the second largest distinct value
What it is: To write a program to find the second largest value, track both the largest and second largest candidates during one traversal. The word distinct matters. In an array containing repeated copies of the maximum, the second largest distinct value must be smaller than that maximum.
Who it suits: This suits candidates who are comfortable with basic arrays and want to improve condition ordering. It is a frequent follow up to the largest element problem.
Pros: A one pass solution avoids the unnecessary cost of sorting the entire array. It also creates a useful discussion about duplicate values and result contracts.
Limits: Arrays with too few distinct values have no valid result. Initial sentinel values can be risky, so wrapper types, optional results, or careful initialisation may be preferable.
Reverse the order of an array or list
What it is: To write a program to reverse order, place one index at each end, swap the values, and move inward. For a mutable list, Java collection utilities may also provide a direct method.
Who it suits: This problem suits students practising indexes, swapping, arrays, and the difference between changing an existing collection and returning a new one.
Pros: The in place method requires little additional memory. It is simple to trace and can be reused for parts of rotation and sorting algorithms.
Limits: You must clarify whether the original input may be modified. Arrays, mutable lists, and immutable collections require different treatment.
Swap two values safely
What it is: To write a program to swap two values, save the first value in a temporary variable, assign the second value to the first location, and then assign the saved value to the second location.
Who it suits: This is a basic but useful exercise for candidates learning assignment order and mutable state. It may also appear as a small step inside reversal, partitioning, or sorting questions.
Pros: A temporary variable is readable, reliable, and works for objects as well as primitive values. It communicates intent immediately.
Limits: Arithmetic tricks can avoid a temporary variable, but they may overflow and are usually harder to read. Exclusive or swapping works only in suitable numeric contexts and adds little practical value in most interviews.
Recursion and sorting tasks for deeper interviews
Generate all permutations
What it is: To write a program to find permutations, choose one available character or value, place it in the current position, recursively arrange what remains, and restore the original state before trying another choice. This choose, explore, and restore pattern is backtracking.
Who it suits: It suits candidates who already understand loops and basic recursion. It is especially useful preparation for later problems involving combinations, paths, and search spaces.
Pros: The exercise reveals whether you understand recursive state and restoration. It also lets you discuss how to avoid duplicate output when the input contains repeated values.
Limits: The number of results grows extremely quickly as the input expands. No implementation can avoid the cost of producing every requested permutation, so it is important to discuss output size rather than claiming the method scales well.
Implement quicksort
What it is: To write a program to implement quicksort, select a pivot, partition the values so smaller and larger elements move to appropriate sides, and recursively sort the resulting ranges. The exact comparisons depend on the chosen partition scheme.
Who it suits: This is better for candidates who are already comfortable with arrays, recursion, swapping, and boundary management. It is less likely to be the first exercise in a basic screening, but it can appear in a deeper technical round.
Pros: Quicksort brings several core ideas together and can perform very well with sensible partitioning. Explaining it clearly shows stronger algorithmic maturity than merely reproducing memorised code.
Limits: Poor pivot choices can produce highly unbalanced partitions. Recursive depth, duplicate values, and index errors also require attention. Java provides reliable sorting utilities for production work, so a manual version is mainly an exercise in understanding.
Choose your practice route and prepare interview answers together
Your best starting point depends on what the role is likely to test. Someone preparing for a first campus assessment should begin with reversal, counting, sums, and maximum values. A candidate comfortable with those topics can add GCD, factorial, Fibonacci, and second largest value. Permutations and quicksort make more sense after recursion and index boundaries feel familiar.
For each exercise, prepare a short spoken answer with this sequence:
- Restate the requirement and ask about unclear input.
- Describe the simplest correct approach.
- Name the variables or data structures you need.
- Write the solution in small, testable steps.
- Walk through a normal case and an edge case.
- Discuss efficiency and a possible alternative.
Answers for freshers do not need to sound advanced. A calm explanation of a correct loop is more convincing than using streams, recursion, or clever syntax that you cannot debug. If you forget a library method, tell the interviewer the operation you need and continue with logic you understand.
Broader internship interview questions often combine coding with prompts such as why you want the role, what you built, how you handled a problem, and what you learned from feedback. Prepare concise examples from coursework, personal projects, volunteering, or group assignments. Common internship interview questions are usually intended to uncover your motivation, communication, reliability, and willingness to learn rather than years of professional experience.
The technical scope should follow the job description. If the role involves Java web services, include REST API interview questions covering HTTP methods, status codes, validation, authentication concepts, and error handling. API interview questions may also ask how a Java client serialises data or how a service should respond to invalid input.
Apache Kafka interview questions are relevant only when the listing mentions event driven systems or messaging. In that case, learn the purpose of topics, partitions, consumers, offsets, and delivery behaviour. Kafka testing interview questions may cover how you verify producers, consumers, message formats, and failure handling, but they should not replace core Java practice for an entry level role.
React coding interview questions belong to a different language and user interface skill set. If a position combines Java with a front end framework, practise React coding exercises for interview preparation separately, including state, props, events, rendering, and component behaviour. Do not assume that React interview coding challenges prepare you for Java syntax or object oriented design.
A short do and do not guide
| Do | Do not |
|---|---|
| Ask whether input can be null or empty | Invent assumptions and hide them |
| Explain a direct solution before optimising | Start with a complex trick you cannot defend |
| Use meaningful variable and method names | Compress every operation into one expression |
| Test duplicates and negative values | Test only the easiest example |
| Correct mistakes aloud and continue | Stay silent when you notice a bug |
What recruiters notice
Recruiters and technical interviewers notice more than the final output. They look at whether you clarify the problem, keep your code readable, recognise invalid input, and respond constructively when a test exposes a mistake. They may also notice whether you understand the Java features you choose rather than using them only because you saw them in a sample answer.
Good interview questions for interns often leave room for follow up discussion. An interviewer might ask you to remove duplicate permutations, preserve the original array, process a very large value, or replace a loop with a stream. These changes are not necessarily attempts to catch you out. They show whether you can adapt an existing solution.
When preparing questions to ask in an internship interview, focus on the work and learning environment. Ask how interns receive feedback, what a typical project involves, which Java tools the team uses, and how success is evaluated. Avoid asking something that the public job description already answers unless you need clarification.
What else people want to know
Are these coding problems enough for a Java internship interview?
It depends, because they provide a strong foundation but not a complete preparation plan. Many IT internship interview questions also cover object oriented programming, exceptions, collections, interfaces, testing, SQL, Git, and projects. Read the role description and add the technologies it names.
Should I memorise Java solutions before an interview?
No, memorising complete answers is risky because a small change in the requirement can make the remembered solution unsuitable. Learn the reasoning pattern, write the program from a blank page, and practise explaining why each step exists.
Can I use built in Java methods during a coding interview?
Yes, unless the interviewer specifically asks you to implement the operation yourself. Explain what the library method does, mention its effect on the input, and be ready to describe a manual alternative when the question is testing fundamentals.
Do internship interviews include behavioural questions as well as coding?
Yes, internship interview questions and answers commonly cover motivation, teamwork, challenges, deadlines, feedback, and learning alongside technical work. Prepare honest examples and explain your own contribution instead of describing only what the whole group did.
Is an internship portal useful after I finish practising?
Yes, an internship portal can help you compare role descriptions and identify recurring requirements before you apply for internship opportunities. You can use Apply My Internship as one internship website to explore Java internships, while also checking employer career pages and other trusted sources.
Turn practice into applications
The best preparation is repeated, active practice. Write each solution without copying, explain it aloud, test awkward input, and then compare it with a cleaner alternative. This approach builds the confidence to handle both familiar exercises and variations you have not seen before.
Once your Java fundamentals, project examples, and questions for the interviewer are ready, move from preparation to relevant opportunities. Explore internships on Apply My Internship and use the role requirements to guide your next round of focused practice.
