[Java]更新できないSetをメンバ変数で初期化する

何かの照合用にメンバー変数にSetを持っておきたいことって時々あると思います。
でも引数付のコンストラクタがないので、インスタンスイニシャライザやスタティックイニシャライザで処理することは多いと思います。でも定義と宣言が分かれてしまうので、ちょっとわかりづらくなるケースがあります。

というのを組みわせで解決してみました。がこんな感じ。

// 更新できないSetをメンバ変数として生成する
private final Set<String> set = Collections.unmodifiableSet(
        new HashSet<String>(
                Arrays.asList(
                        "aaa",
                        "bbb",
                        "ccc",
                        "ddd"
                )
            )
        );

ていうか、素直にユーティリティ系のメソッドを準備すべきですよね。

    private final Set<Integer> set2 = newUmSet(
            1,
            2,
            3,
            4
    );

    @SafeVarargs
    static <E> Set<E> newUmSet(T... args){
        Set<E> set = new HashSet<E>(Arrays.asList(args));
        return Collections.unmodifiableSet(set);
    }

[Android]FragmentTransactionをロールバックする

そういえば。FragmentTransactionのrollbackってどうやってやるんだろう？
と思ってFragmentTransactionのリファレンスを見てみました。
きっとrollbackみたいなメソッドがあるんだろうなぁ。と思って眺めていても見つからない。
で、いろんなサイトを見渡してみると、
　ロールバック＝FragmentTransaction#commitを呼ばない。
ということらしい。

「トランザクション＝DB」みたいな感覚があるので、commitもrollbackもしないなんて、なんか気持ち悪いなぁと思って調べてみました。

一般的にFragmentの操作は以下のように行います。

• FragmetnManarerを取得する
• FragmetnManarer#beginTransactionでFragmentTransactionを取得する
• FragmentTransaction#addなどで、Fragmentの操作を行う
• FragmentTransaction#commitを呼ぶ→UIが切り替わる

です。

調べてみると、FragmentTransactionの実装クラスBackStackRecordでは、Fragmentの操作をリストで管理しており、実装は以下のようになっていました。

• add/replase/deleteが呼ばれるたびに、内部のリンクリストへ情報を追加
• commitでためていたリストをFragmentManagerへ渡す
• FragmentManagerはHandler経由でUI処理

という感じでした。

一口にトランザクションって言っても実装方法はそれぞれですが、インタフェースとしての対称性としてどうなのか？と思ってしまいます。

• FragmetnManarerでbeginTransactionするのに、commitはFragmentTransaction
• FragmentTransactionにもFragmetnManarerにもrollbackがない

デザイン的に、Builderです。という風に言われるとなるほどそうかもしれない。と思えます（クラス名的にダメじゃないと思いますが）。

たとえばAlertDialog.Builderでいろいろ値を設定し、createやshowを呼ばなかったら。と同じですね。

[Java]コードから動的にinstanceofしたい

特定の型を継承または実装しているオブジェクトに対して、何等か処理をしたい場合、判定にinstanceofを使います。 しかし、instanceofはJavaの構文であるため、動的に判定することはできません。

何とかする方法ないかなぁと調べてみると、以下のような方法がありました。Class.isInstanceかisAssignableFromを使います。

