Java编程思想（十）持有对象

作者: kaiker | 来源:发表于2022-06-18 10:13 被阅读0次

Java编程思想（十）持有对象
Java编程思想学习笔记(11)
类与对象（1） - Class、Object
Java编程思想——第十一章：持有对象
面向对象编程，类和对象
java的面向对象的三大特性
十年资深架构师以最新的Java技术结合实际项目，诠释编程的艺术
《JAVA编程思想》学习笔记：第11章（持有对象）
25天成为java大神之——对象-类(class)
Java面向对象基本概念

通常，程序总是根据运行时才知道的某些条件取创建新对象。在此之前，不会知道所需对象的数量，甚至不知道确切的类型。Java提供一套完整的容器类来解决这个问题。

1、泛型和类型安全的容器

将元素取出时，类型转换时不需要的，因为List在调用get的时候会执行转型。

public class ApplesAndOrangesWithGenerics {
  public static void main(String[] args) {
    ArrayList<Apple> apples = new ArrayList<Apple>();
    for(int i = 0; i < 3; i++)
      apples.add(new Apple());
    // Compile-time error:
    // apples.add(new Orange());
    for(int i = 0; i < apples.size(); i++)
      System.out.println(apples.get(i).id());
    // Using foreach:
    for(Apple c : apples)
      System.out.println(c.id());
  }
} /* Output:
0
1
2
0
1
2
*///:~

2、基本概念

Java容器类类库用途是保存对象，并将其划分为两个不同的概念：

Collection。一个独立元素的序列，这些元素都服从一条或多条规则。
Map。一组成对的键值对对象，允许你使用键来查找值。

3、添加一组元素

Collections.addAll()接收一个Collection对象，以及一个数组或是一个用逗号分隔的列表。

public class AddingGroups {
  public static void main(String[] args) {
    Collection<Integer> collection =
      new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4, 5));
    Integer[] moreInts = { 6, 7, 8, 9, 10 };
    collection.addAll(Arrays.asList(moreInts));
    // Runs significantly faster, but you can't
    // construct a Collection this way:
    Collections.addAll(collection, 11, 12, 13, 14, 15);
    Collections.addAll(collection, moreInts);
    // Produces a list "backed by" an array:
    List<Integer> list = Arrays.asList(16, 17, 18, 19, 20);
    list.set(1, 99); // OK -- modify an element
    // list.add(21); // Runtime error because the
                     // underlying array cannot be resized.
  }
} ///:~

Arrays.asList 底层表示是数组，不能调整尺寸
使用的时候可以显示指定类型。Arrays.<T>asList();

class Snow {}
class Powder extends Snow {}
class Light extends Powder {}
class Heavy extends Powder {}
class Crusty extends Snow {}
class Slush extends Snow {}

public class AsListInference {
  public static void main(String[] args) {
    List<Snow> snow1 = Arrays.asList(
      new Crusty(), new Slush(), new Powder());

    // Won't compile:
    // List<Snow> snow2 = Arrays.asList(
    //   new Light(), new Heavy());
    // Compiler says:
    // found   : java.util.List<Powder>
    // required: java.util.List<Snow>

    // Collections.addAll() doesn't get confused:
    List<Snow> snow3 = new ArrayList<Snow>();
    Collections.addAll(snow3, new Light(), new Heavy());

    // Give a hint using an
    // explicit type argument specification:
    List<Snow> snow4 = Arrays.<Snow>asList(
       new Light(), new Heavy());
  }
} ///:~

4、容器打印

Arrays.toString来产生数组的可打印表示，但容器打印无需任何帮助

5、List

List承诺可以将元素维护在特定的序列中。
ArrayList，可随机访问元素，在List中间插入较慢。
LinkedList，插入代价低，随机访问慢。

6、迭代器

迭代器提供了一种解耦具体对象类型的遍历方式。
Iterator可以移除由next()产生的最后一个元素，意味着在调用remove()之前必须先调用next()

public class CrossContainerIteration {
  public static void display(Iterator<Pet> it) {
    while(it.hasNext()) {
      Pet p = it.next();
      System.out.print(p.id() + ":" + p + " ");
    }
    System.out.println();
  } 
  public static void main(String[] args) {
    ArrayList<Pet> pets = Pets.arrayList(8);
    LinkedList<Pet> petsLL = new LinkedList<Pet>(pets);
    HashSet<Pet> petsHS = new HashSet<Pet>(pets);
    TreeSet<Pet> petsTS = new TreeSet<Pet>(pets);
    display(pets.iterator());
    display(petsLL.iterator());
    display(petsHS.iterator());
    display(petsTS.iterator());
  }
} /* Output:
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
4:Pug 6:Pug 3:Mutt 1:Manx 5:Cymric 7:Manx 2:Cymric 0:Rat
5:Cymric 2:Cymric 7:Manx 1:Manx 3:Mutt 6:Pug 4:Pug 0:Rat
*///:~

