ここでSCJPの質問をたくさん読んだり、SunとHead Firstの発行元からのヒントやコツをすべて読んだりしましたが、何かが足りないのではないかと思います。
Javaのコンポーネントに関する知識から、その知識を適用する質問に答えられるようになるのに苦労しています。言語やAPIについて具体的な質問があれば、答えることができます。しかし、その知識を使って模擬コーディングの質問に答えようとすると、質問を処理するのに永遠に時間がかかり、点をつなぐのに苦労します。何もクリックしないようなものです。私が知っていることに基づいて、質問についてより適切に結論を出すことができるプロセスはありますか？
シンプル：あなたはそれを使います。
それは些細なことのように聞こえるかもしれませんが、プログラミングで何か新しいことを学ぶことは、それを使って何かをしようとすること以外に方法はありません。コードを書くときのように。
それが本当に新しい場合は、既存のプログラムを使用して、必要なことを実行するように変更することから始めることができます。これは通常それを壊し、あなたはその理由を解明するために次の2時間を費やすでしょう。その2時間で、プログラム構造の基本（その言語/フレームワーク）、プログラムの組み立て方などについて、本から読む時間の5倍以上に学ぶことができます。
私が本が無価値であることを示唆しているわけではありません：それから遠く離れています。しかし、プログラミングは最終的には実用的な分野です。
新しい概念に出会ったときは、ユースケースを考え出し、実際にコードを記述してください。
たとえば、Runnablesと、それらを使用して新しいThreadsを作成する方法について学習した場合は、実際にコードを記述して試してみてください。
Thread t = new Thread(new Runnable() {
public void run() {
// Do something.
}
});
t.start();
何か新しいことを学ぶとき、実際に物事を試すことに勝るものはありません。
実際、Stack Overflowに関する質問に答えて答えようとすることは、学習した概念を適用するための非常に良い方法だと思います。実際に回答を投稿しなくても、回答を書くプロセスを経ること自体が、学習した概念を強化するのに役立ちます。
私はかなり優秀なプログラマーです。私はSCJPの本の半分を読み終えましたが、JavaOneでテストを受けたとき（ありがたいことに無料で）、60％しか得点しませんでした。
この試験を受けて私が学んだことは、彼らはあなたを可能な限り騙そうとしているということです。これに対抗する唯一の方法は、ばかげたものをコーディングして何が起こるかを確認することです。
class Foo {
public void doSomething() { System.out.println("Foo"); }
}
class MyFoo extends Foo {
public void doSomething() { System.out.println("MyFoo"); }
}
public class MyClass extends MyFoo {
Foo f;
static {
f = new MyFoo().doSomething();
}
public static void main(String args[]) {
new MyClass();
}
}
上記のような愚かな例を作成して、何が出力されるかを確認してください。次に、セット、TreeSet、その他すべての種類のセットを試してみてください。次に、マップとマップのすべてのサブセットで同じことを行います。セットで遊んでいる他の人のスニピットから取った次のクラスを思いついた。
public class PlayingWithSets {
private Set<Integer> s1;
private Set<Integer> s2;
enum Test {
A,B,C
};
/*
* Cannot be a static block because the variable is not static. This block
* happens before the call to super() in the constructor.
*/
{
s1 = generateSet();
s2 = generateSet();
}
/**
* Helper method to set up a new HashSet
* @return
*/
private Set<Integer> generateSet() {
Set<Integer> s = new HashSet<Integer>();
Random r = new Random();
for (int i = 0; i < 20; ++i) {
s.add(r.nextInt(30));
}
return s;
}
/* ********************** Merges two sets *****************************/
private void mergeSets() {
System.out.println("Set s1 = " + s1);
System.out.println("Set s2 = " + s2);
/*
* Causes an error if you use the wildcard for the generic type. I.E.
* Set<?> s1; in the declaration.
*
* The cast is needed when using wild cards for declaration. The reason
* is that you cannot gurantee that the object is of the same type,
* which defeats the purpose of generics and type safety.
*/
s1.addAll(s2);
System.out.println(s1);
}
/* ************************ Sorting on a set ***************************/
private void sortSets() {
/*
* Collections.sort() is ONLY for lists.
*/
// Collections.sort(s1);
TreeSet<Integer> ts = new TreeSet<Integer>(s1);
System.out.println("Sorted set s1 = " + ts);
}
/* ******************** Tests the Uniqueness of sets (i.e. no duplicates) **************************/
static void fill(Set s) {
s.addAll(Arrays.asList("one two three four five six seven".split(" ")));
}
public static void testSetUniqueness(Set s) {
// Strip qualifiers from class name:
System.out.println(s.getClass().getName().replaceAll("\\w+\\.", ""));
fill(s);
fill(s);
fill(s);
System.out.println(s); // No duplicates!
// Add another set to this one:
s.addAll(s);
s.add("one");
s.add("one");
s.add("one");
System.out.println(s);
// Look something up:
System.out.println("s.contains(\"one\"): " + s.contains("one"));
}
/* ****************** Subset / Union / Intersection **********************/
public static <T> Set<T> union(Set<T> setA, Set<T> setB) {
Set<T> tmp = new TreeSet<T>(setA);
tmp.addAll(setB);
return tmp;
}
public static <T> Set<T> intersection(Set<T> setA, Set<T> setB) {
Set<T> tmp = new TreeSet<T>();
for (T x : setA)
if (setB.contains(x))
tmp.add(x);
return tmp;
}
public static <T> Set<T> difference(Set<T> setA, Set<T> setB) {
Set<T> tmp = new TreeSet<T>(setA);
tmp.removeAll(setB);
return tmp;
}
public static <T> Set<T> symDifference(Set<T> setA, Set<T> setB) {
Set<T> tmpA;
Set<T> tmpB;
tmpA = union(setA, setB);
tmpB = intersection(setA, setB);
return difference(tmpA, tmpB);
}
public static <T> boolean isSubset(Set<T> setA, Set<T> setB) {
return setB.containsAll(setA);
}
public static <T> boolean isSuperset(Set<T> setA, Set<T> setB) {
return setA.containsAll(setB);
}
private void subsetUnionIntersection() {
TreeSet<Character> set1 = new TreeSet<Character>();
TreeSet<Character> set2 = new TreeSet<Character>();
set1.add('A');
set1.add('B');
set1.add('C');
set1.add('D');
set2.add('C');
set2.add('D');
set2.add('E');
set2.add('F');
System.out.println("set1: " + set1);
System.out.println("set2: " + set2);
System.out.println("Union: " + union(set1, set2));
System.out.println("Intersection: " + intersection(set1, set2));
System.out.println("Difference (set1 - set2): "
+ difference(set1, set2));
System.out
.println("Symmetric Difference: " + symDifference(set1, set2));
TreeSet<Character> set3 = new TreeSet<Character>(set1);
set3.remove('D');
System.out.println("set3: " + set3);
System.out.println("Is set1 a subset of set2? " + isSubset(set1, set3));
System.out.println("Is set1 a superset of set2? "
+ isSuperset(set1, set3));
System.out.println("Is set3 a subset of set1? " + isSubset(set3, set1));
System.out.println("Is set3 a superset of set1? "
+ isSuperset(set3, set1));
}
/* ************************ ***************************/
/**
* @param args
*/
public static void main(String[] args) {
/*
* Testing different types of sets
*/
testSetUniqueness(new HashSet());
testSetUniqueness(new TreeSet());
testSetUniqueness(new LinkedHashSet());
Test test = new Test();
Test values[] = test.values();
System.out.println("\nValues: " + values);
for(Test t: values) {
System.out.println("T: " + t.toString());
}
PlayingWithSets p = new PlayingWithSets();
p.mergeSets();
p.sortSets();
p.subsetUnionIntersection();
}
本当に、これが経験の出番だと思います。物事が実際にどのように組み合わされているかを感じるには、座っていくつかのプログラムを作成する必要があります。