public static void main(String[] args) {

    Object baseClass = new BaseClass();
    Object subClass = new SubClass();

    Object baseClassWithSubOthreType = new BaseClassWithSubOthreType();
    Object subClassWithSubOthreType = new SubClassWithSubOthreType();

    // instance of
    System.out.println("baseClass is Object=" + (baseClass instanceof Object));
    System.out.println("baseClass is BaseClass=" + (baseClass instanceof BaseClass));
    System.out.println("baseClass is SubClass=" + (baseClass instanceof SubClass));
    System.out.println("baseClass is BaseOthreType=" + (baseClass instanceof BaseOthreType));

    System.out.println("subClass is Object=" + (subClass instanceof Object));
    System.out.println("subClass is BaseClass=" + (subClass instanceof BaseClass));
    System.out.println("subClass is SubClass=" + (subClass instanceof SubClass));
    System.out.println("subClass is BaseOthreType=" + (subClass instanceof BaseOthreType));

    System.out.println("baseClassWithSubOthreType is Object=" + (baseClassWithSubOthreType instanceof Object));
    System.out.println("baseClassWithSubOthreType is BaseClass=" + (baseClassWithSubOthreType instanceof BaseClass));
    System.out.println("baseClassWithSubOthreType is SubClass=" + (baseClassWithSubOthreType instanceof SubClass));
    System.out.println("baseClassWithSubOthreType is BaseOthreType=" + (baseClassWithSubOthreType instanceof BaseOthreType));

    System.out.println("subClassWithSubOthreType is Object=" + (subClassWithSubOthreType instanceof Object));
    System.out.println("subClassWithSubOthreType is BaseClass=" + (subClassWithSubOthreType instanceof BaseClass));
    System.out.println("subClassWithSubOthreType is SubClass=" + (subClassWithSubOthreType instanceof SubClass));
    System.out.println("subClassWithSubOthreType is BaseOthreType=" + (subClassWithSubOthreType instanceof BaseOthreType));

    // isInstance
    System.out.println("-----------");
    // 比較対象のクラスが自クラスの型に対してい代入可能か判定する
    System.out.println("baseClass is Object=" + Object.class.isInstance(baseClass));
    System.out.println("baseClass is BaseClass=" + BaseClass.class.isInstance(baseClass));
    System.out.println("baseClass is SubClass=" + SubClass.class.isInstance(baseClass));
    System.out.println("baseClass is BaseOthreType=" + BaseOthreType.class.isInstance(baseClass));

    System.out.println("subClass is Object=" + Object.class.isInstance(subClass));
    System.out.println("subClass is BaseClass=" + BaseClass.class.isInstance(subClass));
    System.out.println("subClass is SubClass=" + SubClass.class.isInstance(subClass));
    System.out.println("subClass is BaseOthreType=" + BaseOthreType.class.isInstance(subClass));

    System.out.println("baseClassWithSubOthreType is Object=" + (Object.class.isInstance(baseClassWithSubOthreType)));
    System.out.println("baseClassWithSubOthreType is BaseClass=" + (BaseClass.class.isInstance(baseClassWithSubOthreType)));
    System.out.println("baseClassWithSubOthreType is SubClass=" + (SubClass.class.isInstance(baseClassWithSubOthreType)));
    System.out.println("baseClassWithSubOthreType is BaseOthreType=" + BaseOthreType.class.isInstance(baseClassWithSubOthreType));

    System.out.println("subClassWithSubOthreType is Object=" + Object.class.isInstance(subClassWithSubOthreType));
    System.out.println("subClassWithSubOthreType is BaseClass=" + BaseClass.class.isInstance(subClassWithSubOthreType));
    System.out.println("subClassWithSubOthreType is SubClass=" + SubClass.class.isInstance(subClassWithSubOthreType));
    System.out.println("subClassWithSubOthreType is BaseOthreType=" + BaseOthreType.class.isInstance(subClassWithSubOthreType));

    // isAssignableFrom
    System.out.println("-----------");
    // 比較対象のクラスが自クラスのサブクラスか判定する
    System.out.println("baseClass is Object=" + Object.class.isAssignableFrom(baseClass.getClass()));
    System.out.println("baseClass is BaseClass=" + BaseClass.class.isAssignableFrom(baseClass.getClass()));
    System.out.println("baseClass is SubClass=" + SubClass.class.isAssignableFrom(baseClass.getClass()));
    System.out.println("baseClass is BaseOthreType=" + BaseOthreType.class.isAssignableFrom(baseClass.getClass()));

    System.out.println("subClass is Object=" + Object.class.isAssignableFrom(subClass.getClass()));
    System.out.println("subClass is BaseClass=" + BaseClass.class.isAssignableFrom(subClass.getClass()));
    System.out.println("subClass is SubClass=" + SubClass.class.isAssignableFrom(subClass.getClass()));
    System.out.println("subClass is BaseOthreType=" + BaseOthreType.class.isAssignableFrom(subClass.getClass()));

    System.out.println("baseClassWithSubOthreType is Object=" + (Object.class.isAssignableFrom(baseClassWithSubOthreType.getClass())));
    System.out.println("baseClassWithSubOthreType is BaseClass=" + (BaseClass.class.isAssignableFrom(baseClassWithSubOthreType.getClass())));
    System.out.println("baseClassWithSubOthreType is SubClass=" + (SubClass.class.isAssignableFrom(baseClassWithSubOthreType.getClass())));
    System.out.println("baseClassWithSubOthreType is BaseOthreType=" + BaseOthreType.class.isAssignableFrom(baseClassWithSubOthreType.getClass()));

    System.out.println("subClassWithSubOthreType is Object=" + Object.class.isAssignableFrom(subClassWithSubOthreType.getClass()));
    System.out.println("subClassWithSubOthreType is BaseClass=" + BaseClass.class.isAssignableFrom(subClassWithSubOthreType.getClass()));
    System.out.println("subClassWithSubOthreType is SubClass=" + SubClass.class.isAssignableFrom(subClassWithSubOthreType.getClass()));
    System.out.println("subClassWithSubOthreType is BaseOthreType=" + BaseOthreType.class.isAssignableFrom(subClassWithSubOthreType.getClass()));


}