迭代器统一了对容器访问的方式。

ListIterator

可以双向移动。
可以使用set()方法替换它访问过的最后一个元素。

public class ListIteration {
  public static void main(String[] args) {
    List<Pet> pets = Pets.arrayList(8);
    ListIterator<Pet> it = pets.listIterator();
    while(it.hasNext())
      System.out.print(it.next() + ", " + it.nextIndex() +
        ", " + it.previousIndex() + "; ");
    System.out.println();
    // Backwards:
    while(it.hasPrevious())
      System.out.print(it.previous().id() + " ");
    System.out.println();
    System.out.println(pets);   
    it = pets.listIterator(3);
    while(it.hasNext()) {
      it.next();
      it.set(Pets.randomPet());
    }
    System.out.println(pets);
  }
} /* Output:
Rat, 1, 0; Manx, 2, 1; Cymric, 3, 2; Mutt, 4, 3; Pug, 5, 4; Cymric, 6, 5; Pug, 7, 6; Manx, 8, 7;
7 6 5 4 3 2 1 0
[Rat, Manx, Cymric, Mutt, Pug, Cymric, Pug, Manx]
[Rat, Manx, Cymric, Cymric, Rat, EgyptianMau, Hamster, EgyptianMau]
*///:~

7、LinkedList

LinkedList添加了可以使其用作栈、队列或双端队列的方法。
有removeFirtst addFirst peek poll等操作

8、Set

Set具有与Collection完全一样的接口，没有任何额外的功能。

9、Queue

LinkedList提供了方法以支持队列行为，并且它实现了Queue接口，因此可以看做是Queue的一种实现。
offer方法可以在允许的情况下进行插入或返回false。peek和element都将在不移除的情况下返回队头，但是为空时peek返回null，element抛异常；poll() remove()类似，也是一个null，一个抛异常。

PriorityQueue

优先队列声明下一个弹出元素是优先级最高的元素。
默认是个小顶堆

public class PriorityQueueDemo {
  public static void main(String[] args) {
    PriorityQueue<Integer> priorityQueue =
      new PriorityQueue<Integer>();
    Random rand = new Random(47);
    for(int i = 0; i < 10; i++)
      priorityQueue.offer(rand.nextInt(i + 10));
    QueueDemo.printQ(priorityQueue);

    List<Integer> ints = Arrays.asList(25, 22, 20,
      18, 14, 9, 3, 1, 1, 2, 3, 9, 14, 18, 21, 23, 25);
    priorityQueue = new PriorityQueue<Integer>(ints);
    QueueDemo.printQ(priorityQueue);
    priorityQueue = new PriorityQueue<Integer>(
        ints.size(), Collections.reverseOrder());
    priorityQueue.addAll(ints);
    QueueDemo.printQ(priorityQueue);

    String fact = "EDUCATION SHOULD ESCHEW OBFUSCATION";
    List<String> strings = Arrays.asList(fact.split(""));
    PriorityQueue<String> stringPQ =
      new PriorityQueue<String>(strings);
    QueueDemo.printQ(stringPQ);
    stringPQ = new PriorityQueue<String>(
      strings.size(), Collections.reverseOrder());
    stringPQ.addAll(strings);
    QueueDemo.printQ(stringPQ);

    Set<Character> charSet = new HashSet<Character>();
    for(char c : fact.toCharArray())
      charSet.add(c); // Autoboxing
    PriorityQueue<Character> characterPQ =
      new PriorityQueue<Character>(charSet);
    QueueDemo.printQ(characterPQ);
  }
} /* Output:
0 1 1 1 1 1 3 5 8 14
1 1 2 3 3 9 9 14 14 18 18 20 21 22 23 25 25
25 25 23 22 21 20 18 18 14 14 9 9 3 3 2 1 1
       A A B C C C D D E E E F H H I I L N N O O O O S S S T T U U U W
W U U U T T S S S O O O O N N L I I H H F E E E D D C C C B A A
  A B C D E F H I L N O S T U W
*///:~

10、Collection与Iterator

实现Collection就意味着需要提供Iterator()方法。
如果要实现一个不是Collection的外部类，使用Iterator会更好，因为实现Collection步骤比较多。
Iterable接口，有一个iterator方法，可以使用foreach来遍历。

