20070329 Java Programing Tips

String str1 = new String(“hoge”);
String str2 = “hoge”;

System.out.println(str1 == str2);
System.out.println(str1.equals(str2));

False
True

== equals

char[] value

str1 str1 int length

boolean equals(Object obj)

char[] value

str2 str2 int length


str1 == str2 str1 str2
char[] value
str1.equals(str2)

java.lang.String
public final class String implements java.io.Serializable, Comparable<String>, CharSequence{
private final char value[];
private final int count;
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = count;
if (n == anotherString.count) {
char v1[] = value;
char v2[] = anotherString.value;
int i = offset;
int j = anotherString.offset;
while (n-- != 0) {
if (v1[i++] != v2[j++])
return false;
}
return true;
}
}
return false;
}

equals

True
False
Account equals

Account equals

public abstract class Account{
private char[] custmorCode = new char[4];
Account(char[] custmorCode){
this.custmorCode = custmorCode;
}
public char[] getCustmorCode(){
return this.custmorCode;
}
@Override public boolean equals(Object obj){
//
}
}

SavingAccount a1 = new SavingAccount(new char[]{‘0’,’1’,’2’,’3’});
SavingAccount a2 = new SavingAccount(new char[]{‘9’,’1’,’2’,’3’});
TimeDepositAccount a3 = new TimeDepositAccount(new char[]{‘0’,’1’,’2’,’3’});
TimeDepositAccount a4 = new TimeDepositAccount(new char[]{‘9’,’1’,’2’,’3’});

System.out.println(a1.equals(a3));

True
True
False
False

getClass instanceof


Object

ClassCastException

instanceof Class getClass()

→ true → true
→ false
→ true
→ false

public abstract class Account{
//
@Override public boolean equals(Object obj){
if(obj instanceof Account){
//if(getClass() == obj.getClass()){
char[] compareCode = ((Account)obj).getCustmorCode();
if(custmorCode.length != compareCode.length){
return false;
}
for(int i = 0; i<custmorCode.length; i++){
if(custmorCode[i] != compareCode[i]){
return false;
}
}
return true;
} else {
return false;
}
}
}

equals
java.lang.Object String
char[] value

equals Instanceof
getClass equals

Inspector

Inspector
100ms

Inspector Account

 100ms
 100ms
 100ms
 100ms
 100ms CPU

Inspector

Inspector

Inspector

public class Account{
private byte[] lock = new byte[0];
private ArrayList<Inspector> targets = new ArrayList<Inspector>();

public int get(int amount){
synchronized(lock){
if(this.amount < amount){
return 0;
}
for(Inspector i : targets){
i.inspect();
}
this.amount = this.amount - amount;
return amount;
}
}
public void addInspector(Inspector insp){
this.targets.add(insp);
}

 addInspector
 Inspector

String
public class Main{
public static void main(String[] args){
String className = "RefrectionTest";
RefrectionTest rt = null;
try{
rt = (RefrectionTest)Class
.forName(className).newInstance();
} catch(Exception e) {
}
rt.dosth();
}
}

public class RefrectionTest{
public void dosth(){
System.out.println("Do Something");
}
}

String
public class Main{
String className = "RefrectionTest";
RefrectionTest rt = null;
try{
rt = (RefrectionTest)Class.forName(className).newInstance();
}

String methodName = "dosth";
Method method = null;
try{
method = (Method)Class.forName(className)
.getMethod(methodName,null);
}
method.invoke(Class.forName(className).newInstance(),null);
}
}

import java.io.*;
public class Main{
Account a1 = new Account("hoge",5000);
a1.get(100);
try{
ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream("hoge.ser"));
oos.writeObject(a1);
oos.close();
} catch(Exception e) {}

System.out.println(a1);
Account ser = null;
try{
ObjectInputStream ois = new ObjectInputStream(
new FileInputStream("hoge.ser"));
ser = (Account)ois.readObject();
ois.close();
} catch(Exception e) {}

ser.get(100);
System.out.println(ser);
}
}

public class Account implements Serializable{ // }

1 2
100 100

0

0

100

100



 1 2

synchronized
private int amount;
private byte[] lock = new byte[0];

Account(int amount){
this.amount = amount;
}
synchronized(lock){
this.amount = this.amount - amount;
return amount;
}
}
public void put(int amount){
synchronized(lock){
this.amount = this.amount + amount;
}
}
}

 Synchonized:

synchronized

1 2
100 100

0

100

0

200

 2 1

volatile

private volatile int amount;

this.amount = amount;
}

public int getAmount(){
return this.amount;
}
}



 syncronized
 sysnronized

volatile

1 2
100

0

0

100

100

 1

 2

Java.util.concurrent
import java.util.concurrent.atomic.*;

private AtomicInteger amount;

this.amount = new AtomicInteger(amount);
}
if(this.amount.get() < amount){
return 0;
}
do{
if(this.amount.get() < amount){
break;
}
} while(!this.amount.compareAndSet(this.amount.get(), this.amount.get() - amount));
return amount;
}
public void put(int amount){
do{
if(amount < this.amount.get()){
break;
}
} while(!this.amount.compareAndSet(this.amount.get(), this.amount.get() + amount));
}

public int getAmount(){
return amount.get();
}
}

AtomicInteger
public class AtomicInteger extends Number implements java.io.Serializable {
private volatile int value;
public AtomicInteger(int initialValue) {
value = initialValue;
}
public final int get() {
return value;
}
public final void set(int newValue) {
value = newValue;
}
public final int getAndSet(int newValue) {
for (;;) {
int current = get();
if (compareAndSet(current, newValue))
return current;
}
}
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
}
 CAS
 CAS
 Int CAS

CAS Compare And Swap

1 2
100
0

0

100

CAS





 2 0 CAS
100

synchonize

volatile

JDK5.0 java.util.concurrent
Java

20070329 Java Programing Tips

More Related Content

What's hot

Similar to 20070329 Java Programing Tips

More from Shingo Furuyama

Recently uploaded

20070329 Java Programing Tips