Thinking in Java：第十一章-持有对象

最新推荐文章于 2024-11-13 00:33:15 发布

原创最新推荐文章于 2024-11-13 00:33:15 发布 · 318 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Java #容器 #持有对象

Think In Java 专栏收录该内容

18 篇文章

订阅专栏

本文探讨了Java容器类的特性，包括自动调整尺寸、数组与容器的区别、List与队列的操作方式，以及Map的不同实现形式。此外，还介绍了迭代器与foreach循环的应用场景，并通过实例展示了如何实现自定义可迭代类。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1：java容器类都可以自动的调整自己的尺寸。因此，与数组不同，可以将任意数目的对象放置到容器中。

2：程序的输出是从Object默认的toString()方法产生的，该方法打印类名，后面跟随该对象的散列码的无符号十六进制表示。（看看源码就知道了）。

3：Arrays.asLlist() 方法接受一个数组或是一个用逗号分隔的元素列表，并将其转换为一个List对象，Collections.addAll(),接受一个Collection对象，以及一个数组或者一个用逗号分隔的元素列表，将元素添加到Collection对象中。

4：优化是一个很复杂的问题，最好的策略就是置之不理，直到你发现需要担心它了。

5：toArray()方法允许将任意的Collection对象转换为一个数组，这是一个重载方法，其无参数版本返回的是Object数组，也可以向这个方法传递目标类型的数据，那么它将产生指定类型的数据。

Pet[] o = pets.toArray(new Pet);

ListFeatures

/**
 * Arrays.asList产生的List对象会使用底层数组作为其物理实现。只要执行的操作会修改这个List，
 * 并且不希望原来的数组被修改，那么就应该建立一个副本
 */
// p223

public class ListFeatures {

    public static void main(String[] args) {

        String[] arr = "this is a good god".split(" ");
        List<String> lists = Arrays.asList(arr);

        String[] strings = lists.toArray(new String[1]);
        System.out.println(strings.length);

        //不允许这样操作
        //lists.remove(1);
        //lists.add("key");

        Collections.shuffle(lists);

        // 对lists的修改反映到了原数组arr中
        System.out.println(arr.length);
        for (int i = 0; i < arr.length; i ++) {
            System.out.println(arr[i]);
        }
    }
}

6：ListItetator是一个更加强大的Iterator 的子类型，它只能用于各种List 类的访问，尽管Iterator只能向前移动，但是ListItetator可以双向移动。它还可以产生相对于迭代器在列表中指向的当前位置的前一个和后一个元素的索引。

ListIteratorDemo:

public class ListIteratorDemo {

    public static void main(String[] args) {
        List<String> lists = Arrays.asList("this is a good god".split(" "));

        ListIterator<String> iterator = lists.listIterator();

        System.out.println("正序");
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        System.out.println("反序");
        while (iterator.hasPrevious()) {
            System.out.println(iterator.previous());
        }

        iterator = lists.listIterator(3);

        System.out.println(iterator.next());

    }
}

7:队列常被当作一种可靠的将对象从程序的某个区域传输到另一个区域的途径（并发编程中用到）。

8：像数组一样，List也建立数字索引与对象的关联，因此，数组和List都是排好序的容器，List能够自动扩充容量。

9：如果要进行大量随机访问，就是用ArrayList，如果经常从表间插入或者删除元素就使用LinkedList

10：各种Queue以及栈的行为，由LinkedList提供支持。

11：Map是一种将对象与对象相关联的设计，HashMap设计用来快速访问，TreeMap（使用红黑树来实现保持“键”始终处于排序状态），所以没有HashMap快，LinkedHashMap保持元素插入的顺序，但是也通过散列提供快速访问的能力。

12：Foreach与迭代器

/**
 * 这里的foreach之所以能够工作，是因为java se5 引入了新的被称为Iterable的接口，
 * 该接口包含一个能够产生Iterator 的 iterator() 方法, 并且Iterable 接口被foreach用来在
 * 序列中移动，如果创建了任何实现了Iterable的类，都有可以使用foreach语法。
 */
public class ForEachCollections {

    public static void main(String[] args) {
        Collection<String> cs = new LinkedList<>();

        Collections.addAll(cs, "take me to your heart".split(" "));

        for (String c : cs) {
            System.out.println(c);
        }
    }
}

/**
 * 这里的foreach之所以能够工作，是因为java se5 引入了新的被称为Iterable的接口，
 * 该接口包含一个能够产生Iterator 的 iterator() 方法, 并且Iterable 接口被foreach用来在
 * 序列中移动，如果创建了任何实现了Iterable的类，都有可以使用foreach语法。
 */
public class IterableClass implements Iterable<String> {

    protected String input;

    protected String[] words;

    public IterableClass() {}

    public IterableClass(String input) {
        this.input = input;
        words = (input).split(" ");
    }

    // 匿名内部类
    public Iterator<String> iterator() {
        return new Iterator<String>() {

            private int index;
            @Override
            public boolean hasNext() {
                return index < words.length;
            }

            @Override
            public String next() {
                return words[index ++];
            }

            @Override
            public void remove() {
                throw new UnsupportedOperationException("不支持的操作");
            }
        };
    }

    public static void main(String[] args) {
        IterableClass it = new IterableClass("that is how i want to do");

        for (String s : it) {
            System.out.println(s);
        }
        
        System.out.println("第二种调用");
        Iterator iterator = it.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

/**
 * Created by ivalue on 2017/12/23.
 */
public class MultiIterableClass extends IterableClass {

    public MultiIterableClass(String input) {
        super(input);
    }

    public Iterable<String> reversed() {
      return new Iterable<String>() {
          @Override
          public Iterator<String> iterator() {
              return new Iterator<String>() {

                  int current = words.length - 1;

                  @Override
                  public boolean hasNext() {
                      return (current > -1);
                  }

                  @Override
                  public String next() {
                      return words[ current --];
                  }

                  public void remove() {
                      throw new UnsupportedOperationException("...");
                  }
              };
          }
      };
    }


    public static void main(String[] args) {
        MultiIterableClass mtc = new MultiIterableClass("dose it very ok ?");

        for (String s : mtc) {
            System.out.println(s);
        }

        System.out.println("取反");
        for (String s : mtc.reversed()) {
            System.out.println(s);
        }

        System.out.println("第二种调用");

        Iterator iterator = mtc.reversed().iterator();

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

    }
}