// BaseClass
static class BaseClass {

}

// SubClass
static class SubClass extends BaseClass {

}

// BaseClass + SubOthreType
static class BaseClassWithSubOthreType implements SubOthreType {

}

// SubClass + SubOthreType
static class SubClassWithSubOthreType extends SubClass implements SubOthreType {

}

// BaseOthreType
interface BaseOthreType {

}

// SubOthreType
interface SubOthreType extends BaseOthreType {

}

■出力結果(どれも同じ結果が出ます)

baseClass is Object=true
baseClass is BaseClass=true
baseClass is SubClass=false
baseClass is BaseOthreType=false
subClass is Object=true
subClass is BaseClass=true
subClass is SubClass=true
subClass is BaseOthreType=false
baseClassWithSubOthreType is Object=true
baseClassWithSubOthreType is BaseClass=false
baseClassWithSubOthreType is SubClass=false
baseClassWithSubOthreType is BaseOthreType=true
subClassWithSubOthreType is Object=true
subClassWithSubOthreType is BaseClass=true
subClassWithSubOthreType is SubClass=true
subClassWithSubOthreType is BaseOthreType=true
-----------
baseClass is Object=true
baseClass is BaseClass=true
baseClass is SubClass=false
baseClass is BaseOthreType=false
subClass is Object=true
subClass is BaseClass=true
subClass is SubClass=true
subClass is BaseOthreType=false
baseClassWithSubOthreType is Object=true
baseClassWithSubOthreType is BaseClass=false
baseClassWithSubOthreType is SubClass=false
baseClassWithSubOthreType is BaseOthreType=true
subClassWithSubOthreType is Object=true
subClassWithSubOthreType is BaseClass=true
subClassWithSubOthreType is SubClass=true
subClassWithSubOthreType is BaseOthreType=true
-----------
baseClass is Object=true
baseClass is BaseClass=true
baseClass is SubClass=false
baseClass is BaseOthreType=false
subClass is Object=true
subClass is BaseClass=true
subClass is SubClass=true
subClass is BaseOthreType=false
baseClassWithSubOthreType is Object=true
baseClassWithSubOthreType is BaseClass=false
baseClassWithSubOthreType is SubClass=false
baseClassWithSubOthreType is BaseOthreType=true
subClassWithSubOthreType is Object=true
subClassWithSubOthreType is BaseClass=true
subClassWithSubOthreType is SubClass=true
subClassWithSubOthreType is BaseOthreType=true