public class IterableClass implements Iterable<String> {
  protected String[] words = ("And that is how " +
    "we know the Earth to be banana-shaped.").split(" ");
  public Iterator<String> iterator() {
    return new Iterator<String>() {
      private int index = 0;
      public boolean hasNext() {
        return index < words.length;
      }
      public String next() { return words[index++]; }
      public void remove() { // Not implemented
        throw new UnsupportedOperationException();
      }
    };
  } 
  public static void main(String[] args) {
    for(String s : new IterableClass())
      System.out.print(s + " ");
  }
} /* Output:
And that is how we know the Earth to be banana-shaped.
*///:~

Collection.shuffle、Arrays.asList()创建的是一个数组实现的List对象，如果原来的数组会修改，则应该另外创建一个副本，比如下面的例子中shuffle修改直接用Arrays.asList生成的List，但是新副本不会被改变。

public class ModifyingArraysAsList {
  public static void main(String[] args) {
    Random rand = new Random(47);
    Integer[] ia = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    List<Integer> list1 =
      new ArrayList<Integer>(Arrays.asList(ia));
    System.out.println("Before shuffling: " + list1);
    Collections.shuffle(list1, rand);
    System.out.println("After shuffling: " + list1);
    System.out.println("array: " + Arrays.toString(ia));

    List<Integer> list2 = Arrays.asList(ia);
    System.out.println("Before shuffling: " + list2);
    Collections.shuffle(list2, rand);
    System.out.println("After shuffling: " + list2);
    System.out.println("array: " + Arrays.toString(ia));
  }
} /* Output:
Before shuffling: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
After shuffling: [4, 6, 3, 1, 8, 7, 2, 5, 10, 9]
array: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Before shuffling: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
After shuffling: [9, 1, 6, 3, 7, 2, 5, 10, 4, 8]
array: [9, 1, 6, 3, 7, 2, 5, 10, 4, 8]
*///:~

Java编程思想（十）持有对象
通常，程序总是根据运行时才知道的某些条件取创建新对象。在此之前，不会知道所需对象的数量，甚至不知道确切的类型。Ja...
Java编程思想学习笔记(11)
Java编程思想学习笔记(11) 持有对象通常，程序总是根据运行时才知道的某些条件去创建新对象，在此之前，不会知...
类与对象（1） - Class、Object
面向对象编程思想 Java开发是利用面向对象的思想实现面向过程的开发。面向对象编程（OOP：Object...
Java编程思想——第十一章：持有对象
容器提供完善的方法来保存对象，还拥有一些特性。Java容器类都可以自动地调整自己的尺寸。 1.泛型和类型安全的容器...
面向对象编程，类和对象
面向对象编程 Java是面向对象的一门编程语言，所以余姚使用者具备面向对象编程的思想。那么，什么是面向对象编程呢...
java的面向对象的三大特性
1、面向对象思想面向对象编程是当今主流的程序设计思想，已经取代了过程化程序开发技术，Java 是完全面向对象编程...
十年资深架构师以最新的Java技术结合实际项目，诠释编程的艺术
《Java面向对象编程(第2版)》的组织结构和主要内容本书以6条主线贯穿全书:面向对象编程思想、Java语言的语...
《JAVA编程思想》学习笔记：第11章（持有对象）
第十一章、持有对象 Java容器架构图： 11.1 迭代器（Iterator） Iterator迭代器...
25天成为java大神之——对象-类(class)
java学习贵在坚持 1:面向对象思想(理解) (1)面向对象是基于面向过程的一种编程思想 (2)思想特点： A:...
Java面向对象基本概念
大家都知道Java是面向对象的编程语言，掌握面向对象的思想是掌握java这门编程语言的关键所在，下面就来谈谈我对于...

Java编程思想（十）持有对象

1、泛型和类型安全的容器

2、基本概念

3、添加一组元素

4、容器打印

5、List

6、迭代器

ListIterator

7、LinkedList

8、Set

9、Queue

PriorityQueue

10、Collection与Iterator

相关文章

Java编程思想（十）持有对象

Java编程思想学习笔记(11)

类与对象（1） - Class、Object

Java编程思想——第十一章：持有对象

面向对象编程，类和对象

java的面向对象的三大特性

十年资深架构师以最新的Java技术结合实际项目，诠释编程的艺术

《JAVA编程思想》学习笔记：第11章（持有对象）

25天成为java大神之——对象-类(class)

Java面向对象基本概念

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Java编程思想（十） 持有对象

1、泛型和类型安全的容器

2、基本概念

3、添加一组元素

4、容器打印

5、List

6、迭代器

ListIterator

7、LinkedList

8、Set

9、Queue

PriorityQueue

10、Collection与Iterator

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Java编程思想（十）持有对象