为您推荐:
精华内容
最热下载
问答
  • 5星
    937KB weixin_44573410 2021-03-08 22:08:34
  • 5星
    836KB weixin_44573410 2021-01-22 14:12:43
  • 5星
    170KB weixin_44573410 2021-02-05 20:58:39
  • 3星
    949KB weixin_44573410 2021-02-05 20:52:44
  • 5星
    258KB m0_52957036 2020-11-03 07:27:01
  • 5星
    2.9MB Primo_ 2021-02-12 01:24:01
  • 5星
    19.68MB wojiaochengxiaozi 2021-08-05 15:33:23
  • 5星
    20.1MB weixin_43959833 2021-06-25 14:26:08
  • 5星
    1.51MB weixin_44573410 2021-02-20 15:06:09
  • 5星
    13.84MB weixin_44573410 2021-02-06 22:11:19
  • 4星
    9.32MB u012822661 2019-01-08 15:28:41
  • 64.47MB richard1997 2019-03-08 15:04:05
  • 3星
    45.84MB white_water 2018-10-24 15:46:56
  • 9.42MB u013076574 2019-08-22 23:26:43
  • sakura392 2021-04-22 10:45:44
  • 5星
    132.15MB weixin_41679316 2018-06-29 10:37:38
  • java 核心技术第11版 集合java集合框架集合接口与实现分离Collection接口迭代器泛型实用方法API集合框架中的接口链表API数组列表散列集API树集API队列与双端队列API优先队列API映射基本映射操作API更新映射条目映射...

    java集合框架

    集合接口与实现分离

    java集合类库将接口与实现(implementation)分离

    队列通常有两种实现方式, 一种是使用循环数组, 一种是使用链表。

    可以使用接口类型存放集合引用

    Queue<Customer> expressLane = new CircularArrayQueue<>(100);
    expressLane.add(new Customer("Harry"));
    

    循环数组容量有限

    API文档中有一组以Abstract开头的类, 这些类是为类库实现者设计的, 若想要实现自己的队列类, 扩展AbstractQueue类比实现Queue接口中所有方法轻松得多

    Collection接口

    集合类的基本接口是Collection接口

    public interface Collection<E>
    {
        boolean add(E element);
        Iterator<E> iterator();
        ...
    }
    

    迭代器

    Iterator接口包含四个方法

    public interface Iterator<E>
    {
        E next();
        boolean hasNext();
        void remove();
        default void forEachRemaining(Consumer<? super E> action);
    }
    

    使用next方法可以诸葛访问集合中的元素, 若到达集合末尾, 则抛出一个NoSuchElementException。

    Collection<String> c = ...;
    Iterator<String> iter = c.iterator();
    while (iter.hasNext())
    {
        String element = iter.next();
        do something with element
    }
    

    for each循环更加简练

    for (String element: c)
    {
        do something with element
    }
    

    也可以调用forEachRemaining方法, 其将对每一个元素调用Iambda表达式

    iterator.forEachRemaining(element -> do something with the element);
    

    可以将Iterator.next与Inputstream.read看成等效的。

    remove会删除上次调用next时返回的元素

    Iterator<String> it = c.iterator();
    it.next();
    it.remove();
    

    若想删除两个相邻的元素

    it.remove();
    it.next();
    it.remove();
    

    泛型实用方法

    可以编写任何处理集合类型的实用方法

    public static <E> boolean contains(Collection<E> c, Object obj)
    {
        for (E element : c)
        {
            if (element.equals(obj))
                return true;
        }
        return false;
    }
    

    Collection接口声明了很多有用的方法, 所有实现类都必须提供这些方法

    AbstractCollection类保持基础方法size和iterator仍为抽象方法, 但是为实现者实现了其他例行方法

    public abstract class AbstractCollection<E>
        implements Collection<E>
    {
        ...
        public abstract Iterator<E> iterator();
        
        public boolean contains(Object obj)
        {
            for (E element: this) // calls iterator()
                if(element.equals(obj))
                    return true;
            return false;
        }
        ...
    }
    

    Collection接口还有一个很好用的方法

    default boolean removeIf(Predicate<? super E> )
    

    API

    java.util.Collection

    • Iterator<E>
      iterator()
      

      Returns an iterator over the elements in this collection.

    • int
      size()
      

      Returns the number of elements in this collection.

    • boolean
      isEmpty()
      

      Returns true if this collection contains no elements.

    • boolean
      contains(Object o)
      

      Returns true if this collection contains the specified element.

    • boolean
      containsAll(Collection<?> c)
      

      Returns true if this collection contains all of the elements in the specified collection.

    • boolean
      add(E e)
      

      Ensures that this collection contains the specified element (optional operation).

    • boolean
      addAll(Collection<? extends E> c)
      

      Adds all of the elements in the specified collection to this collection (optional operation).

    • boolean
      remove(Object o)
      

      Removes a single instance of the specified element from this collection, if it is present (optional operation).

    • boolean
      removeAll(Collection<?> c)
      

      Removes all of this collection’s elements that are also contained in the specified collection (optional operation).

    • default boolean
      removeIf(Predicate<? super E> filter)
      

      Removes all of the elements of this collection that satisfy the given predicate.

    • void
      clear()
      

      Removes all of the elements from this collection (optional operation).

    • boolean
      retainAll(Collection<?> c)
      

      Retains only the elements in this collection that are contained in the specified collection (optional operation).

    • Object[]
      toArray()
      

      Returns an array containing all of the elements in this collection.

    • <T> T[]
      toArray(T[] a)
      

      Returns an array containing all of the elements in this collection; the runtime type of the returned array is that of the specified array.

    java.util.Iterator< E >

    • default void
      forEachRemaining(Consumer<? super E> action)
      

      Performs the given action for each remaining element until all elements have been processed or the action throws an exception.

    • boolean
      hasNext()
      

      Returns true if the iteration has more elements.

    • E
      next()
      

      Returns the next element in the iteration.

    • default void
      remove()
      

      Removes from the underlying collection the last element returned by this iterator (optional operation).

    集合框架中的接口

    集合有两个基本接口: Collection和Map

    映射用put方法插入

    V put (K key, V value)
    

    读取使用get方法

    V get (K key)
    

    List是一个有序集合(ordered collection)。

    List定义了多个随机访问的方法

    void add(int index, E element)
    void remove (int index)
    E get (int index)
    E set (int index, E element)
    

    ListIterator接口定义了一个方法用于在迭代器前面增加一个元素

    void add(E element)
    

    Set等同于Collection接口, 不过其方法定义更加严格。

    SortedSet和SortedMap接口会提供用于排序的比较器对象, 这两个接口定义了可以得到集合子集视图的方法

    接口NavigableSet和NabigableMap中包含一些用于搜索和遍历有序集和映射的方法, TreeSet和TreeMap实现了这些接口

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BeBKOlOU-1625927053107)(E:\学习笔记\java\java核心技术 第11版\image-20210609193454664.png)]

    链表

    java中所有链表都是双向链接的

    var staff = new LinkedList<String>();
    staff.add("Amy");
    staff.add("Bob");
    staff.add("Carl");
    Iterator<String> iter = staff.iterator();
    String first = iter.next();
    String second = iter.next();
    iter.remove();		//remove last visited element
    

    集合类库提供ListIterator子接口, 包含add方法

    interface ListIterator<E> extends Iterator<E>
    {
        void add(E element);
        ...
    }
    

    还有两个方法用来反向遍历链表

    E previous()
    boolean hasPrevious()
    

    声明迭代器如下:

    ListIterator<String> iter = staff.listIterator();
    
    var staff = new LinkedList<String>();
    staff.add("Amy");
    staff.add("Bob");
    staff.add("Carl");
    ListIterator<String> iter = staff.listIterator();
    iter.next();
    iter.add("Juliet");
    

    set方法用一个新元素替换调用next或prevoius方法返回的上一个元素

    LIstIterator<String> iter = list.listIterator();
    String oldValue = iter.next();
    iter.set(newValue);
    

    当一个迭代器发现其集合被另一个迭代器修改, 或该集合自身某个方法修改, 会抛出ConcurrentModificationException异常

    List<String> list = ...;
    ListIterator<String> iter1 = list.listIterator();
    LIstIterator<String> iter2 = list.listIterator();
    iter1.next();
    iter2.remove();
    iter2.next();		//throws ConcurrentModificationException
    

    有一种简单的方法检测并发修改:

    集合可以跟踪更改操作的次数, 每个迭代器都会为它负责的更改操作维护一个单独的更改操作数。每个迭代器方法的开始处检查它自己的更改操作数是否和集合的更改操作数相等, 若不一致, 抛出一个ConcurrentModificationException

    nextIndex和previousIndex方法返回元素的整数索引

    package linkedList;
    
    import java.util.*;
    
    /**
     * This program demonstrates operations on linked lists.
     * @author Cay Horstmann
     */
    
     public class LinkedListTest
     {
        public static void main(String[] args) {
            var a = new LinkedList<String>();
            a.add("Amy");
            a.add("Carl");
            a.add("Erica");
    
            var b = new LinkedList<String>();
            b.add("Bob");
            b.add("Doug");
            b.add("Frances");
            b.add("Gloria");
    
            //merge the words from b into a
    
            ListIterator<String> aIter = a.listIterator();
            Iterator<String> bIter = b.iterator();
    
            while (bIter.hasNext())
            {
                if(aIter.hasNext()) aIter.next();
                aIter.add(bIter.next());
            }
    
            System.out.println(a);
    
            //remove every second word from b
    
            bIter = b.iterator();
    
            while(bIter.hasNext())
            {
                bIter.next();
                if(bIter.hasNext())
                {
                    bIter.next();
                    bIter.remove();
                }
            }
    
            System.out.println(b);
    
            //bulk operation: remove all words in b from a
            a.removeAll(b);
            System.out.println(a);
        }
     }
    

    API

    java.util.List< E >

    • ListIterator<E>
      listIterator()
      

      Returns a list iterator over the elements in this list (in proper sequence).

    • ListIterator<E>
      listIterator(int index)
      

      Returns a list iterator over the elements in this list (in proper sequence), starting at the specified position in the list.

    • void
      add(int index, E element)
      

      Inserts the specified element at the specified position in this list (optional operation).

    • boolean
      add(E e)
      

      Appends the specified element to the end of this list (optional operation).

    • boolean
      addAll(int index, Collection<? extends E> c)
      

      Inserts all of the elements in the specified collection into this list at the specified position (optional operation).

    • boolean
      addAll(Collection<? extends E> c)
      

      Appends all of the elements in the specified collection to the end of this list, in the order that they are returned by the specified collection’s iterator (optional operation).

    • boolean
      remove(Object o)
      

      Removes the first occurrence of the specified element from this list, if it is present (optional operation).

    • E
      get(int index)
      

      Returns the element at the specified position in this list.

    • E
      set(int index, E element)
      

      Replaces the element at the specified position in this list with the specified element (optional operation).

    • int
      indexOf(Object o)
      

      Returns the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element.

    • int
      lastIndexOf(Object o)
      

      Returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element.

    java.util.ListIterator< E >

    • void 
      add(E e)
      

      Inserts the specified element into the list (optional operation).

    • boolean hasNext()
      

      Returns true if this list iterator has more elements when traversing the list in the forward direction.

    • boolean
      hasPrevious()
      

      Returns true if this list iterator has more elements when traversing the list in the reverse direction.

    • E
      next()
      

      Returns the next element in the list and advances the cursor position.

    • int
      nextIndex()
      

      Returns the index of the element that would be returned by a subsequent call to next().

    • E
      previous()
      

      Returns the previous element in the list and moves the cursor position backwards.

    • int
      previousIndex()
      

      Returns the index of the element that would be returned by a subsequent call to previous().

    • void
      remove()
      

      Removes from the list the last element that was returned by next() or previous() (optional operation).

    • void
      set(E e)
      

      Replaces the last element returned by next() or previous() with the specified element (optional operation).

    java.util.LinkedList< E >

    • LinkedList()
      

      Constructs an empty list.

    • LinkedList(Collection<? extends E> c)
      

      Constructs a list containing the elements of the specified collection, in the order they are returned by the collection’s iterator.

    • void
      addFirst(E e)
      

      Inserts the specified element at the beginning of this list.

    • void
      addLast(E e)
      

      Appends the specified element to the end of this list.

    • E
      getFirst()
      

      Returns the first element in this list.

    • E
      getLast()
      

      Returns the last element in this list.

    • E
      removeFirst()
      

      Removes and returns the first element from this list.

    • E
      removeLast()
      

      Removes and returns the last element from this list.

    数组列表

    ArrayList封装了一个动态再分配的数组

    单线程时使用ArrayList, 多线程时使用Vector

    散列集

    散列表(hash table)用来快速查找对象, 散列表为每个对象计算一个整数称为散列码(hash code)

    hashCode方法必须与equals方法兼容

    通常将桶数设置为预计元素个数的75%-150%, 标准库默认类值是16

    若散列表太满, 就需要再散列(rehashed), 装填因子(load factor)默认为0.75.

    HashSet类实现了基于散列表的集

    package set;
    
    import java.util.*;
    
    /**
     * This program uses a set to print all unique words in System.in.
     * @author Cat Horstmann
     */
    
    public class SetTest 
    {   
        public static void main(String[] args) {
            var words = new HashSet<String>();
            long totalTime = 0;
    
            try(var in = new Scanner(System.in))
            {
                while(in.hasNext())
                {
                    String word = in.next();
                    long callTime = System.currentTimeMillis();
                    words.add(word);
                    callTime = System.currentTimeMillis() - callTime;
                    totalTime += callTime;
                }
            }
    
            Iterator<String> iter = words.iterator();
            for (int i = 1; i <= 20 && iter.hasNext(); i++) 
            {
                System.out.println(iter.next());
            }
            System.out.println("...");
            System.out.println(words.size() + " distinct words. " + totalTime + "milliseconds.");
        }
        
    }
    

    API

    java.util.HashSet< E >

    • HashSet()
      

      Constructs a new, empty set; the backing HashMap instance has default initial capacity (16) and load factor (0.75).

    • HashSet(int initialCapacity)
      

      Constructs a new, empty set; the backing HashMap instance has the specified initial capacity and default load factor (0.75).

    • HashSet(int initialCapacity, float loadFactor)
      

      Constructs a new, empty set; the backing HashMap instance has the specified initial capacity and the specified load factor.

    • HashSet(Collection<? extends E> c)
      

      Constructs a new set containing the elements in the specified collection.

    java.lang.Object

    • int
      hashCode()
      

      Returns a hash code value for the object.

    树集

    树集与散列集十分类似, 不过树集是一个有序集合(sorted collection), 当前实现使用的是红黑树(red-black tree)

    treeSet/TreeSetTest.java

    package treeSet;
    import java.util.*;
    
    /**
     * This program sorts a set of Item objects by comparing their descriptions.
     * @author Cay Horstmann
     */
    
    
    public class TreeSetTest 
    {
        public static void main(String[] args) {
            var parts = new TreeSet<Item>();
            parts.add(new Item("Toaster", 1234));
            parts.add(new Item("Widget", 4562));
            parts.add(new Item("Modem", 9912));
            System.out.println(parts);
    
            var sortByDescription = new TreeSet<Item>(Comparator.comparing(Item::getDescription));
    
            sortByDescription.addAll(parts);
            System.out.println(sortByDescription);
        }
    }
    

    treeSet/Item.java

    package treeSet;
    
    import java.util.*;
    
    /**
     * An item with a description and a part number.
     */
    
    public class Item implements Comparable<Item>
    {
        private String description;
        private int partNumber;
    
        /**
         * Constructs an item.
         * @param aDescription the item's description
         * @param aPartNumber the item's part number
         */
        public Item(String aDescription, int aPartNumber)
        {
            description = aDescription;
            partNumber = aPartNumber;
        }
    
        /**
         * Gets the description of this item.
         * @return the description
         */
    
        public String getDescription() {
            return description;
        }
        @Override
        public String toString() {
            return "[description=" + description + ", partNumber=" + partNumber + "]";
        }
        @Override
        public boolean equals(Object otherObject) {
            if(this == otherObject) return true;
            if(otherObject == null) return false;
            if(getClass() != otherObject.getClass())   return false;
            var other = (Item)otherObject;
            return Objects.equals(description, other.description) && partNumber == other.partNumber;
        }
        @Override
        public int hashCode() {
            return Objects.hash(description, partNumber);
        }
        @Override
        public int compareTo(Item other) 
        {
            int diff = Integer.compare(partNumber, other.partNumber);
            return diff!= 0 ? diff : description.compareTo(other.description);
            
        }
    }
    

    API

    java.util.TreeSet< E >

    • TreeSet()
      

      Constructs a new, empty tree set, sorted according to the natural ordering of its elements.

    • TreeSet(Collection<? extends E> c)
      

      Constructs a new tree set containing the elements in the specified collection, sorted according to the natural ordering of its elements.

    • TreeSet(Comparator<? super E> comparator)
      

      Constructs a new, empty tree set, sorted according to the specified comparator.

    • TreeSet(SortedSet<E> s)
      

      Constructs a new tree set containing the same elements and using the same ordering as the specified sorted set.

    java.util.SortedSet< E >

    • Comparator<? super E>
      comparator()
      

      Returns the comparator used to order the elements in this set, or null if this set uses the natural ordering of its elements.

    • E
      first()
      

      Returns the first (lowest) element currently in this set.

    • E
      last()
      

      Returns the last (highest) element currently in this set.

    java.util.NavigableSet < E >

    • E
      higher(E e)
      

      Returns the least element in this set strictly greater than the given element, or null if there is no such element.

    • E
      lower(E e)
      

      Returns the greatest element in this set strictly less than the given element, or null if there is no such element.

    • E
      ceiling(E e)
      

      Returns the least element in this set greater than or equal to the given element, or null if there is no such element.

    • E
      floor(E e)
      

      Returns the greatest element in this set less than or equal to the given element, or null if there is no such element.

    • E
      pollFirst()
      

      Retrieves and removes the first (lowest) element, or returns null if this set is empty.

    • E
      pollLast()
      

      Retrieves and removes the last (highest) element, or returns null if this set is empty.

    • Iterator<E>
      descendingIterator()
      

      Returns an iterator over the elements in this set, in descending order.

    队列与双端队列

    双端队列(deque)允许在头部和尾部都高效地添加元素, ArrayDequeue和LinkedList都实现了Deque, 使用这两个类可以实现双端队列

    API

    java.util.Queue< E >

    • boolean
      add(E e)
      

      Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions, returning true upon success and throwing an IllegalStateException if no space is currently available.

    • boolean
      offer(E e)
      

      Inserts the specified element into this queue if it is possible to do so immediately without violating capacity restrictions.

    • E
      remove()
      

      Retrieves and removes the head of this queue.

    • E
      poll()
      

      Retrieves and removes the head of this queue, or returns null if this queue is empty.

    • E
      element()
      

      Retrieves, but does not remove, the head of this queue.

    • E
      peek()
      

      Retrieves, but does not remove, the head of this queue, or returns null if this queue is empty.

    java.util.Deque< E >

    • void
      addFirst(E e)
      

      Inserts the specified element at the front of this deque if it is possible to do so immediately without violating capacity restrictions, throwing an IllegalStateException if no space is currently available.

    • void
      addLast(E e)
      

      Inserts the specified element at the end of this deque if it is possible to do so immediately without violating capacity restrictions, throwing an IllegalStateException if no space is currently available.

    • boolean
      offerFirst(E e)
      

      Inserts the specified element at the front of this deque unless it would violate capacity restrictions.

    • boolean
      offerLast(E e)
      

      Inserts the specified element at the end of this deque unless it would violate capacity restrictions.

    • E
      removeFirst()
      

      Retrieves and removes the first element of this deque.

    • E
      removeLast()
      

      Retrieves and removes the last element of this deque.

    • E
      pollFirst()
      

      Retrieves and removes the first element of this deque, or returns null if this deque is empty.

    • E
      pollLast()
      

      Retrieves and removes the last element of this deque, or returns null if this deque is empty.

    • E
      getFirst()
      

      Retrieves, but does not remove, the first element of this deque.

    • E
      getLast()
      

      Retrieves, but does not remove, the last element of this deque.

    • E
      peekFirst()
      

      Retrieves, but does not remove, the first element of this deque, or returns null if this deque is empty.

    • E
      peekLast()
      

      Retrieves, but does not remove, the last element of this deque, or returns null if this deque is empty.

    java.util.ArrayDeque< E >

    • ArrayDeque()
      

      Constructs an empty array deque with an initial capacity sufficient to hold 16 elements.

    • ArrayDeque(int numElements)
      

      Constructs an empty array deque with an initial capacity sufficient to hold the specified number of elements.

    优先队列

    优先队列( priority queue)中的元素可以按照任意的顺序插入, 但对按照有序的顺序进行检索。

    因为优先队列使用了堆(heap)的数据结构, 堆是一个可以自组织的二叉树, 若母节点的值恒小于子节点, 称为最小堆, 反之称为最大堆

    package priorityQueue;
    
    import java.util.*;
    
    
    import java.time.*;
    
    /**
     * This program demonstrates the use of a priority queue.
     * @author Cay Horstmann
     */
    
    public class PriorityQueueTest
    {
        public static void main(String[] args) {
            var pq = new PriorityQueue<LocalDate>();
            pq.add(LocalDate.of(1906, 12, 9));      //G.Hopper
            pq.add(LocalDate.of(1815, 12, 10));
            pq.add(LocalDate.of(1903, 12, 3));
            pq.add(LocalDate.of(1910, 6, 22));
            System.out.println("Iterating over elements...");
            for (LocalDate date : pq) 
                System.out.println(date);
            System.out.println("Removing elements...");
            while(!pq.isEmpty())
            System.out.println(pq.remove());
        }
    }
    

    API

    java.util.PriorityQueue

    • PriorityQueue()
      

      构造一个空的优先队列(容量默认11)

      PriorityQueue(int initialCapacity)
      

      构造一个具有指定容量的优先队列

    • PriorityQueue(int initialCapacity, Comparator<? super E> c)
      

    构造一个使用指定比较器的优先队列

    映射

    基本映射操作

    如果不需要按照有序的顺序访问键, 散列映射相对更快

    size方法返回映射中的元素数, 可以用lambda表达式对映射进行迭代处理

    score.forEach(k, v) ->
        System.out.println("key=" + K + ", value=" + v);
    
    package map;
    import java.util.*;
    
    /**
     * This program demonstrates the use of a map with key type String and value type Employee.
     * @author Cay Horstmann
     */
    
    
    public class MapTest
    {
        public static void main(String[] args)
        {
            var staff = new HashMap<String, Employee>();
            staff.put("144-25-5464", new Employee("Amy Lee"));
            staff.put("567-24-2546", new Employee("Harry Hacker"));
            staff.put("157-62-7935", new Employee("Gary Cooper"));
            staff.put("456-62-5527", new Employee("Francesca Cruz"));
    
            //print all entries
    
            System.out.println(staff);
            //remove an entry
            staff.remove("567-24-2546");
    
            //replace an entry
            staff.put("456-62-5527", new Employee("Francesca Miller"));
    
            //look up a value
            System.out.println(staff.get("157-62-7935"));
    
            // iterate through all entries
            staff.forEach((k, v) ->
            System.out.println("key=" + k + ", value=" + v));
        }
    
    }
    

    API

    java.util.Map<K, V>

    • V
      get(Object key)
      

      Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.

    • default V
      getOrDefault(Object key, V defaultValue)
      

      Returns the value to which the specified key is mapped, or defaultValue if this map contains no mapping for the key.

    • V
      put(K key, V value)
      

      Associates the specified value with the specified key in this map (optional operation).

    • void
      putAll(Map<? extends K,? extends V> m)
      

      Copies all of the mappings from the specified map to this map (optional operation).

    • boolean
      containsKey(Object key)
      

      Returns true if this map contains a mapping for the specified key.

    • boolean
      containsValue(Object value)
      

      Returns true if this map maps one or more keys to the specified value.

    • default void
      forEach(BiConsumer<? super K,? super V> action)
      

      Performs the given action for each entry in this map until all entries have been processed or the action throws an exception.

    java.util.HashMap< K, V >

    HashMap()
    

    Constructs an empty HashMap with the default initial capacity (16) and the default load factor (0.75).

    HashMap(int initialCapacity)
    

    Constructs an empty HashMap with the specified initial capacity and the default load factor (0.75).

    HashMap(int initialCapacity, float loadFactor)
    

    Constructs an empty HashMap with the specified initial capacity and load factor.

    java.util.TreeMap< K, V >

    • TreeMap()
      

      Constructs a new, empty tree map, using the natural ordering of its keys.

      TreeMap(Comparator<? super K> comparator)
      

      Constructs a new, empty tree map, ordered according to the given comparator.

      TreeMap(Map<? extends K,? extends V> m)
      

      Constructs a new tree map containing the same mappings as the given map, ordered according to the natural ordering of its keys.

      TreeMap(SortedMap<K,? extends V> m)
      

      Constructs a new tree map containing the same mappings and using the same ordering as the specified sorted map.

    java.util. SortedMap< K, V>

    • Comparator<? super K>
      comparator()
      

      Returns the comparator used to order the keys in this map, or null if this map uses the natural ordering of its keys.

    • K
      firstKey()
      

      Returns the first (lowest) key currently in this map.

    • K
      lastKey()
      

      Returns the last (highest) key currently in this map.

    更新映射条目

    更新映射有如下方式:

    counts.put(word, counts.get(word) + 1);
    

    但是第一次见到word时会有问题

    counts.put(word, counts.getOrDefaule(word, 0) + 1);
    

    另一种方法是使用putIfAbsent

    counts.putIfAbsent(word, 0);
    counts.put(word, counts.get(word) + 1);
    

    merge方法更为方便

    counts.merge(word, 1, Integer::sum);
    

    映射视图

    可以得到映射的视图(view)

    Set< K > KeySet();
    Collection< V > values();
    Set< Map.Entry< K, V > > entrySet();
    

    分别返回键集合, 值集合, 键值对集合

    Set接口扩展了Collection接口

    Set< String > keys = map.keySet();
    for (String key: keys)
    {
        do something with key
    }
    

    若想同时查看键和值

    for (Map.Entry< String, Employee> entry : staff.entrySet())
    {
        String k = entry.getKey();
        Empolyee v = entry.getValue();
        do something with key, value
    }
    
    for (var entry: map.entrySet())
    {
        do something with entry.getKey(), entry.getValue()
    }
    

    现在只需要使用forEach方法

    map.forEach((k, v) -> {
        do something with k, v
    });
    

    键集视图可以调用迭代器的remove方法, 但不能进行添加, 映射条目集视图同样

    弱散列映射

    当对键的最后一个引用都没有时(此时对键的唯一引用来自于散列表映射条目时), WeakHashMap类可以与垃圾回收器一起删除键值对

    WeakHashMap类使用弱引用(weak references)保存键

    如果某个对象没有被他人再引用时, 垃圾回收器会将其回收

    如果某个对象只由WeakReference引用时, 垃圾回收也会将其回收, 其将会将该对象的一个弱引用加入队列, WeakHashMap检查队列, 删除相关联的映射条目

    链接散列集和映射

    LinkedHashMap和LinkedHashSet 由双向链表实现, 会记住插入元素项的顺序(TreeSet使用的是大小顺序, HashSet使用随机顺序)。

    连接散列映射使用访问顺序来迭代处理映射条目

    每次使用get或put时会将项放到链表的尾部

    构造散列映射使用

    LinkedHashMap< K, V > (initialCapacity, loadFactor, true)
    

    作为一般规则,默认负载因子(0.75)在时间和空间成本上提供了很好的折衷。较高的值会降低空间开销,但提高查找成本(体现在大多数的HashMap类的操作,包括get和put)。设置初始大小时,应该考虑预计的entry数在map及其负载系数,并且尽量减少rehash操作的次数。如果初始容量大于最大条目数除以负载因子,rehash操作将不会发生。

    当在表中找不到元素项且表相当满时, 可以得到表的一个迭代器, 删除其枚举的前几个项, 这些项会是近期最少使用的几个元素。

    可以通过构造子类, 覆盖方法来实现自动化

    protected boolean removeEldestEntry(Map.Entry<K, V> eldest)
    
    var cache = new LinkedHashMap<K, V>(128, 0.75F,true)
    {
        protected boolean removeEldestEntry(Map.entry<K, V> eldest)
        {
            return size() > 100;
        }
    }
    

    当方法返回true时, 添加一个新映射条目将会删除eldest项

    枚举集与映射

    EnumSet是枚举类型元素集的高效实现, EnumSet内部使用位序列实现, 若对应的值在集中, 相应的位被设置为1

    EnumSet使用静态工厂方法构造

            enum Weekday {MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY};
            EnumSet<Weekday> always = EnumSet.allof(Weekday.class);
            EnumSet<Weekday> never = EnumSet.noneOf(Weekday.class);
            EnumSet<Weekday> workday = EnumSet.range(Weekday.MONDAY, Weekday.FRIDAY);
            EnumSet<Weekday> mwf = EnumSet.of(Weekday.MONDAY, Weekday.WEDNESDAY, Weekday.FRIDAY);
    

    可以使用set’常用接口来修改EnumSet

    EnumMap是一个键类型位枚举类型的映射, 直接且高效地实现为一个值数组。需要在构造器中指定键类型

    var personInCharge = new EnumMap<Weekday, Employee>(Weekday.class);
    

    表示散列映射

    IdentityHashMap类中, 键的散列值使用System.identityHashCode计算, 这是Object.hashCode的计算方法

    IdentityHashMap类使用==进行比较, 而不是equals

    视图与包装器

    keySet方法返回一个 实现了Set接口的类对象, 由这个类的方法操纵原映射

    小集合

    List<String> names =  List.of("Peter", "Paul", "Mary");
    Set<Integer> numbers = Set.of(2, 3, 5);
    

    对于映射

    Map<String, Integer> scores = Map.of("Peter", 2, "Paul", 3, "Mary", 5);
    

    元素, 键或值不能为null

    对于Map接口, 无法提供参数可变的of方法版本, 因为参数类型会在键和值类型之间交替

    不过其ofEntries静态方法可以实现

    import static java.util.Map.*;
    ...
    Map<String, Integer> scores = ofentries(
    	entry("Peter", 2), 
    	entry("Paul", 3),
    	entry("Mary", 5));
    

    of或ofEntries方法生成的集合对象无法更改

    var names = new ArrayList<>(List.of("Peter", "Paul", "Mary"));
    

    方法调用

    Collections.nCopies(n, anObject)
    

    会返回一个实现了List接口的不可变对象

    List<String> settings = Collections.nCopies(100, "DEFAULT");
    

    子范围

    若想取出第10到第19个元素

    List<Employee> group2 = staff.subList(10, 20);
    

    该方法与String类的substring方法参数情况相同。

    对子范围操作会自动反映到整个列表。

    对于有序集和映射, 可以适应排序顺序建立子范围

    SortedSet<E> subSet(E from, E to);
    SortedSet<E> headSet(E to);
    SortedSet<E> tailSet(E from);
    
    SortedMap<K, V> subMap(K from, K to);
    SortedMap<K, V> headMap(K to);
    SortedMap<K, v> tailMap(K from);
    

    java6引入的NavigableSet接口允许更多地控制子范围操作, 包括指定是否包括边界

    NavigableSet<E> subSet(E from, boolean fromInclusive,E to, boolean toInclusive);
    NavigableSet<E> headSet(E to, boolean toInclusive);
    NavigableSet<E> tailSet(E from, boolean fromInclusive);
    

    不可修改的视图

    Collections类中由生成不可改变视图的几个方法(unmodifiable view)。

    使用如下8个方法来获得不可修改视图

    Collections.unmodifiableCollection;
    Collections.unmodifiableList;
    Collections.unmodifiableSet;
    Collections.unmodifiableSortedSet;
    Collections.unmodifiableNavigableSet;
    Collections.unmodifiableMap;
    Collections.unmodifiableSortedMap;
    Collections.unmodifiableNavigableMap;
    
    var staff = new LinkedList<String>();
    ...
    lookAt(Collections.unmodifiableList(staff));
    

    同步视图

    视图机制确保了常规集合是线程安全的, 而没有实现线程安全的集合类

    Collections类的静态synchronizedMap方法可以将任何一个映射转换为有同步访问方法的Map

    var map = Collections.synchronizedMap(new HashMap< String, Emloyee >());
    

    检查型视图

    var strings = new ArrayList<String>();
    ArrayList rawList = strings;			//warning only, not an error,
    										//for conpatibility with legacy code
    rawList.add(new Date());				//now strings contains a Date object!
    

    只有当调用get时, 会出现报错。

    检查型视图可以检测该类问题

    List<String> safeStrings = Collections.checkedList(strings, String.class);
    

    算法

    泛型算法

    找出数组中最大元素:

    if(a.length == 0) throw new NoSuchElementException();
    T largest = a[0];
    for (int i = 1; i < a.length; i++)
        if(largest.compareTo(a[i]) < 0)
            largest = a[i];
    

    数组列表最大元素:

    if(v.size() == 0) throw new NoSuchElementException();
    T largest = v.get(0);
    for(int i = 1; i < v.size(); i++)
        if(largest.compareTo(v.get(i)) < 0)
            largest = v.get(i);
    

    链表:

    if (l.isEmpty()) throw new NoSuchElementException();
    Iterator<T> iter = l.iterator();
    T.largest = iter.next();
    while(iter.hasNext())
    {
        T next = iter.next();
        if(largest.compareTo(next) < 0)
            largest = next;
    }
    

    泛型算法:

    public static <T extends Comparable> T max(Collection<T> c)
        {
            if(c.isEmpty()) throw new NoSuchElementException();
            Iterator<T> iter = c.iterator();
            T largest = iter.next();
            while(iter.hasNext())
            {
                T next = iter.next();
                if(largest.compareTo(next) < 0)
                    largest = next;
            }
            return largest;
        }
    

    排序和混排

    Collections类中sort方法可以对实现了List接口的集合进行排序

    var staff = new LinkedList<String>();
    ...
    Collections.sort(staff);
    

    该调用默认使用默认比较器

    使用List接口的sort方法并传入一个Comparator对象,可采用其他原则排序

    staff.sort(Comparator.comparingDouble(Employee::getSalary));
    

    降序排序:

    staff.sort(Comparator.reverseOrder())
    
    staff.sort(Comparator.comparingDouble(Employee::getSalary).reversed())
    

    Collections类中shuffle算法实现随机混排。

    package shuffle;
    
    import java.util.*;
    
    /**
     * This program demonstrates the random shuffle and sort algorithms.
     * @author Cay Horstmann
     */
    public class ShuffleTest
    {
        public static void main(String[] args) {
            var numbers = new ArrayList<Integer>();
            for (int i = 1; i <= 49 ; i++)
            {
                numbers.add(i);
            }
            Collections.shuffle(numbers);
            List<Integer> winningCombination = numbers.subList(0, 6);
            
            System.out.println(numbers);
            Collections.sort(winningCombination);
            System.out.println(winningCombination);
            System.out.println(numbers);
        }
    }
    
    

    二分查找

    Collections类实现了binarySearch方法

    前提: 集合必须有序

    i = Collections.binarySearch(c, element);
    i = Collections.binarySearch(c, element, comparator);
    

    简单算法

    Collections.replaceAll(words, "C++", "Java");
    

    等于以下方法

    for (int i = 0; i < words.size(); i++)
        if(words.get(i).equals("C++")) words.set(i, "java");
    

    Collection.removeIf和List.replaceAll需要提供一个lambda表达式来测试或转换元素

    words.removeIf(w -> w.length() <= 3);
    words.replaceAll(String.toLowerCase);
    

    批操作

    从coll1中删除coll2的元素

    coll1.removeAll(coll2);
    

    找出交集:

    var result = new HashSet<String>(firstSet);
    result.retainAll(secondSet);
    
    staff.subList(0, 10),clear();
    

    集合和数组间的转换

    String [] values = ...;
    var staff = new HashSet<>(List.of(values));
    

    集合到数组有些困难

    Object[] values = staff.toArray();	//toArray方法创建Object[]数组, 不能强制类型转换
    String[] values = staff.toArray(new String[0]);	//返回的数组创建相同数据类型
    staff.toArray(new String[staff.size()]);		//在这种情况下不会创建新数组
    

    遗留的集合

    Hashtable类

    Hashtable和HashMap一样

    枚举

    遗留的集合使用Enumeration接口遍历元素序列, 实现的两个方法为hasMoreElements 和nextElement

    可以使用Collections.list将元素收集到一个ArrayList中

    ArrayList<String> loggerNames = Collections.list(LogManager.getLoggerNames());
    

    静态方法Collections.enumeration产生枚举对象

    List<InputStream> streams = ...;
    var in = new SequenceInputStream(Collections.enumeration(stream));
    

    属性映射

    属性映射(property map)是一个特殊类型的映射结构

    1. 键和值都是字符串
    2. 映射可以很容易保存到文件以及从文件加载
    3. 有一个二级表存放默认值

    实现类名为Properties

    对于指定程序的配置选项很有用

    var settings = new Properties();
    setting.setProperty("width", "600.0");
    setting.setProperty("filename", "home/cay/books/cj11/code/v1ch11/raven.html");
    

    使用store方法保存到文件

    var out = new FileOutputStream("program.properies");
    setting.store(out, "Program Properties");
    

    加载使用如下调用

    var in = new FileInputStream("program.properties");
    setting.load(in);
    

    System.getProperties方法生成Properties对象描述信息

    getProperty方法1生成描述的字符串

    String userDir = System.getProperty("user.home");
    

    如下调用当键不存在时自动设置为相应的字符串

    String filename = setting.getProperty("filename", "");
    

    可以将所有默认值放在一个二级属性映射中, 并在主属性映射构造器中提供该二级映射。

    var defaultSettings = new Properties();
    defaultSettings.setProperty("width", "600");
    defaultSettings.setProperty("height", "400");
    dafaultSettings.setProperty("filename", "");
    ...
    var settings = new Properties(dafaultSettings);
    

    Stack类有push方法和pop方法与peek方法

    位集

    BitSet类用于存储一个位序列

    位集将位包装在字节中, 使用位集比使用Boolean对象的ArrayList更高效

    package sieve;
    
    import java.util.BitSet;
    
    /**
     * This program runs the Sieve of Erathostenes benchmark. It computes all primes
     * up to 2,000,000
     * @author Cay Horstmann
     */
    public class Sieve
    {
        public static void main(String[] args) {
            int n = 2000000;
            long start = System.currentTimeMillis();
            var bitSet = new BitSet(n + 1);
            int count = 0;
            int i;
            for (i = 2; i <= n; i++)
            {
                bitSet.set(i);
            }
            i = 2;
            while(i * i <= n)
            {
                if(bitSet.get(i))
                {
                    count++;
                    int k = 2 * i;
                    while(k <= n)
                    {
                        bitSet.clear(k);
                        k += i;
                    }
                }
                i++;
            }
            while(i <= n)
            {
                if(bitSet.get(i)) count++;
                i++;
            }
            long end = System.currentTimeMillis() ;
            System.out.println(count + "primes");
            System.out.println((end - start) + "milliseconds");
        }
    }
    
    /**
     *@author Cay Horstmann
     */
    #include <bitset>
    #include <iostream>
    #include <ctime>
    
    using namespace std;
    
    int main()
    {
    	const int N = 2000000;
    	clock_t cstart = clock();
    	bitset<N + 1> b;
    	int count = 0;
    	int i;
    	for (i = 2; i <= N; i++)
    		b.set(i);
    	i = 2;
    	while (i * i <= N)
    	{
    		if (b.test(i))
    		{
    			count++;
    			int k = 2 * i;
    			while (k <= N)
    			{
    				b.reset(k);
    				k += i;
    			}
    		}
    		i++;
    	}
    	while (i <= N)
    	{
    		if (b.test(i))
    			count++;
    		i++;
    	}
    	clock_t cend = clock();
    	double millis = 1000.0 * (cend - cstart) / CLOCKS_PER_SEC;
    	cout << count << "primes\n" << millis << "milliseconds\n";
    	return 0;
    }
    

    (“width”, “600”);
    defaultSettings.setProperty(“height”, “400”);
    dafaultSettings.setProperty(“filename”, “”);

    var settings = new Properties(dafaultSettings);

    
    ## 栈
    
    Stack类有push方法和pop方法与peek方法
    
    
    
    ## 位集
    
    BitSet类用于存储一个位序列
    
    位集将位包装在字节中, 使用位集比使用Boolean对象的ArrayList更高效
    
    ```java
    package sieve;
    
    import java.util.BitSet;
    
    /**
     * This program runs the Sieve of Erathostenes benchmark. It computes all primes
     * up to 2,000,000
     * @author Cay Horstmann
     */
    public class Sieve
    {
        public static void main(String[] args) {
            int n = 2000000;
            long start = System.currentTimeMillis();
            var bitSet = new BitSet(n + 1);
            int count = 0;
            int i;
            for (i = 2; i <= n; i++)
            {
                bitSet.set(i);
            }
            i = 2;
            while(i * i <= n)
            {
                if(bitSet.get(i))
                {
                    count++;
                    int k = 2 * i;
                    while(k <= n)
                    {
                        bitSet.clear(k);
                        k += i;
                    }
                }
                i++;
            }
            while(i <= n)
            {
                if(bitSet.get(i)) count++;
                i++;
            }
            long end = System.currentTimeMillis() ;
            System.out.println(count + "primes");
            System.out.println((end - start) + "milliseconds");
        }
    }
    
    /**
     *@author Cay Horstmann
     */
    #include <bitset>
    #include <iostream>
    #include <ctime>
    
    using namespace std;
    
    int main()
    {
    	const int N = 2000000;
    	clock_t cstart = clock();
    	bitset<N + 1> b;
    	int count = 0;
    	int i;
    	for (i = 2; i <= N; i++)
    		b.set(i);
    	i = 2;
    	while (i * i <= N)
    	{
    		if (b.test(i))
    		{
    			count++;
    			int k = 2 * i;
    			while (k <= N)
    			{
    				b.reset(k);
    				k += i;
    			}
    		}
    		i++;
    	}
    	while (i <= N)
    	{
    		if (b.test(i))
    			count++;
    		i++;
    	}
    	clock_t cend = clock();
    	double millis = 1000.0 * (cend - cstart) / CLOCKS_PER_SEC;
    	cout << count << "primes\n" << millis << "milliseconds\n";
    	return 0;
    }
    
    展开全文
    Nexas 2021-07-10 22:24:24
  • 45.61MB mitrol 2018-08-15 20:56:31
  • 161.82MB hahar226 2018-09-30 09:04:04
  • 100MB mrrightmeng 2017-11-15 09:08:20
  • JAVA核心技术第11版卷1,2》 Java核心技术与Thinking in Java(Java编程思想)齐名的 Core Java。2018年9月才出版的英文原版,包括了Java9,Java10,Java11的新特性,中文的翻译版还没有出,估计还要很久,多看看...

    《JAVA核心技术第11版卷1,2》 Java核心技术与Thinking in Java(Java编程思想)齐名的 Core Java。2018年9月才出版的英文原版,包括了Java9,Java10,Java11的新特性,中文的翻译版还没有出,估计还要很久,多看看英文文档对自己也是很有帮助的。书中囊括了Java的全部基础知识,提供了大量完整且具有实际意义的应用示例,详细介绍了Java语言基础、面向对象编程、反射与代理、接口与内部类、事件监听器模型、使用Swing GUI工具进行图形用户界面程序设计、打包应用程序、异常处理、登录与调试、泛型编程、集合框架、多线程、并发等内容。本书赢得了全球程序员的广泛赞誉,即使是最晦涩的概念,在Bruce Eckel的文字亲和力和小而直接的编程示例面前也会化解于无形。从Java的基础语法到最高级特性(深入的面向对象概念、多线程、自动项目构建、单元测试和调试等),本书都能逐步指导你轻松掌握。
    《JAVA编程思想第四版中文版》 从本书获得的各项大奖以及来自世界各地的读者评论中,不难看出这是一本经典之作。本书的作者拥有多年教学经验,对C、C++以及Java语言都有独到、深入的见解,以通俗易懂及小而直接的示例解释了一个个晦涩抽象的概念。本书共22章,包括操作符、控制执行流程、访问权限控制、复用类、多态、接口、通过异常处理错误、字符串、泛型、数组、容器深入研究、Java I/O系统、枚举类型、并发以及图形化用户界面等内容。这些丰富的内容,包含了Java语言基础语法以及高级特性,适合各个层次的Java程序员阅读,同时也是高等院校讲授…
    提取码:rnal

    展开全文
    weixin_43013063 2020-02-26 18:26:32
  • (文中内容参考了Java 核心技术-2和网上资料) 1Java流分为输入流和输出流。 可以从其中读入一个字节序列的对象称作输入流, 可以向其中写入一个写入一个字节序列的对象叫做输出流。 这些字节序列的...

    第1章 流与文件

    (文中内容参考了Java 核心技术-卷2和网上资料)

    1 流

    Java流分为输入流输出流
    可以从其中读入一个字节序列的对象称作输入流
    可以向其中写入一个写入一个字节序列的对象叫做输出流
    这些字节序列的来源地和目的地址可以是文件,也可以是网络连接,甚至是内存块。

    1.1 字节输入流InputStream、字节输出流OutputStream、字符输入流Reader、字符输出流Writer四个基本的抽象流类型。
    这里写图片描述

    1.2 节点流和处理流
    这里写图片描述

    • 节点流类型
      这里写图片描述
    • 处理流类型
      这里写图片描述

      1.3 InputStream输入流
      这里写图片描述

    • InputStream基本用法
      这里写图片描述

      1.4 OutputStream输出流
      这里写图片描述

    • OutputStream基本用法
      这里写图片描述

      1.5 Reader流
      这里写图片描述

    • Reader流基本用法
      这里写图片描述

      1.6 Writer流
      这里写图片描述

    • Writer流基本用法
      这里写图片描述

    展开全文
    LearnMore666 2018-03-21 16:40:58
  • 新书推荐《Java核心技术卷Ⅰ:基础知识(原书第11版)》长按二维码了解及购买全新第11版!针对Java SE9、10、11全面更新!Java领域极具影响力和价值的著作之一,与《Java...

    新书推荐

    《Java核心技术卷Ⅰ:基础知识(原书第11版)》

    长按二维码
    了解及购买

    全新第11版!针对Java SE9、10、11全面更新!Java领域极具影响力和价值的著作之一,与《Java编程思想》齐名,10余年全球畅销不衰,广受好评。

    内容简介

    本书由拥有20多年教学与研究经验的资深Java技术专家撰写(获Jolt大奖),是程序员的优选Java指南。本版针对Java SE 9、10和 11全面更新。


    全书共12章。

    • 第1章概述Java语言的特色功能;

    • 第2章详细论述如何下载和安装JDK以及本书的程序示例;

    • 第3章开始讨论Java 语言,包括变量、循环和简单的函数;

    • 第4章介绍面向对象两大基石中极要的一个概念——封装,以及Java语言实现封装的机制,即类与方法;

    • 第5章介绍面向对象的另一个重要概念——继承,继承使程序员可以使用现有的类,并根据需要进行修改;

    • 第6章展示如何使用Java的接口(可帮助你充分获得Java的完全面向对象程序设计能力)、lambda表达式(用来表述可以在以后某个时间点执行的代码块)和内部类;

    • 第7章讨论异常处理,并给出大量实用的调试技巧;

    • 第8章概要介绍泛型程序设计,使程序更可读、更安全;

    • 第9章讨论Java平台的集合框架,以及如何充分利用内建的标准集合;

    • 第10章介绍GUI程序设计(包括如何建立窗口、如何在窗口中绘图、如何利用几何图形绘图、如何采用多种字体格式化文本,以及如何显示图像)和编写代码来响应事件(如鼠标点击事件和按键事件);

    • 第11章详细讨论Swing GUI工具包,以建立跨平台的图形用户界面,包括各种按钮、文本组件、边框、滑块、列表框、菜单以及对话框的有关内容;

    • 第12章讨论并发。本书最后还有一个附录,其中列出了Java语言的保留字。

    作者简介

    凯•S.霍斯特曼(Cay S. Horstmann )圣何塞州立大学计算机科学系教授、Java的倡导者。他是《Java核心技术》两卷本的作者,并著有《Core Java SE 9 for the Impatient, Second Edition》 (Addison-Wesley 2018)和《Scala for the Impatient, Second Edition》(Addison- Wesley, 2017)。他还为专业程序员和计算机科学专业的学生撰写过数十本其他图书。

    目录

    译者序

    前言

    致谢

    第1章 Java程序设计概述  1

    1.1 Java程序设计平台  1

    1.2 Java“白皮书”的关键术语  2

    1.2.1 简单性  2

    1.2.2 面向对象  3

    1.2.3 分布式  3

    1.2.4 健壮性  3

    1.2.5 安全性  3

    1.2.6 体系结构中立  4

    1.2.7 可移植性  4

    1.2.8 解释型  5

    1.2.9 高性能  5

    1.2.10 多线程  5

    1.2.11 动态性  6

    1.3 Java applet与Internet  6

    1.4 Java发展简史  7

    1.5 关于Java的常见误解  10

    第2章 Java程序设计环境  12

    2.1 安装Java开发工具包  12

    2.1.1 下载JDK  12

    2.1.2 设置JDK  14

    2.1.3 安装库源文件和文档  16

    2.2 使用命令行工具  16

    2.3 使用集成开发环境  20

    2.4 JShell  23

    第3章 Java的基本程序设计结构  26

    3.1 一个简单的Java应用程序  26

    3.2 注释  29

    3.3 数据类型  29

    3.3.1 整型  30

    3.3.2 浮点类型  31

    3.3.3 char类型  32

    3.3.4 Unicode和char类型  33

    3.3.5 boolean类型  34

    3.4 变量与常量  34

    3.4.1 声明变量  34

    3.4.2 变量初始化  35

    3.4.3 常量  36

    3.4.4 枚举类型  37

    3.5 运算符  37

    3.5.1 算术运算符  37

    3.5.2 数学函数与常量  38

    3.5.3 数值类型之间的转换  40

    3.5.4 强制类型转换  41

    3.5.5 结合赋值和运算符  41

    3.5.6 自增与自减运算符  41

    3.5.7 关系和boolean运算符  42

    3.5.8 位运算符  43

    3.5.9 括号与运算符级别  43

    3.6 字符串  44

    3.6.1 子串  45

    3.6.2 拼接  45

    3.6.3 不可变字符串  45

    3.6.4 检测字符串是否相等  47

    3.6.5 空串与Null串  48

    3.6.6 码点与代码单元  48

    3.6.7 String API  49

    3.6.8 阅读联机API文档  51

    3.6.9 构建字符串  54

    3.7 输入与输出  55

    3.7.1 读取输入  55

    3.7.2 格式化输出  57

    3.7.3 文件输入与输出  61

    3.8 控制流程  62

    3.8.1 块作用域  63

    3.8.2 条件语句  63

    3.8.3 循环  66

    3.8.4 确定循环  69

    3.8.5 多重选择:switch语句  72

    3.8.6 中断控制流程的语句  74

    3.9 大数  76

    3.10 数组  79

    3.10.1 声明数组  79

    3.10.2 访问数组元素  80

    3.10.3 for each循环  81

    3.10.4 数组拷贝  82

    3.10.5 命令行参数  82

    3.10.6 数组排序  83

    3.10.7 多维数组  86

    3.10.8 不规则数组  88

    第4章 对象与类  92

    4.1 面向对象程序设计概述  92

    4.1.1 类  93

    4.1.2 对象  94

    4.1.3 识别类  94

    4.1.4 类之间的关系  95

    4.2 使用预定义类  96

    4.2.1 对象与对象变量  96

    4.2.2 Java类库中的LocalDate类  99

    4.2.3 更改器方法与访问器方法  100

    4.3 用户自定义类  103

    4.3.1 Employee类  104

    4.3.2 多个源文件的使用  106

    4.3.3 剖析Employee类  107

    4.3.4 从构造器开始  107

    4.3.5 用var声明局部变量  109

    4.3.6 使用null引用  109

    4.3.7 隐式参数与显式参数  110

    4.3.8 封装的优点  111

    4.3.9 基于类的访问权限  113

    4.3.10 私有方法  114

    4.3.11 f?inal实例字段  114

    4.4 静态字段与静态方法  115

    4.4.1 静态字段  115

    4.4.2 静态常量  116

    4.4.3 静态方法  116

    4.4.4 工厂方法  117

    4.4.5 main方法  118

    4.5 方法参数  121

    4.6 对象构造  126

    4.6.1 重载  126

    4.6.2 默认字段初始化  127

    4.6.3 无参数的构造器  127

    4.6.4 显式字段初始化  128

    4.6.5 参数名  129

    4.6.6 调用另一个构造器  129

    4.6.7 初始化块  130

    4.6.8 对象析构与f?inalize方法  134

    4.7 包  134

    4.7.1 包名  134

    4.7.2 类的导入  135

    4.7.3 静态导入  136

    4.7.4 在包中增加类  137

    4.7.5 包访问  139

    4.7.6 类路径  140

    4.7.7 设置类路径  142

    4.8 JAR文件  143

    4.8.1 创建JAR文件  143

    4.8.2 清单文件  144

    4.8.3 可执行JAR文件  145

    4.8.4 多版本JAR文件  145

    4.8.5 关于命令行选项的说明  146

    4.9 文档注释  148

    4.9.1 注释的插入  148

    4.9.2 类注释  149

    4.9.3 方法注释  149

    4.9.4 字段注释  150

    4.9.5 通用注释  150

    4.9.6 包注释  151

    4.9.7 注释抽取  151

    4.10 类设计技巧  152

    第5章 继承  155

    5.1 类、超类和子类  155

    5.1.1 定义子类  155

    5.1.2 覆盖方法  157

    5.1.3 子类构造器  158

    5.1.4 继承层次  162

    5.1.5 多态  162

    5.1.6 理解方法调用  163

    5.1.7 阻止继承:f?inal类和方法  165

    5.1.8 强制类型转换  166

    5.1.9 抽象类  168

    5.1.10 受保护访问  173

    5.2 Object:所有类的超类  174

    5.2.1 Object类型的变量  174

    5.2.2 equals方法  175

    5.2.3 相等测试与继承  176

    5.2.4 hashCode方法  179

    5.2.5 toString方法  181

    5.3 泛型数组列表  186

    5.3.1 声明数组列表  187

    5.3.2 访问数组列表元素  189

    5.3.3 类型化与原始数组列表的

    兼容性  191

    5.4 对象包装器与自动装箱  192

    5.5 参数数量可变的方法  195

    5.6 枚举类  196

    5.7 反射  198

    5.7.1 Class类  199

    5.7.2 声明异常入门   201

    5.7.3 资源  202

    5.7.4 利用反射分析类的能力  203

    5.7.5 使用反射在运行时分析

    对象  208

    5.7.6 使用反射编写泛型数组

    代码  213

    5.7.7 调用任意方法和构造器  216

    5.8 继承的设计技巧  219

    第6章 接口、lambda表达式与

    内部类  222

    6.1 接口  222

    6.1.1 接口的概念  222

    6.1.2 接口的属性  228

    6.1.3 接口与抽象类  229

    6.1.4 静态和私有方法  230

    6.1.5 默认方法  230

    6.1.6 解决默认方法冲突  231

    6.1.7 接口与回调  233

    6.1.8 Comparator接口  235

    6.1.9 对象克隆  236

    6.2 lambda表达式  242

    6.2.1 为什么引入lambda表达式  242

    6.2.2 lambda表达式的语法  243

    6.2.3 函数式接口  245

    6.2.4 方法引用  247

    6.2.5 构造器引用  250

    6.2.6 变量作用域  250

    6.2.7 处理lambda表达式  252

    6.2.8 再谈Comparator  254

    6.3 内部类  255

    6.3.1 使用内部类访问对象状态  256

    6.3.2 内部类的特殊语法规则  259

    6.3.3 内部类是否有用、必要和

    安全  260

    6.3.4 局部内部类  262

    6.3.5 由外部方法访问变量  263

    6.3.6 匿名内部类  264

    6.3.7 静态内部类  267

    6.4 服务加载器  270

    6.5 代理  273

    6.5.1 何时使用代理  273

    6.5.2 创建代理对象  273

    6.5.3 代理类的特性  277

    第7章 异常、断言和日志  279

    7.1 处理错误  279

    7.1.1 异常分类  280

    7.1.2 声明检查型异常  282

    7.1.3 如何抛出异常  284

    7.1.4 创建异常类  285

    7.2 捕获异常  286

    7.2.1 捕获异常  286

    7.2.2 捕获多个异常  288

    7.2.3 再次抛出异常与异常链  289

    7.2.4 f?inally子句  290

    7.2.5 try-with-Resources语句  292

    7.2.6 分析堆栈轨迹元素  294

    7.3 使用异常的技巧  297

    7.4 使用断言  300

    7.4.1 断言的概念  300

    7.4.2 启用和禁用断言  301

    7.4.3 使用断言完成参数检查  302

    7.4.4 使用断言提供假设文档  303

    7.5 日志  304

    7.5.1 基本日志  305

    7.5.2 高级日志  305

    7.5.3 修改日志管理器配置  307

    7.5.4 本地化  308

    7.5.5 处理器  309

    7.5.6 过滤器  312

    7.5.7 格式化器  313

    7.5.8 日志技巧  313

    7.6 调试技巧  321

    第8章 泛型程序设计  326

    8.1 为什么要使用泛型程序设计  326

    8.1.1 类型参数的好处  326

    8.1.2 谁想成为泛型程序员  328

    8.2 定义简单泛型类  328

    8.3 泛型方法  330

    8.4 类型变量的限定  331

    8.5 泛型代码和虚拟机  333

    8.5.1 类型擦除  333

    8.5.2 转换泛型表达式  335

    8.5.3 转换泛型方法  335

    8.5.4 调用遗留代码  337

    8.6 限制与局限性  338

    8.6.1 不能用基本类型实例化类型参数  338

    8.6.2 运行时类型查询只适用于原始类型  338

    8.6.3 不能创建参数化类型的数组  338

    8.6.4 Varargs警告  339

    8.6.5 不能实例化类型变量  340

    8.6.6 不能构造泛型数组  341

    8.6.7 泛型类的静态上下文中类型变量无效  342

    8.6.8 不能抛出或捕获泛型类的实例  343

    8.6.9 可以取消对检查型异常的检查  343

    8.6.10 注意擦除后的冲突  345

    8.7 泛型类型的继承规则  346

    8.8 通配符类型  348

    8.8.1 通配符概念  348

    8.8.2 通配符的超类型限定  349

    8.8.3 无限定通配符  351

    8.8.4 通配符捕获  352

    8.9 反射和泛型  354

    8.9.1 泛型Class类  354

    8.9.2 使用Class<T>参数进行类型匹配  355

    8.9.3 虚拟机中的泛型类型信息  356

    8.9.4 类型字面量  359

    第9章 集合  365

    9.1 Java集合框架  365

    9.1.1 集合接口与实现分离  365

    9.1.2 Collection接口  368

    9.1.3 迭代器  368

    9.1.4 泛型实用方法  370

    9.2 集合框架中的接口  373

    9.3 具体集合  375

    9.3.1 链表  375

    9.3.2 数组列表  384

    9.3.3 散列集  385

    9.3.4 树集  388

    9.3.5 队列与双端队列  391

    9.3.6 优先队列  392

    9.4 映射  394

    9.4.1 基本映射操作  394

    9.4.2 更新映射条目  397

    9.4.3 映射视图  398

    9.4.4 弱散列映射  399

    9.4.5 链接散列集与映射  400

    9.4.6 枚举集与映射  401

    9.4.7 标识散列映射  402

    9.5 视图与包装器  403

    9.5.1 小集合  404

    9.5.2 子范围  405

    9.5.3 不可修改的视图  405

    9.5.4 同步视图  406

    9.5.5 检查型视图  407

    9.5.6 关于可选操作的说明  407

    9.6 算法  411

    9.6.1 为什么使用泛型算法  411

    9.6.2 排序与混排  412

    9.6.3 二分查找  414

    9.6.4 简单算法  415

    9.6.5 批操作  417

    9.6.6 集合与数组的转换  418

    9.6.7 编写自己的算法  418

    9.7 遗留的集合  419

    9.7.1 Hashtable类  419

    9.7.2 枚举  419

    9.7.3 属性映射  421

    9.7.4 栈  424

    9.7.5 位集  424

    第10章 图形用户界面程序设计  429

    10.1 Java用户界面工具包简史  429

    10.2 显示窗体  430

    10.2.1 创建窗体  431

    10.2.2 窗体属性  433

    10.3 在组件中显示信息  435

    10.3.1 处理2D图形  439

    10.3.2 使用颜色  445

    10.3.3 使用字体  446

    10.3.4 显示图像  452

    10.4 事件处理  453

    10.4.1 基本事件处理概念  453

    10.4.2 实例:处理按钮点击事件  454

    10.4.3 简洁地指定监听器  457

    10.4.4 适配器类  458

    10.4.5 动作  460

    10.4.6 鼠标事件  464

    10.4.7 AWT事件继承层次  469

    10.5 首选项API  472

    第11章 Swing用户界面组件  478

    11.1 Swing和模型–视图–控制器设计模式  478

    11.2 布局管理概述  481

    11.2.1 布局管理器  482

    11.2.2 边框布局  483

    11.2.3 网格布局  484

    11.3 文本输入  485

    11.3.1 文本域  486

    11.3.2 标签和标签组件  487

    11.3.3 密码域  488

    11.3.4 文本区  489

    11.3.5 滚动窗格  489

    11.4 选择组件  491

    11.4.1 复选框  492

    11.4.2 单选按钮  494

    11.4.3 边框  497

    11.4.4 组合框  499

    11.4.5 滑动条  502

    11.5 菜单  507

    11.5.1 菜单构建  507

    11.5.2 菜单项中的图标  509

    11.5.3 复选框和单选按钮菜单项  510

    11.5.4 弹出菜单  511

    11.5.5 键盘助记符和加速器  512

    11.5.6 启用和禁用菜单项  514

    11.5.7 工具条  518

    11.5.8 工具提示  519

    11.6 复杂的布局管理  520

    11.6.1 网格包布局  520

    11.6.2 定制布局管理器  529

    11.7 对话框  532

    11.7.1 选项对话框  533

    11.7.2 创建对话框  536

    11.7.3 数据交换  540

    11.7.4 文件对话框  545

    第12章 并发  552

    12.1 什么是线程  552

    12.2 线程状态  555

    12.2.1 新建线程  556

    12.2.2 可运行线程  556

    12.2.3 阻塞和等待线程  556

    12.2.4 终止线程  558

    12.3 线程属性  558

    12.3.1 中断线程  558

    12.3.2 守护线程  561

    12.3.3 线程名  561

    12.3.4 未捕获异常的处理器  561

    12.3.5 线程优先级  563

    12.4 同步  563

    12.4.1 竞态条件的一个例子  563

    12.4.2 竞态条件详解  567

    12.4.3 锁对象  568

    12.4.4 条件对象  571

    12.4.5 synchronized关键字  576

    12.4.6 同步块  579

    12.4.7 监视器概念  580

    12.4.8 volatile字段  581

    12.4.9 final变量  582

    12.4.10 原子性  582

    12.4.11 死锁  584

    12.4.12 线程局部变量  586

    12.4.13 为什么废弃stop和suspend方法  587

    12.5 线程安全的集合  589

    12.5.1 阻塞队列  589

    12.5.2 高效的映射、集和队列  595

    12.5.3 映射条目的原子更新  596

    12.5.4 对并发散列映射的批操作  599

    12.5.5 并发集视图  600

    12.5.6 写数组的拷贝  601

    12.5.7 并行数组算法  601

    12.5.8 较早的线程安全集合  602

    12.6 任务和线程池  603

    12.6.1 Callable与Future  603

    12.6.2 执行器  605

    12.6.3 控制任务组  607

    12.6.4 fork-join框架  612

    12.7 异步计算  615

    12.7.1 可完成Future  615

    12.7.2 组合可完成Future  616

    12.7.3 用户界面回调中的长时间运行任务  622

    12.8 进程  628

    12.8.1 建立一个进程  628

    12.8.2 运行一个进程  630

    12.8.3 进程句柄  631

    附录 Java关键字  634

    你与世界

    只差一个

    公众号

    展开全文
    hzbooks 2019-11-26 07:00:00
  • 41B u012234583 2017-10-30 17:49:47
  • 127.58MB artist_l 2018-04-19 14:51:42
  • hong_shao 2019-12-29 11:25:25
  • qq_34626094 2021-01-26 10:56:02
  • 17.98MB wjf199 2018-04-17 00:32:51
  • hzbooks 2019-12-31 07:00:00
  • 1.5MB birdgcc520 2010-11-24 15:20:18
  • 101KB death_note_ 2013-03-21 17:53:01
  • ZeromaXHe 2019-05-01 20:26:36
  • 5星
    36.16MB we427 2016-01-03 15:33:01
  • 5星
    70MB zm250282524 2017-11-24 13:31:47
  • qq_52549458 2021-08-16 21:41:07
  • weixin_43824410 2020-07-29 20:07:55
  • 4星
    1.54MB wei_xiao0125 2007-09-04 19:01:12
  • qq_61476828 2021-11-11 18:18:00
  • ant2335340189 2021-08-24 07:24:15
  • Nexas 2021-07-10 22:23:50

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 187
精华内容 74
关键字:

java核心技术第11版卷1

java 订阅