Java Archivi

Java Reflection Esempio

Copiare due classi diverse ma con gli stessi campi tramite la reflection

Bean

A.java

package com;

import java.lang.reflect.Field;

public class A {
private String name;

private long punteggio;

public long getPunteggio() {
return punteggio;
}

public void setPunteggio(long punteggio) {
this.punteggio = punteggio;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

}

B.java

package com;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class B {
private String name;

private long punteggio;

public long getPunteggio() {
return punteggio;
}

public void setPunteggio(long punteggio) {
this.punteggio = punteggio;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public void copy(Object obj) {
try {

Method[] methods = obj.getClass().getMethods();

for (int i = 0; i < methods.length; i++) {
String methodName = methods[i].getName();
try{
if(methodName.startsWith(“get”)){
this.getClass().getMethod(methodName.replaceFirst(“get”, “set”) , methods[i].getReturnType() ).invoke(this, methods[i].invoke(obj, null));
}else if(methodName.startsWith(“is”) ){
this.getClass().getMethod(methodName.replaceFirst(“is”, “set”) , methods[i].getReturnType() ).invoke(this, methods[i].invoke(obj, null));
}

}catch (NoSuchMethodException e) {
// TODO: handle exception
}catch (IllegalArgumentException e) {
// TODO: handle exception
}

}

} catch (Exception ex) {
ex.printStackTrace();
}
}

}

Classe per il test:

TestReflection.java

package com;

public class TestReflection {

public static void main(String[] args) {

A obj1 = new A();

obj1.setName(“hello world”);

A obj2 = new A();

obj2.copy(obj1);

System.out.println(“name obj copy with reflection:”+obj2.getName());

}

Esecuzione

lanciando il main si ottiene una copia identica dell’istanza obj1:

Read Write File With InputStream OutputStream Java

Le istruzioni che leggono il file con InputStream sono:

InputStream inputStream = new FileInputStream(“c:/myFile.txt”);
inputStream.read(bytes);

Per scrivere su un file con OutputStream:

OutputStream outputStream = new FileOutputStream(new File(“c:/myFileNew.txt”));
outputStream.write(bytes, off, len);// scrive un array di byte di lunghezza len a partire da posizione off

Esempio completo:

package com;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class InputStreamToFile {
public static void main(String[] args) {

InputStream inputStream = null;
OutputStream outputStream = null;

try {
inputStream = new FileInputStream(“c:/myFile.txt”);

// write the inputStream to a FileOutputStream
outputStream = new FileOutputStream(new File(“c:/myFileNew.txt”));

int read = 0;
byte[] bytes = new byte[1024];

while ((read = inputStream.read(bytes)) != -1) {
outputStream.write(bytes, 0, read);
}

System.out.println(“Done!”);

} catch (IOException e) {
e.printStackTrace();
} finally {
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (outputStream != null) {
try {
// outputStream.flush();
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}

}
}
}
}

How To Create New File

import java.io.*;

public class CreateFile{
public static void main(String[] args) throws IOException{
File f;
f=new File(“myfile.txt”);
if(!f.exists()){
f.createNewFile();
System.out.println(“New file “myfile.txt” has been created
to the current directory”);
}
}
}

How To Write To File In Java with BufferedWriter

BufferedWriter è una classe per gestire uno Stream dati di tipo carattere.

package com;
 
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
 
public class WriteToFileExample {
 public static void main(String[] args) {
  try {
 
   String content = "bla bla bla";
 
   File file = new File("/prova/filename.txt");
 
   // if file doesnt exists, then create it
   if (!file.exists()) {
    file.createNewFile();
   }
 
   FileWriter fw = new FileWriter(file.getAbsoluteFile());
   BufferedWriter bw = new BufferedWriter(fw);
   bw.write(content);
   bw.close();
 
   System.out.println("Done");
 
  } catch (IOException e) {
   e.printStackTrace();
  }
 }
}

HashCode

Quando si ha che fare con gli oggetti, è buona norma riderifinire il metodo equals e anche il metodo hashcode().
In particolare, se abbiamo a che fare per esempio con mappe (hashset, set, etc), gli oggetti verranno inseriti in locazioni di
memoria identificati con un valore detto bucket. All’interno dello bucket ci possono essere più oggetti.
Questo bucket è dato appunto dal metodo hashCode.
Il metodo hashcode deve essere ridefinito in base alle seguenti regole:
– se due oggetti risultano uguali in base a equals() allora anche i loro hash code devono essere uguali.
– se due oggetti hanno hash code differenti, allora equals() deve indicare che sono diversi.
Esistono anche gli altri 2 casi:
– se due oggetti sono diversi, secondo equals, possono avere hash code uguali o differenti.
– se due oggetti hanno hash code uguali, possono essere uguali o no.
Quando si fa una ricerca di un oggetto nella mappa, prima si controlla se si ha il suo hashcode(bucket),
se, e solo se, il bucket è presente si chiamare il metodo equals per fare l’ultima verifica. Questo
perche come abbiamo detto nello stesso bucket possono essere inseriti più bucket.