Knowledge Never Sets
|
1 2 3 4 5 6 7 8 |
public class MyClass { public static void main(String args[]) { StringBuilder sb=new StringBuilder("Hello"); System.out.println("String is " + sb); sb=sb.reverse(); System.out.println("Reverse String is " + sb); } } |
A Leap Year is a year which has 366 days. This year February is of 29 days. Leap years occurs in every four years.
A leap year has following constraints.
We can check in programming as below
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
import java.util.Scanner; public class MyClass { public static void main(String args[]) { System.out.println("Enter the year to check it is prime or not"); Scanner scanner = new Scanner(System.in); int year = scanner.nextInt(); if (year % 4 == 0) { if (year % 100 == 0) { if (year % 400 == 0) { System.out.println("Year " + year + " is a leap year"); } else { System.out.println("Year " + year + " is not a leap year"); } } else { System.out.println("Year " + year + " is a leap year"); } } else { System.out.println("Year " + year + " is not a leap year"); } } } |
|
1 2 3 |
Enter the year to check it is prime or not 2020 Year 2020 is a leap year |
See another program
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
import java.util.Scanner; public class LeapYearTest { public static void main(String args[]) { System.out.println("Enter the year to check it is prime or not"); Scanner scanner = new Scanner(System.in); int year = scanner.nextInt(); if ((year % 400 == 0) || ( ( year % 100 != 0) && (year % 4 == 0 ))){ System.out.println("Year " + year + " is a leap year"); } else { System.out.println("Year " + year + " is not a leap year"); } } } |
|
1 2 3 |
Enter the year to check it is prime or not 2000 Year 2000 is a leap year |
Database connection with java is one of the essential feature of java, In java to connect with database we use java database connectivity(JDBC) programs.
JDBC is an Application Program Interface(API) that is used to interact with database and java program in database independent way.
So JDBC (full form Java Database Connectivity) code to interact with mysql, oracle database and with other database.
Here we used jdbc with mysql to connect it we need a mysql jdbc driver to connect mysql with java.
Here we will see a java jdbc project to perform all basic operations involved in Database interaction.
JDBC project setup is in two part
Above all details are set in following script.
Run this script before running java jdbc program
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
CREATE USER 'ebhor_user'@'localhost' IDENTIFIED BY '21V6'; GRANT ALL ON *.* TO 'ebhor_user'@'localhost'; create database ebhor; use ebhor; create table employee( id bigint(20) unsigned NOT NULL AUTO_INCREMENT, fname varchar(100), lname varchar(30), address varchar(80), mobile_no varchar(12), email_id varchar(100), city varchar(50), add_date timestamp DEFAULT CURRENT_TIMESTAMP, primary key(id), unique key(mobile_no), unique key(email_id) ) ENGINE = InnoDB DEFAULT CHARSET = utf8; |
A Java Bean is a simple java class, that holds all properties, getter setter methods and constructors of the class.
Java Bean for Employee class is given below
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 |
/* This class contains getter setter and constructor of class */ package pojo; import java.sql.Timestamp; /** * * @author Manish Sahu */ public class Employee { private long id; private String fname; private String lname; private String address; private String mobileNo; private String mailId; private String city; private Timestamp addDate; public Employee() { } public Employee(String fname, String lname, String address, String mobileNo, String mailId, String city) { this.fname = fname; this.lname = lname; this.address = address; this.mobileNo = mobileNo; this.mailId = mailId; this.city = city; } public Employee(long id, String fname, String lname, String address, String mobileNo, String mailId, String city) { this.id = id; this.fname = fname; this.lname = lname; this.address = address; this.mobileNo = mobileNo; this.mailId = mailId; this.city = city; } public long getId() { return id; } public void setId(long id) { this.id = id; } public String getFname() { return fname; } public void setFname(String fname) { this.fname = fname; } public String getLname() { return lname; } public void setLname(String lname) { this.lname = lname; } public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } public String getMobileNo() { return mobileNo; } public void setMobileNo(String mobileNo) { this.mobileNo = mobileNo; } public String getMailId() { return mailId; } public void setMailId(String mailId) { this.mailId = mailId; } public String getCity() { return city; } public void setCity(String city) { this.city = city; } public Timestamp getAddDate() { return addDate; } public void setAddDate(Timestamp addDate) { this.addDate = addDate; } @Override public String toString() { return "Employee{" + "id=" + id + ", fname=" + fname + ", lname=" + lname + ", address=" + address + ", mobileNo=" + mobileNo + ", mailId=" + mailId + ", city=" + city + ", addDate=" + addDate + '}'; } } |
Below is main class for running all java jdbc examples
Here you find various examples like to insert in table, to update table ,delete a recored from mysql table and select a specific or all record from table.
To insert record see comment data Create Employee that is used to create table at that time comment all other below data.
When data is inserted then comment the create employee and uncomment the update employee.
similar for all.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 |
/* * main method to call action */ package ebhor.start; import ebhor.action.EmployeeAction; import ebhor.model.Employee; import java.math.BigDecimal; import java.sql.Date; /** * * @author Manish Sahu */ public class MainClass { public static void main(String[] args) { EmployeeAction action = new EmployeeAction(); /*----------- 1 Create Employee-----------*/ Employee employee1 = new Employee("Ram", "Kumar", "Street no 5 sector 5", "456456122", "[email protected]", "Bhilai", "CEO", Date.valueOf("1988-03-22"), Date.valueOf("2015-05-05"), new BigDecimal(150000)); Employee employee2 = new Employee("Mohan", "Lal", "Near Super market", "2342424343", "[email protected]", "Indore", "Manager", Date.valueOf("1988-05-20"), Date.valueOf("2015-05-15"), new BigDecimal(130000)); Employee employee3 = new Employee("Shyam", "Bajpayee", "Shanti Nagar", "3452342423", "[email protected]", "Pune", "Manager", Date.valueOf("1989-06-10"), Date.valueOf("2016-06-22"), new BigDecimal(130000)); Employee employee4 = new Employee("Rita", "Kapoor", "Near HAL Layout", "6538659801", "[email protected]", "Bangalore", "Analyst", Date.valueOf("1989-06-12"), Date.valueOf("2016-06-06"), new BigDecimal(120000)); Employee employee5 = new Employee("Nita", "Rai", "Sundar Nagar", "8345354325", "[email protected]", "Raipur", "Analyst", Date.valueOf("1988-03-22"), Date.valueOf("2015-05-05"), new BigDecimal(120000)); action.insert(employee1); action.insert(employee2); action.insert(employee3); action.insert(employee4); action.insert(employee5); /*----------- 2 Update Employee-----------*/ /* Employee employee1 = new Employee(1l, "Ram", "Kumar", "Street no 5 sector 5", "4564563442", "[email protected]", "Bhilai","CEO", Date.valueOf("1988-03-22"), Date.valueOf("2015-05-05"), new BigDecimal(150000)); action.update(employee1);*/ /*----------- 3 Delete Employee-----------*/ /*Employee employee6 = new Employee("Ramesh", "Kumar", "Sadar market", "345234234", "[email protected]", "Bhopal", "Manager", Date.valueOf("1989-12-20"), Date.valueOf("2015-05-15"), new BigDecimal(100000)); action.insert(employee6);*/ /*action.delete(6l);*/ /*----------- 4 Fetch By Employee Id -----------*/ /*action.fetchById(2l);*/ /*----------- 5 Fetch By Employee Email Id -----------*/ /*action.fetchByEmailId("[email protected]");*/ /*----------- 6 Fetch By Employee Mobile No -----------*/ /*action.fetchByMobileNo("6538659801");*/ /*----------- 7 Search By Employee Name -----------*/ /*action.searchByName("Ram");*/ /*----------- 8 Fetch By Employee City -----------*/ /*action.fetchByCity("Pune");*/ /*----------- 9 Fetch By Employee Salary Range -----------*/ /*action.fetchBySalaryRange(new BigDecimal(100000), new BigDecimal(130000));*/ /*----------- 10 Fetch By Employee Dob -----------*/ /* action.fetchByDob(Date.valueOf("1988-03-22"));*/ /*----------- 9 Fetch By Employee Range Doj -----------*/ /*action.fetchByRangeDoj(Date.valueOf("2015-05-05"), Date.valueOf("2016-06-06"));*/ /*----------- 10FetchAll Employee-----------*/ action.fetchAll(); } } |
Create Action Class
Above class will call method of below action class
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 |
package ebhor.action; import ebhor.dao.EmployeeDao; import java.util.List; import ebhor.model.Employee; import java.math.BigDecimal; import java.sql.Date; /** * All data accept and manipulation should be done here * * @author Manish Sahu */ public class EmployeeAction { EmployeeDao dao = new EmployeeDao(); int st; public void insert(Employee employee) { st = dao.insert(employee); if (st == 1) { System.out.println("Employee Inserted Successfully"); } else if (st == -1) { System.out.println("Employee Already exists"); } else { System.out.println("Unable to Insert Employee"); } } public void update(Employee employee) { st = dao.update(employee); if (st == 1) { System.out.println("Employee Updated Successfully"); } else { System.out.println("Unable to update Employee"); } } public void delete(Long id) { st = dao.delete(id); if (st == 1) { System.out.println("Employee Deleted Successfully"); } else { System.out.println("Unable to Delete Employee"); } } public void fetchById(Long id) { Employee employee = dao.fetchById(id); System.out.println("Employee Details are :"); System.out.println(employee); } public void fetchByEmailId(String emailId) { Employee employee = dao.fetchByEmailId(emailId); System.out.println("Employee Details are :"); System.out.println(employee); } public void fetchByMobileNo(String mobileNo) { Employee employee = dao.fetchByMobileNo(mobileNo); System.out.println("Employee Details are :"); System.out.println(employee); } public void searchByName(String name) { List<Employee> employeeList = dao.searchByName(name); System.out.println("Employee Details are :"); for (Employee employee : employeeList) { System.out.println(employee); } } public void fetchByCity(String city) { List<Employee> employeeList = dao.fetchByCity(city); System.out.println("Employee Details are :"); for (Employee employee : employeeList) { System.out.println(employee); } } public void fetchBySalaryRange(BigDecimal lowerSalary, BigDecimal higherSalary) { List<Employee> employeeList = dao.fetchBySalaryRange(lowerSalary, higherSalary); System.out.println("Employee Details are :"); for (Employee employee : employeeList) { System.out.println(employee); } } public void fetchByDob(Date dob) { List<Employee> employeeList = dao.fetchByDob(dob); System.out.println("Employee Details are :"); for (Employee employee : employeeList) { System.out.println(employee); } } public void fetchByRangeDoj(Date startDate, Date endDate) { List<Employee> employeeList = dao.fetchByRangeDoj(startDate,endDate); System.out.println("Employee Details are :"); for (Employee employee : employeeList) { System.out.println(employee); } } public void fetchAll() { List<Employee> employeeList = dao.fetchAll(); System.out.println("Employee Details are :"); for (Employee employee : employeeList) { System.out.println(employee); } } } |
Create DAO class
The above action class will call to below DAO class method
Here All JDBC Prepared statement are used to interact with mysql
Various JDBC operations used here are
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 |
/* * All database operation create update delete and select * of employee should be done here * */ package ebhor.dao; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.util.ArrayList; import java.util.List; import ebhor.model.Employee; import com.mysql.jdbc.exceptions.MySQLIntegrityConstraintViolationException; import java.math.BigDecimal; import java.sql.Date; public class EmployeeDao { Connection con = null; PreparedStatement ps = null; ResultSet rs = null; int st;//status /*JDBC Insert method*/ public int insert(Employee employee) { con = ConnectionFactory.getConnection(); try { String query = "insert into employee(fname,lname,address,mobile_no,email_id,city,designation,dob,doj,salary) " + "values(?,?,?,?,?,?,?,?,?,?)"; ps = con.prepareStatement(query); ps.setString(1, employee.getFname()); ps.setString(2, employee.getLname()); ps.setString(3, employee.getAddress()); ps.setString(4, employee.getMobileNo()); ps.setString(5, employee.getMailId()); ps.setString(6, employee.getCity()); ps.setString(7, employee.getDesignation()); ps.setDate(8, employee.getDob()); ps.setDate(9, employee.getDoj()); ps.setBigDecimal(10, employee.getSalary()); st = ps.executeUpdate(); System.out.println("inserted employee " + st); } catch (MySQLIntegrityConstraintViolationException e) { st = -1; e.printStackTrace(); } catch (Exception e) { st = -2; e.printStackTrace(); } finally { try { con.close(); } catch (SQLException ex) { ex.printStackTrace(); } } return st; } /*JDBC Update method*/ public int update(Employee employee) { con = ConnectionFactory.getConnection(); try { String query = "update employee set fname=?,lname=?,address=?,mobile_no=?,email_id=?,city=?, " + "designation=?,dob=?,doj=?,salary=? " + "where id=? "; ps = con.prepareStatement(query); ps.setString(1, employee.getFname()); ps.setString(2, employee.getLname()); ps.setString(3, employee.getAddress()); ps.setString(4, employee.getMobileNo()); ps.setString(5, employee.getMailId()); ps.setString(6, employee.getCity()); ps.setString(7, employee.getDesignation()); ps.setDate(8, employee.getDob()); ps.setDate(9, employee.getDoj()); ps.setBigDecimal(10, employee.getSalary()); ps.setLong(11, employee.getId()); st = ps.executeUpdate(); System.out.println("updated employee " + st); } catch (Exception e) { st = -2; e.printStackTrace(); } finally { try { con.close(); } catch (SQLException ex) { ex.printStackTrace(); } } return st; } /*JDBC delete method*/ public int delete(long id) { con = ConnectionFactory.getConnection(); try { String query = "delete from employee where id=? "; ps = con.prepareStatement(query); ps.setLong(1, id); st = ps.executeUpdate(); System.out.println("deleted employee " + st); } catch (Exception e) { st = -2; e.printStackTrace(); } finally { try { con.close(); } catch (SQLException ex) { ex.printStackTrace(); } } return st; } /*JDBC fetchById method*/ public Employee fetchById(long id) { Employee employee = new Employee(); con = ConnectionFactory.getConnection(); try { String query = "select * from employee where id=?"; ps = con.prepareStatement(query); ps.setLong(1, id); rs = ps.executeQuery(); while (rs.next()) { employee.setId(rs.getLong("id")); employee.setFname(rs.getString("fname")); employee.setLname(rs.getString("lname")); employee.setAddress(rs.getString("address")); employee.setMobileNo(rs.getString("mobile_no")); employee.setMailId(rs.getString("email_id")); employee.setCity(rs.getString("city")); employee.setDesignation(rs.getString("designation")); employee.setDob(rs.getDate("dob")); employee.setDoj(rs.getDate("doj")); employee.setSalary(rs.getBigDecimal("salary")); employee.setAddDate(rs.getTimestamp("add_date")); } } catch (Exception e) { e.printStackTrace(); } finally { try { con.close(); } catch (SQLException ex) { ex.printStackTrace(); } } return employee; } /*JDBC fetchByEmailId method*/ public Employee fetchByEmailId(String emailId) { Employee employee = new Employee(); con = ConnectionFactory.getConnection(); try { String query = "select * from employee where email_id=?"; ps = con.prepareStatement(query); ps.setString(1, emailId); rs = ps.executeQuery(); while (rs.next()) { employee.setId(rs.getLong("id")); employee.setFname(rs.getString("fname")); employee.setLname(rs.getString("lname")); employee.setAddress(rs.getString("address")); employee.setMobileNo(rs.getString("mobile_no")); employee.setMailId(rs.getString("email_id")); employee.setCity(rs.getString("city")); employee.setDesignation(rs.getString("designation")); employee.setDob(rs.getDate("dob")); employee.setDoj(rs.getDate("doj")); employee.setSalary(rs.getBigDecimal("salary")); employee.setAddDate(rs.getTimestamp("add_date")); } } catch (Exception e) { e.printStackTrace(); } finally { try { con.close(); } catch (SQLException ex) { ex.printStackTrace(); } } return employee; } /*JDBC fetchByMobileNo method*/ public Employee fetchByMobileNo(String mobileNo) { Employee employee = new Employee(); con = ConnectionFactory.getConnection(); try { String query = "select * from employee where mobile_no=?"; ps = con.prepareStatement(query); ps.setString(1, mobileNo); rs = ps.executeQuery(); while (rs.next()) { employee.setId(rs.getLong("id")); employee.setFname(rs.getString("fname")); employee.setLname(rs.getString("lname")); employee.setAddress(rs.getString("address")); employee.setMobileNo(rs.getString("mobile_no")); employee.setMailId(rs.getString("email_id")); employee.setCity(rs.getString("city")); employee.setDesignation(rs.getString("designation")); employee.setDob(rs.getDate("dob")); employee.setDoj(rs.getDate("doj")); employee.setSalary(rs.getBigDecimal("salary")); employee.setAddDate(rs.getTimestamp("add_date")); } } catch (Exception e) { e.printStackTrace(); } finally { try { con.close(); } catch (SQLException ex) { ex.printStackTrace(); } } return employee; } /*JDBC searchByName method*/ public List<Employee> searchByName(String name) { List<Employee> employeeList = new ArrayList<Employee>(); con = ConnectionFactory.getConnection(); try { String query = "select * from employee where fname like ? or lname like ?"; ps = con.prepareStatement(query); ps.setString(1, "%" + name + "%"); ps.setString(2, "%" + name + "%"); rs = ps.executeQuery(); while (rs.next()) { Employee employee = new Employee(); employee.setId(rs.getLong("id")); employee.setFname(rs.getString("fname")); employee.setLname(rs.getString("lname")); employee.setAddress(rs.getString("address")); employee.setMobileNo(rs.getString("mobile_no")); employee.setMailId(rs.getString("email_id")); employee.setCity(rs.getString("city")); employee.setDesignation(rs.getString("designation")); employee.setDob(rs.getDate("dob")); employee.setDoj(rs.getDate("doj")); employee.setSalary(rs.getBigDecimal("salary")); employee.setAddDate(rs.getTimestamp("add_date")); employeeList.add(employee); } } catch (Exception e) { e.printStackTrace(); } finally { try { con.close(); } catch (SQLException ex) { ex.printStackTrace(); } } return employeeList; } /*JDBC fetchByCity method*/ public List<Employee> fetchByCity(String city) { List<Employee> employeeList = new ArrayList<Employee>(); con = ConnectionFactory.getConnection(); try { String query = "select * from employee where city=?"; ps = con.prepareStatement(query); ps.setString(1, city); rs = ps.executeQuery(); while (rs.next()) { Employee employee = new Employee(); employee.setId(rs.getLong("id")); employee.setFname(rs.getString("fname")); employee.setLname(rs.getString("lname")); employee.setAddress(rs.getString("address")); employee.setMobileNo(rs.getString("mobile_no")); employee.setMailId(rs.getString("email_id")); employee.setCity(rs.getString("city")); employee.setDesignation(rs.getString("designation")); employee.setDob(rs.getDate("dob")); employee.setDoj(rs.getDate("doj")); employee.setSalary(rs.getBigDecimal("salary")); employee.setAddDate(rs.getTimestamp("add_date")); employeeList.add(employee); } } catch (Exception e) { e.printStackTrace(); } finally { try { con.close(); } catch (SQLException ex) { ex.printStackTrace(); } } return employeeList; } /*JDBC fetchBySalaryRange method*/ public List<Employee> fetchBySalaryRange(BigDecimal lowerSalary, BigDecimal higherSalary) { List<Employee> employeeList = new ArrayList<Employee>(); con = ConnectionFactory.getConnection(); try { String query = "select * from employee where salary between ? and ?"; ps = con.prepareStatement(query); ps.setBigDecimal(1, lowerSalary); ps.setBigDecimal(2, higherSalary); rs = ps.executeQuery(); while (rs.next()) { Employee employee = new Employee(); employee.setId(rs.getLong("id")); employee.setFname(rs.getString("fname")); employee.setLname(rs.getString("lname")); employee.setAddress(rs.getString("address")); employee.setMobileNo(rs.getString("mobile_no")); employee.setMailId(rs.getString("email_id")); employee.setCity(rs.getString("city")); employee.setDesignation(rs.getString("designation")); employee.setDob(rs.getDate("dob")); employee.setDoj(rs.getDate("doj")); employee.setSalary(rs.getBigDecimal("salary")); employee.setAddDate(rs.getTimestamp("add_date")); employeeList.add(employee); } } catch (Exception e) { e.printStackTrace(); } finally { try { con.close(); } catch (SQLException ex) { ex.printStackTrace(); } } return employeeList; } /*JDBC fetchByDob method*/ public List<Employee> fetchByDob(Date dob) { List<Employee> employeeList = new ArrayList<Employee>(); con = ConnectionFactory.getConnection(); try { String query = "select * from employee where dob=?"; ps = con.prepareStatement(query); ps.setDate(1, dob); rs = ps.executeQuery(); while (rs.next()) { Employee employee = new Employee(); employee.setId(rs.getLong("id")); employee.setFname(rs.getString("fname")); employee.setLname(rs.getString("lname")); employee.setAddress(rs.getString("address")); employee.setMobileNo(rs.getString("mobile_no")); employee.setMailId(rs.getString("email_id")); employee.setCity(rs.getString("city")); employee.setDesignation(rs.getString("designation")); employee.setDob(rs.getDate("dob")); employee.setDoj(rs.getDate("doj")); employee.setSalary(rs.getBigDecimal("salary")); employee.setAddDate(rs.getTimestamp("add_date")); employeeList.add(employee); } } catch (Exception e) { e.printStackTrace(); } finally { try { con.close(); } catch (SQLException ex) { ex.printStackTrace(); } } return employeeList; } /*JDBC fetchByRangeDoj method*/ public List<Employee> fetchByRangeDoj(Date startDate, Date endDate) { List<Employee> employeeList = new ArrayList<Employee>(); con = ConnectionFactory.getConnection(); try { String query = "select * from employee where doj between ? and ?"; ps = con.prepareStatement(query); ps.setDate(1, startDate); ps.setDate(2, endDate); rs = ps.executeQuery(); while (rs.next()) { Employee employee = new Employee(); employee.setId(rs.getLong("id")); employee.setFname(rs.getString("fname")); employee.setLname(rs.getString("lname")); employee.setAddress(rs.getString("address")); employee.setMobileNo(rs.getString("mobile_no")); employee.setMailId(rs.getString("email_id")); employee.setCity(rs.getString("city")); employee.setDesignation(rs.getString("designation")); employee.setDob(rs.getDate("dob")); employee.setDoj(rs.getDate("doj")); employee.setSalary(rs.getBigDecimal("salary")); employee.setAddDate(rs.getTimestamp("add_date")); employeeList.add(employee); } } catch (Exception e) { e.printStackTrace(); } finally { try { con.close(); } catch (SQLException ex) { ex.printStackTrace(); } } return employeeList; } /*JDBC fetchAll method*/ public List<Employee> fetchAll() { List<Employee> employeeList = new ArrayList<Employee>(); con = ConnectionFactory.getConnection(); try { String query = "select * from employee"; ps = con.prepareStatement(query); rs = ps.executeQuery(); while (rs.next()) { Employee employee = new Employee(); employee.setId(rs.getLong("id")); employee.setFname(rs.getString("fname")); employee.setLname(rs.getString("lname")); employee.setAddress(rs.getString("address")); employee.setMobileNo(rs.getString("mobile_no")); employee.setMailId(rs.getString("email_id")); employee.setCity(rs.getString("city")); employee.setDesignation(rs.getString("designation")); employee.setDob(rs.getDate("dob")); employee.setDoj(rs.getDate("doj")); employee.setSalary(rs.getBigDecimal("salary")); employee.setAddDate(rs.getTimestamp("add_date")); employeeList.add(employee); } } catch (Exception e) { e.printStackTrace(); } finally { try { con.close(); } catch (SQLException ex) { ex.printStackTrace(); } } return employeeList; } } |
Download this Java Project with source code for github
Gson is Java JSON library that is used to convert Java object to/from JSON
GSON is developed by google.
GSON Maven dependency is as below
|
1 2 3 4 5 6 |
<!-- https://mvnrepository.com/artifact/com.google.code.gson/gson --> <dependency> <groupId>com.google.code.gson</groupId> <artifactId>gson</artifactId> <version>2.8.5</version> </dependency> |
You can also download Gson Jar from here
Gson jar contains API to work with JSON
GOal of GSON is provide simple methods to convert and receive JSON, Provides extensive support for Generics, support complex objects
GSON provides simple functions to convert in to JSON it has toJSON() and from JSON to Java Object it has fromJSON()
1. Gson gson=new Gson();
2. GsonBuilder gsonBuilder = new GsonBuilder();
Gson gson1 = gsonBuilder.create();
Here Gson() is no argument constructor that will create Gson object.
Using GsonBuilder by calling create() we get Gson object
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 |
package jsonpkg; import com.google.gson.Gson; import com.google.gson.GsonBuilder; import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; public class GsonExample { public static void main(String[] args) { int a = 5; double d = 45.44; String name = "Rama"; int[] age = {23, 22, 25, 26, 27, 30}; double[] price = {34.33, 55.43, 51.33, 54.22, 77.00}; List<String> names = new ArrayList<String>(); names.add("Ram"); names.add("Mohan"); names.add("Sohan"); Set<String> branch = new HashSet<String>(); branch.add("Computer Science"); branch.add("Electronics and TeleCommunications"); branch.add("Civil Engg"); Map map = new HashMap(); map.put(1, "Computer"); map.put(2, "Printer"); map.put(3, "Scanner"); Gson gson = new Gson(); System.out.println("JSON of a =" + gson.toJson(a)); System.out.println("JSON of d =" + gson.toJson(d)); System.out.println("JSON of name =" + gson.toJson(name)); System.out.println("JSON of age =" + gson.toJson(age)); System.out.println("JSON of price =" + gson.toJson(price)); GsonBuilder gsonBuilder = new GsonBuilder(); Gson gson1 = gsonBuilder.create(); System.out.println("JSON of names =" + gson1.toJson(names)); System.out.println("JSON of branch =" + gson1.toJson(branch)); System.out.println("JSON of map =" + gson1.toJson(map)); } } |
Result:
|
1 2 3 4 5 6 7 8 |
JSON of a =5 JSON of d =45.44 JSON of name ="Rama" JSON of age =[23,22,25,26,27,30] JSON of price =[34.33,55.43,51.33,54.22,77.0] JSON of names =["Ram","Mohan","Sohan"] JSON of branch =["Civil Engg","Computer Science","Electronics and TeleCommunications"] JSON of map ={"1":"Computer","2":"Printer","3":"Scanner"} |
Some times JSON is difficult to read to make JSON readable .setPrettyPrinting() can be used as below
GsonBuilder gsonBuilder = new GsonBuilder();
Gson gson1= gsonBuilder.setPrettyPrinting().create();
Replace line 40 of program with second line of above code.
Then output is as below.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
JSON of a =5 JSON of d =45.44 JSON of name ="Rama" JSON of age =[23,22,25,26,27,30] JSON of price =[34.33,55.43,51.33,54.22,77.0] JSON of names =[ "Ram", "Mohan", "Sohan" ] JSON of branch =[ "Civil Engg", "Computer Science", "Electronics and TeleCommunications" ] JSON of map ={ "1": "Computer", "2": "Printer", "3": "Scanner" } |
Here a student class is defined it contains Address class. Create object of student and serializing it as below
Student.java
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 |
package jsonpkg; public class Student { private long rollNo; private String fname; private String lname; private String branch; private Address address; public Student(long rollNo, String fname, String lname, String branch, Address address) { this.rollNo = rollNo; this.fname = fname; this.lname = lname; this.branch = branch; this.address = address; } public long getRollNo() { return rollNo; } public void setRollNo(long rollNo) { this.rollNo = rollNo; } public String getFname() { return fname; } public void setFname(String fname) { this.fname = fname; } public String getLname() { return lname; } public void setLname(String lname) { this.lname = lname; } public String getBranch() { return branch; } public void setBranch(String branch) { this.branch = branch; } public Address getAddress() { return address; } public void setAddress(Address address) { this.address = address; } } |
Address.java
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 |
package jsonpkg; public class Address { private String street; private String city; private String state; private long zip; public Address(String street, String city, String state, long zip) { this.street = street; this.city = city; this.state = state; this.zip = zip; } public String getStreet() { return street; } public void setStreet(String street) { this.street = street; } public String getCity() { return city; } public void setCity(String city) { this.city = city; } public String getState() { return state; } public void setState(String state) { this.state = state; } public long getZip() { return zip; } public void setZip(long zip) { this.zip = zip; } } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
package jsonpkg; import com.google.gson.Gson; public class GsonExample2 { public static void main(String[] args) { Address address = new Address("Lake view street", "Bhopal", "MP", 12322); Student student = new Student(1, "Ram", "Kumar", "CSE", address); Gson gson = new GsonBuilder().setPrettyPrinting().create(); System.out.println(gson.toJson(student)); } } |
Result
|
1 2 3 4 5 6 7 8 9 10 11 12 |
{ "rollNo": 1, "fname": "Ram", "lname": "Kumar", "branch": "CSE", "address": { "street": "Lake view street", "city": "Bhopal", "state": "MP", "zip": 12322 } } |
Parsing JSON to Java is prerformed as here.
We have saved JSON of a student (same as above structure few parameter changed) in student.json file then we are reading its content from student.json.
student = gson.fromJson(new FileReader(“d://student.json”), Student.class);
To read file from student.json File reader is used. after reading file it is converted to Student type.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
package jsonpkg; import com.google.gson.Gson; import java.io.FileNotFoundException; import java.io.FileReader; public class GsonRead { public static void main(String[] args) { Gson gson = new Gson(); Student student = null; try { student = gson.fromJson(new FileReader("d://student.json"), Student.class); } catch (FileNotFoundException ex) { ex.printStackTrace(); } System.out.println("Received Student Data"); System.out.println("Roll No " + student.getRollNo()); System.out.println("First Name " + student.getFname()); System.out.println("Last Name " + student.getLname()); System.out.println("Branch " + student.getBranch()); System.out.println("Address " + student.getAddress().getStreet() + " " + student.getAddress().getCity() + " " + student.getAddress().getState() + " " + student.getAddress().getZip()); } } |
Result
|
1 2 3 4 5 6 |
Received Student Data Roll No 2 First Name Mohan Last Name Kumar Branch CSE Address Street 5 sector 10 Bhilai CG 232112 |
|
1 2 3 4 5 |
URL url = new URL("https://www.ebhor.com/examples/a/student.json"); HttpURLConnection httpcon = (HttpURLConnection) url.openConnection(); httpcon.addRequestProperty("User-Agent", "Mozilla/4.76"); InputStreamReader reader = new InputStreamReader(httpcon.getInputStream()); student = new Gson().fromJson(reader, Student.class); |
Working code is as below
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
package jsonpkg; import com.google.gson.Gson; import java.io.IOException; import java.io.InputStreamReader; import java.net.HttpURLConnection; import java.net.URL; public class ReadFromUrl { public static void main(String[] args) { Gson gson = new Gson(); Student student = null; try { URL url = new URL("https://www.ebhor.com/examples/a/student.json"); HttpURLConnection httpcon = (HttpURLConnection) url.openConnection(); httpcon.addRequestProperty("User-Agent", "Mozilla/4.76"); InputStreamReader reader = new InputStreamReader(httpcon.getInputStream()); student = new Gson().fromJson(reader, Student.class); } catch (IOException ex) { ex.printStackTrace(); } System.out.println("Received Student Data"); System.out.println("Roll No " + student.getRollNo()); System.out.println("First Name " + student.getFname()); System.out.println("Last Name " + student.getLname()); System.out.println("Branch " + student.getBranch()); System.out.println("Address " + student.getAddress().getStreet() + " " + student.getAddress().getCity() + " " + student.getAddress().getState() + " " + student.getAddress().getZip()); } } |
Annotation Export is used to serialize and deserialize fields it is defined in import com.google.gson.annotations.Expose
@Expose(serialize = true, deserialize = true) is used serialize true represents it has to be serialize same for deserialize. false value is used to not include the field in process of serialize or deserialize.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
import com.google.gson.annotations.Expose; public class Student { @Expose(serialize = true, deserialize = true) private long rollNo; @Expose(serialize = true, deserialize = true) private String fname; @Expose(serialize = true, deserialize = true) private String lname; @Expose(serialize = false,deserialize = false) private String branch; @Expose(serialize = true, deserialize = true) private Address address; //getter setter and constructors } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
import com.google.gson.annotations.Expose; public class Address { @Expose(serialize = true, deserialize = true) private String street; @Expose(serialize = true, deserialize = true) private String city; @Expose(serialize = true, deserialize = true) private String state; @Expose(serialize = true, deserialize = true) private long zip; //getter and setter and constructor } |
in main method to create object we have to use GsonBuilder as below
call a method excludeFieldWithoutExposeAnnotation()
|
1 2 3 |
GsonBuilder gsonBuilder = new GsonBuilder(); gsonBuilder.excludeFieldsWithoutExposeAnnotation(); Gson gson = gsonBuilder.create(); |
This interface is also used to exclude any field in serializing and deserialization.
To implement ExcludeStrategy a class has to implement this.
Below is an example to remove fname field from serialization
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
package jsonpkg; import com.google.gson.ExclusionStrategy; import com.google.gson.FieldAttributes; public class MyExclusionStrategy implements ExclusionStrategy { public boolean shouldSkipField(FieldAttributes f) { if (f.getName().equals("fname")) { return true; } return false; } public boolean shouldSkipClass(Class aClass) { return false; } } |
To create Gson object use GsonBuilder as below
|
1 |
Gson gson1 = new GsonBuilder().setExclusionStrategies(new MyExclusionStrategy()).create(); |
To learn about exception handling first you must know what is an exception
An exception is run time error that can occur due to wrong user input or due to logical error in programming.
Consider a simple example.
Take two integer number from command prompt and divide the number.
The code is
|
1 2 3 4 5 6 7 8 |
public class division { public static void main(String [] s) { int a = Integer.parseInt(s[0]); int b = Integer.parseInt(s[1]); int c = a / b; System.out.println("division is " + c); } } |
We complice above program
c:\> javac division.java
while running this program we will pass
two values to program as below
> java division 10 2
Above two values 10 and 2 known as command line argument these values are accessed in string [] s.
There s is string array first value 10 is stored in s[0] and second value is stored in s[1]
S is string array so we converted these string values to integer by calling Integer.parseInt(value)
Here Integer is a class and parseInt is static method used to convert string value to int value.
The converted value is stroed in a and in b
The result of division operation is
C= a/b; //c = 10/2 =5
It will store value 5 in c.
Next statement print division is 5
This is our desired result.
What happen if user enters value 10 and 0.
What happen if user enters value 10 and 0.
Then the statement
C= a/b; // c= 10/0 –
This statement throw arithmetic exception.
The output is a below.
Exception in thread “main” java.lang.ArithmeticException: / by zero
at division.main(division.java:5)
The above exception is due to Wrong user input.
To handle above situation we can use user input validation or exception handling.
Lets see user input validation here before division operation check whether the value of b is zero or not.
If it is zero information to user and stop the program else perform the division as below.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
public class division { public static void main(String s[]) { int a = Integer.parseInt(s[0]); int b = Integer.parseInt(s[1]); int c; if (b == 0) { System.out.println("divisor should not be zero"); } else { c = a / b; System.out.println("result is " + c); } } } |
>javac 10 0
divisor should not be zero
This program validate the denominator is zero then print message to user else perform division operation.
Here validation is used to avoid the exception. This is good practice to validate user input to avoid exceptions.
Here we want to learn exception handling so lets see the above program with java exception handling
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
public class Division { public static void main(String s[]) { int a = Integer.parseInt(s[0]); int b = Integer.parseInt(s[1]); int c; try{ c=a/b; System.out.println("Division is "+c); }catch(ArithmeticException e){ System.out.println("Arithmetic Exception"); } } } |
lets run again above code
>java Division 10 2
Division is 3
>java Division 10 0
Arithmetic Exception
In above program to handle exception try and catch blocked is used.
Inside try block the code is written which can throw exception.
The statements which can throw expection is written inside try block.
To catch the exception a catch block is used with exception type . inside the catch block appropriate exception handling is done.
Catch block executes when exception is thrown from code inside try block.
In above program int c= a/b;
exception is thrown when the value of b is zero so it should be inside try block.
The statement System.out.println(“division is “ + c); is not throwing an exception it is also inside the try block.
If division statement throw an exception. The control is passed to catch block and necessary action is performed inside catch block.
The catch block is only executed if statements inside try block throws an exception.
Lets again execute above program with value 10 and String value lets a
>javac Division 10 a
Exception in thread "main" java.lang.NumberFormatException: For input string: "a"
at java.lang.NumberFormatException.forInputString(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at division.main(division.java:4)
Here second value is string so throwing above exception
Integer.parseInt (s[1]) throw an exception because it is unable to convert string to int.
In our program we handled only arithmetic exception
To handle this exception lets modify our code
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
public class division { public static void main(String s[]) { int a = 0, b = 0, c; try { a = Integer.parseInt(s[0]); b = Integer.parseInt(s[1]); } catch (NumberFormatException e) { System.out.println("Please enter valid number"); System.exit(1); } try { c = a / b; System.out.println("Division is " + c); } catch (ArithmeticException e) { System.out.println("Arithmetic Exception"); } } } |
again compiling and running this code
>javac Division 10 a
Please enter valid number
System.exit(1) is used to exit from program.
Here denominator is not a number so no need to continue the program.
here we used two try block and its corrosponding catch blocks.
If you want we can use one try block and multiple catch block.
Lets again change this code to handle multiple catch in single try block.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
public class division { public static void main(String s[]) { int a = 0, b = 0, c; try { a = Integer.parseInt(s[0]); b = Integer.parseInt(s[1]); c = a / b; System.out.println("Division is " + c); } catch (NumberFormatException e) { System.out.println("Please enter valid number"); } catch (ArithmeticException e) { System.out.println("Arithmetic Exception"); } } } |
Here all type of exceptions are checked in try block when an exception is thrown based on exception a catch block is executed.
Exception is parent class for all exceptions.
Any exception thrown can handle by catching exception.
Standing multiple exceptions in program, then general exception should be last catch statement otherwise specific exception catch statement will not reached.
Concatenate: It is possible to concatenate two or more files and save in a different file.
In java, by using SequenceInputStream class we can concatenate two or more files.
Buffer Files: In java, we can create a buffer to store temporary data that is read from & written to a stream and this process known as i/o buffer operation.
Buffer is sit between programmer and source/destination file.
Buffer can be created by using following classes:
Example: write a program to concatenate two file A & B and concatenated data print on output screen.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
import java.io.*; public class FileConcat { public static void main(String arg[]) throws IOException { FileInputStream I1 = null; FileInputStream I2 = null; I1 = new FileInputStream("A.txt"); //open file A for concatenate I2 = new FileInputStream("B.txt"); //open file B for concatenate // declare sis to store combined file SequenceInputStream sis = null; sis = new SequenceInputStream(I1, I2); // create buffer for input output BufferedInputStream ibs = new BufferedInputStream(sis); BufferedOutputStream obs = new BufferedOutputStream(System.out); int c; while ((c = ibs.read()) != -1) // read& write till the end of buffer { obs.write((char) c); } ibs.close(); obs.close(); I1.close(); I2.close(); } } |
Suppose we have a File “A.txt”
| Hello students I am aditya. |
and File “B.txt”
| Hello |
Output: Hello students I am
Example: Write a program to copy the content of one file to another file using buffer/BufferReader.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
import java.io.*; public class FileCopy1 { public static void main(String[] args) throws IOException { PrintWriter pw = new PrintWriter("B.txt"); // PrintWriter for write on file B BufferedReader br = new BufferedReader(new FileReader("A.txt")); String line = br.readLine(); // read first line from file A while (line != null) // loop to copy each line of A.txt to C.txt { pw.println(line); line = br.readLine(); } pw.flush(); // closing resources br.close(); pw.close(); } } |
Suppose we have a File “A .txt”
| Hello students I am aditya. |
Output: File “B”
| Hello students I am aditya. |
Note: If there is no file “B” it will be create automatically.
Example: Write a program to concatenate two
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
import java.io.*; public class FileMerge { public static void main(String[] args) throws IOException { PrintWriter pw = new PrintWriter("C.txt"); // PrintWriter for write on C.txt // BufferedReader object for A.txt BufferedReader br = new BufferedReader(new FileReader("A.txt")); String line = br.readLine(); // read first line from file A while (line != null) // loop to copy each line of A.txt to C.txt { pw.println(line); line = br.readLine(); } br = new BufferedReader(new FileReader("B.txt")); line = br.readLine(); // read first line from file B while (line != null) // loop to copy each line of B.txt to C.txt { pw.println(line); line = br.readLine(); } pw.flush(); // closing resources br.close(); pw.close(); } } |
Suppose we have a File “A.txt” and File “B.txt”
| Hello students I am aditya. |
| Hello |
Output: File “C”
| Hello students I am aditya. Hello |
Note: Ifthere is no file “C” it will be create automatically.
In java, basic input-output stream provides a method for reading & writing bytes or character in a file. If we want to read-write primitive data typa(such as int , float etc.) than we can use filter classes to filter data in the original stream.
DataInputStream & DataOutputStream are two filter classes used for creating “data streams” for handling primitive data type.
Example: Write a program to write & read a primitive data on a same file.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
import java.io.*; public class PrimitiveReadWrite { public static void main(String args[]) throws IOException { FileOutputStream o = new FileOutputStream("A.txt"); //Open file “A” for write DataOutputStream O = new DataOutputStream(o); //write primitive data on file A O.writeInt(1999); O.writeDouble(333.89); O.writeBoolean(false); O.writeChar('X'); O.close(); o.close(); //read primitive data from file A FileInputStream i = new FileInputStream("A.txt"); //open file A for read DataInputStream I = new DataInputStream(i); System.out.println(I.readInt()); System.out.println(I.readDouble()); System.out.println(I.readBoolean()); System.out.println(I.readChar()); I.close(); i.close(); } } |
|
1 2 3 4 5 |
Output: 1999 333.89 false X |
In a java programming, like a Byte stream Character stream is also used for input-output for 16 bit. But Byte streams are used to perform input and output of 8-bit.
Most common Character streams classes are, FileReader and FileWriter.
FileReader- FileReader uses for reads two bytes at a time.
FileWriter– FileWriter uses for writes two bytes at a time.
Example: Write a program, to copy the content of file A into file B using Byte stream class.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
import java.io.*; public class FileReaderExample { public static void main(String arg[]) throws IOException { FileReader I = null; FileWriter O = null; try { I = new FileReader("A.txt"); O = new FileWriter("B.txt"); int c; while ((c = I.read()) != -1) { O.write(c); } } finally { if (I != null) { I.close(); } if (O != null) { O.close(); } } } } |
Note: if there is only file A in which data is written and no file B then, file B will be create automatically.
Suppose we have a File “A”
| Hello students I am aditya. |
Output: When we run above program one new file create with Name “B” and content of file “A” will be copy into file “B”.
File “B”
| Hello students I am aditya. |
In java programming, to perform input and output of 8-bit, Byte stream is used.
Most common byte streams classes are, FileInputStream and FileOutputStream.
FileInputStream : FileInputStream is used for reads one byte at a time .
FileOutputStream : FileOutputStream is used for writes one byte at a time
Example: Write a program, to write a bytes to a file using Byte stream class.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
import java.io.*; public class WriteBytes { public static void main(String args[]) throws IOException { byte b[] = { 'h', 'e', 'l', 'l', 'o', 'a', 'd', 'i' }; //create a byte array FileOutputStream out = null; try { out = new FileOutputStream("A.txt"); //open file A for write out.write(b); // write byte data to file output } finally { out.close(); } } } |
Result
checking file A.txt it will show following content.
Note: If there is no file A then, file A will be create automatically
|
1 |
helloadi |
Suppose we have a file “A.txt”
| Hello Students I am Aditya |
Example: Write a program, to read a bytes from file A using Byte stream class and print on output screen.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
import java.io.*; public class ReadBytes { public static void main(String args[]) throws IOException { FileInputStream in = null; try { in = new FileInputStream("A.txt"); int c; while ((c = in .read()) != -1) { System.out.print((char) c); } } finally { in .close(); } } } |
|
1 |
Hello Students I am Aditya |
Example: Write a program, to copy the content of file A into file B using Byte stream class.
Note: if there is only file A in which data is written and no file B then, file B will be create automatically.
Suppose we have a File “A”
| Hello students I am aditya. |
Output: When we run above program one new file create with Name “B” and content of file “A” will be copy into file “B”.
File “B”
| Hello students I am aditya. |
In Java programming, to perform the input-output in file handling Java has a java.io package which contain contains nearly every class you might ever need.
In file
Stream
In java programming, a sequence of data defined as a “stream”.
Simply there are two type of streams:
Stream Classes
In java, package “java.io” contains a large number of stream classes and these classes can be divided into two groups: