学号 20175216 《Java程序设计》第八周学习总结

• Z时代
• 2024-01-10
• 分类：综合

学号 20175216 《Java程序设计》第八周学习总结

第九章 Collection与Map

9.1 使用Collection收集对象

收集对象的行为，像是新增对象的add（）方法、移除对象的remove（）方法等，都是定义在java.util.Collection中。既然可以收集对象，也要能逐一取得对象，这就是java.lang.Iterable定义的行为，它定义了iterator()方法返回java.lang.Iterable操作对象，可以让你逐一取得收集的对象。

收集对象的共同行为定义在Collection中，然而收集对象会有不同的需求。如果希望收集时记录每个对象的索引顺序，并可依索引取回对象，这样的行为定义在java.util.List接口中。如果希望收集的对象不重复，具有集合的行为，则由java.util.Set定义。如果希望收集对象时以队列方式，收集的对象加入至尾端，取得对象时从前端，则可以使用java.util.Queue。如果希望Queue的两端进行加入、移除等操作,则可以使用java.util.Deque。

List是一种Collection,作用是收集对象，并以索引方式保留收集的对象顺序，其操作类之一是java.util.ArrayList。如：

import java.util.*;
import static java.lang.System.out;
public class Guest
{
    public static void main(String[] args)
    {
        List names = new java.util.ArrayList();
        collectNameTo(names);
        out.println("訪客名單：");
        printUpperCase(names); 
    }
    static void collectNameTo(List names) 
    {
        Scanner console = new Scanner(System.in);
        while(true)
        {
            out.print("訪客名稱：");
            String name = console.nextLine();
            if(name.equals("quit")) 
            {
                break;
            }
            names.add(name);
        }
    }
    static void printUpperCase(List names)
    {
        for(int i = 0; i < names.size(); i++) 
        {
           String name = (String) names.get(i);
            out.println(name.toUpperCase());
        }        
    }        
}

数组在内存中会是连续的线性空间，根据索引随机存取时速度快，如果操作上有这类需求时，像是排序，就可使用ArrayList，可得到较好的速度表现。

LinkedList在操作List接口时，采用了链接（Link）结构。

若收集的对象经常会有变动索引的情况，也许考虑链接方式操作的List会比较好，像是随时会有客户端登录或注销的客户端List，使用LinkedList会有比较好的效率。

在收集过程中若有相同对象，则不再重复收集，如果有这类需求，可以使用Set接口的操作对象。如：

import java.util.*;
public class WordCount
{
    public static void main(String[] args) 
    {
        Scanner console = new Scanner(System.in);
        System.out.print("請輸入英文：");
        Set words = tokenSet(console.nextLine());
        System.out.printf("不重複單字有 %d 個：%s%n", words.size(), words);
    }
    static Set tokenSet(String line)
    {
        String[] tokens = line.split(" ");
        return new HashSet(Arrays.asList(tokens));
    }
}

HashSet的操作概念是，在内存中开设空间，每个空间会有个哈希编码。

Queue继承自Collection，所以也具有Collection的add()、remove()、element()等方法，然而Queue定义了自己的offer()、poll()与peek()等方法，最主要的差别之一在于：add()、remove()、element()等方法操作失败时会抛出异常，而offer()、poll()与peek()等方法操作失败时会返回特定值。

如果对象有操作Queue，并打算以队列方式使用，且队列长度受限，通常建议使用offer()、poll()与peek()等方法。

LinkedList不仅操作了List接口，与操作了Queue的行为，所以可以将LinkedList当作队列来使用。如：

import java.util.*;
interface Request 
{
    void execute();
}
public class RequestQueue
{        
    public static void main(String[] args)
   {
        Queue requests = new LinkedList();
        offerRequestTo(requests);
        process(requests);
    }
    static void offerRequestTo(Queue requests)
    {
        for (int i = 1; i < 6; i++) 
        {
            Request request = new Request()
            {
                public void execute() 
                {
                    System.out.printf("處理資料 %f%n", Math.random());
                }
            };
            requests.offer(request);
        }
    }
    static void process(Queue requests) 
    {
        while(requests.peek() != null)
        {
            Request request = (Request) requests.poll();
            request.execute();
        }
    }
}

想对队列的前端与尾端进行操作，在前端加入对象与取出对象，在尾端加入对象与取出对象，Queue的子接口Deque就定义了这类行为。

java.util.ArrayDeque操作了Deque接口，可以使用ArrayDeque来操作容量有限的堆栈。

泛型语法：类名称旁有角括号<>，这表示此类支持泛型。实际加入的对象是客户端声明的类型。如：

import java.util.Arrays;
public class ArrayList<E>
{
     Object[] elems;
    private int next;
   public ArrayList(int capacity)
   {
        elems = new Object[capacity];
   }        
   public ArrayList()
   {
        this(16);
   }
   public void add(E e)
   {
        if(next == elems.length) 
        {
            elems = Arrays.copyOf(elems, elems.length * 2);
        }
        elems[next++] = e;
   }
   public E get(int index)
   {
        return (E) elems[index];
   }
   public int size()
   {
        return next;
   }
}