・・・そもそもタイプ別で分岐しないといけないというのは設計が悪い。というケースが多いのかなぁと思います。 しかし、実装レベルで楽をするために。というのはありかなぁと思います。
たとえば、例外発生時のエラーメッセージの判定を一括して行う処理を実装する場合、これをMap<Exceptionのラッパー,String>で処理できるとずいぶんすっきりすると思います。

キーになる情報のhashcode()を工夫すれば、楽に実装できるような気がします。 instanceofだとif文たくさんになる図が目に浮かびますね。

しかし、この2つは、何が違うんでしょう？リファレンスを見ると、

• isInstanceは、Java 言語の instanceof 演算子と動的に等価
• isAssignableFromは、型として等しいか。プリミティブのタイプも判定できる

ということらしいです。

・・・じゃあ、相互互換ってどうなんだろう？ということでやってみました。コードと結果は以下の通り

    System.out.println("Integer isInstance int = " + int.class.isInstance(new Integer(1)));
    System.out.println("int isInstance Integer = " + Integer.class.isInstance(1));

    System.out.println("Integer isAssignableFrom int = " + int.class.isAssignableFrom(Integer.class));
    System.out.println("int isAssignableFrom Integer = " + Integer.class.isAssignableFrom(int.class));

--以下出力結果

Integer isInstance int = false
int isInstance Integer = true
Integer isAssignableFrom int = false
int isAssignableFrom Integer = false

Class.isInstanceでは、双方向でtrueを予想していたのですが、Integerとintは互換があり、逆は互換がない。っていう結果になりました。
Class.isAssignableFromに関しては、両方false。理由がよくわからない。。。

[java]メソッドで配列化する

javaでその辺にある引数やローカル変数で配列を作る場合に、new 型[]{arg1, arg2,arg4};とするのが一般的です。

その他の方法として、可変長引数を使ってメソッド化する方法があります。コードはこんな感じ。

public static void main(String[] args) {
// Stringの場合
String[] stringArray = Converter.convert("a", "b", "c");
// 数値はラッパー型になる。intで処理できないのが残念。。。
Integer[] intArray = Converter.convert(1, 2, 3);
// オーバーロードすればそれなりに

}

public static class Converter {
static <T> T[] convert(T... args) {
    // テンプレート型指定でキャスト不要
    // 引数をそのまま返すだけ!
    return args;
}

この方式で何かいいことあるか？といわれると。。。とくにありません。

[Java]C#のusingのような構文でリソースを開放する(try-with-resources)

時代はJava8に突入しようとしていますが、Java7の話題です。。。
C#のusingは、リソースを開放するのがすごく楽になる構文です。 コード的にはこんな感じ。

class Program
{
    static void Main(string[] args)
    {
        using (Hoge1 hoge1 = new Hoge1())
        {
            hoge1.execute();
        }
    }
}

class Hoge1 : IDisposable
{
    public void execute()
    {
        Console.WriteLine("Hoge1 execute");
    }

