- 浏览: 112775 次
- 性别:
- 来自: 大连
文章分类
最新评论
-
ccfangle:
bestchenwu 写道什么时候用“==”还是“equals ...
操作符“==”与对象的equals()方法 -
bestchenwu:
什么时候用“==”还是“equals()”,跟你是把这个对象作 ...
操作符“==”与对象的equals()方法
THINKING IN JAVA(4TH) 答案免費分享 chapter 11 Holding Your Object
- 博客分类:
- java基础
// holding/Ex1.java
// TIJ4 Chapter Holding, Exercise 1, page 394
/* Create a new class called Gerbil with an int gerbilNumber that's
* initialized in the constructor. Give it a method called hop() that displays
* which gerbil number that is, and that it's hopping. Create an ArrayList and
* add Gerbil objects to the List. Now use the get() method to move through
* the List and call hop() for each Gerbil.
*/
import java.util.*;
class Gerbil {
private int gerbilNumber;
public Gerbil(int i) {
gerbilNumber = i;
}
public void hop() {
System.out.println("Gerbil " + gerbilNumber + " hops");
}
}
public class Ex1 {
public static void main(String[] args) {
ArrayList<Gerbil> gerbils = new ArrayList<Gerbil>();
for(int i = 0; i < 10; i++)
gerbils.add(new Gerbil(i));
for(int i = 0; i < 10; i++)
gerbils.get(i).hop();
// or, alternatively, using foreach syntax:
for(Gerbil g : gerbils)
g.hop();
}
}
// holding/Ex2.java
// TIJ4 Chapter Holding, Exercise 2, page 396
// Modify SimpleCollection.java to use a Set for c.
import java.util.*;
public class Ex2 {
public static void main(String[] args) {
Set<Integer> c = new HashSet<Integer>();
for(int i = 0; i < 10; i++)
c.add(i); // Autoboxing
for(Integer i : c)
System.out.print(i + ", ");
}
}
// holding/Sequence3.java
// TIJ4 Chapter Holding, Exercise 3, page 396
/* Modify innerclasses/Sequence.java so that you can add any number
* of elements to it.
*/
import java.util.*;
interface Selector {
boolean end();
Object current();
void next();
}
public class Sequence3 {
private ArrayList<Object> items = new ArrayList<Object>();
public void add(Object x) {
items.add(x);
}
private class Sequence3Selector implements Selector {
private int i = 0;
public boolean end() {
return i == items.size();
}
public Object current() {
return items.get(i);
}
public void next() {
i++;
}
}
public Selector selector() {
return new Sequence3Selector();
}
public static void main(String[] args) {
Sequence3 s3 = new Sequence3();
for(int i = 0; i < 10; i++)
s3.add(i);
Selector selector = s3.selector();
while(!selector.end()) {
System.out.print(selector.current() + " ");
selector.next();
}
s3.add(10);
s3.add(11);
s3.add(12);
s3.add(13);
s3.add(13);
s3.add("good bye");
while(!selector.end()) {
System.out.print(selector.current() + " ");
selector.next();
}
}
}
// holding/Ex4.java
// TIJ4 Chapter Holding, Exercise 4, page 401
/* Create a generator class that produces character names (as String objects)
* from your favorite movie (you can use Snow White or Star Wars as a
* fallback) each time you call next(), and loops around to the beginning of
* the character list when it runs out of names. Use this generator to fill
* an array, an ArrayList, a LinkedList, a HashSet, a LinkedHashSet, and a
* TreeSet, then print each container.
*/
import java.util.*;
class Generator {
int key = 0;
public String next() {
switch(key) {
default:
case 0 : key++; return "Snow White";
case 1 : key++; return "Bashful";
case 2 : key++; return "Doc";
case 3 : key++; return "Dopey";
case 4 : key++; return "Grumpy";
case 5 : key++; return "Happy";
case 6 : key++; return "Sleepy";
case 7 : key = 0; return "Sneezy";
}
}
public void fillA(String[] a) {
for(int i = 0; i < a.length; i++)
a[i] = next();
}
public Collection fill(Collection<String> c, int n) {
for(int i = 0; i < n; i++) c.add(next());
return c;
}
}
public class Ex4 {
public static void main(String[] args) {
Generator gen = new Generator();
String[] a = new String[10];
gen.fillA(a);
for(String s : a) System.out.print(s + ", ");
System.out.println();
System.out.println(gen.fill(new ArrayList<String>(), 10));
System.out.println(gen.fill(new LinkedList<String>(), 10));
System.out.println(gen.fill(new HashSet<String>(), 10));
System.out.println(gen.fill(new LinkedHashSet<String>(), 10));
System.out.println(gen.fill(new TreeSet<String>(), 10));
}
}
// holding/Ex5.java
// TIJ4 Chapter Holding, Exercise 5, page 406
/* Modify ListFeatures.java so that it uses Integers (remember
* autoboxing!) instead of Pets, and explain any difference in
* results.
*/
import java.util.*;
import static net.mindview.util.Print.*;
public class Ex5 {
// method to make a List<Integer> with random values < n:
public static List<Integer> listOfRandInteger(int length, int n) {
Random rand = new Random();
List<Integer> li = new ArrayList<Integer>();
for(int i = 0; i < length; i++)
li.add(rand.nextInt(n));
return li;
}
public static void main(String[] args) {
Random rand = new Random();
List<Integer> li = listOfRandInteger(7, 10);
print("1: " + li);
Integer h = new Integer(rand.nextInt(10));
li.add(h);
print("2: " + li);
print("3: " + li.contains(h));
// removes the first instance equivalent to Integer h:
li.remove(h);
print("3.5: " + li);
Integer p = li.get(2);
print("4: " + p + " " + li.indexOf(p));
Integer cy = new Integer(rand.nextInt(10));
print("5: " + cy +" " + li.indexOf(cy));
print("6: " + li.remove(cy));
print("7: " + li.remove(p));
print("8: " + li);
li.add(3, new Integer(rand.nextInt(10)));
print("9: " + li);
List<Integer> sub = li.subList(1, 4);
print("sublist: " + sub);
print("10: " + li.containsAll(sub));
// will also sort sub elements within li:
Collections.sort(sub);
print("sorted sublist: " + sub);
print("11: " + li.containsAll(sub));
print("11.25: " + li);
// will also shuffle sub elements within li:
Collections.shuffle(sub, rand);
print("11.5: " + li);
print("shuffled sublist: " + sub);
print("12: " + li.containsAll(sub));
List<Integer> copy = new ArrayList<Integer>(li);
print("12.5: " + li);
sub = Arrays.asList(li.get(1), li.get(4));
print("sub: " + sub);
copy.retainAll(sub);
print("13: " + copy);
copy = new ArrayList<Integer>(li);
copy.remove(2);
print("14: " + copy);
copy.removeAll(sub);
print("15: " + copy);
if(copy.size() > 1) // to avoid out of bounds exception
copy.set(1, 8); // autoboxing int -> Integer
print("16: " + copy);
if(copy.size() > 2)
copy.addAll(2, sub);
print("17: " + copy);
print("18: " + li.isEmpty());
li.clear();
print("19: " + li);
print("20: " + li.isEmpty());
li.addAll(listOfRandInteger(4, 10));
print("21: " + li);
Object[] o = li.toArray();
print("22: " + o[3]);
Integer[] ia = li.toArray(new Integer[0]);
print("23: " + ia[3]);
}
}
// holding/Ex6.java
// TIJ4 Chapter Holding, Exercise 6, page 406
/* Modify listFeatures.java so that it uses String instead of Pets,
* and explain any difference in results.
*/
import java.util.*;
import static net.mindview.util.Print.*;
public class Ex6 {
public static void main(String[] args) {
Random rand = new Random();
List<String> ls = new ArrayList<String>();
print("0: " + ls);
Collections.addAll(ls, "oh", "what", "a", "beautiful", "Manila", "Monday", "morning");
print("1: " + ls);
String h = new String("hi");
ls.add(h);
print("2: " + ls);
print("3: " + ls.contains(h));
// removes the first instance equivalent to String h:
ls.remove(h);
print("3.5: " + ls);
String p = ls.size() > 2 ? ls.get(2) : null;
print("4: " + p + " " + ls.indexOf(p));
String cy = new String("cy");
print("5: " + cy +" " + ls.indexOf(cy));
print("6: " + ls.remove(cy));
print("7: " + ls.remove(p));
print("8: " + ls);
if(ls.size() > 3)
ls.add(3, "wonderful");
print("9: " + ls);
if(ls.size() < 4) {
List<String> s =
Arrays.asList("let's", "jump", "in", "here");
ls.addAll(0, s);
}
List<String> sub = ls.subList(1, 4);
print("sublist: " + sub);
print("10: " + ls.containsAll(sub));
// will also sort sub elements within ls:
Collections.sort(sub);
print("sorted sublist: " + sub);
print("11: " + ls.containsAll(sub));
print("11.25: " + ls);
// will also shuffle sub elements within ls:
Collections.shuffle(sub, rand);
print("11.5: " + ls);
print("shuffled sublist: " + sub);
print("12: " + ls.containsAll(sub));
List<String> copy = new ArrayList<String>(ls);
print("12.5: " + ls);
if(ls.size() < 5) {
ls.add("two");
ls.add("more");
}
sub = Arrays.asList(ls.get(1), ls.get(4));
print("sub: " + sub);
copy.retainAll(sub);
print("13: " + copy);
copy = new ArrayList<String>(ls);
copy.remove(2);
print("14: " + copy);
copy.removeAll(sub);
print("15: " + copy);
if(copy.size() > 1) // to avoid out of bounds exception
copy.set(1, "excellent");
print("16: " + copy);
if(copy.size() > 2)
copy.addAll(2, sub);
print("17: " + copy);
print("18: " + ls.isEmpty());
ls.clear();
print("19: " + ls);
print("20: " + ls.isEmpty());
ls.addAll(0, sub);
ls.addAll(2, sub);
print("21: " + ls);
Object[] o = ls.toArray();
print("22: " + o[3]);
String[] sa = ls.toArray(new String[0]);
print("23: " + sa[3]);
}
}
// holding/Ex7.java
// TIJ4 Chapter Holding, Exercise 7, page 406
/* Create a class, then make an initialized array of objects of your class
* Fill a List from your array. Create a subset of your List by using
* subList(), then remove this subset from your List.
*/
import java.util.*;
import static net.mindview.util.Print.*;
class Tester {
public static int counter = 0;
private int id = counter++;
public String toString() { return String.valueOf(id); }
}
public class Ex7 {
public static void main(String[] args) {
Tester[] t = new Tester[10];
for(int i = 0; i < t.length; i++)
t[i] = new Tester();
List<Tester> lt = new ArrayList<Tester>();
for(Tester x : t) lt.add(x);
print("list of Tester: " + lt);
List<Tester> sub = lt.subList(2, 6);
print("subList: " + sub);
// produces run time ConcurrentModificationException:
// lt.removeAll(sub);
// so, first make copy, remove sub, re-assign lt:
List<Tester> copy = new ArrayList<Tester>(lt);
copy.removeAll(sub);
print("copy: " + copy);
lt = copy;
print("list of Tester: " + lt);
}
}
// holding/Ex8.java
// TIJ4 Chapter Holding, Exercise 8, page 409
// Modify Exercise 1 so it uses an Iterator to move through the List while
// calling hop().
import java.util.*;
class Gerbil {
private int gerbilNumber;
public Gerbil(int i) {
gerbilNumber = i;
}
public void hop() {
System.out.println("Gerbil " + gerbilNumber + " hops");
}
}
public class Ex8 {
public static void main(String[] args) {
ArrayList<Gerbil> gerbils = new ArrayList<Gerbil>();
for(int i = 0; i < 10; i++)
gerbils.add(new Gerbil(i));
Iterator<Gerbil> it = gerbils.iterator();
while(it.hasNext())
it.next().hop();
}
}
// holding/Sequence9.java
// TIJ4 Chapter Holding, Exercise 9, page 409
// Modify innerclasses/Sequence.java so that Sequence works with an Iterator
// instead of a Selector.
import java.util.*;
public class Sequence9 {
private ArrayList<Object> items = new ArrayList<Object>();
public void add(Object x) {
items.add(x);
}
public Iterator iterator() {
return items.iterator();
}
public static void main(String[] args) {
Sequence9 sequence = new Sequence9();
for(int i = 0; i < 10; i++)
sequence.add(Integer.toString(i));
Iterator it = sequence.iterator();
while(it.hasNext()) { System.out.print(it.next() + " ");
}
}
}
// holding/Rodent10.java
// TIJ4 Chapter Holding, Exercise 10, page 409
/* Change Exercise 9 in the Polymorphism chapter to use an ArrayList to
* hold the Rodents and an Iterator to move through the sequence of
* Rodents.
*/
import java.util.*;
import static org.greggordon.tools.Print.*;
class RandomRodentGenerator {
private Random rand = new Random();
public Rodent next() {
switch(rand.nextInt(3)) {
default:
case 0: return new Mouse();
case 1: return new Rat();
case 2: return new Squirrel();
}
}
}
class Rodent {
private String name = "Rodent";
protected void eat() { println("Rodent.eat()"); }
protected void run() { println("Rodent.run()"); }
protected void sleep() { println("Rodent.sleep()"); }
public String toString() { return name; }
}
class Mouse extends Rodent {
private String name = "Mouse";
protected void eat() { println("Mouse.eat()"); }
protected void run() { println("Mouse.run()"); }
protected void sleep() { println("Mouse.sleep()"); }
public String toString() { return name; }
}
class Rat extends Rodent {
private String name = "Rat";
protected void eat() { println("Rat.eat()"); }
protected void run() { println("Rat.run()"); }
protected void sleep() { println("Rat.sleep()"); }
public String toString() { return name; }
}
class Squirrel extends Rodent {
private String name = "Squirrel";
protected void eat() { println("Squirrel.eat()"); }
protected void run() { println("Squirrel.run()"); }
protected void sleep() { println("Squirrel.sleep()"); }
public String toString() { return name; }
}
public class Rodent10 {
private static RandomRodentGenerator gen =
new RandomRodentGenerator();
public static void main(String[] args) {
List<Rodent> rodentList = new ArrayList<Rodent>();
for(int i = 0; i < 10; i++)
rodentList.add(gen.next());
Iterator<Rodent> it = rodentList.iterator();
while(it.hasNext()) {
Rodent r = it.next();
print(r + ": ");
r.eat();
r.run();
r.sleep();
}
}
}
// holding/Ex11.java
// TIJ4 Chapter Holding, Exercise 11, page 409
/* Write a method that uses an Iterator to step through a Collection and
* print the toString() of each object in the container. Fill all the different
* types of Collections with objects and apply your method to each container.
*/
import java.util.*;
import static org.greggordon.tools.Print.*;
public class Ex11 {
public static void printAny(Collection c) {
Iterator it = c.iterator();
while(it.hasNext())
print(it.next() + " ");
println();
}
public static void main(String[] args) {
ArrayList<Integer> al =
new ArrayList<Integer>(Arrays.asList(1, 2, 3));
LinkedList<Character> ll =
new LinkedList<Character>(Arrays.asList('a', 'b', 'c'));
HashSet<Float> hs =
new HashSet<Float>(Arrays.asList(1.1f, 2.2f, 3.3f));
TreeSet<Double> ts =
new TreeSet<Double>(Arrays.asList(1.11, 2.22, 3.33));
LinkedHashSet<Integer> lhs =
new LinkedHashSet<Integer>(Arrays.asList(11, 22, 33));
printAny(al);
printAny(ll);
printAny(hs);
printAny(ts);
printAny(lhs);
}
}
// holding/Ex12.java
// TIJ4 Chapter Holding, Exercise 12, page 410
/* Create and populate a List<Integer>. Create a second List<Integer> of the
* same size as the first, and use ListIterator to read elements of the first
* List and insert them into the second in reverse order. (You may want to
* explore a number of different ways to solve this problem.)
*/
import java.util.*;
import static org.greggordon.tools.Print.*;
public class Ex12 {
public static void main(String[] args) {
List<Integer> li1 =
new ArrayList<Integer>(Arrays.asList(0, 1, 2, 3, 4));
List<Integer> li2 =
new ArrayList<Integer>(Arrays.asList(5, 6, 7, 8, 9));
ListIterator<Integer> it1 = li1.listIterator();
ListIterator<Integer> it2 = li2.listIterator();
println("li1: " + li1);
println("li2: " + li2);
// move it1 to end:
while(it1.hasNext())
it1.next();
// now use it2 to re-set li2:
while(it2.hasNext()) {
it2.next();
it2.set(it1.previous());
}
println("li1: " + li1);
println("li2: " + li2);
}
}
// holding/Ex12a.java
// TIJ4 Chapter Holding, Exercise 12, page 410
/* Create and populate a List<Integer>. Create a second List<Integer> of the
* same size as the first, and use ListIterator to read elements of the first
* List and insert them into the second in reverse order. (You may want to
* explore a number of different ways to solve this problem.)
*/
import java.util.*;
import static org.greggordon.tools.Print.*;
public class Ex12a {
public static void main(String[] args) {
List<Integer> li1 =
new ArrayList<Integer>(Arrays.asList(0, 1, 2, 3, 4));
List<Integer> li2 =
new ArrayList<Integer>(Arrays.asList(5, 6, 7, 8, 9));
// start it1 at the end:
ListIterator<Integer> it1 = li1.listIterator(5);
ListIterator<Integer> it2 = li2.listIterator();
println("li1: " + li1);
println("li2: " + li2);
// now use it2 to re-set li2
while(it2.hasNext()) {
it2.next();
it2.set(it1.previous());
}
println("li1: " + li1);
println("li2: " + li2);
}
}
// holding/Controller13.java
// TIJ4 Chapter Holding, Exercise 13, page 412
/* In the innerclasses/GreenhouseController.java example, the class
* Controller uses an ArrayList. Change the code to use a LinkedList
* instead, and use an Iterator to cycle through the set of events.
*/
import java.util.*;
public class Controller13 {
// A class from java.util to hold Event objects:
private LinkedList<Event> eventList = new LinkedList<Event>();
public void addEvent(Event c) { eventList.add(c); }
public void run() {
LinkedList<Event> eventListCopy =
new LinkedList<Event>(eventList);
ListIterator<Event> it
= eventListCopy.listIterator();
while(it.hasNext()) {
it.next().action();
it.previous();
System.out.println(it.next());
}
}
}
// holding/Ex14.java
// TIJ4 Chapter Holding, Exercise 14, page 412
/* Create an empty LlinkedList<Integer>. Using a ListIterator, add Integers
* to the list by always inserting them in the middle of the list.
*/
import java.util.*;
public class Ex14 {
static void addMiddle(LinkedList<Integer> l, Integer[] ia) {
for(Integer i : ia) {
ListIterator<Integer> it =
l.listIterator((l.size())/2);
it.add(i);
System.out.println(l);
}
}
public static void main(String[] args) {
LinkedList<Integer> li = new LinkedList<Integer>();
Integer[] x = {0, 1, 2, 3, 4, 5, 6, 7};
Ex14.addMiddle(li, x);
}
}
// holding/Ex15.java
// TIJ4 Chapter Holding, Exercise 15, page 415
/* Stacks are often used to evaluate expressions in programming
* languages. Using net.mindview.util.Stack, evaluate the following
* expression, where '+' means "push the following letter onto the
* stack," and '-' means "pop the top of the stack and print it":
* "+U+n+c---+e+r+t---+a+i+n+t+y---+ -+r+u--+l+e+s---"
*/
import net.mindview.util.*;
public class Ex15 {
public static void main(String[] args) {
Stack<Character> sc = new Stack<Character>();
sc.push('U');
sc.push('n');
sc.push('c');
System.out.print(sc.pop());
System.out.print(sc.pop());
System.out.print(sc.pop());
sc.push('e');
sc.push('r');
sc.push('t');
System.out.print(sc.pop());
System.out.print(sc.pop());
System.out.print(sc.pop());
sc.push('a');
sc.push('i');
sc.push('n');
sc.push('t');
System.out.print(sc.pop());
System.out.print(sc.pop());
System.out.print(sc.pop());
sc.push(' ');
System.out.print(sc.pop());
sc.push('r');
sc.push('u');
System.out.print(sc.pop());
System.out.print(sc.pop());
sc.push('l');
sc.push('e');
sc.push('s');
System.out.print(sc.pop());
System.out.print(sc.pop());
System.out.print(sc.pop());
}
}
// holding/Vowels16.java
// TIJ4 Chapter Holding, Exercise 16, page 419
/* Create a Set of the vowels. Working from UniqueWords.java, count and
* display the number of vowels in each input word, and also display the total
* number of vowels in the input file.
*/
import java.util.*;
import net.mindview.util.*;
public class Vowels16 {
static void vowelCounter(Set<String> st) {
Set<Character> vowels = new TreeSet<Character>();
Collections.addAll(vowels,
'A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u');
int allVowels = 0;
for(String s : st) {
int count = 0;
for(Character v : s.toCharArray()) {
if(vowels.contains(v)) {
count++;
allVowels++;
}
}
System.out.print(s + ": " + count + ", ");
}
System.out.println();
System.out.print("Total vowels: " + allVowels);
}
public static void main(String[] args) {
Set<String> words = new TreeSet<String>(
new TextFile("SetOperations.java", "\\W+"));
System.out.println(words);
System.out.println();
vowelCounter(words);
}
}
// holding/Gerbils17.java
// TIJ4 Chapter Holding, Exercise 17, page 422
/* Take the Gerbil class in Exercise 1 and put it into a Map instead,
* associating each Gerbil's name (e.g. "Fuzzy" or "Spot") as a String (the
* key) for each Gerbil (the value) you put in the table. Get an Iterator for
* the keySet() and use it to move through the Map, looking up the Gerbil for
* each key and printing out the key and telling the Gerbil to hop().
*/
import java.util.*;
class Gerbil {
private int gerbilNumber;
public Gerbil(int i) {
gerbilNumber = i;
}
public void hop() {
System.out.println("gerbil " + gerbilNumber + " hops");
}
}
public class Gerbils17 {
public static void main(String[] args) {
Map<String, Gerbil> gerbils = new HashMap<String, Gerbil>();
gerbils.put("Fuzzy", new Gerbil(0));
gerbils.put("Spot", new Gerbil(1));
gerbils.put("Speedy", new Gerbil(2));
gerbils.put("Dopey", new Gerbil(3));
gerbils.put("Sleepy", new Gerbil(4));
gerbils.put("Happy", new Gerbil(5));
Iterator<String> it = gerbils.keySet().iterator();
while(it.hasNext()) {
String s = it.next();
System.out.print(s + ": ");
gerbils.get(s).hop();
}
}
}
// holding/Ex18.java
// TIJ4 Chapter Holding, Exercise 18, page 422
/* Fill a HashMap with key-value pairs. Print the results to show ordering
* by hash code. Extract the pairs, sort by key, and place the result into a
* LinkedHashMap. Show that the insertion order is maintained.
*/
import java.util.*;
class Gerbil {
private int gerbilNumber;
public Gerbil(int i) {
gerbilNumber = i;
}
public void hop() {
System.out.println("gerbil " + gerbilNumber + " hops");
}
}
public class Ex18 {
public static void main(String[] args) {
Map<String, Gerbil> gerbils = new HashMap<String, Gerbil>();
gerbils.put("Fuzzy", new Gerbil(0));
gerbils.put("Spot", new Gerbil(1));
gerbils.put("Speedy", new Gerbil(2));
gerbils.put("Dopey", new Gerbil(3));
gerbils.put("Sleepy", new Gerbil(4));
gerbils.put("Happy", new Gerbil(5));
gerbils.put("Funny", new Gerbil(6));
gerbils.put("Silly", new Gerbil(7));
gerbils.put("Goofy", new Gerbil(8));
gerbils.put("Wowee", new Gerbil(9));
System.out.println(gerbils);
System.out.println();
Set<String> sortedKeys =
new TreeSet<String>(gerbils.keySet());
System.out.println(sortedKeys);
System.out.println();
Map<String, Gerbil> sortedGerbils =
new LinkedHashMap<String, Gerbil>();
for(String s : sortedKeys) {
System.out.print("Adding " + s + ", ");
sortedGerbils.put(s, gerbils.get(s));
}
System.out.println();
System.out.println();
System.out.println(sortedGerbils);
System.out.println();
// or, just:
Map<String, Gerbil> sortedGerbils2 =
new TreeMap<String, Gerbil>(gerbils);
System.out.println(sortedGerbils2);
}
}
// holding/Ex19.java
// TIJ4 Chapter Holding, Exercise 19, page 422
// Repeat the previous exercise with a HashSet and a LinkedHashSet.
import java.util.*;
class Gerbil {
private int gerbilNumber;
public Gerbil(int i) {
gerbilNumber = i;
}
public void hop() {
System.out.println("gerbil " + gerbilNumber + " hops");
}
}
public class Ex19 {
public static void main(String[] args) {
Map<String, Gerbil> gerbils = new HashMap<String, Gerbil>();
gerbils.put("Fuzzy", new Gerbil(0));
gerbils.put("Spot", new Gerbil(1));
gerbils.put("Speedy", new Gerbil(2));
gerbils.put("Dopey", new Gerbil(3));
gerbils.put("Sleepy", new Gerbil(4));
gerbils.put("Happy", new Gerbil(5));
gerbils.put("Funny", new Gerbil(6));
gerbils.put("Silly", new Gerbil(7));
gerbils.put("Goofy", new Gerbil(8));
gerbils.put("Wowee", new Gerbil(9));
System.out.println(gerbils);
System.out.println();
Set<String> hashedKeys =
new HashSet<String>(gerbils.keySet());
System.out.println("HashSet: " + hashedKeys);
System.out.println();
Map<String, Gerbil> hashedGerbils =
new LinkedHashMap<String, Gerbil>();
for(String s : hashedKeys) {
System.out.print("Adding " + s + ", ");
hashedGerbils.put(s, gerbils.get(s));
}
System.out.println();
System.out.println();
System.out.println("From HashSet: " + hashedGerbils);
System.out.println();
Set<String> linkedHashedKeys =
new LinkedHashSet<String>(gerbils.keySet());
System.out.println("LinkedHashSet: " + linkedHashedKeys);
System.out.println();
Map<String, Gerbil> linkedHashedGerbils =
new LinkedHashMap<String, Gerbil>();
for(String s : linkedHashedKeys) {
System.out.print("Adding " + s + ", ");
linkedHashedGerbils.put(s, gerbils.get(s));
}
System.out.println();
System.out.println();
System.out.println("From LinkedHashSet: "
+ linkedHashedGerbils);
}
}
// holding/Vowels20.java
// TIJ4 Chapter Holding, Exercise 20, page 422
// Modify Exercise 16 so that you keep a count of the occurence of each vowel.
import java.util.*;
import net.mindview.util.*;
public class Vowels20 {
static void vowelCounter20(Set<String> st) {
Set<Character> vowels = new TreeSet<Character>();
Collections.addAll(vowels,
'A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u');
int allVowels = 0;
Map<Character,Integer> vowelMap =
new TreeMap<Character,Integer>();
for(String s : st) {
for(Character v : s.toCharArray()) {
if(vowels.contains(v)) {
Integer count = vowelMap.get(v);
vowelMap.put(v,
count == null ? 1 : count + 1);
allVowels++;
}
}
}
System.out.println("Vowels: " + vowelMap);
System.out.println("Total vowels: " + allVowels);
}
public static void main(String[] args) {
Set<String> words = new TreeSet<String>(
new TextFile("SetOperations.java", "\\W+"));
System.out.println(words);
System.out.println();
vowelCounter20(words);
}
}
// holding/UniqueWords21.java
// TIJ4 Chapter Holding, Exercise 21, page422
/* Using a Map<String,Integer>, follow the form. of UniqueWords.java to create a
* program that counts the occurrence of words in a file. Sort the results using
* Collections.sort() with a second argument of String.CASE_INSENSITIVE_ORDER (to
* produce an alphabetic sort), and display the result.
*/
import java.util.*;
import net.mindview.util.*;
public class UniqueWords21 {
public static void main(String[] args) {
List<String> words = new ArrayList<String>(
new TextFile("SetOperations.java", "\\W+"));
System.out.println("Words to count: " + words);
Collections.sort(words, String.CASE_INSENSITIVE_ORDER);
Map<String,Integer> wordCount =
new LinkedHashMap<String,Integer>();
Iterator it = words.iterator();
int totalWords = 0;
while(it.hasNext()) {
String s = (String)it.next();
if(words.contains(s)) {
Integer count = wordCount.get(s);
wordCount.put(s,
count == null ? 1 : count + 1);
totalWords++;
}
}
System.out.println();
System.out.println("Word count: " + wordCount);
System.out.println();
System.out.println("Total words: " + totalWords);
}
}
// holding/UniqueWords22.java
// TIJ4 Chapter Holding, Exercise 22, page422
/* Modify the previous exercise so that it uses a class containing a String and
* a count field to store each different word, and a Set of these objects to
* maintain the list of words.
*/
import java.util.*;
import net.mindview.util.*;
class Word {
static int totalWords = 0;
String s;
int count;
Word(String s, int count) {
this.s = s;
this.count = count;
totalWords++;
}
public String toString() { return s + ": " + count; }
}
public class UniqueWords22 {
public static void main(String[] args) {
List<String> words = new ArrayList<String>(
new TextFile("SetOperations.java", "\\W+"));
Collections.sort(words, String.CASE_INSENSITIVE_ORDER);
System.out.println("Words to count, sorted: " + words);
Set<Word> wordObjects = new HashSet<Word>();
Iterator it = words.iterator();
while(it.hasNext()) {
String s = (String)it.next();
int count = 0;
for(int i = 0; i < words.size(); i++) {
if(s.equals(words.get(i))) count++;
}
Word w = new Word(s, count);
wordObjects.add(w);
}
System.out.println("Word count: " + wordObjects);
System.out.println("Total words: " + Word.totalWords);
}
}
// holding/Statistics23.java
// TIJ4 Chapter Holding, Exercise 23, page 423
/* Starting with Statistics.java, create a program that runs the test repeatedly
* and looks to see if any one number tends to appear more than the others in the
* results.
*/
import java.util.*;
public class Statistics23 {
private static int getBestInt20(int n) {
Random rand = new Random();
Map<Integer, Integer> m =
new TreeMap<Integer, Integer>();
for(int i = 0; i < 10000; i++) {
// Produce a number between 0 and 20:
int r = rand.nextInt(20);
Integer freq = m.get(r);
m.put(r, freq == null ? 1 : freq + 1);
}
int max = 0;
for(int i = 0; i < m.keySet().size(); i++) {
max = max < m.get(i) ? m.get(i) : max;
}
Set<Map.Entry<Integer,Integer>> me = new
LinkedHashSet<Map.Entry<Integer,Integer>>(m.entrySet());
int maxKey = 0;
Iterator<Map.Entry<Integer,Integer>> it = me.iterator();
while(it.hasNext()) {
Map.Entry<Integer,Integer> findMax = it.next();
if(findMax.getValue() == max)
maxKey = findMax.getKey();
}
return maxKey;
}
public static void main(String[] args) {
Map<Integer,Integer> m20 =
new TreeMap<Integer,Integer>();
for(int i = 0; i < 2000; i++) {
int x = getBestInt20(10000);
Integer freq = m20.get(x);
m20.put(x, freq == null ? 1 : freq + 1);
}
System.out.println("Most often picked ints, 0 - 19, in 2000 tests of 10,000 random picks: " + m20);
}
}
// holding/Ex24.java
// TIJ4 Chapter Holding, Exercise 24, page 423
/* Fill a LinkedHashMap with String keys and objects of your choice.
* Now extract the pairs, sort them based on the keys, and reinsert
* them into the Map.
*/
// see also solution - holding/Ex24b.java
import java.util.*;
import static org.greggordon.tools.Print.*;
public class Ex24{
public static void main(String[] args) {
Map<String,Integer> m =
new LinkedHashMap<String,Integer>();
m.put("ten", 10);
m.put("nine", 9);
m.put("eight", 8);
m.put("seven", 7);
m.put("six", 6);
m.put("five", 5);
m.put("four", 4);
m.put("three", 3);
m.put("two", 2);
m.put("one", 1);
m.put("zero", 0);
println("Map to sort: " + m);
// temporary map to hold entrys:
Map<String,Integer> mTemp =
new LinkedHashMap<String,Integer>();
// use TreeSet to sort the keySet():
Set<String> ss = new TreeSet<String>(m.keySet());
// mover sorted keys to temp map:
Iterator<String> itss = ss.iterator();
while(itss.hasNext()) {
String s = (String)itss.next();
Integer i = m.get(s);
m.remove(s);
mTemp.put(s, i);
}
// get sorted list of temp keys:
Set<String> ssTemp =
new TreeSet<String>(mTemp.keySet());
// move sorted entrys back to map:
Iterator<String> itssTemp = ssTemp.iterator();
while(itssTemp.hasNext()) {
String s = (String)itssTemp.next();
Integer i = mTemp.get(s);
mTemp.remove(s);
m.put(s, i);
}
// done with temp:
mTemp.clear();
println("Sorted map: " + m);
}
}
// holding/Ex24b.java
// TIJ4 Chapter Holding, Exercise 24, page 423
/* Fill a LinkedHashMap with String keys and objects of your choice.
* Now extract the pairs, sort them based on the keys, and reinsert
* them into the Map.
*/
// (see also solution - holding/Ex24.java)
import java.util.*;
import static org.greggordon.tools.Print.*;
public class Ex24b{
public static void main(String[] args) {
Map<String,Integer> m =
new LinkedHashMap<String,Integer>();
m.put("ten", 10);
m.put("nine", 9);
m.put("eight", 8);
m.put("seven", 7);
m.put("six", 6);
m.put("five", 5);
m.put("four", 4);
m.put("three", 3);
m.put("two", 2);
m.put("one", 1);
m.put("zero", 0);
println("Map to sort: " + m);
// temp map to hold entrys:
Map<String,Integer> mTemp =
new LinkedHashMap<String,Integer>();
// to sort the keySet():
// convert Set to List:
List<String> ss2List =
new LinkedList<String>(m.keySet());
// sort List:
Collections.sort(ss2List);
// move entrys in sorted order from m to mTemp:
Iterator<String> itss2List = ss2List.iterator();
while(itss2List.hasNext()) {
String s = (String)itss2List.next();
Integer i = m.get(s);
m.remove(s);
mTemp.put(s, i);
}
// get list of temp keys:
List<String> ssTemp =
new LinkedList<String>(mTemp.keySet());
// move sorted entrys back from mTemp to m:
Iterator<String> itssTemp = ssTemp.iterator();
while(itssTemp.hasNext()) {
String s = (String)itssTemp.next();
Integer i = mTemp.get(s);
mTemp.remove(s);
m.put(s, i);
}
// done with temp:
mTemp.clear();
println("Sorted map: " + m);
}
}
// holding/Ex25.java
// TIJ4 Chapter Holding, Exercise 25, page 423
/* Create a Map<String, ArrayList<Integer>>. Use net.mindview.TextFile
* to open a text file and read it in a word at a time (use "\\W+\" as
* the second argument to the TextFile constructor). Count the words as
* you read them in, and for each word in the file, record in the
* ArrayList<Integer> the word count associated with that word - that is,
* in effect, the location in the file where that word was found.
*/
import java.util.*;
import net.mindview.util.*;
public class Ex25 {
public static void main(String[] args) {
Map<String,ArrayList<Integer>> m =
new LinkedHashMap<String,ArrayList<Integer>>();
List<String> words = new LinkedList<String>();
words.addAll(new TextFile("SetOperations.java", "\\W+"));
System.out.println("Words in file: " + words);
Iterator itWords = words.iterator();
int count = 0;
while(itWords.hasNext()) {
String s = (String)itWords.next();
count++;
if(!m.keySet().contains(s)) {
ArrayList<Integer> ai =
new ArrayList<Integer>();
ai.add(0, count);
m.put(s, ai);
}
else {
m.get(s).add(count);
m.put(s, m.get(s));
}
}
System.out.println("Map of word locations: " + m);
}
}
// holding/Ex26.java
// TIJ4 Chapter Holding, Exercise 26, page 423
/* Take the resulting Map from the previous exercise and re-create the
* order of the words as they appeared in the original file.
*/
import java.util.*;
import net.mindview.util.*;
public class Ex26 {
public static void main(String[] args) {
Map<String,ArrayList<Integer>> m =
new LinkedHashMap<String,ArrayList<Integer>>();
List<String> words = new LinkedList<String>();
words.addAll(new TextFile("SetOperations.java", "\\W+"));
System.out.println("Words in file: " + words);
Iterator itWords = words.iterator();
int count = 0;
while(itWords.hasNext()) {
String s = (String)itWords.next();
count++;
if(!m.keySet().contains(s)) {
ArrayList<Integer> ai =
new ArrayList<Integer>();
ai.add(0, count);
m.put(s, ai);
}
else {
m.get(s).add(count);
m.put(s, m.get(s));
}
}
System.out.println();
System.out.println("Map of word locations: " + m);
// New Map to hold sorted words, keyed by location:
Map<Integer,String> replay = new TreeMap<Integer,String>();
Iterator<Map.Entry<String,ArrayList<Integer>>> it =
m.entrySet().iterator();
while(it.hasNext()) {
Map.Entry<String,ArrayList<Integer>> me = it.next();
for(int i = 0; i < me.getValue().size(); i++)
replay.put(me.getValue().get(i),
me.getKey());
}
System.out.println();
System.out.println("TreeMap of ordered locations, words: " + replay);
System.out.println();
// Display words in order as TreeMap values():
System.out.println("Words in original order: " +
replay.values());
}
}
// holding/Queue27.java
// TIJ4 Chapter Holding, Exercise 27, page 424
/* Write a class called Command that contains a String and has a method operation()
* that displays the String. Write a second class with a method that fills a Queue
* with Command objects and returns it. Pass the filled Queue to a method in a third
* class that consumes the objects in the Queue and calls their operation() methods.
*/
import java.util.*;
class Command {
String s;
Command(String s) { this.s = s; }
void operation() { System.out.print(s); }
}
class Build {
Queue<Command> makeQ() {
Queue<Command> q = new LinkedList<Command>();
for(int i = 0; i < 10; i++)
q.offer(new Command(i + " "));
return q;
}
}
public class Queue27 {
public static void commandEater(Queue<Command> qc) {
while(qc.peek() != null)
qc.poll().operation();
}
public static void main(String[] args) {
Build b = new Build();
commandEater(b.makeQ());
}
}
// holding/Ex28.java
// TIJ4 Chapter Holding, Exercise 28, page 427
/* Fill a PriorityQueue (using offer()) with Double values created using
* java.util.Random, then remove the elements using poll() and display them.
*/
import java.util.*;
public class Ex28 {
public static void main(String[] args) {
Random rand = new Random();
PriorityQueue<Double> d = new PriorityQueue<Double>();
for(int i = 0; i < 10; i++)
d.offer(rand.nextDouble() * i);
while(d.peek() != null)
System.out.print(d.poll() + " ");
}
}
// holding/Ex29.java
// TIJ4 Chapter Holding, Exercise 29, page 427
/* Fill a PriorityQueue (using offer()) with Double values created using
* java.util.Random, then remove the elements using poll() and display them.
*/
import java.util.*;
class Simple extends Object {}
public class Ex29 {
public static void main(String[] args) {
PriorityQueue<Simple> s = new PriorityQueue<Simple>();
// OK to add one Simple:
s.offer(new Simple());
// but no more allowed; get runtime exception:
// Simple cannot be cast to Comparable:
s.offer(new Simple());
}
}
// holding/CollectionSequence30.java
import typeinfo.pets.*;
import java.util.*;
public class CollectionSequence30 implements Collection<Pet> {
private Pet[] pets = Pets.createArray(8);
public int size() { return pets.length; }
public Iterator<Pet> iterator() {
return new Iterator<Pet>() {
private int index = 0;
public boolean hasNext() {
return index < pets.length;
}
public Pet next() { return pets[index++]; }
public void remove() { // not implemented
throw new UnsupportedOperationException();
}
};
}
public void clear() {
if(this.size() != 0)
for(Pet p : pets)
p = null;
}
public boolean retainAll(Collection<?> c) {
throw new UnsupportedOperationException();
}
public boolean removeAll(Collection<?> c) {
throw new UnsupportedOperationException();
}
public boolean addAll(Collection<? extends Pet> c) {
throw new UnsupportedOperationException();
}
public boolean contains(Object o) {
throw new UnsupportedOperationException();
}
public boolean isEmpty() {
return (this.size() == 0) ? true : false;
}
public boolean containsAll(Collection<?> c) {
throw new UnsupportedOperationException();
}
public boolean remove(Object o) {
throw new UnsupportedOperationException();
}
public boolean add(Pet p) {
throw new UnsupportedOperationException();
}
public Object[] toArray() {
return pets;
}
public <T> T[] toArray(T[] a) {
throw new UnsupportedOperationException();
}
public static void main(String[] args) {
CollectionSequence30 c = new CollectionSequence30();
InterfaceVsIterator.display(c);
InterfaceVsIterator.display(c.iterator());
}
}
// holding/shape/RcdandomShapeGenerator31.java
// TIJ4 Chapter Holding, Exercise 31, page 434
/* Modify polymorphism/shape/RandomShapeGenerator.java to make it
* Iterable. You'll need to add a constructor that takes the number of
* elements that you want the iterator to produce before stopping. Verify
* that it works.
*/
/* Solution includes, in same package:
* public class Shape {
* public void draw() {}
* public void erase() {}
* public void amend() { System.out.println("Shape.amend()"); }
* @Override public String toString() { return "Shape"; }
* }
* public class Circle extends Shape {
* @Override public void draw() { print("Circle.draw()"); }
* @Override public void erase() { print("Circle.erase()"); }
* @Override public void amend() { print("Circle.amend()"); }
* @Override public String toString() { return "Circle"; }
* }
* public class Square extends Shape {
* @Override public void draw() { print("Square.draw()"); }
* @Override public void erase() { print("Square.erase()"); }
* @Override public void amend() { print("Square.amend()"); }
* @Override public String toString() { return "Square"; }
* }
* public class Triangle extends Shape {
* @Override public void draw() { print("Triangle.draw()"); }
* @Override public void erase() { print("Triangle.erase()"); }
* @Override public void amend() { print("Triangle.amend()"); }
* @Override public String toString() { return "Triangle"; }
* }
*/
package holding.shape;
import java.util.*;
public class RandomShapeGenerator31 implements Iterable<Shape> {
private Random rand = new Random();
public Shape make() {
switch(rand.nextInt(3)) {
default:
case 0: return new Circle();
case 1: return new Square();
case 2: return new Triangle();
}
}
private Shape[] shapes;
RandomShapeGenerator31(int n) {
shapes = new Shape[n];
for(int i = 0; i < n; i++)
shapes[i] = make();
}
public Iterator<Shape> iterator() {
return new Iterator<Shape>() {
private int index = 0;
public boolean hasNext() {
return index < shapes.length;
}
public Shape next() {
return shapes[index++];
}
public void remove() {
throw new UnsupportedOperationException();
}
};
}
public static void main(String[] args) {
RandomShapeGenerator31 rsg = new RandomShapeGenerator31(20);
for(Shape s : rsg)
System.out.println(s);
}
}
// holding/NonCollectionSequence32.java
// TIJ4 Chapter Holding, Exercise 32, page 437
/* Following the example of MultiIterableClass, add reversed() and randomized()
* methods to NonCollectionSequence.java, as well as making NonCollectionSequence.java
* implement Iterable and show that all the approaches * work in foreach statements.
*/
import typeinfo.pets.*;
import java.util.*;
import static org.greggordon.tools.Print.*;
class PetSequence {
protected Pet[] pets = Pets.createArray(8);
}
public class NonCollectionSequence32
extends PetSequence implements Iterable {
public Iterator<Pet> iterator() {
return new Iterator<Pet>() {
private int index = 0;
public boolean hasNext() {
return index < pets.length;
}
public Pet next() { return pets[index++]; }
public void remove() {
throw new UnsupportedOperationException();
}
};
}
public Iterable<Pet> reversed() {
return new Iterable<Pet>() {
public Iterator<Pet> iterator() {
return new Iterator<Pet>() {
int current = pets.length - 1;
public boolean hasNext() {
return current > -1;
}
public Pet next() {
return pets[current--];
}
public void remove() {
throw new
UnsupportedOperationException();
}
};
}
};
}
public Iterable<Pet> randomized() {
return new Iterable<Pet>() {
public Iterator<Pet> iterator() {
List<Pet> shuffled = new
ArrayList<Pet>(Arrays.asList(pets));
Collections.shuffle(shuffled, new Random());
return shuffled.iterator();
}
};
}
public static void main(String[] args) {
NonCollectionSequence32 nc = new NonCollectionSequence32();
print("pets: ");
for(Pet p : nc.pets)
print(p + " ");
println();
print("reversed: ");
for(Pet p : nc.reversed())
print(p + " ");
println();
print("randomized: ");
for(Pet p : nc.randomized())
print(p + " ");
}
}
发表评论
-
iText watermark(pdf 新增水印,有一页总是新增不了)
2015-10-21 12:11 976pdf 新增水印,有个总是新增不了:水印能选中,但是就是不 ... -
JDBC userenv('LANG')
2015-08-25 15:51 1388select userenv('LANGUAGE') ,us ... -
回调函数理解
2013-05-17 17:07 995http://www.cnblogs.com/wangche ... -
JAVA5线程并发库[8]-Exchanger(转)
2011-12-21 10:18 955用于实现两个线程之间的数据交换,每个人在完成一定的事务 ... -
Annotation 的作用
2011-12-05 15:51 1180JDK1.5开始,Java中增加了对元数据(Meta ... -
Java 泛型参数类型理解
2011-11-19 16:03 8810<1>泛型参数类型限制 (1) ... -
THINKING IN JAVA(4TH) 答案免費分享 chapter 12 Error Handing With Exceptions
2011-11-03 21:37 3003// exceptions/Ex1.java// TIJ4 ... -
THINKING IN JAVA(4TH) 答案免費分享 chapter 10 Inner Classes
2011-10-21 13:56 1852// innerclasses/Outer1.java// T ... -
java中怎样反向显示字符串(包含实际开发中的例子),有很多地方值得借鉴
2011-10-16 20:16 1775链接地址:http://blog.csdn.net/zha ... -
访问控制作用
2011-10-07 16:55 966进来学习 《Think in Java》很多Java的思想观点 ... -
写一个方法,输入一个文件名和一个字符串,统计这个字符串在这个文件中出......
2011-08-02 11:16 1965写一个方法,输入一个文 ... -
java.lang.Math.round()学习
2011-07-29 23:16 2900<!-- 正文开始 --> public c ... -
Java Socket编程的详细介绍-2
2011-07-29 10:36 959客户机代码: import java.net.*; i ... -
Java Socket编程的详细介绍-1
2011-07-29 10:33 797事实上网络编程简单的理解就是两台计算机相互通讯数据而已.对于程 ... -
操作符“==”与对象的equals()方法
2011-07-27 14:52 1240很多时候都会用到类型或者是对象是否相等的比较应用,需要 ... -
Java反射机制
2011-07-21 11:00 761Java提供了一套机制来动态执行方法和构造方法,以及 ... -
Error与Exception有什么区别?
2011-07-20 23:26 2534Error(错误)表示系统级的错误和程序不必处理的异 ... -
StringBuffer与StringBuilder
2011-06-24 11:38 821<1>StringBuffer 线程安全的可变 ...
相关推荐
Thinking in Java 4th Edition Annotated Solutions Guide!
Thinking in Java 4th Edition及习题答案
Thinking in Java 4th Edition 英文文字版,带书签 Annotated Solution Guide 有代码
thinking in java 4th edition)
第四版Thinking in Java的习题答案,让我们在做题的时候有个对照。
Thinking in java 4th 源代码
Thinking in Java 4th Edition English. Total 16 blocks
Thinking in java 4th , 英文版
Annotated Solution Guide for Thinking in Java 4th Edition 中文资源名称:Thinking In Java第四版 课后练习答案。这本是 herosongly 上传的,但是他要 10 分 的资源分,导致很多朋友不能下载。我现在将其免费公布...
Thinking in Java Fourth Edition Bruce Eckel President, MindView, Inc....Holding Your Objects 275 Error Handling with Exceptions 313 Strings 355 Type Information 393 .... ....
Thinking in java 4th
Annotated Solution Guide for Thinking in Java Fourth Edition; 官方原版答案 For Thinking in Java 4,PDF文档,共778页,英文。
该压缩包包含以下三份内容: 1.thinking in java 4th英文版本 2.thinking in java 4th中文版 3.thinking in java 4th相应代码(code)
Thinking in Java 4th 及答案 非常详细 英文版
Thinking in Java 4Edition 练习题答案
Thinking in java 4th 习题答案 包括大部分的章节
我自己用正则表达式在英文版电子书里扒的源代码,已经自动生成了java文件,里面还附带有部分的jar包,学习的朋友可以看看