Q1. Given the string "strawberries" saved in a variable called fruit, what would fruit.substring(2, 5)
return?
- rawb
- raw
- awb
- traw
Reasoning: The substring method is accepting two arguments.
- The first argument being the index to start(includes that char at 2)
- and the second the index of the string to end the substring(excludes the char at 5).
- Strings in Java are like arrays of chars.
- Therefore, the method will return "raw" as those are the chars in indexes 2,3, and 4.
- You can also take the ending index and subtract the beginning index from it, to determine how many chars will be included in the substring (5-2=3).
- method overloading
- method overrunning
- method overriding
- method calling
boolean b1 = true, b2 = false; int i1 = 1, i2 = 2;
-
(i1 | i2) == 3
-
i2 && b1
-
b1 || !b2
-
(i1 ^ i2) < 4
1: class Main {
2: public static void main (String[] args) {
3: int array[] = {1, 2, 3, 4};
4: for (int i = 0; i < array.size(); i++) {
5: System.out.print(array[i]);
6: }
7: }
8: }
- It will not compile because of line 4.
- It will not compile because of line 3.
- 123
- 1234
interface Interface1 {
static void print() {
System.out.print("Hello");
}
}
interface Interface2 {
static void print() {
System.out.print("World!");
}
}
-
super1.print(); super2.print();
-
this.print();
-
super.print();
-
Interface1.print(); Interface2.print();
String str = "abcde";
str.trim();
str.toUpperCase();
str.substring(3, 4);
System.out.println(str);
- CD
- CDE
- D
- "abcde"
class Main {
public static void main (String[] args){
System.out.println(print(1));
}
static Exception print(int i){
if (i>0) {
return new Exception();
} else {
throw new RuntimeException();
}
}
}
- It will show a stack trace with a runtime exception.
- "java.lang.Exception"
- It will run and throw an exception.
- It will not compile.
interface One {
default void method() {
System.out.println("One");
}
}
interface Two {
default void method () {
System.out.println("One");
}
}
- A
class Three implements One, Two {
public void method() {
super.One.method();
}
}
- B
class Three implements One, Two {
public void method() {
One.method();
}
}
- C
class Three implements One, Two {
}
- D
class Three implements One, Two {
public void method() {
One.super.method();
}
}
class Main {
public static void main (String[] args) {
List list = new ArrayList();
list.add("hello");
list.add(2);
System.out.print(list.get(0) instanceof Object);
System.out.print(list.get(1) instanceof Integer);
}
}
- The code does not compile.
- truefalse
- truetrue
- falsetrue
package mypackage;
public class Math {
public static int abs(int num){
return num < 0 ? -num : num;
}
}
package mypackage.elementary;
public class Math {
public static int abs (int num) {
return -num;
}
}
import mypackage.Math;
import mypackage.elementary.*;
class Main {
public static void main (String args[]){
System.out.println(Math.abs(123));
}
}
- Lines 1 and 2 generate compiler errors due to class name conflicts.
- "-123"
- It will throw an exception on line 5.
- "123"
Explanation: The answer is "123". The abs()
method evaluates to the one inside mypackage.Math class, because The import statements of the form:
import packageName.subPackage.*
is Type-Import-on-Demand Declarations, which never causes any other declaration to be shadowed.
1: class MainClass {
2: final String message(){
3: return "Hello!";
4: }
5: }
6: class Main extends MainClass {
7: public static void main(String[] args) {
8: System.out.println(message());
9: }
10: String message(){
11: return "World!";
12: }
13: }
- It will not compile because of line 10.
- "Hello!"
- It will not compile because of line 2.
- "World!"
Explanation: Compilation error at line 10 because of final methods cannot be overridden, and here message() is a final method, and also note that Non-static method message() cannot be referenced from a static context.
class Main {
public static void main(String[] args) {
System.out.println(args[2]);
}
}
-
java Main 1 2 "3 4" 5
-
java Main 1 "2" "2" 5
-
java Main.class 1 "2" 2 5
-
java Main 1 "2" "3 4" 5
class Main {
public static void main(String[] args){
int a = 123451234512345;
System.out.println(a);
}
}
- "123451234512345"
- Nothing - this will not compile.
- a negative integer value
- "12345100000"
Reasoning: The int type in Java can be used to represent any whole number from -2147483648 to 2147483647. Therefore, this code will not compile as the number assigned to 'a' is larger than the int type can hold.
class Main {
public static void main (String[] args) {
String message = "Hello world!";
String newMessage = message.substring(6, 12)
+ message.substring(12, 6);
System.out.println(newMessage);
}
}
- The code does not compile.
- A runtime exception is thrown.
- "world!!world"
- "world!world!"
-
for (Pencil pencil : pencilCase) {}
-
for (pencilCase.next()) {}
-
for (Pencil pencil : pencilCase.iterator()) {}
-
for (pencil in pencilCase) {}
System.out.print("apple".compareTo("banana"));
-
0
- positive number
- negative number
- compilation error
Q17. You have an ArrayList of names that you want to sort alphabetically. Which approach would NOT work?
-
names.sort(Comparator.comparing(String::toString))
-
Collections.sort(names)
-
names.sort(List.DESCENDING)
-
names.stream().sorted((s1, s2) -> s1.compareTo(s2)).collect(Collectors.toList())
Q18. By implementing encapsulation, you cannot directly access the class's _ properties unless you are writing code inside the class itself.
- private
- protected
- no-modifier
- public
-
new SimpleDateFormat("yyyy-MM-dd").format(new Date())
-
new Date(System.currentTimeMillis())
-
LocalDate.now()
-
Calendar.getInstance().getTime()
Explanation: LocalDate is the newest class added in java 8
boolean isDivisibleBy5 = _____
-
int0 / 5 ? true: false
-
int0 % 5 == 0
-
int0 % 5 != 5
-
Math.isDivisible(int0, 5)
class Main {
public static void main(String[] args){
for (int i=0; i<10; i=i++){
i+=1;
System.out.println("Hello World!");
}
}
}
- 10 times
- 9 times
- 5 times
- infinite number of times
Explanation: Observe the loop increment. It's not an increment, it's an assignment(post).
- iterative
- hello
- main
public class Jedi {
/* Constructor A */
Jedi(String name, String species){}
/* Constructor B */
Jedi(String name, String species, boolean followsTheDarkSide){}
}
-
Jedi(name, species, false)
-
new Jedi(name, species, false)
-
this(name, species, false)
-
super(name, species, false)
Note: This code won't compile, possibly broken code sample.
- An anonymous class may specify an abstract base class as its base type.
- An anonymous class does not require a zero-argument constructor.
- An anonymous class may specify an interface as its base type.
- An anonymous class may specify both an abstract class and interface as base types.
import java.util.LinkedList;
public class Main {
public static void main(String[] args){
LinkedList<Integer> list = new LinkedList<>();
list.add(5);
list.add(1);
list.add(10);
System.out.println(list);
}
}
- [5, 1, 10]
- [10, 5, 1]
- [1, 5, 10]
- [10, 1, 5]
class Main {
public static void main(String[] args){
String message = "Hello";
for (int i = 0; i<message.length(); i++){
System.out.print(message.charAt(i+1));
}
}
}
- "Hello"
- A runtime exception is thrown.
- The code does not compile.
- "ello"
Q27. Object-oriented programming is a style of programming where you organize your program around _ rather than _ and data rather than logic.
- functions; actions
- objects; actions
- actions; functions
- actions; objects
-
"nifty".getType().equals("String")
-
"nifty".getType() == String
-
"nifty".getClass().getSimpleName() == "String"
-
"nifty" instanceof String
import java.util.*;
class Main {
public static void main(String[] args) {
List<Boolean> list = new ArrayList<>();
list.add(true);
list.add(Boolean.parseBoolean("FalSe"));
list.add(Boolean.TRUE);
System.out.print(list.size());
System.out.print(list.get(1) instanceof Boolean);
}
}
- A runtime exception is thrown.
- 3false
- 2true
- 3true
1: class Main {
2: Object message(){
3: return "Hello!";
4: }
5: public static void main(String[] args) {
6: System.out.print(new Main().message());
7: System.out.print(new Main2().message());
8: }
9: }
10: class Main2 extends Main {
11: String message(){
12: return "World!";
13: }
14: }
- It will not compile because of line 7.
- Hello!Hello!
- Hello!World!
- It will not compile because of line 11.
- another instance
- field
- constructor
- private method
Q32. Which is the most reliable expression for testing whether the values of two string variables are the same?
- string1 == string2
- string1 = string2
- string1.matches(string2)
- string1.equals(string2)
public static void main(String[] args) {
try {
System.out.println("A");
badMethod();
System.out.println("B");
} catch (Exception ex) {
System.out.println("C");
} finally {
System.out.println("D");
}
}
public static void badMethod() {
throw new Error();
}
- A, B, and D
- A, C, and D
- C and D
- A and D
Explanation: Error
is not inherited from Exception
class Main {
static int count = 0;
public static void main(String[] args) {
if (count < 3) {
count++;
main(null);
} else {
return;
}
System.out.println("Hello World!");
}
}
- It will throw a runtime exception.
- It will not compile.
- It will print "Hello World!" three times.
- It will run forever.
import java.util.*;
class Main {
public static void main(String[] args) {
String[] array = {"abc", "2", "10", "0"};
List<String> list = Arrays.asList(array);
Collections.sort(list);
System.out.println(Arrays.toString(array));
}
}
-
[abc, 0, 2, 10]
- The code does not compile.
-
[abc, 2, 10, 0]
-
[0, 10, 2, abc]
Explanation: The java.util.Arrays.asList(T... a)
returns a fixed-size list backed by the specified array. (Changes to the returned list "write through" to the array.)
class Main {
public static void main(String[] args) {
String message = "Hello";
print(message);
message += "World!";
print(message);
}
static void print(String message){
System.out.print(message);
message += " ";
}
}
- Hello World!
- HelloHelloWorld!
- Hello Hello World!
- Hello HelloWorld!
public class Main {
public static void main(String[] args) {
int x = 5;
x = 10;
System.out.println(x);
}
}
- x
- null
- 10
- 5
- A
for (int i = 0; i < theList.size(); i++) {
System.out.println(theList.get(i));
}
- B
for (Object object : theList) {
System.out.println(object);
}
- C
Iterator it = theList.iterator();
for (it.hasNext()) {
System.out.println(it.next());
}
- D
theList.forEach(System.out::println);
Explanation: for (it.hasNext())
should be while (it.hasNext())
.
boolean healthyOrNot = isHealthy("avocado");
- public void isHealthy(String avocado)
- boolean isHealthy(String string)
- public isHealthy("avocado")
- private String isHealthy(String food)
- provides, employs
- imports, exports
- consumes, supplies
- requires, exports
- non-static
- static
- final
- private
- It will be read by only one thread at a time.
- It will be stored on the hard drive.
- It will never be cached by the CPU.
- It will be preferentially garbage collected.
char smooch = 'x';
System.out.println((int) smooch);
- an alphanumeric character
- a negative number
- a positive number
- a ClassCastException
- A file that needs to be opened cannot be found.
- A network connection has been lost in the middle of communications.
- Your code has used up all available memory.
- The object you are using has not been instantiated.
public class Nosey {
int age;
public static void main(String[] args) {
System.out.println("Your age is: " + age);
}
}
- Make age static.
- Make age global.
- Make age public.
- Initialize age to a number.
public class Duck {
private String name;
Duck(String name) {}
}
-
Duck waddles = new Duck();
ducks.add(waddles);
-
Duck duck = new Duck("Waddles");
ducks.add(waddles);
-
ducks.add(new Duck("Waddles"));
-
ducks.add(new Waddles());
Q47. If you encounter UnsupportedClassVersionError
it means the code was ___
on a newer version of Java than the JRE ___
it.
- executed; interpreting
- executed; compiling
- compiled; executing
- compiled, translating
public class TheClass {
private final int x;
}
- A
public TheClass() {
x += 77;
}
- B
public TheClass() {
x = null;
}
- C
public TheClass() {
x = 77;
}
- D
private void setX(int x) {
this.x = x;
}
public TheClass() {
setX(77);
}
Explanation: final
class members are allowed to be assigned only in three places: declaration, constructor or an instance-initializer block.
public class Solution {
public static void main(String[] args) {
for (int i = 44; i > 40; i--) {
System.out.println("f");
}
}
}
- 4
- 3
- 5
- A Runtime exception will be thrown
1. They can be instantiated.
2. They allow member variables and methods to be inherited by subclasses.
3. They can contain constructors.
- 1, 2, and 3
- only 3
- 2 and 3
- only 2
- parent
- super
- this
- new
1: int a = 1;
2: int b = 0;
3: int c = a/b;
4: System.out.println(c);
- It will throw an ArithmeticException.
- It will run and output 0.
- It will not compile because of line 3.
- It will run and output infinity.
Q53. Normally, to access a static member of a class such as Math.PI, you would need to specify the class "Math". What would be the best way to allow you to use simply "PI" in your code?
- Add a static import.
- Declare local copies of the constant in your code.
- This cannot be done. You must always qualify references to static members with the class form which they came from.
- Put the static members in an interface and inherit from that interface.
- extends
- implements
- inherits
- import
- You don't have to decide the size of an ArrayList when you first make it.
- You can put more items into an ArrayList than into an array.
- ArrayLists can hold more kinds of objects than arrays.
- You don't have to decide the type of an ArrayList when you first make it.
- int pi = 3.141;
- decimal pi = 3.141;
- double pi = 3.141;
- float pi = 3.141;
Reasoning:
public class TestReal {
public static void main (String[] argv)
{
double pi = 3.14159265; //accuracy up to 15 digits
float pi2 = 3.141F; //accuracy up to 6-7 digits
System.out.println ("Pi=" + pi);
System.out.println ("Pi2=" + pi2);
}
}
The default Java type which Java will be using for a float variable will be double.
So, even if you declare any variable as float, what the compiler has to actually do is to assign a double value to a float variable,
which is not possible. So, to tell the compiler to treat this value as a float, that 'F' is used.
public class MagicPower {
void castSpell(String spell) {}
}
-
new MagicPower().castSpell("expecto patronum")
-
MagicPower magicPower = new MagicPower();
magicPower.castSpell();
-
MagicPower.castSpell("expelliarmus");
-
new MagicPower.castSpell();
Q58. What language construct serves as a blueprint containing an object's properties and functionality?
- constructor
- instance
- class
- method
public static void main(String[] args) {
int x=5,y=10;
swapsies(x,y);
System.out.println(x+" "+y);
}
static void swapsies(int a, int b) {
int temp=a;
a=b;
b=temp;
}
- 10 10
- 5 10
- 10 5
- 5 5
try {
System.out.println("Hello World");
} catch (Exception e) {
System.out.println("e");
} catch (ArithmeticException e) {
System.out.println("e");
} finally {
System.out.println("!");
}
- Hello World
- It will not compile because the second catch statement is unreachable
- Hello World!
- It will throw runtime exception
- finally
- native
- interface
- unsigned
Explanation: native
is a part of JNI interface
-
%
-
//
-
/
-
DIV
- Overridden methods of the parent class cannot be reused.
- Responsibilities are not evenly distributed between parent and child classes.
- Classes related by inheritance are tightly coupled to each other.
- The internal state of the parent class is accessible to its children.
-
Array<Integer> numbers = new Array<Integer>(10);
-
Array[int] numbers = new Array[int](10);
-
int[] numbers = new int[10];
-
int numbers[] = int[10];
groucyButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("Press me one more time..");
}
});
-
groucyButton.addActionListener(ActionListener listener -> System.out.println("Press me one more time..."));
-
groucyButton.addActionListener((event) -> System.out.println("Press me one more time..."));
-
groucyButton.addActionListener(new ActionListener(ActionEvent e) {() -> System.out.println("Press me one more time...");});
-
groucyButton.addActionListener(() -> System.out.println("Press me one more time..."));
- Observer, Observable
- Collector, Builder
- Filter, Map, Reduce
- Consumer, Predicate, Supplier
- encrypting user passwords
- deciding if two instances of a class are equal
- enabling HashMap to find matches faster
- moving objects from a List to a HashMap
- uses-a
- is-a
- has-a
- was-a
- Set object to null and call Runtime.gc()
- Set object to null and call System.gc()
- Set object to null and call Runtime.getRuntime().runFinalization()
- There is no way to force an object to be garbage collected
Q70. Java programmers commonly use design patterns. Some examples are the _, which helps create instances of a class, the _, which ensures that only one instance of a class can be created; and the _, which allows for a group of algorithms to be interchangeable.
- static factory method; singleton; strategy pattern
- strategy pattern; static factory method; singleton
- creation pattern; singleton; prototype pattern
- singleton; strategy pattern; static factory method
Q71. Using Java's Reflection API, you can use _ to get the name of a class and _ to retrieve an array of its methods.
- this.getClass().getSimpleName(); this.getClass().getDeclaredMethods()
- this.getName(); this.getMethods()
- Reflection.getName(this); Reflection.getMethods(this)
- Reflection.getClass(this).getName(); Reflection.getClass(this).getMethods()
-
a -> false;
-
(a) -> false;
-
String a -> false;
-
(String a) -> false;
Q73. Which access modifier makes variables and methods visible only in the class where they are declared?
- public
- protected
- nonmodifier
- private
- private
- non-static
- final
- static
-
"21".intValue()
-
String.toInt("21")
-
Integer.parseInt("21")
-
String.valueOf("21")
public class Duck {
private String name;
Duck(String name) {
this.name = name;
}
public static void main(String[] args) {
System.out.println(new Duck("Moby"));
}
}
-
public String toString() { return name; }
-
public void println() { System.out.println(name); }
-
String toString() { return this.name; }
-
public void toString() { System.out.println(this.name); }
-
+
-
&
-
.
-
-
for (int i = 44; i > 40; i--) {
System.out.println("exterminate");
}
- two
- four
- three
- five
1: public class Main {
2: public static void main (String[] args) {
3: char myCharacter = "piper".charAt(3);
4: }
5: }
- p
- r
- e
- i
- when your method is related to the object's characteristics
- when you want your method to be available independently of class instances
- when your method uses an object's instance variable
- when your method is dependent on the specific instance that calls it
Q81. What phrase indicates that a function receives a copy of each argument passed to it rather than a reference to the objects themselves?
- pass by reference
- pass by occurrence
- pass by value
- API call
- inside the method
- both inside and outside the method
- neither inside nor outside the method
- outside the method
public class Main {
public static void main (String[] args) {
int[] sampleNumbers = {8, 5, 3, 1};
System.out.println(sampleNumbers[2]);
}
}
- 5
- 8
- 1
- 3
1: public class Main {
2: String MESSAGE ="Hello!";
3: static void print(){
4: System.out.println(message);
5: }
6: void print2(){}
7: }
- Change line 2 to
public static final String message
- Change line 6 to
public void print2(){}
- Remove the body of the
print2
method and add a semicolon. - Remove the body of the
print
method.
Explanation: Changing line 2 to public static final String message
raises the error message not initialized in the default constructor
import java.util.*;
class Main {
public static void main(String[] args) {
String[] array = new String[]{"A", "B", "C"};
List<String> list1 = Arrays.asList(array);
List<String> list2 = new ArrayList<>(Arrays.asList(array));
List<String> list3 = new ArrayList<>(Arrays.asList("A", new String("B"), "C"));
System.out.print(list1.equals(list2));
System.out.print(list1.equals(list3));
}
}
- falsefalse
- truetrue
- falsetrue
- truefalse
-
ArrayList<String> words = new ArrayList<String>(){"Hello", "World"};
-
ArrayList words = Arrays.asList("Hello", "World");
-
ArrayList<String> words = {"Hello", "World"};
-
ArrayList<String> words = new ArrayList<>(Arrays.asList("Hello", "World"));
class Main {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder("hello");
sb.deleteCharAt(0).insert(0, "H")." World!";
System.out.println(sb);
}
}
- A runtime exception is thrown.
- "HelloWorld!"
- "hello"
- ????
class TaxCalculator {
static calculate(total) {
return total * .05;
}
}
- TaxCalculator.calculate(50);
- new TaxCalculator.calculate(50);
- calculate(50);
- new TaxCalculator.calculate($50);
Note: This code won't compile, broken code sample
- uses hashcode of objects when inserted
- contains unordred elements
- contains unique elements
- contains sorted elements
Explanation: HashSet makes no guarantees as to the iteration order of the set; in particular, it does not guarantee that the order will remain constant over time.
import java.util.*;
public class Main {
public static void main(String[] args)
{
PriorityQueue<Integer> queue = new PriorityQueue<>();
queue.add(4);
queue.add(3);
queue.add(2);
queue.add(1);
while (queue.isEmpty() == false) {
System.out.printf("%d", queue.remove());
}
}
}
- 1 3 2 4
- 4 2 3 1
- 1 2 3 4
- 4 3 2 1
System.out.println("hello my friends".split(" ")[0]);
- my
- hellomyfriends
- hello
- friends
Q92. You have an instance of type Map<String, Integer> named instruments containing the following key-value pairs: guitar=1200, cello=3000, and drum=2000. If you add the new key-value pair cello=4500 to the Map using the put method, how many elements do you have in the Map when you call instruments.size()?
- 2
- When calling the put method, Java will throw an exception
- 4
- 3
- Clonable
- Throwable
- Object
- Serializable
- java.util.Vector
- java.util.ArrayList
- java.util.HashSet
- java.util.HashMap
Explanation: HashMap class implements Map interface.
Q95. You have a variable of named employees
of type List<Employee>
containing multiple entries. The Employee
type has a method getName()
that returns te employee name. Which statement properly extracts a list of employee names?
-
employees.collect(employee -> employee.getName());
-
employees.filter(Employee::getName).collect(Collectors.toUnmodifiableList());
-
employees.stream().map(Employee::getName).collect(Collectors.toList());
-
employees.stream().collect((e) -> e.getName());
public enum Direction {
EAST("E"),
WEST("W"),
NORTH("N"),
SOUTH("S");
private final String shortCode;
public String getShortCode() {
return shortCode;
}
}
- Add a constructor that accepts a
String
parameter and assigns it to the fieldshortCode
. - Remove the
final
keyword for the fieldshortCode
. - All enums need to be defined on a single line of code.
- Add a setter method for the field
shortCode
.
Q97. Which language feature ensures that objects implementing the AutoCloseable
interface are closed when it completes?
- try-catch-finally
- try-finally-close
- try-with-resources
- try-catch-close
class Main {
public static void main(String[] args) {
array[0] = new int[]{1, 2, 3};
array[1] = new int[]{4, 5, 6};
array[2] = new int[]{7, 8, 9};
for (int i = 0; i < 3; i++)
System.out.print(array[i][1]); //prints 258
}
}
-
int[][] array = new int[][];
-
int[][] array = new int[3][3];
-
int[][] array = new int[2][2];
-
int[][] array = [][];
class Car {
public void accelerate() {}
}
class Lambo extends Car {
public void accelerate(int speedLimit) {}
public void accelerate() {}
}
- neither
- both
- overloading
- overriding
- float
- String
- double
- BigDecimal
- A class can have multiple constructors with a different parameter list.
- You can call another constructor with
this
orsuper
. - A constructor does not define a return value.
- Every class must explicitly define a constructor without parameters.
Q102. What language feature allows types to be parameters on classes, interfaces, and methods in order to reuse the same code for different data types?
- Regular Expressions
- Reflection
- Generics
- Concurrency
public class Berries{
String berry = "blue";
public static void main( String[] args ) {
new Berries().juicy( "straw" );
}
void juicy(String berry){
this.berry = "rasp";
System.out.println(berry + "berry");
}
}
- raspberry
- strawberry
- blueberry
- rasp
Map<String, Integer> forestSpecies = new HashMap<>();
forestSpecies.put("Amazon", 30000);
forestSpecies.put("Congo", 10000);
forestSpecies.put("Daintree", 15000);
forestSpecies.put("Amazon", 40000);
int forestCount = forestSpecies.size();
- 3
- 4
- 2
- When calling the put method, Java will throw an exception
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
class Main {
public static void main( String[] args ) {
List<String> list = new ArrayList<String>( Arrays.asList( "a", "b", "c" ) );
for( String value :list ){
if( value.equals( "a" ) ) {
list.remove( value );
}
}
System.out.println(list); // outputs [b,c]
}
}
- String should be compared using == method instead of equals.
- Modifying a collection while iterating through it can throw a ConcurrentModificationException.
- The List interface does not allow an argument of type String to be passed to the remove method.
- ArrayList does not implement the List interface.
public int square(int x){
return x * x;
}
-
Function<Integer, Integer> squareLambda = (int x) -> { x * x };
-
Function<Integer, Integer> squareLambda = () -> { return x * x };
-
Function<Integer, Integer> squareLambda = x -> x * x;
-
Function<Integer, Integer> squareLambda = x -> return x * x;
interface MyInterface {
int foo(int x);
}
- A
public class MyClass implements MyInterface {
// ....
public void foo(int x){
System.out.println(x);
}
}
- B
public class MyClass implements MyInterface {
// ....
public double foo(int x){
return x * 100;
}
}
- C
public class MyClass implements MyInterface {
// ....
public int foo(int x){
return x * 100;
}
}
- D
public class MyClass implements MyInterface {
// ....
public int foo(){
return 100;
}
}
interface Foo{
int x = 10;
}
public class Main{
public static void main( String[] args ) {
Foo.x = 20;
System.out.println(Foo.x);
}
}
- 10
- 20
- null
- An error will occur when compiling.
1:
2: Optional<String> opt = Optional.of(val);
3: System.out.println(opt.isPresent());
-
Integer val = 15;
-
String val = "Sam";
-
String val = null;
-
Optional<String> val = Optional.empty();
System.out.println(true && false || true);
System.out.println(false || false && true);
- false
true - true
true - true
false - false
false
List<String> list1 = new ArrayList<>();
list1.add( "One" );
list1.add( "Two" );
list1.add( "Three" );
List<String> list2 = new ArrayList<>();
list2.add( "Two" );
list1.remove( list2 );
System.out.println(list1);
-
[Two]
-
[One, Two, Three]
-
[One, Three]
-
Two
-
if(time <> money){}
-
if(time.equals(money)){}
-
if(time == money){}
-
if(time = money){}
Q113. An _ is a serious issue thrown by the JVM that the JVM is unlikely to recover from. An _ is an unexpected event that an application may be able to deal with in order to continue execution.
- exception,assertion
- AbnormalException, AccidentalException
- error, exception
- exception, error
class Unicorn {
_____ Unicorn(){}
}
- static
- protected
- public
- void
List[] myLists = {
new ArrayList<>(),
new LinkedList<>(),
new Stack<>(),
new Vector<>(),
};
for (List list : myLists){
list.clear();
}
- composition
- generics
- polymorphism
- encapsulation
Explanation: switch between different implementations of the List
interface
String a = "bikini";
String b = new String("bikini");
String c = new String("bikini");
System.out.println(a == b);
System.out.println(b == c);
- true; false
- false; false
- false; true
- true; true
Explanation: == operator
compares the object reference. String a = "bikini"; String b = "bikini";
would result in True. Here new creates a new object, so false. Use equals() method
to compare the content.
Q117. What keyword is added to a method declaration to ensure that two threads do not simultaneously execute it on the same object instance?
- native
- volatile
- synchronized
- lock
Java Documentation: Synchronized methods
_____ oddOrEven = x -> {
return x % 2 == 0 ? "even" : "odd";
};
-
Function<Integer, Boolean>
-
Function<String>
-
Function<Integer, String>
-
Function<Integer>
import java.util.HashMap;
public class Main {
public static void main(String[] args) {
HashMap<String, Integer> pantry = new HashMap<>();
pantry.put("Apples", 3);
pantry.put("Oranges", 2);
int currentApples = pantry.get("Apples");
pantry.put("Apples", currentApples + 4);
System.out.println(pantry.get("Apples"));
}
}
- 6
- 3
- 4
- 7
List<String> songTitles = Arrays.asList("humble", "element", "dna");
_______ capitalize = (str) -> str.toUpperCase();
songTitles.stream().map(capitalize).forEach(System.out::println);
-
Function<String, String>
-
Stream<String>
-
String<String, String>
-
Map<String, String>
_____ processFunction(Integer number, Function<Integer, String> lambda) {
return lambda.apply(number);
}
-
Integer
-
String
-
Consumer
-
Function<Integer, String>
List<String> dates = new ArrayList<String>();
// missing code
dates.replaceAll(replaceSlashes);
-
UnaryOperator<String> replaceSlashes = date -> date.replace("/", "-");
-
Function<String, String> replaceSlashes = dates -> dates.replace("-", "/");
-
Map<String, String> replaceSlashes = dates.replace("/", "-");
-
Consumer<Date> replaceSlashes = date -> date.replace("/", "-");
Explanation: replaceAll
method for any List only accepts UnaryOperator to pass every single element into it then put the result into the List again.
-
Object
-
Main
-
Java
-
Class
import java.util.date;
public class CurrentDateRunnable implements Runnable {
@Override
public void run () {
while (true) {
System.out.println("Current date: " + new Date());
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
-
Thread thread = new Thread(new CurrentDateRunnable()); thread.start();
-
new Thread(new CurrentDateRunnable()).join();
-
new CurrentDateRunnable().run();
-
new CurrentDateRunnable().start();
List<Integer> numbers = List.of(1,2,3,4);
int total = 0;
for (Integer x : numbers) {
if (x % 2 == 0)
total += x * x;
}
- A
int total = numbers.stream()
.transform(x -> x * x)
.filter(x -> x % 2 == 0)
.sum ();
- B
int total = numbers.stream()
.filter(x -> x % 2 == 0)
.collect(Collectors.toInt());
- C
int total = numbers.stream()
.mapToInt (x -> {if (x % 2 == 0) return x * x;})
.sum();
- D
int total = numbers.stream()
.filter(x -> x % 2 == 0)
.mapToInt(x -> x * x)
.sum();
Explanation: The given code in the question will give you the output 20 as total
numbers // Input `List<Integer>` > [1, 2, 3, 4] <br>
.stream() // Converts input into `Stream<Integer>` <br>
.filter(x -> x % 2 == 0) // Filter even numbers and return `Stream<Integer>` > [2, 4] <br>
.mapToInt(x -> x * x) // Square the number, converts `Integer` to an `int`, and returns `IntStream` > [4, 16] <br>
.sum() // Returns the sum as `int` > 20
- out
- err
- in
Q127. The compiler is complaining about this assignment of the variable pickle to the variable jar. How woulld you fix this?
double pickle = 2;
int jar = pickle;
- Use the method toInt() to convert pickle before assigning it to jar.
- Cast pickle to an int before assigning it to jar.
- Make pickle into a double by adding + ".0"
- Use the new keyword to create a new Integer from pickle before assigning it to jar.
for(int i=0; i<30; i+=x) {}
- 10
- 3
- 1
- 0
- IDE; JRE
- JDK; IDE
- JRE; JDK
- JDK; JRE
- java.net
- java.util
- java.lang
- All above
String buy = "bitcoin";
System.out.println(buy.substring(x, x+1) + buy.substring(y, y+2))
- int x = 0; int y = 2;
- int x = 1; int y = 3;
- int x = 0; int y = 3;
- int x = 1; int y = 3;
- exception
- args
- static
- String
Q133. You have a list of Bunny objects that you want to sort by weight using Collections.sort. What modification would you make to the Bunny class?
- Implement the comparable interface by overriding the compareTo method.
- Add the keyword default to the weight variable.
- Override the equals method inside the Bunny class.
- Implement Sortable and override the sortBy method.
- Object oriented
- Use of pointers
- Dynamic
- Architectural neural
int yearsMarried = 2;
switch (yearsMarried) {
case 1:
System.out.println("paper");
case 2:
System.out.println("cotton");
case 3:
System.out.println("leather");
default:
System.out.println("I don't gotta buy gifts for nobody!");
}
- cotton
- cotton
leather - cotton
leather
I don't gotta buy gifts for nobody! - cotton
I don't gotta buy gifts for nobody!