Scribd
Upload
9 views

Corejava Interview Booster 11

Uploaded by

tellapuri.naresh
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
9 views

Corejava Interview Booster 11

Uploaded by

tellapuri.naresh
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 5

Date : 04/11/2024 (Interview Booster)

======================================
`java.util.Date` and `java.sql.Date` are both classes in Java that represent dates,
but they serve different purposes and have different characteristics. Here’s a
brief comparison along with examples.

### 1. **Purpose**
- **`java.util.Date`**: Represents a specific instant in time, with millisecond
precision. It can be used in general-purpose applications.
- **`java.sql.Date`**: A subclass of `java.util.Date`, specifically designed for
working with SQL `DATE` values. It represents only the date (year, month, day)
without time information (hours, minutes, seconds).

### 2. **Time Information**


- **`java.util.Date`**: Contains both date and time information.
- **`java.sql.Date`**: Contains only the date part. The time part is set to
00:00:00.

### 3. **Usage in Databases**


- **`java.util.Date`**: Not suitable for JDBC operations where you need to handle
SQL dates.
- **`java.sql.Date`**: Specifically used for SQL operations, especially when you
are working with `DATE` columns in databases.

### Examples

#### Example 1: Using `java.util.Date`

```java
import java.util.Date;

public class UtilDateExample {


public static void main(String[] args) {
Date utilDate = new Date();
System.out.println("Util Date: " + utilDate);

// Output includes time


}
}
```

#### Example 2: Using `java.sql.Date`

```java
import java.sql.Date;

public class SqlDateExample {


public static void main(String[] args) {
// Get the current date
long currentTimeMillis = System.currentTimeMillis();
Date sqlDate = new Date(currentTimeMillis);

System.out.println("SQL Date: " + sqlDate);

// Output shows only date part


}
}
```
### Key Points
- When you print `java.util.Date`, it includes both date and time.
- When you print `java.sql.Date`, the time is set to 00:00:00.

### Conversion Between the Two


You often need to convert between `java.util.Date` and `java.sql.Date` when working
with databases:

```java
import java.util.Date;
import java.sql.Date as SqlDate;

public class DateConversionExample {


public static void main(String[] args) {
// Convert java.util.Date to java.sql.Date
Date utilDate = new Date();
SqlDate sqlDate = new SqlDate(utilDate.getTime());
System.out.println("Converted SQL Date: " + sqlDate);

// Convert java.sql.Date to java.util.Date


Date convertedBack = new Date(sqlDate.getTime());
System.out.println("Converted back to Util Date: " + convertedBack);
}
}
```

### Summary
- Use `java.util.Date` for general date-time operations.
- Use `java.sql.Date` when working specifically with SQL databases to handle dates
without time.
================================
package com.InterviewPrep;

public class SwappingArrayElements {


public static void main(String[] args) {
String [][] x = {{"A","B"},{"C","D"}};
for (int i=x.length-1;i>=0;i--){
for(int j=0;j<x[i].length;j++){
System.out.print(x[i][j]);
}
}
}
}
============
Sure! Here’s a concise explanation of the code and its output:

### Code Overview

```java
String [][] x = {{"A","B"},{"C","D"}};
```
- A 2D array `x` is defined with two rows:
- Row 0: `{"A", "B"}`
- Row 1: `{"C", "D"}`

### Loop Explanation

1. **Outer Loop**:
```java
for (int i = x.length - 1; i >= 0; i--)
```
- Starts from the last row (`i = 1` for `{"C", "D"}`) and goes to the first row
(`i = 0` for `{"A", "B"}`).

2. **Inner Loop**:
```java
for(int j = 0; j < x[i].length; j++)
```
- Iterates through each column of the current row.

3. **Printing**:
```java
System.out.print(x[i][j]);
```
- Prints each element without a newline.

### Output Breakdown

- **First Iteration (`i = 1`)**:


- Prints "C" and "D" → Output: `CD`

- **Second Iteration (`i = 0`)**:


- Prints "A" and "B" → Final Output: `CDBA`

### Final Output


The program prints:
```
CDBA
```

### Summary
The code effectively prints the elements of a 2D array in reverse order, resulting
in the output "CDBA".
==================================
package com.InterviewPrep;

public class SwappingArrayindexvalues {


public static void main(String[] args) {
String [][] s = {{"A","B"},{"C","D"}};
for(int i=0; i<s.length;i++){
for(int j=s[i].length-1;j>=0;j--){
System.out.print(s[i][j]);
}
}
}
}
================
Sure! Let’s break down the code and its output step by step.

### Code Overview

```java
String [][] s = {{"A","B"},{"C","D"}};
```
- A 2D array `s` is defined with two rows:
- Row 0: `{"A", "B"}`
- Row 1: `{"C", "D"}`
### Loop Explanation

1. **Outer Loop**:
```java
for(int i = 0; i < s.length; i++)
```
- Iterates through each row of the array, starting from the first row (`i = 0`
for `{"A", "B"}`) to the last row (`i = 1` for `{"C", "D"}`).

2. **Inner Loop**:
```java
for(int j = s[i].length - 1; j >= 0; j--)
```
- For each row, it starts from the last column (`j = 1` for the first row) and
goes to the first column (`j = 0`).

3. **Printing**:
```java
System.out.print(s[i][j]);
```
- Prints each element without a newline.

### Output Breakdown

- **First Iteration (`i = 0`)** (Row: `{"A", "B"}`):


- Starts with `j = 1`: Prints "B"
- Next, `j = 0`: Prints "A"
- Output so far: `BA`

- **Second Iteration (`i = 1`)** (Row: `{"C", "D"}`):


- Starts with `j = 1`: Prints "D"
- Next, `j = 0`: Prints "C"
- Final Output: `BACD`

### Final Output


The program prints:
```
BACD
```

### Summary
This code prints the elements of a 2D array in reverse order for each row,
resulting in the output "BACD".
===================
Yes, when you create an object of a class in Java, the `toString()` method is
implicitly called when you try to print that object or when the object is
concatenated with a string.

### Example

Here's a simple example to illustrate this:

```java
class MyClass {
@Override
public String toString() {
return "This is MyClass object";
}
}
public class Main {
public static void main(String[] args) {
MyClass obj = new MyClass();
System.out.println(obj); // This will call obj.toString() internally
}
}
```

### Output
```
This is MyClass object
```

### Explanation
- When you use `System.out.println(obj)`, the `println` method calls
`obj.toString()` internally to get the string representation of the object.
- If you don't override the `toString()` method in your class, the default
implementation from the `Object` class is called, which returns a string containing
the class name and the object's hash code.

So, yes, `toString()` is called internally when printing an object or using it in


string contexts.
===============================

You might also like