相对于匿名类语法来说，Lambda表达式的语法省略了接口类型与方法名称，->左边是参数列，而右边是方法本体。

在Lambda表达式中使用区块时，如果方法必须有返回值，在区块中就必须使用return。

interator()方法提升至新的java.util.Iterable父接口。

Collections的sort（）方法要求被排序的对象必须操作java.lang.Comparable接口，这个接口有个compareTo（）方法必须返回大于0、等于0或小于0的数。

Collections的sort（）方法有另一个重载版本，可接受java.util.Comparator接口的操作对象，如果使用这个版本，排序方式将根据Comparator的compare（）定义来决定。如：

import java.util.*;
class StringComparator implements Comparator<String> 
{        
    @Override
    public int compare(String s1, String s2)
    {
        return -s1.compareTo(s2);
    }
}
public class Sort5
{
    public static void main(String[] args) 
    {
        List<String> words = Arrays.asList("B", "X", "A", "M", "F", "W", "O");
        Collections.sort(words, new StringComparator());
       System.out.println(words);
   }
}

在java的规范中，与顺序有关的行为，通常要不对象本身是Comparable，要不就是另行指定Comparator对象告知如何排序。

若要根据某个键来取得对应的值，可以事先利用java.util.Map接口的操作对象来建立键值对应数据，之后若要取得值，只要用对应的键就可以迅速取得。常用的Map操作类为java.util.HashMap与java.util.TreeMap，其继承自抽象类java.util.AbstractMap。

Map也支持泛型语法，如使用HashMap的范例：如：

import java.util.*;
import static java.lang.System.out;
public class Messages 
{
    public static void main(String[] args) 
    {
        Map<String, String> messages = new HashMap<>();
        messages.put("Justin", "Hello！Justin的訊息！");
        messages.put("Monica", "給Monica的悄悄話！");
        messages.put("Irene", "Irene的可愛貓喵喵叫！");
        Scanner console = new Scanner(System.in);
       out.print("取得誰的訊息：");
        String message = messages.get(console.nextLine());
        out.println(message);
        out.println(messages);
    }
}

如果使用TreeMap建立键值对应，则键的部分则会排序，条件是作为键的对象必须操作Comparable接口，或者是在创建TreeMap时指定操作Comparator接口的对象。如：

import java.util.*;
public class Messages2 
{
    public static void main(String[] args) 
    {
        Map<String, String> messages = new TreeMap<>(); 
        messages.put("Justin", "Hello！Justin的訊息！");
        messages.put("Monica", "給Monica的悄悄話！");
        messages.put("Irene", "Irene的可愛貓喵喵叫！");
        System.out.println(messages);
    }        
}

Properties类继承自Hashtable，HashTable操作了Map接口，Properties自然也有Map的行为。虽然也可以使用put（）设定键值对应、get（）方法指定键取回值，不过一般常用Properties的setProperty（）指定字符串类型的键值，getProperty（）指定字符串类型的键，取回字符串类型的值，通常称为属性名称与属性值。

如果想取得Map中所有的键，可以调用Map的keySet（）返回Set对象。由于键是不重复的，所以用Set操作返回是理所当然的做法，如果想取得Map中所有的值，则可以使用values（）返回Collection对象。如：

import java.util.*;
import static java.lang.System.out;
public class MapKeyValue 
{
    public static void main(String[] args)
    {               
        Map<String, String> map = new HashMap<>();
        map.put("one", "一");
        map.put("two", "二");
        map.put("three", "三");
        out.println("顯示鍵");
        map.keySet().forEach(key -> out.println(key));
        out.println("顯示值");
        map.values().forEach(key -> out.println(key));
    }
}

如果想同时取得Map的键与值，可以使用entrySet（）方法，这会返回一个Set对象，每个元素都是Map.Entry实例。可以调用getKey（）取得键，调用getValue（）取得值。如：

import java.util.*;
public class MapKeyValue2
{
    public static void main(String[] args) 
    {
        Map<String, String> map = new TreeMap<>();
        map.put("one", "一");
        map.put("two", "二");
        map.put("three", "三");
        foreach(map.entrySet());
    }
    static void foreach(Iterable<Map.Entry<String, String>> iterable)
    {
        for(Map.Entry<String, String> entry: iterable)
        {
            System.out.printf("(鍵 %s, 值 %s)%n", 
                    entry.getKey(), entry.getValue());
        }
    }
}

其他（感悟、思考等，可选）

虚拟机一定记得备份，否则虚拟机崩了之后就会丢失，非常麻烦。

在学习教材的时候，发现其实自己编一遍代码与对着书编代码还是有很大区别的，自己编一遍的话，会发现很多只对着书编所察觉不到的细节，而这些细节也正是我们全面认识这个代码的关键点所在

学习进度条

• 计划学习时间:15小时

• 实际学习时间:13小时

• 改进情况：
  

  这周学习了第九章知识，通过运行代码明白各代码的具体含义，体会到了娄老师上课一直提到的“做中学，学中做”。

参考资料

• Java学习笔记(第8版)

• 《Java学习笔记(第8版)》学习指导

以上是 学号 20175216 《Java程序设计》第八周学习总结 的全部内容， 来源链接： utcz.com/z/394668.html