练习1：创建一个新类Gerbil（沙鼠），包含int gerbilNumber，在构造器中初始化它。添加一个方法hop()，用以打印沙鼠的号码以及它正在跳跃的信息。创建一个ArrayList,并向其中添加一串Gerbil对象，使用get()遍历List，并且对每个Gerbil调用hop()。
package testPackage3;
import java.util.ArrayList;
public class Gerbil {
private int gerbilNumber;
public Gerbil(int gerbilNumber) {
this.gerbilNumber = gerbilNumber;
}
public void hop() {
System.out.println("沙鼠" + gerbilNumber);
}
public static void main(String[] args) {
ArrayList<Gerbil> gerbils = new ArrayList<Gerbil>();
for (int i = 0; i <= 5; i++) {
gerbils.add(new Gerbil(i));
}
for (Gerbil g : gerbils) {
g.hop();
}
}
}结果显示
娌欓紶0
娌欓紶1
娌欓紶2
娌欓紶3
娌欓紶4
娌欓紶5
Process finished with exit code 0练习2:修改SimpleCollection.java,使用Set来表示c
package testPackage3;
import java.util.ArrayList;
import java.util.Collection;
public class SimpleCollection {
public static void main(String[] args) {
Collection<Integer> c = new ArrayList<Integer>();
for (int i = 0; i < 10; i++) {
c.add(i);
}
for (Integer integer : c) {
System.out.print(integer + " ");
}
}
}运行结果：
0 1 2 3 4 5 6 7 8 9
Process finished with exit code 0练习3：修改innerclasses/Sequence.java,使你可以向其中添加任意数量的元素。
package testPackage3;
import java.util.ArrayList;
interface Selector {
boolean end();
Object current();
void next();
}
public class Sequence {
private ArrayList<Object> items = new ArrayList<Object>();
public void add(Object x) {
items.add(x);
}
private class SequenceSelector 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 SequenceSelector();
}
public static void main(String[] args) {
Sequence sequence = new Sequence();
sequence.add(0.1);
sequence.add(100);
sequence.add("你好");
sequence.add("hello");
Selector selector = sequence.selector();
while (!selector.end()) {
System.out.print(selector.current() + " ");
selector.next();
}
}
}运行结果：
0.1 100 浣犲ソ hello
Process finished with exit code 0练习4：创建一个生成器类，它可以在每次调用其next()方法时，产生你由你最喜欢的电影（你可以使用Snow White 或Star Wars）的字符构成的名字（作为String对象）。在字符列表中的电影名字用完之后，循环到这个字符列表的开始处。使用这个生成器来填充数组、ArrayList、LinkedList、HashSet、LinkedHashSet和TreeSet，然后打印每一个容器。
package testPackage3;
import java.util.*;
public class CollectionSetMap {
static int i;
static String[] s = {"Snow White", "Star Wars", "Play Japanese", "Make Aduowan"};
static String next() {
if (i <= 3) {
return s[i++];
}else {
return s[0];
}
}
static Collection cc(Collection<String> collection) {
for (int i = 0; i < 4; i++) {
collection.add(next());
}
return collection;
}
public static void main(String[] args) {
System.out.println(" ");
System.out.println(cc(new ArrayList<String>()));
System.out.println(cc(new LinkedList<String>()));
System.out.println(cc(new HashSet<String>()));
System.out.println(cc(new LinkedHashSet<String>()));
System.out.println(cc(new TreeSet<String>()));
}
}这个有点问题，，，目前解决不了，以后再来看看。。
结果显示：
[Snow White, Star Wars, Play Japanese, Make Aduowan]
[Snow White, Snow White, Snow White, Snow White]
[Snow White]
[Snow White]
[Snow White]
Process finished with exit code 0练习5：修改ListFeatures.java，让它使用Integer（记住自动包装机制！）而不是Pet，并解释在结果上有何不同。
package testPackage3;
import java.util.*;
public class ListFeatures {
public static List<Integer> change(int length, int n) {
Random rand = new Random();
List<Integer> a = new ArrayList<Integer>();
for (int i = 0; i < length; i++)
a.add(rand.nextInt(n));
return a;
}
public static void main(String[] args) {
Random rand = new Random(47);
List<Integer> a = change(5, 10);
System.out.println("1: " + a);
Integer b = rand.nextInt(10);
a.add(b);
System.out.println("2: " + a);
System.out.println("3: " + a.contains(b));
a.remove(b);
Integer p = a.get(2);
System.out.println("4: " + p + " " + a.indexOf(p));
Integer c = rand.nextInt(10);
System.out.println("5: " + a.indexOf(c));
System.out.println("6: " + a.remove(c));
System.out.println("7: " + a.remove(p));
System.out.println("8: " + a);
a.add(3, rand.nextInt(10));
System.out.println("9: " + a);
List<Integer> sub = a.subList(1, 4);
System.out.println("sublist: " + sub);
System.out.println("10: " + a.containsAll(sub));
Collections.sort(sub);
System.out.println("sorted sublist: " + sub);
System.out.println("11: " + a.containsAll(sub));
Collections.shuffle(sub, rand);
System.out.println("shuffled sublist: " + sub);
System.out.println("12: " + a.containsAll(sub));
List<Integer> copy = new ArrayList<Integer>(a);
sub = Arrays.asList(a.get(1), a.get(4));
System.out.println("sub: " + sub);
copy.retainAll(sub);
System.out.println("13: " + copy);
copy = new ArrayList<Integer>(a);
copy.remove(2);
System.out.println("14: " + copy);
copy.removeAll(sub);
System.out.println("15: " + copy);
if (copy.size() > 1)
copy.set(1, 8);
System.out.println("16: " + copy);
if (copy.size() > 2)
copy.addAll(2, sub);
System.out.println("17: " + copy);
System.out.println("18: " + a.isEmpty());
a.clear();
System.out.println("19: " + a);
System.out.println("20: " + a.isEmpty());
a.addAll(change(4, 10));
System.out.println("21: " + a);
Object[] o = a.toArray();
System.out.println("22: " + o[3]);
Integer[] f = a.toArray(new Integer[0]);
System.out.println("23: " + f[3]);
}
}结果显示：
1: [6, 9, 5, 1, 0]
2: [6, 9, 5, 1, 0, 8]
3: true
4: 5 2
5: 2
6: true
7: false
8: [6, 9, 1, 0]
9: [6, 9, 1, 3, 0]
sublist: [9, 1, 3]
10: true
sorted sublist: [1, 3, 9]
11: true
shuffled sublist: [3, 1, 9]
12: true
sub: [3, 0]
13: [3, 0]
14: [6, 3, 9, 0]
15: [6, 9]
16: [6, 8]
17: [6, 8]
18: false
19: []
20: true
21: [5, 7, 9, 3]
22: 3
23: 3
Process finished with exit code 0容器类不能放基本类型的，放进放出都要先包装和解包。
练习6：修改ListFeatures.java，让它使用String而不是Pet，并解释在结果上有何不同。
package testPackage3;
import java.util.*;
public class ListFeatures1 {
public static void main(String[] args) {
Random rand = new Random(47);
List<String> Str = new ArrayList<String>();
String a1 = "rat";
Str.add(a1);
String a2 = "cat";
Str.add(a2);
String a3 = "dog";
Str.add(a3);
List<String> Str1 = new ArrayList<String>();
String a4 = "rat";
Str1.add(a1);
String a5 = "cat";
Str1.add(a2);
String a6 = "dog";
Str1.add(a3);
System.out.println("1: " + Str);
String b = "god";
Str.add(b);
System.out.println("2: " + Str);
System.out.println("3: " + Str.contains(b));
Str.remove(b);
String p = Str.get(2);
System.out.println("4: " + p + " " + Str.indexOf(p));
String c = "smb";
System.out.println("5: " + Str.indexOf(c));
System.out.println("6: " + Str.remove(c));
System.out.println("7: " + Str.remove(p));
System.out.println("8: " + Str);
Str.add(1, "rmb");
System.out.println("9: " + Str);
List<String> sub = Str.subList(1, 2);
System.out.println("sublist: " + sub);
System.out.println("10: " + Str.containsAll(sub));
Collections.sort(sub);
System.out.println("sorted sublist: " + sub);
System.out.println("11: " + Str.containsAll(sub));
Collections.shuffle(sub, rand);
System.out.println("shuffled sublist: " + sub);
System.out.println("12: " + Str.containsAll(sub));
List<String> copy = new ArrayList<String>(Str);
sub = Arrays.asList(Str.get(0), Str.get(2));
System.out.println("sub: " + sub);
copy.retainAll(sub);
System.out.println("13: " + copy);
copy = new ArrayList<String>(Str);
copy.remove(2);
System.out.println("14: " + copy);
copy.removeAll(sub);
System.out.println("15: " + copy);
copy.set(0,"tmd");
System.out.println("16: " + copy);
copy.addAll(0, sub);
System.out.println("17: " + copy);
System.out.println("18: " + Str.isEmpty());
Str.clear();
System.out.println("19: " + Str);
System.out.println("20: " + Str.isEmpty());
Str.addAll(0,Str1);//这个地方str调用不了ArrayList()方法,目前不知道怎么解决，先备注着。
System.out.println("21: " + Str);
Object[] o = Str.toArray();
System.out.println("22: " + o[2]);
String[] f = Str.toArray(new String[0]);
System.out.println("23: " + f[1]);
}
}结果显示：
1: [rat, cat, dog]
2: [rat, cat, dog, god]
3: true
4: dog 2
5: -1
6: false
7: true
8: [rat, cat]
9: [rat, rmb, cat]
sublist: [rmb]
10: true
sorted sublist: [rmb]
11: true
shuffled sublist: [rmb]
12: true
sub: [rat, cat]
13: [rat, cat]
14: [rat, rmb]
15: [rmb]
16: [tmd]
17: [rat, cat, tmd]
18: false
19: []
20: true
21: [rat, cat, dog]
22: dog
23: cat
Process finished with exit code 0不太好，需要修改。
练习7：创建一个类，然后创建一个用你的类的对象进行过初始化的数组。通过使用subList()方法，创建你的List的子集，然后在你的List中移除这个子集。
package testPackage3;
import java.util.ArrayList;
import java.util.List;
public class Asublist {
static class A3{
}
public static void main(String[] args) {
List<A3> ab = new ArrayList<A3>();
for (int i = 0; i < 3; i++) {
ab.add(new A3());
}
System.out.println(ab);
List list = ab.subList(0,2);
System.out.println(list);
list.remove(list);
System.out.println(ab);
}
}结果显示：
[testPackage3.Asublist$A3@1b6d3586, testPackage3.Asublist$A3@4554617c, testPackage3.Asublist$A3@74a14482]
[testPackage3.Asublist$A3@1b6d3586, testPackage3.Asublist$A3@4554617c]
[testPackage3.Asublist$A3@1b6d3586, testPackage3.Asublist$A3@4554617c, testPackage3.Asublist$A3@74a14482]
Process finished with exit code 0练习8：修改练习1,以便调用hop()时使用Iterator遍历List。
package testPackage3;
import java.util.ArrayList;
import java.util.Iterator;
public class GerbilIterator {
private int gerbilNumber;
public GerbilIterator(int gerbilNumber) {
this.gerbilNumber = gerbilNumber;
}
public void hop(Iterator<GerbilIterator> it) {
while (it.hasNext()) {
GerbilIterator gerbilIterator = it.next();
System.out.println("shashu:" + gerbilIterator.gerbilNumber);
}
}
public static void main(String[] args) {
ArrayList<GerbilIterator> gerbils = new ArrayList<GerbilIterator>();
for (int i = 0; i <= 5; i++) {
gerbils.add(new GerbilIterator(i));
}
GerbilIterator g = new GerbilIterator(5);
g.hop(gerbils.iterator());
}
}结果显示：
shashu:0
shashu:1
shashu:2
shashu:3
shashu:4
shashu:5
Process finished with exit code 0练习9：修改innerclasses/Sequence.java，使得在Sequence中，用Iterator取代Selector。
package testPackage3;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
interface SelectorIterator {
boolean end();
Object current();
void next();
}
public class SequenceIterator {
private ArrayList<Object> items = new ArrayList<>();
public void add(Object x) {
items.add(x);
}
private class SequenceSelector implements Selector {
private int i = 0;
@Override
public boolean end() {
return i == items.size();
}
@Override
public Object current() {
return items.get(i);
}
@Override
public void next() {
i++;
}
}
public static void main(String[] args) {
List<Integer> ig = new LinkedList<>();
for (int i = 0; i < 10; i++) {
ig.add(i);
}
Iterator<Integer> it = ig.iterator();
while (it.hasNext()){
Integer integer = it.next();
System.out.println(integer);
}
}
}结果显示：
0
1
2
3
4
5
6
7
8
9
Process finished with exit code 0感觉有点问题，，，，以后再瞅瞅
练习10：修改第8章中的练习9，使其使用一个ArrayList来存放Rodents，并使用一个Iterator来访问Rodent序列。
package testPackage3;
import java.util.ArrayList;
import java.util.Iterator;
public class RodentArrayList {
void bit() {
System.out.println("Rodent bit");
}
static class Mouse extends RodentArrayList {
@Override
void bit() {
System.out.println("Mouse bit");
}
}
static class Gerbil extends RodentArrayList {
@Override
void bit() {
System.out.println("Gerbil bit");
}
}
static class Hamster extends RodentArrayList {
@Override
void bit() {
System.out.println("Hamster bit");
}
}
public static void main(String[] args) {
ArrayList<RodentArrayList> ra = new ArrayList<>();
ra.add(new Mouse());
ra.add(new Gerbil());
ra.add(new Hamster());
Iterator<RodentArrayList> itra = ra.iterator();
while (itra.hasNext()){
RodentArrayList rodentArrayList = itra.next();
rodentArrayList.bit();
}
}
}结果显示：
Mouse bit
Gerbil bit
Hamster bit
Process finished with exit code 0练习11：写一个方法，使用Iterator遍历Collection，并打印容器中每个对象的toString()。填充各种类型的Collection,然后对其使用此方法。
package testPackage3;
import java.util.*;
public class TestCollection {
public static void printAny(Collection c){
Iterator it = c.iterator();
while (it.hasNext()) {
System.out.print(it.next() + " ");
}
System.out.println();
}
public static void main(String[] args) {
ArrayList<Integer> arrayList = new ArrayList<>(Arrays.asList(1, 2, 3));
LinkedList<Character> linkedList = new LinkedList<>(Arrays.asList('a', 'b', 'c'));
HashSet<Float> hashSet = new HashSet<>(Arrays.asList(1.1f, 2.2f, 3.3f));
TreeSet<Double> treeSet = new TreeSet<>(Arrays.asList(1.11, 2.22, 3.33));
LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>(Arrays.asList(11, 22, 33));
printAny(arrayList);
printAny(linkedList);
printAny(hashSet);
printAny(treeSet);
printAny(linkedHashSet);
}
}结果显示：
1 2 3
a b c
3.3 1.1 2.2
1.11 2.22 3.33
11 22 33
Process finished with exit code 0练习12：创建并组装一个List<Integer>，然后创建第二个具有相同尺寸的List<Integer>，并使用ListIterator读取第一个List中的元素，然后再将它们以反序插入到第二个列表中。
package testPackage3;
import java.util.*;
public class ListInter {
public static void main(String[] args) {
List<Integer> frontlist = new ArrayList<>(10);
for (int i = 0; i < 5; i++) {
frontlist.add(i);
}
System.out.println(frontlist);
ListIterator<Integer> lit = frontlist.listIterator();
while (lit.hasNext()){
System.out.print(lit.next() + " ");
}
System.out.println();
while (lit.hasPrevious()){
System.out.print(lit.previous() + " ");
}
System.out.println();
for (int i = 4; i >= 0 ; i--) {
frontlist.add(i);
}
System.out.println(frontlist);
}
}结果显示：
[0, 1, 2, 3, 4]
0 1 2 3 4
4 3 2 1 0
[0, 1, 2, 3, 4, 4, 3, 2, 1, 0]
Process finished with exit code 0反序插入应该不是最优解，暂时想不到更好的解决方案，，，，，，，，，
练习13：在innerclasses/GreenhouseController.java示例中，Controller类使用的是ArrayList，修改代码，用LinkedList替换之，并使用Iterator来循环遍历事件集。
package testPackage2;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class Controller2 {
List<Event> eventList = new LinkedList<>();
public void addEvent(Event e) {
eventList.add(e);
}
public void run() {
while (eventList.size() > 0) {
// 由于会对LinkedList产生结构性修改（如Bell事件触发的action()，会将
// 自己添加到LinkedList里等），因此需要拷贝一个副本进行操作。
List<Event> copyEventList = new LinkedList<>(eventList);
Iterator<Event> it = copyEventList.iterator();
while (it.hasNext()) {
Event e = it.next();
if (e.ready()) {
System.out.println(e);
e.action();
it.remove();
}
}
}
}
}结果显示：
无，太长了，需要暂停的。
练习14：创建一个空的LinkedList<Integer>,通过使用ListIterator，将若干个Integer插入这个List中，插入时，总是将它们插入到List的中间。
package testPackage3;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
public class AddLinkedList {
public static void main(String[] args) {
List<Integer> list = new LinkedList<>();
for (int i = 0; i < 10; i++) {
ListIterator<Integer> it = list.listIterator(list.size()/2);
it.add(i);
System.out.println(list);
}
}
}结果显示：
[0]
[1, 0]
[1, 2, 0]
[1, 3, 2, 0]
[1, 3, 4, 2, 0]
[1, 3, 5, 4, 2, 0]
[1, 3, 5, 6, 4, 2, 0]
[1, 3, 5, 7, 6, 4, 2, 0]
[1, 3, 5, 7, 8, 6, 4, 2, 0]
[1, 3, 5, 7, 9, 8, 6, 4, 2, 0]
Process finished with exit code 0练习15：栈在编程语言中经常用来对表达式求值。请使用net.mindview.util.Stack对下面表达式求值，其中“+”表示“将后面的字母压进栈”，而“-”表示“弹出栈顶字母并打印它”：“+U+n+c---+e+r+t---+a-+i-+n+t+y---+ -+r+u--+l+e+s---”
public static void main(String[] args) {
String s = "+U+n+c---+e+r+t---+a-+i-+n+t+y---+ -+r+u--+l+e+s---";
Stack<Character> Sc = new Stack<Character>();
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (c == '+') {
Sc.push(s.charAt(++i));
} else if (c == '-') {
System.out.print(Sc.pop());
}
}
System.out.println();
}结果显示：
cnUtreaiytn ursel
Process finished with exit code 0练习16：创建一个元音字母Set。对UniqueWords.java操作，计数并显示在每一个输入单词中的元音字母数量，并显示输入文件中的所有元音字母的数量总和。
package testPackage3;
import net.mindview.util.TextFile;
import java.util.Collections;
import java.util.Set;
import java.util.TreeSet;
public class UniqueWords {
static void vowelCounter(Set<String> st) {
Set<Character> vowels = new TreeSet<>();
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 c : s.toCharArray()) {
if (vowels.contains(c)) {
count++;
allVowels++;
}
}
System.out.println(s + ": " + count + ", ");
}
System.out.println();
System.out.print("元音总数: " + allVowels);
}
public static void main(String[] args) {
Set<String> words = new TreeSet<>(
new TextFile("src/testPackage3/SetOperations.java", "\\W+"));
System.out.println(words);
System.out.println();
vowelCounter(words);
}
}结果显示：
[SetOperations, class, package, public, testPackage3]
SetOperations: 6,
class: 1,
package: 3,
public: 2,
testPackage3: 4,
元音总数: 16
Process finished with exit code 0练习17：使用练习1中的Gerbil类，将其放入Map中，将每个Gerbil的名字String（键）与每个Gerbil（值）关联起来。为keySet()获取Iteratror，使用它遍历Map，针对每个“键”查询Gerbil，然后打印出“键”，并让gerbil执行hop()。
package testPackage3;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class GerbilMap {
private int gerbilNumber;
public GerbilMap(int gerbilNumber) {
this.gerbilNumber = gerbilNumber;
}
public void hop() {
System.out.print(gerbilNumber);
System.out.print(" Jumping");
System.out.println();
}
static Map<String, GerbilMap> map = new HashMap<>();
static {
map.put("First:", new GerbilMap(1));
map.put("Second:", new GerbilMap(2));
}
static Iterator<String> it = map.keySet().iterator();
public static void main(String[] args) {
for (String s : map.keySet()){
String c = it.next();
System.out.print(s + " ");
map.get(c).hop();
}
}
}结果显示：
Second: 2 Jumping
First: 1 Jumping
Process finished with exit code 0练习18：用键值对填充一个HashMap。打印结果，通过散列码来展示其排序。抽取这些键值对，按照键进行排序，并将结果置于一个LinkedHashMap中。展示其所维护的插入排序。
package testPackage3;
import java.util.*;
public class MapTest {
static Map<String, Integer> map = new HashMap<>();
static {
map.put("cat:", 1);
map.put("mouse:", 2);
map.put("cheers:", 3);
map.put("kasri:", 4);
}
public static void main(String[] args) {
SortedMap<String, Integer> smap = new TreeMap<>(map);
LinkedHashMap<String, Integer> lmap = new LinkedHashMap<>(smap);
for (String e : lmap.keySet()) {
System.out.println(e + " " + lmap.get(e));
}
}
}结果显示：
cat: 1
cheers: 3
kasri: 4
mouse: 2
Process finished with exit code 0练习19：使用HashSet和LinkedHashSet重复前一个练习。
Hashset
package testPackage3;
import java.util.*;
public class TestSet {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
set.add("3");
set.add("1");
set.add("9");
set.add("7");
SortedSet<String> ss = new TreeSet<>(set);
HashSet<String> hs = new HashSet<>(ss);
for (String e : hs) {
System.out.println(e);
}
}
}结果显示：
1
3
7
9
Process finished with exit code 0LinkedHashSet
package testPackage3;
import java.util.*;
public class TestSet {
public static void main(String[] args) {
Set<String> set = new LinkedHashSet<>();
set.add("3");
set.add("1");
set.add("9");
set.add("7");
SortedSet<String> ss = new TreeSet<>(set);
LinkedHashSet<String> hs = new LinkedHashSet<>(ss);
for (String e : hs) {
System.out.println(e);
}
}
}结果显示：
1
3
7
9
Process finished with exit code 0练习20：修改练习16，使得你可以跟踪每一个元音字母出现的次数。
package testPackage3;
import net.mindview.util.TextFile;
import java.util.*;
public class TestVowels {
static void vowelCounter(Set<String> st) {
Set<Character> vowels = new TreeSet<>();
Collections.addAll(vowels, 'A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u');
int allVowels = 0;
Map<Character, Integer> vowelsmap = new TreeMap<>();
for (String s : st) {
for (Character c : s.toCharArray()) {
if (vowels.contains(c)) {
Integer count = vowelsmap.get(c);
vowelsmap.put(c, count == null ? 1 : count + 1);
allVowels++;
}
}
}
System.out.println("Vowels:" + vowelsmap);
System.out.println("Total Vowels:" + allVowels);
}
public static void main(String[] args) {
Set<String> words = new TreeSet<>(new TextFile("src/testPackage3/SetOperations.java", "\\W+"));
System.out.println(words);
System.out.println();
vowelCounter(words);
}
}结果显示：
Vowels:{O=1, a=6, e=5, i=2, o=1, u=1}
Total Vowels:16
Process finished with exit code 0练习21：通过使用Map<String,Integer>，遵循UniqueWords.java的形式来创建一个程序，它可以对一个文件中出现的单词计数。使用带有第二个参数**String.CASE_INSENSITIVE_OREDER的Collection.sort()**方法对结果进行排序（将产生字母序），然后显示结果。
package testPackage3;
import net.mindview.util.TextFile;
import java.util.*;
public class UniqueWordsMap {
public static void main(String[] args) {
List<String> list = new ArrayList<>(new TextFile("src/testPackage3/SetOperations.java", "\\W+"));
Collections.sort(list, String.CASE_INSENSITIVE_ORDER);
Map<String, Integer> wordMap = new LinkedHashMap<>();
Iterator it = list.iterator();
int totalwolds = 0;
while (it.hasNext()) {
String s = (String) it.next();
if (list.contains(s)) {
Integer count = wordMap.get(s);
wordMap.put(s, count == null ? 1 : count + 1);
totalwolds++;
}
}
System.out.println();
System.out.println("word count:" + wordMap);
System.out.println();
System.out.println("Total words:" + totalwolds);
}
}结果显示：
word count:{class=1, package=1, public=1, SetOperations=1, testPackage3=1}
Total words:5练习22：修改前一个练习，使其用一个包含有一个String域和一个计数域的类来存储每一个不同的单词，并使用一个由这些对象构成的Set来维护单词列表。
package testPackage3;
import net.mindview.util.TextFile;
import java.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 UniqueWordsMap {
public static void main(String[] args) {
List<String> list = new ArrayList<>(new TextFile("src/testPackage3/SetOperations.java", "\\W+"));
Collections.sort(list, String.CASE_INSENSITIVE_ORDER);
System.out.println("Words to count,sorted:" + list);
Set<Word> sw = new HashSet<>();
Iterator it = list.iterator();
while (it.hasNext()) {
String s = (String) it.next();
int count = 0;
for (int i = 0; i < list.size(); i++) {
if (s.equals(list.get(i))) {
count++;
}
}
Word w = new Word(s, count);
sw.add(w);
}
System.out.println();
System.out.println("word count:" + sw);
System.out.println();
System.out.println("Total words:" + Word.totalwords);
}
}结果显示：
Words to count,sorted:[class, package, public, SetOperations, testPackage3]
word count:[public:1, testPackage3:1, class:1, SetOperations:1, package:1]
Total words:5
Process finished with exit code 0练习23：从Statistics.java开始，写一个程序，让它重复做测试，观察是否某个数字比别的数字出现的次数多。
package testPackage3;
import java.util.*;
public class Statistics {
public static int getBestInt(){
Random rand = new Random(47);
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < 10000; i++) {
int r = rand.nextInt(20);
Integer freq = map.get(r);
map.put(r, freq == null ? 1 : freq + 1);
}
int max = 0;
for (int i = 0; i < map.keySet().size(); i++) {
max = max < map.get(i) ? map.get(i) : max;
}
Set<Map.Entry<Integer, Integer>> setm = new LinkedHashSet<>(map.entrySet());
int maxKey = 0;
Iterator<Map.Entry<Integer, Integer>> itM = setm.iterator();
while (itM.hasNext()) {
Map.Entry<Integer, Integer> findMax = itM.next();
if (findMax.getValue() == max) {
maxKey = findMax.getKey();
}
}
return maxKey;
}
public static void main(String[] args) {
Map<Integer, Integer> mapI = new TreeMap<>();
for (int i = 0; i < 10000; i++) {
int x = getBestInt();
Integer freq = mapI.get(x);
mapI.put(x, freq == null ? 1 : freq + 1);
}
System.out.println("Most often picked ints, 0 - 19: " + mapI);
}
}结果显示：
Most often picked ints, 0 - 19: {9=10000}
Process finished with exit code 0练习24：使用String“键”和你选择的对象填充LinkedHashMap。然后从中提取键值对，以键排序，然后重新插入此Map。
package testPackage3;
import java.util.*;
public class TestMapString {
public static void main(String[] args) {
Map<String, Integer> map = new LinkedHashMap<>();
map.put("ten", 10);
map.put("nine", 9);
map.put("six", 6);
map.put("eight", 8);
map.put("seven", 7);
map.put("five", 5);
map.put("four", 4);
map.put("first", 1);
map.put("three", 3);
map.put("second", 2);
System.out.println("Map to sert:" + map);
Map<String, Integer> map1 = new LinkedHashMap<>();
Set<String> ss = new TreeSet<>(map.keySet());
Iterator<String> it = ss.iterator();
while (it.hasNext()) {
String s = it.next();
Integer i = map.get(s);
map.remove(s);
map1.put(s, i);
}
Set<String> map2 = new TreeSet<>(map1.keySet());
Iterator<String> its = map2.iterator();
while (its.hasNext()) {
String s = its.next();
Integer i = map1.get(s);
map1.remove(s);
map.put(s, i);
}
map1.clear();
System.out.println("Sorted map:" + map);
}
}结果显示：
Map to sert:{ten=10, nine=9, six=6, eight=8, seven=7, five=5, four=4, first=1, three=3, second=2}
Sorted map:{eight=8, first=1, five=5, four=4, nine=9, second=2, seven=7, six=6, ten=10, three=3}
Process finished with exit code 0练习25：创建一个Map<String,ArrayList<Integer>>，使用net.mindview.TextFile来打开一个文本文件，并一次读入一个单词。在读入单词时对它们进行计数，并且对于文件中的每一个单词，都在ArrayList<Integer>中记录下与这个词相关联的单词计数。实际上，它记录的是该单词在文件中被发现的位置。
package testPackage3;
import net.mindview.util.TextFile;
import java.util.*;
public class TestMapInsert {
public static void main(String[] args) {
Map<String, ArrayList<Integer>> ma = new LinkedHashMap<>();
List<String> words = new LinkedList<>();
words.addAll(new TextFile("src/testPackage3/SetOperations.java", "\\W+"));
System.out.println("Words in file:" + words);
Iterator<String> it = words.iterator();
int count = 0;
while (it.hasNext()) {
String s = it.next();
count++;
if (!ma.keySet().contains(s)) {
ArrayList<Integer> al = new ArrayList<>();
al.add(0, count);
ma.put(s, al);
} else {
ma.get(s).add(count);
ma.put(s, ma.get(s));
}
}
System.out.println("Map of word locations: " + ma);
}
}结果显示：
Words in file:[package, testPackage3, public, class, SetOperations]
Map of word locations: {package=[1], testPackage3=[2], public=[3], class=[4], SetOperations=[5]}
Process finished with exit code 0练习26：拿到前一个练习中所产生的Map，并按照它们在最初的文件中出现的顺序重新创建单词顺序。
package testPackage3;
import net.mindview.util.TextFile;
import java.util.*;
public class TestMapInsert {
public static void main(String[] args) {
Map<String, ArrayList<Integer>> ma = new LinkedHashMap<>();
List<String> words = new LinkedList<>();
words.addAll(new TextFile("src/testPackage3/SetOperations.java", "\\W+"));
System.out.println("Words in file:" + words);
Iterator<String> it = words.iterator();
int count = 0;
while (it.hasNext()) {
String s = it.next();
count++;
if (!ma.keySet().contains(s)) {
ArrayList<Integer> al = new ArrayList<>();
al.add(0, count);
ma.put(s, al);
} else {
ma.get(s).add(count);
ma.put(s, ma.get(s));
}
}
System.out.println("Map of word locations: " + ma);
Map<Integer, String> replay = new TreeMap<>();
Iterator<Map.Entry<String,ArrayList<Integer>>> ite = ma.entrySet().iterator();
while (ite.hasNext()) {
Map.Entry<String, ArrayList<Integer>> me = ite.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("Words in original order:" + replay.values());
}
}结果显示：
Words in file:[package, testPackage3, public, class, SetOperations]
Map of word locations: {package=[1], testPackage3=[2], public=[3], class=[4], SetOperations=[5]}
TreeMap of ordered locations,words: {1=package, 2=testPackage3, 3=public, 4=class, 5=SetOperations}
Words in original order:[package, testPackage3, public, class, SetOperations]
Process finished with exit code 0练习27：写一个称为Command的类，它包含一个String域和一个显示该String的operation()方法。写第二类，它具有一个使用Command对象来填充一个Queue并返回这个对象的方法。将填充后的Queue传递给第三个类的一个方法，该方法消耗掉Queue中的对象，并调用它们的operation()方法。
package testPackage3;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
public class Command {
private String s;
public void operation(){
System.out.println(s);
}
public static void main(String[] args) {
A a = new A();
B b = new B();
b.removea(a.queue);
}
}
class A{
public Queue<Command> queue = new LinkedList<>(Arrays.asList(new Command(), new Command()));
}
class B{
public void removea(Queue<Command> queue){
for (Command com : queue) {
com.operation();
System.out.println(queue.remove());
}
}
}结果显示：
null
testPackage3.Command@677327b6
Process finished with exit code 0练习28：用由java.util.Random创建的Double值填充一个PriorityQueue（用offer()）方法，然后使用poll()移除并显示它们。
package testPackage3;
import java.util.PriorityQueue;
import java.util.Random;
public class Test28 {
public static void main(String[] args) {
PriorityQueue<Double> priorityQueue = new PriorityQueue<>();
Random random = new Random(47);
for (int i = 0; i < 10; i++) {
priorityQueue.offer(random.nextDouble());
}
while (!priorityQueue.isEmpty()) {
Double d = priorityQueue.poll();
System.out.println(d);
}
}
}结果显示：
0.0508673570556899
0.16020656493302599
0.18847866977771732
0.2613610344283964
0.2678662084200585
0.5166020801268457
0.5309454508634242
0.7271157860730044
0.7620665811558285
0.8037155449603999
Process finished with exit code 0练习29：创建一个继承自Object的简单类，它不包含任何成员，展示你不能将这个类的多个示例成功地添加到一个PriorityQueue中。这个问题将在第17章中详细解释。
package testPackage3;
import java.util.PriorityQueue;
class A29 {
}
public class Test29 {
public static void main(String[] args) {
PriorityQueue<A29> priorityQueue = new PriorityQueue<>();
for (int i = 0; i < 10; i++) {
priorityQueue.offer(new A29());
}
}
}结果显示：
Exception in thread "main" java.lang.ClassCastException: testPackage3.A29 cannot be cast to java.lang.Comparable
at java.util.PriorityQueue.siftUpComparable(PriorityQueue.java:652)
at java.util.PriorityQueue.siftUp(PriorityQueue.java:647)
at java.util.PriorityQueue.offer(PriorityQueue.java:344)
at testPackage3.Test29.main(Test29.java:12)练习30：修改CollectionSequeuece.java，使其不要继承AbstractCollection，而是实现Collection。
package testPackage3;
import typeinfo.pets.Pet;
import typeinfo.pets.Pets;
import java.util.Collection;
import java.util.Iterator;
public class CollectionSequence implements Collection<Pet> {
private Pet[] pets = Pets.createArray(8);
public int size() {
return pets.length;
}
@Override
public boolean isEmpty() {
return this.size() == 0;
}
@Override
public boolean contains(Object o) {
throw new UnsupportedOperationException();
}
public Iterator<Pet> iterator() {
return new Iterator<Pet>() {
private int index = 0;
@Override
public boolean hasNext() {
return index < pets.length;
}
@Override
public Pet next() {
return pets[index++];
}
public void remove() {
throw new UnsupportedOperationException();
}
};
}
@Override
public Object[] toArray() {
return pets;
}
@Override
public <T> T[] toArray(T[] a) {
throw new UnsupportedOperationException();
}
@Override
public boolean add(Pet pet) {
throw new UnsupportedOperationException();
}
@Override
public boolean remove(Object o) {
throw new UnsupportedOperationException();
}
@Override
public boolean containsAll(Collection<?> c) {
throw new UnsupportedOperationException();
}
@Override
public boolean addAll(Collection<? extends Pet> c) {
throw new UnsupportedOperationException();
}
@Override
public boolean removeAll(Collection<?> c) {
throw new UnsupportedOperationException();
}
@Override
public boolean retainAll(Collection<?> c) {
throw new UnsupportedOperationException();
}
@Override
public void clear() {
if (this.size() != 0) {
for (Pet p : pets) {
p = null;
}
}
}
public static void main(String[] args) {
CollectionSequence c = new CollectionSequence();
InterfaceVsIterator.display(c);
InterfaceVsIterator.display(c.iterator());
}
}结果显示：
0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx
0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx
Process finished with exit code 0练习31：修改polymorphism/shape/RandomShapeGenerator.java，使其成为一个Iterable。你需要添加一个接受元素数量为参数的构造器，这个数量是指在停止之前，你想用迭代器生成的元素的数量。验证这个程序可以工作。
package testPackage3;
import java.util.Iterator;
import java.util.Random;
class Shape {
public void draw() {
}
public void erase() {
}
public void amend() {
System.out.println("Shape.amend()");
}
public String toString() {
return "Shape";
}
}
class Circle extends Shape {
public void draw() {
System.out.println("Circle.draw()");
}
public void erase() {
System.out.println("Circle.erase()");
}
public void amend() {
System.out.println("Circle.amend()");
}
public String toString() {
return "Circle";
}
}
class Square extends Shape {
public void draw() {
System.out.println("Square.draw()");
}
public void erase() {
System.out.println("Square.erase()");
}
public void amend() {
System.out.println("Square.amend()");
}
public String toString() {
return "Square";
}
}
class Triangle extends Shape {
public void draw() {
System.out.println("Triangle.draw()");
}
public void erase() {
System.out.println("Triangle.erase()");
}
public void amend() {
System.out.println("Triangle.amend()");
}
public String toString() {
return "Triangle";
}
}
public class RandomShapeGenerator implements Iterable<Shape> {
private Random random = new Random(47);
private Shape[] shapes;
public RandomShapeGenerator(int n) {
shapes = new Shape[n];
for (int i = 0; i < n; i++) {
shapes[i] = next();
}
}
public Shape next() {
switch (random.nextInt(3)) {
default:
case 0:
return new Circle();
case 1:
return new Square();
case 2:
return new Triangle();
}
}
@Override
public Iterator<Shape> iterator() {
return new Iterator<Shape>() {
private int index = 0;
@Override
public boolean hasNext() {
return index < shapes.length;
}
@Override
public Shape next() {
return shapes[index++];
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
};
}
public static void main(String[] args) {
RandomShapeGenerator rsg = new RandomShapeGenerator(20);
for (Shape s : rsg) {
System.out.println(s);
}
}
}结果显示：
Triangle
Triangle
Square
Triangle
Square
Triangle
Square
Triangle
Circle
Square
Circle
Circle
Circle
Square
Triangle
Square
Square
Square
Triangle
Square
Process finished with exit code 0练习32：按照MultiIterableClass示例，在NonCollectionSequence.java中添加reversed()和randomized()方法，并让NonCollectionSequence实现Iterable。然后在foreach语句中展示所有的使用方式。
package testPackage3;
import typeinfo.pets.Pet;
import typeinfo.pets.Pets;
import java.util.*;
class PetSequence {
protected Pet[] pets = Pets.createArray(8);
}
public class NonCollectionSequence extends PetSequence {
public Iterator<Pet> iterator() {
return new Iterator<Pet>() {
private int index = 0;
@Override
public boolean hasNext() {
return index < pets.length;
}
@Override
public Pet next() {
return pets[index++];
}
public void remove() {
throw new UnsupportedOperationException();
}
};
}
public Iterable<Pet> reversed() {
return new Iterable<Pet>() {
@Override
public Iterator<Pet> iterator() {
return new Iterator<Pet>() {
int current = pets.length - 1;
@Override
public boolean hasNext() {
return current > -1;
}
@Override
public Pet next() {
return pets[current--];
}
};
}
};
}
public Iterable<Pet> randomized() {
return new Iterable<Pet>() {
@Override
public Iterator<Pet> iterator() {
List<Pet> shuffled = new ArrayList<>(Arrays.asList(pets));
Collections.shuffle(shuffled, new Random());
return shuffled.iterator();
}
};
}
public static void main(String[] args) {
NonCollectionSequence nc = new NonCollectionSequence();
System.out.print("pets:");
for (Pet p : nc.pets) {
System.out.print(p + " ");
}
System.out.println();
System.out.print("reversed:");
for (Pet p : nc.reversed()) {
System.out.print(p + " ");
}
System.out.println();
System.out.print("randomized:");
for (Pet p : nc.randomized()) {
System.out.print(p + " ");
}
}
}结果显示：
pets:Rat Manx Cymric Mutt Pug Cymric Pug Manx
reversed:Manx Pug Cymric Pug Mutt Cymric Manx Rat
randomized:Cymric Pug Rat Manx Cymric Pug Mutt Manx
Process finished with exit code 0望大佬们指点！
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
