Java编程思想第四版第十一章习题（中）

编译器：IDEA

(下)的时候可能会有个小总结

题目5-26

5.修改ListFeature.java，让它使用Integer（记住自动包装机制！）而不是Pet，并解释在结果上有何不同。

package job;
import java.util.*;
public class Main {
    public static List<Integer> change(int length, int n) {
        Random rand = new Random();
        List<Integer> a = new ArrayList<>();
        for (int i = 0; i < length; i++)
            a.add(rand.nextInt(n));
        return a;
    }

    public static void main(String[] args) {
        Random rand = new Random();
        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));
        //removes the first instance equivalent to Integer b:
        a.remove(b);
        System.out.println("3.5 " + a);
        Integer p = a.get(2);
        System.out.println("4: " + p + " " + a.indexOf(p));
        Integer c = rand.nextInt(10);
        System.out.println("5: " + c + " " + 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> d = a.subList(1, 4);
        System.out.println("sublist: " + d);
        System.out.println("10: " + a.containsAll(d));
        Collections.sort(d);
        System.out.println("sorted sublist: " + d);
        System.out.println("11: " + a.containsAll(d));
        System.out.println("11.25: " + a);
        Collections.shuffle(d, rand);
        System.out.println("11.5: " + a);
        System.out.println("shuffled sublist: " + d);
        System.out.println("12: " + a.containsAll(d));
        List<Integer> e = new ArrayList<Integer>(a);
        System.out.println("12.5 " + a);
        d = Arrays.asList(a.get(1), a.get(4));
        System.out.println("d: " + d);
        e.retainAll(d);
        System.out.println("13: " + e);
        e = new ArrayList<Integer>(a);
        e.remove(2);
        System.out.println("14: " + e);
        e.removeAll(d);
        System.out.println("15: " + e);
        if (e.size() > 1)
            e.set(1, 8);
        System.out.println("16: " + e);
        if (e.size() > 2)
            e.addAll(2, d);
        System.out.println("17: " + e);
        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]);
    }
}

 

容器类不能放基本类型的，放进放出都要先包装和解包。 

6.修改ListFeatures.java，让它使用String而不是Pet，并解释在结果上有何不同。

 同上。

7.创建一个类，然后创建一个用你的类的对象进行过初始化的数组。通过使用subList()方法，创建你的List子集，然后在你的List中移除这个子集。

package job;
import java.util.*;
class A{

}
public class Main {
    static List<A> a=new LinkedList<>();
    public static void main(String[] args) {
        a.add(new A());
        System.out.println(a);
        a.remove(0);
        System.out.println(a);
    }
}

8.修改练习1，以便调用hop()时使用Iterator遍历List。

package job;

import java.util.*;

class Gerbil{

    int getbilNumber;

    Gerbil(int x){

        getbilNumber=x;

    }

    void hop(){

        System.out.print(getbilNumber);

        System.out.println(" jumping");

    }

}

public class Main{

    public static void main(String[] args){

        ArrayList<Gerbil> a= new ArrayList<>();

        a.add(new Gerbil(5));

        a.add(new Gerbil(8));

        a.add(new Gerbil(10));
        Iterator<Gerbil> b=a.iterator();

        while (b.hasNext()){
            Gerbil c=b.next();
            c.hop();
        }

    }

}

 

9.修改innerclasses/Sequence.java，使得在Sequence中，用Iterator取代Selector。

package job;
import java.util.*;
interface Selector {
    boolean end();
    Object current();
    void next();
}
public class Main {

    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 static void main(String[] args) {
        List<Integer> a = new LinkedList<>();
        for (int i = 0; i < 10; i++)
            a.add(i);
        Iterator<Integer> b = a.iterator();
        while (b.hasNext()) {
            Integer c = b.next();
            System.out.print(c + " ");
        }
        System.out.println();
        a.add(05);
        a.add(16);
        a.add(27);
        a.add(38);
        a.add(38);
        b = a.iterator();
        while (b.hasNext()) {
            Integer c = b.next();
            System.out.print(c + " ");
        }
    }
}

 

10.修改第8章中的练习9，使其使用一个ArrayList来存放Rodents，并使用一个Iterator来访问Rodent序列。

package job;
import java.awt.*;
import java.util.*;
class Rodent{
    void bit(){};
}
class Mouse extends Rodent{
    @Override
    void bit(){
        System.out.println("Mouse bit");
    }
}
class Gerbil extends Rodent{
    @Override
    void bit(){
        System.out.println("Gerbil bit");
    }
}
class Hamster extends Rodent{
    @Override
    void bit(){
        System.out.println("Hamster bit");
    }
}
public class Main {
    public static void main(String[] args) {
        ArrayList<Rodent> a=new ArrayList<>();
        a.add(new Mouse());
        a.add(new Hamster());
        a.add(new Gerbil());
        Iterator<Rodent>b=a.iterator();
        while (b.hasNext()){
            Rodent c=b.next();
            c.bit();
        }
    }
}

 

