cs61b笔记 6.1-6.4

Java有内置的数据结构，不需要我们从头构建，只要套用即可。

我们从头开始构建了一个列表，但是 Java 提供了一个内置的 List 接口和几个实现，例如 数组列表。

通过import java.util.List 和 import java.util.ArrayList 我们可以使代码更加紧凑

Java List（列表）

• add(value) 向set里添加value（如果value不存在）
• contains(value) 检查ArraySet里是否含value
• size() 返回value的个数。

我们从零开始创建了一个 list，但 Java 提供了一个内置的 List 接口和多个实现，例如 ArrayList。请记住，由于 List 是一个接口，我们不能将其实例化！我们必须实例化其实现之一。

要访问它，我们可以使用类、接口的全名（"规范名"）：

java.util.List<Integer> L = new java.util.ArrayList<>()；
不过，这样做有点啰嗦。与导入 JUnit 的方式类似，我们也可以导入 java 库：

//使用了ArrayList创建一个动态数组（又称数组列表）的实例。
import java.util.List;
import java.util.ArrayList;

public class BuiltInListExample
{
    public static void main(String[] args)
    {
        List<Integer> L = new ArrayList<>();
        L.add(5);
        L.add(10);
        L.add(15);
        System.out.println(L);
    }
}

Java Set

set里不能添加相同的事物两次，并且set内部元素没有顺序。

Java 有集合接口和实现，如 HashSet。如果不想使用全名，请记住导入它们！

import java.util.Set;
import java.util.HashSet;

使用示例：

Set<String> s = new HashSet<>();
s.add("Tokyo");
s.add("Lagos");
System.out.println(S.contains("Tokyo")); //true

ArraySet

老师的代码：

import java.util.Iterator;

public class ArraySet<T> implements Iterable<T> {
    private T[] items;
    private int size; // the next item to be added will be at position size

    public ArraySet() {
        items = (T[]) new Object[100];
        size = 0;
    }

    /* Returns true if this map contains a mapping for the specified key.
     */
    public boolean contains(T x) {
        for (int i = 0; i < size; i += 1) {
            if (items[i].equals(x)) {
                return true;
            }
        }
        return false;
    }

    /* Associates the specified value with the specified key in this map. */
    public void add(T x) {
        if (contains(x)) {
            return;
        }
        items[size] = x;
        size += 1;
    }

    /* Returns the number of key-value mappings in this map. */
    public int size() {
        return size;
    }
}

Throwing Exceptions

程序出现错误后，系统会自动抛出异常；此外，Java也允许程序自行抛出异常，自行抛出异常使用throw语句来完成。

throw ExceptionInstance;

例如：throw new Exception("坐标点有棋了");

当 Java运行时接收到开发者自行抛出的异常是，会中止当前的执行流，跳到该异常对应的catch块来处理该异常。即不管是系统抛出的异常还是程序员手动抛出的异常，Java运行时对异常的处理没有任何差异。

Iteration迭代

前言：遍历集合的三种方法

1. for loop

for (int i = 0, len = strings.size(); i < len; i++) {
    System.out.println(strings.get(i));
}

2. for-each循环

for (String var : strings) {
    System.out.println(var);
}

3. Iterator

Iterator iterator = strings.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

for循环我们很熟悉了，就是根据下标来获取元素，这个特性与数组十分吻合；
foreach则主要对类似链表的结构提供遍历支持，链表没有下标，所以使用for循环遍历会大大降低性能。
Iterator 就是我们今天要讲述的主角，它实际上就是foreach。

加强型的for循环

String[] cars = {"Volvo", "B", "Ford", "Mazda"};
for(String i : cars)
{
    System.out.println(i);
}

可以看到运行时i从数组cars的第0个开始遍历一直到最后一个。

上面的例子可以这样理解：打印cars数组中的每个字符串元素（索引为i）的索引值。

这种循环也叫for-each循环，它不需要计数器（使用Length属性），而且可读性更强。

其中i可以在循环体内调用。并且cars的位置必须是一个数组。

Iterator

Java迭代器（Iterator）是 Java 集合框架中的一种机制，是一种用于遍历集合（如列表、集合和映射等）的接口。

它提供了一种统一的方式来访问集合中的元素，而不需要了解底层集合的具体实现细节。

迭代器接口定义了几个方法，最常用的是以下三个：

• next() - 返回迭代器的下一个元素，并将迭代器的指针移到下一个位置。

• hasNext() - 用于判断集合中是否还有下一个元素可以访问。

• remove() - 从集合中删除迭代器最后访问的元素（可选操作）。

Iterator 类位于 java.util 包中，使用前需要引入它，语法格式如下：

import java.util.Iterator; // 引入 Iterator 类

通过使用迭代器，我们可以逐个访问集合中的元素，而不需要使用传统的 for 循环或索引。这种方式更加简洁和灵活，并且适用于各种类型的集合。

// 引入 ArrayList 和 Iterator 类
import java.util.ArrayList;
import java.util.Iterator;

public class RunoobTest {
    public static void main(String[] args) {

        // 创建集合
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");

        // 获取迭代器
        Iterator<String> it = sites.iterator();

        // 输出集合中的第一个元素
        System.out.println(it.next());
    }
}

oracle官网上的：

注意Iterator和Iterable不是一个概念的，使用的时候不要搞混。 

Java中的Iterable与Iterator详解https://www.cnblogs.com/litexy/p/9744241.html

Object Method （对象方法）

继承

注意Java不支持多继承，但支持多重继承。

toString()

toString() 方法提供了一个对象的字符串表示。无论传递给 System.out.println() 函数的是什么对象，该函数都会隐式调用该方法，并打印返回的字符串。当你运行 System.out.println(dog) 时，它实际上就是在做这件事：

String s = dog.toString();

System.out.println(s);

默认对象类的 toString() 方法会打印对象在内存中的位置。这是一个十六进制字符串。Arraylist 和 java 数组等类都有自己的 toString() 方法的改版版本。这就是为什么在使用 Arraylist 和编写 Arraylist 测试时，错误总是以如下格式返回列表（1, 2, 3, 4），而不是返回内存位置。

对于我们自己编写的类，如 ArrayDeque、LinkedListDeque 等，如果我们想看到以可读格式打印的对象，就需要提供自己的 toString() 方法。

注：@Override表示重写。一方面可以当注释用，方便阅读；另一方面可以让编译器给我们验证@Override下面的方法名是否是父类所有的，如果没有就会报错。以防止你打方法名的时候打错了而导致创建了一个新方法。