    public void Dispose()
    {
        Console.WriteLine("Hoge1 Dispose");
    }
}

Java(6)と比べて非常にすっきりしています。 そのJava6では、こんな感じで非常に残念。

public static void main(String[] args) {
    Hoge1 hoge = null;
    try {
        hoge = new Hoge1();
        hoge.execute();
    } finally {
        if (hoge != null) {
            try {
                hoge.close();
            } catch (IOException e) {
                // ほとんどのケースで、ここで例外が出てもどうしようもない。。。
                // 処理的には割り切りでしょうか。
            }
        }
    }
}

でもJava7のtry-with-resourcesだとこんな感じ。以下の例では、複数のAutoCloseableに対応した場合です。

public static void main(String[] args) {
    try (Hoge2 hoge2 = new Hoge2(); Hoge1 hoge1 = new Hoge1();) {
        hoge1.execute();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

}

static class Hoge1 implements AutoCloseable {

    public void execute() {
        System.out.println("Hoge1 execute");
    }

    @Override
    public void close() throws IOException {
        System.out.println("Hoge1 close");

        throw new IOException("Hoge1 close");
    }

}

static class Hoge2 implements AutoCloseable {

    public void execute() {
        System.out.println("Hoge2 execute");
    }

    @Override
    public void close() throws IOException {
        System.out.println("Hoge2 close");
    }
}

ｔｒｙ構文の特徴も引き継ぐので、ブロック内にcatch文を書くこともできます。
（これ、地味ですが微妙にいい感じ）

C#のusingで複数のIDisposableに対応した書き方をすると、以下の通り。

    using (Hoge1 hoge1 = new Hoge1())
    using (Hoge2 hoge2 = new Hoge2())
    {
        hoge1.execute();
        hoge2.execute();
    }

当時、usingを複数書く構文には違和感を覚えましたが、すっかり慣れてしまいました。あと、import分に対応する文がusingであり、そこも微妙に違和感がありました。
Javaのtry-with-resourcesでは、１つのブロック中に記載するので、逆に違和感が。。。

[Android]設定アプリの「データを削除」を無効化する

Androidのアプリケーションでは、データベースやプレファレンスでデータを保存します。
 たとえば、SQLiteのデータベースの場合一般的には「/data/data/[アプリケーションパッケージ名]/databases」にファイルが生成されます。 しかし、このデータは、設定アプリで削除することができます。 それを抑止する方法として、その処理を無効化する方法がります。その方法とは以下の通りです。

 ■AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.your_app"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="15"
        android:targetSdkVersion="15" />

    <application
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:manageSpaceActivity="com.example.your_app.ManageActivity" >
        <activity
            android:name=".GridLayoutActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

「android:manageSpaceActivity」を指定することで、設定アプリがこのアクティビティ呼ぶようになります。 ボタンの表示も「データを消去」から「容量を管理」に表現が変わりました（端末によって差はあるかもしれません）。

そのため　、onCreate()でfinish()しちゃえば、ほぼ何も起こらない。ということが実現できます。

逆に

• SDカードに管理しているデータもまとめて消す
• プレファレンスだけ残してデータだけです

みたいかことも可能です。応用範囲はいろいろ。企業ユースでは結構ニーズがあるかもしれません。

[Java]Instance Initializerっていうのがあります

Javaで、インスタンスを初期化するのはコンストラクタですが、コンストラクタと同等の初期化を実施することができる、Instance Initializerというのがあります。コードはこんな感じ。

public static void main(String[] args) {

    new ExtendClass();

}

static class BaseClass {

    {
        System.out.println("BaseClass{}1");
    }

    {
        System.out.println("BaseClass{}2");
    }

    public BaseClass() {
        System.out.println("BaseClass()");
    }
}

static class ExtendClass extends BaseClass {

    {
        System.out.println("ExtendClass{}1");
    }

    public ExtendClass() {
        System.out.println("ExtendClass()");
    }

    {
        System.out.println("ExtendClass{}2");
    }
}

普通のメソッド同様に、ローカル変数やsuper/thisなどのキーワードを使うことができます。

■実行結果

BaseClass{}1
BaseClass{}2
BaseClass()
ExtendClass{}1
ExtendClass{}2
ExtendClass()

Static InitializerもInstance Initializerも複数個所に分断してかけますが、分断するとわかりづらくなります。 しかし、以下のような初期化の仕方はありじゃないでしょうか。 個人的な感覚ですが、コレクションの初期化については、コンストラクタや統一ブロックで処理するよりわかりやすくなると思います。

static class SetInitClass {

    final private Collection<Integer> set1;
    {
        Set<Integer> set = new HashSet<Integer>();
        set.add(1);
        set.add(3);
        set.add(5);
        set1 = Collections.unmodifiableCollection(set);
    }

    final private Collection<Integer> set2;
    {
        Set<Integer> set = new HashSet<Integer>();
        set.add(2);
        set.add(4);
        set.add(6);
        set2 = Collections.unmodifiableCollection(set);
    }

}