11.写一个方法，使用Iterator遍历Collection，并打印容器中每个对象的toString()。填充各种类型的Collection，然后对其使用此方法。

package job;
import java.util.*;
public class Main {
    public static void display(Collection c) {
        Iterator it = c.iterator();
        while (it.hasNext())
            System.out.print(it.next() + " ");
        System.out.println();
    }

    public static void main(String[] args) {
        List<Integer> a = new ArrayList<>(
                Arrays.asList(1, 2, 3)
        );
        display(a);
    }
}

12.创建并组装一个List<Integer>，然后创建第二个具有相同尺寸的List<Integer>，并使用ListIterator读取第一个List中的元素，然后再将它们以反序插入到第二个列表中。

package job;
import java.util.*;
public class Main {
    static List<Integer>a=new ArrayList<>(
            Arrays.asList(1,2,3)
    );
    static List<Integer>b=new ArrayList<>(
            Arrays.asList(4,5,6)
    );
    public static void main(String[] args) {
        ListIterator<Integer>c=a.listIterator(a.size());
        ListIterator<Integer>d=b.listIterator(b.size());
        while (c.hasPrevious()){
            Integer e=c.previous();
            d.add(e);
        }
        for (Integer p:b){
            System.out.print(p+" ");
        }
    }
}

13.在innerclasses/GreenhouseController.java示例中，Controller类使用的是ArrayList，修改代码，用LinkedList替换之，并使用Iterator来循环遍历事件集。

找不到源代码，略。

14.创建一个空的LinkedList<Integer>,通过使用ListIterator，将若干个Integer插入这个List中，插入时，总是将它们插入到List的中间。

package job;
import java.lang.reflect.Array;
import java.util.*;
public class Main {
    public static void main(String[] args) {
       LinkedList<Integer> a=new LinkedList<>(
               Arrays.asList(1,2,3,4)
       );
       ListIterator<Integer>b=a.listIterator();
       a.add(2,5);
       a.add(2,8);
       for(Integer c:a){
           System.out.print(c);
       }
    }
}

15.栈在编程语言中经常用来对表达式求值。请使用net.mindview.util.Stack对下面表达式求值，其中“+”表示“将后面的字母压进栈”，而“-”表示“弹出栈顶字母并打印它”：“+U+n+c—+e+r+t—+a-+i-+n+t+y—+ -+r+u–+l+e+s—”。

package job;
import java.lang.reflect.Array;
import java.util.*;
class Stack<T>{
    private LinkedList<T>storage=new LinkedList<T>();
    public void push(T v){
        storage.addFirst(v);
    }
    public T peek(){
        return storage.getFirst();
    }
    public T pop(){
        return storage.removeFirst();
    }
    public boolean empty(){
        return storage.isEmpty();
    }
    public String toString(){
        return storage.toString();
    }
}
public class Main {
    public static void main(String[] args) {
        Stack<Character> a = new Stack<>();
        String s = "+U+n+c---+e+r+t---+a-+i-+n+t+y---+-+r+u--+l+e+s---";
        char p[] = s.toCharArray();
        for (int i = 0; i < p.length; ) {
            switch (p[i++]) {
                case '+':
                    a.push(p[i++]);
                    break;
                case '-':
                    System.out.println(a.pop());
                    break;
            }
        }
    }
}

 

16.创建一个元音字母Set。对UniqueWords.java操作，计数并显示在每一个输入单词中的元音字母数量，并显示输入文件中的所有元音字母的数量总和。

由于还没学习读写，我只把函数写出来：

static void getnum(Set<String> b) {
        Set<Character> a = new TreeSet<Character>();
        Collections.addAll(a, 'A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u');
        int num = 0;
        for (String s : b) {
            int count = 0;
            for (Character v : s.toCharArray()) {
                if (a.contains(v)) {
                    count++;
                    num++;
                }
            }
            System.out.print(s + ": " + count + ", ");
        }
        System.out.println();
        System.out.print("Total a: " + num);
    }

 

17.使用练习1中的Gerbil类，将其放入Map中，将每个Gerbil的名字String（键）与每个Gerbil（值）关联起来。为keySet()获取Iteratror，使用它遍历Map，针对每个“键”查询Gerbil，然后打印出“键”，并让gerbil执行hop()。

package job;

import java.lang.reflect.Array;
import java.util.*;

class Gerbil{

    int getbilNumber;

    Gerbil(int x){

        getbilNumber=x;

    }

    void hop(){
        System.out.println(getbilNumber);

        System.out.println("jumping");

    }

}

public class Main {
    static Map<String, Gerbil> a = new HashMap<>();

    static {
        a.put("FirstPeople", new Gerbil(2));
        a.put("SeconPeople", new Gerbil(5));
    }

    static Iterator<String> b = a.keySet().iterator();

    public static void main(String[] args) {
        for (String s : a.keySet()) {
            String c = b.next();
            System.out.print(s + " ");
            a.get(c).hop();
        }

    }
}

 

18.用键值对填充一个HashMap。打印结果，通过散列码来展示其排序。抽取这些键值对，按照键进行排序，并将结果置于一个LinkedHashMap中。展示其所维护的插入排序。

package job;

import java.lang.reflect.Array;
import java.util.*;

public class Main {

    public static void main(String[] args) {
        Map<Integer, Integer> a = new HashMap<>();
        a.put(9, 2);
        a.put(5, 6);
        a.put(4,2);
        SortedMap<Integer, Integer> b = new TreeMap<>(a);
        LinkedHashMap<Integer, Integer> c = new LinkedHashMap<>(b);
        for (Integer e : c.keySet()) {
            System.out.println(e+" "+" "+c.get(e));
        }
    }
}

 

19.使用HashSet和LinkedHashSet重复前一个练习。

package job;

import java.lang.reflect.Array;
import java.util.*;

public class Main {

    public static void main(String[] args) {
        Set<Integer> a = new HashSet<>();
        a.add(9);
        a.add(5);
        a.add(4);
        SortedSet<Integer> b = new TreeSet<>(a);
        HashSet<Integer> c = new HashSet<>(b);
        for (Integer e : c) {
            System.out.println(e);
        }
    }
}

package job;

import java.lang.reflect.Array;
import java.util.*;

public class Main {

    public static void main(String[] args) {
        Set<Integer> a = new LinkedHashSet<>();
        a.add(9);
        a.add(5);
        a.add(4);
        SortedSet<Integer> b = new TreeSet<>(a);
        LinkedHashSet<Integer> c = new LinkedHashSet<>(b);
        for (Integer e : c) {
            System.out.println(e);
        }
    }
}

 

20.修改练习16，使得你可以跟踪每一个元音字母出现的次数。

还没学习，略。

21.通过使用Map<String,Integer>，遵循UniqueWords.java的形式来创建一个程序，它可以对一个文件中出现的单词计数。使用带有第二个参数**String.CASE_INSENSITIVE_OREDER的Collection.sort()**方法对结果进行排序（将产生字母序），然后显示结果。

还没学习，略。

22.修改前一个练习，使其用一个包含有一个String域和一个计数域的类来存储每一个不同的单词，并使用一个由这些对象构成的Set来维护单词列表。

还没学习，略。

23.从Statistics.java开始，写一个程序，让它重复做测试，观察是否某个数字比别的数字出现的次数多。

package job;
import java.util.*;
import java.util.Map.Entry;

public class Main {
    public static void main(String[] args) {
        Map<Integer, Integer> numsMap = new HashMap<>();
        Random random = new Random();
        for (int i = 0; i < 10000; i++) {
            Integer key = random.nextInt(30);
            Integer vlue = numsMap.get(key);
            numsMap.put(key, vlue == null ? 1 : vlue + 1);

        }
        List<Entry<Integer, Integer>> a = new ArrayList<Entry<Integer, Integer>>(numsMap.entrySet());
        Collections.sort(a, new Comparator<Entry<Integer, Integer>>() {


            @Override
            public int compare(Entry<Integer, Integer> o1, Entry<Integer, Integer> o2) {
                // TODO Auto-generated method stub
                return o2.getValue() - o1.getValue();
            }
        });
        ;

        for (Entry<Integer, Integer> entry : a) {
            System.out.format("%02d -------------%03d\n", entry.getKey(), entry.getValue());
        }


    }
}

 

24.使用String“键”和你选择的对象填充LinkedHashMap。然后从中提取键值对，以键排序，然后重新插入此Map。

package job;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class Main {
    static LinkedHashMap<String, Integer> a = new LinkedHashMap<>();
    static {
        a.put("Three", 3);
        a.put("Eight", 8);
        a.put("Nine", 9);
        a.put("ten", 10);
        a.put("one", 1);
    }
    public static void main(String[] args) {
        System.out.println(a);
        List<Map.Entry<String, Integer>> b = new ArrayList<Map.Entry<String,Integer>>(a.entrySet());
        Collections.sort(b, new Comparator<Map.Entry<String, Integer>>() {
            public int compare(Entry<String, Integer> c,Entry<String, Integer> d) {
                return c.getKey().compareTo(d.getKey());
            }
        });
        a.clear();
        for(Map.Entry<String, Integer> c:b) {
            a.put(c.getKey(), c.getValue());
        }
        System.out.println(a);
    }
}

 

25.创建一个Map<String,ArrayList<Integer>>，使用net.mindview.TextFile来打开一个文本文件，并一次读入一个单词。在读入单词时对它们进行计数，并且对于文件中的每一个单词，都在ArrayList<Integer>中记录下与这个词相关联的单词计数。实际上，它记录的是该单词在文件中被发现的位置。

还没学习，略。

26.拿到前一个练习中所产生的Map，并按照它们在最初的文件中出现的顺序重新创建单词顺序。

还没学习，略。