JavaSE常用API文档中【java全端课】

微客鸟窝
91 阅读37分钟

八、字符串工具类

8.1 java.lang.String类

  • public String() ：初始化新创建的 String对象，以使其表示空字符序列。
  • String(String original)： 初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。
  • public String(char[] value) ：通过当前参数中的字符数组来构造新的String。
  • public String(char[] value,int offset, int count) ：通过字符数组的一部分来构造新的String。
  • public String(byte[] bytes) ：通过使用运行环境的默认字符集解码当前参数中的字节数组来构造新的String。
  • public String(byte[] bytes,String charsetName) ：通过使用指定的字符集解码当前参数中的字节数组来构造新的String。
  • public boolean isEmpty()：判断字符串是否为空字符串，这里的空字符串是说长度为0的字符串。
  • public boolean isBlank()：判断字符串中是否除了空白字符，没有别的字符。长度不一定为0。
  • public int length()：获取字符串的长度，即字符串中字符的个数。
  • public String toUpperCase()：根据当前字符串文本返回大写形式的字符串。
  • public String toLowerCase()：根据当前字符串文本返回小写形式的字符串。
  • public String trim()：去掉当前字符串中前后空白符返回新字符串对象。如果当前字符串前后没有空白符，则返回原字符串对象。
  • public char charAt(int index)：获取[index]位置的字符
  • public char[] toCharArray()：将字符串中的字符放到一个char[]数组中返回。
  • public boolean equals(Object o)：判断两个字符串的内容、长度、顺序、大小写是否完全一致。重写Object类的equals方法。
  • public boolean equalsIgnoreCase(Object o)：忽略大小写比较两个字符串的内容，当然要求长度、顺序要完全一致。
  • public int compareTo(Object obj)：重写Comparable接口的抽象方法，用于比较字符串大小。按照字符的编码值比较大小，长的字符串与短的字符串前面的字符全部都相同，那么按照长度比较大小，短的小，长的大。
  • public int compareToIgnoreCase(String o)：不区分大小写的字符串比较大小。
  • public boolean startWith(String s)：判断当前字符串是否以s开头
  • public boolean endsWith(String s)：判断当前字符串是否以s结尾
  • public String substring(int index)：从当前字符串[index]开始截取到最后构成新字符串。
  • public String substring(int start, int end)：从当前字符串截取[start ,end)部分的字符构成新字符串，Java中凡是表示区间的都是左闭右开。
  • public boolean contains(CharSequence obj)：判断当前字符串中是否包含obj子串。
  • public int indexOf(String s)：查找子串s在当前字符串中的下标，如果出现多个s，返回左边第一次出现的下标
  • public int lastIndexOf(String s)：查找子串s在当前字符串中的下标，如果出现多个s，返回最右边或最后一次出现的下标
  • public byte[] getBytes()：按照程序运行环境默认的编码方式把字符串转为字节数组，例如IDEA设置的UTF-8。
  • public byte[] getBytes(String charset)：按照指定的编码方式把字符串转为字节数组，例如：GBK。
    • 编码：把字符序列转为字节序列，为了网络传输，文件的读写。
    • 解码：把字节序列转为字符序列，为了给人看。
  • public boolean matches(正则表达式)：判断当前字符串是否匹配某个正则表达式。
  • public String[] split(正则表达式)：把当前字符串按照某个规则拆分为多个字符串。
  • public String replace(char oldChar, char newChar)：把当前字符串中oldChar字符替换为newChar。
  • public String replaceFirst(正则表达式, String newStr)：把当前字符串中第一个满足该规则的字符替换为newStr。
  • public String replaceAll(正则表达式, String newStr)：把当前字符串中所有满足该规则的字符替换为newStr。
  • public String concat(String s)：将当前字符串与s字符串拼接构成新字符串。
  • public String intern()：在字符串常量池中查找是否有与当前字符串相同的字符串，如果有返回常量池中那个字符串的首地址；如果没有，将当前放入字符串常量池，并返回其首地址。

8.2 java.lang.StringBuffer类

  • public StringBuffer() ：构造一个没有字符的字符串缓冲区，初始容量为16个字符。

  • public StringBuffer(CharSequence seq) ：构造一个包含与指定的相同字符的字符串缓冲区 CharSequence 。

  • public StringBuffer(int capacity) 构造一个没有字符的字符串缓冲区和指定的初始容量。

  • public StringBuffer(String str) ：构造一个初始化为指定字符串内容的字符串缓冲区。

  • public StringBuffer append(各种数据类型的值)：在当前字符串末尾追加（即拼接）某个值。

  • public StringBuffer insert(int index, 各种数据类型的值：在[index]位置插入某个值。

  • public StringBuffer delete(int start, int end)：删除[start,end)之间字符。

  • public StringBuffer deleteCharAt(int index)：删除[index]位置字符。

  • public void setCharAt(int index, xx)：替换[index]位置字符。

  • public StringBuffer reverse()：将当前字符串中的字符顺序反转。

  • public void setLength(int newLength) ：设置当前字符序列长度为newLength。

  • public StringBuffer replace(int start, int end, String str)：替换[start,end)范围的字符序列为str。

  • public int indexOf(String str)：在当前字符序列中查询str的第一次出现下标。

  • public int indexOf(String str, int fromIndex)：在当前字符序列[fromIndex,最后]中查询str的第一次出现下标。

  • public int lastIndexOf(String str)：在当前字符序列中查询str的最后一次出现下标。

  • public int lastIndexOf(String str, int fromIndex)：在当前字符序列[fromIndex,最后]中查询str的最后一次出现下标。

  • public String substring(int start)：截取当前字符串[start,最后]部分的字符构成String字符串对象。

  • public String substring(int start, int end)：截取当前字符串[start,end)部分的字符构成String字符串对象。

  • public String toString()：将当前StringBuffer对象中的所有字符序列构建为String对象返回。

  • public void trimToSize()：尝试减少用于字符序列的存储空间。如果缓冲区大于保存当前字符序列所需的存储空间，则将重新调整其大小，以便更好地利用存储空间。

8.3 java.lang.StringBuilder类

StringBuilder类的API与StringBuffer类完全兼容，即上述API方法将StringBuffer换成StringBuilder即可。只是StringBuffer是线程安全的，StringBuilder是线程不安全的。

九、Objects工具类

JDK1.7引入，用于判断对象是否为空，计算对象hash值，比较两个对象大小、是否相等，返回对象toString结果。

  • public static boolean isNull(Object obj)：判断某个对象是否为null，如果为null返回true，否则返回false。
  • public static boolean nonNull(Object obj)：判断某个对象是否非null，如果非null返回true，否则返回false。
  • public static int hashCode(Object o)：计算某个对象的哈希值。
  • public static int hash(Object... values)：计算一组对象的哈希值。
  • public static int compare(T a, T b, Comparator<? super T> c)：用指定比较器比较两个对象的大小关系。
  • public static boolean equals(Object a, Object b)：比较两个对象是否相等。
  • public static String toString(Object o)：如果对象o为null，则返回"null"，否则返回o.toString()结果。
  • public static String toString(Object o, String nullDefault)：如果对象o不为null，返回o.toString()结果，否则返回nullDefault值。

十、集合

10.1 集合框架图

10.2 java.lang.Iterable接口

实现这个接口的对象就可以使用Iterator迭代器进行遍历。

实现这个接口允许对象成为 "foreach" 语句的目标。

  • public Iterator iterator()：返回一个迭代器对象，用于遍历容器中的元素。
  • public default void forEach(Consumer<? super T> action)：将action指定的操作应用到容器中的所有元素上。

10.3 java.util.Iterator接口

  • public boolean hasNext()：如果仍有元素可以迭代，则返回 true。
  • public E next() ：返回当前元素，并让迭代器指向下一个元素。
  • public void remove()：从迭代器指向的容器中移除迭代器最后返回的元素。

10.4 java.util.Collection接口

1、添加元素

  • public boolean add(E e)：添加一个元素。

  • public boolean addAll(Collection<? extends E> c)：添加一组元素。即把c集合中的一组元素添加到当前集合(this)。 this = this ∪ c

2、删除元素

  • public void clear()：清空所有元素。

  • public boolean remove(Object o)：在当前集合中找到和o相等的一个元素，然后删除它，并返回true。如果没找到，返回false。

  • public boolean removeAll(Collection<?> c)：从当前集合中删除所有和c集合中“相同的”元素。this = this - this ∩ c。

  • public boolean retainAll(Collection<?> c)：从当前集合中删除和所有和c集合中“不同的”元素，即当前集合中只留下和c集合相同的元素。this = this ∩ c。

  • public default boolean removeIf(Predicate<? super E> filter)：JDK8引入的。从当前集合中删除Predicate接口的实现类的test方法判断为true的元素。在Predicate接口的实现类中会重写一个boolean test(E element)方法，该方法用于判断当前集合的元素是否满足xx条件。在removeIf方法中，会遍历集合所有元素，并将元素作为实参传给test方法，如果该元素满足test方法中的条件，则返回true，该元素就会被删除；该元素不满足test方法中的条件，则返回false，该元素就会被保留。

3、查询元素

  • public boolean contains(Object obj)：用于判断当前集合是否包含obj这个对象。

  • public boolean containsAll(Collection<?> c)：用于判断当前集合是否包含c集合的所有对象。即判断c集合是否是当前集合的“子集”。如果c是this的子集，返回true，否则返回false。

  • public boolean isEmpty()：判断当前集合是否为空。

  • public int size()：用于返回当前集合的元素的总个数。

  • public Object[] toArray() ：把当前集合中所有元素放到一个Object[]数组中返回。

  • public T[] toArray(T[] a)：把当前集合中所有元素放到一个T[]数组中返回。T类型是可以兼容集合元素的任意类型。

4、遍历

  • foreach循环遍历
  • public Iterator iterator()：返回一个Iterator迭代器对象，用于遍历容器中的元素。

10.5 java.util.Set接口

Set是Collection的子接口。Set接口的API和Collection接口完全相同。

10.6 java.util.SortedSet接口

SortedSet是Set的子接口。

  • public Comparator<? super E> comparator()：返回用于对该集合中的元素进行排序的定制比较器对象。如果此集合使用元素的自然比较顺序，则返回null。
  • public E first() ：返回此当前集合的第一个元素。
  • public E last() ：返回此当前集合的最后一个元素。
  • public SortedSet headSet(E toElement)：返回当前之前排在toElement元素之前的所有元素。
  • public SortedSet tailSet(E fromElement)：返回当前之前排在fromElement元素之后的所有元素。
  • public SortedSet subSet(E fromElement, E toElement)：返回当前之前排在[fromElement,toElement)之间的所有元素。

10.7 java.util.List接口

List是Collection的子接口。Collection接口中的所有方法，List接口都有。另外，List接口还包含如下方法：

1、添加

  • public void add(int index, E element)：把新元素element添加到指定到当前集合列表的[index]位置。
  • public boolean addAll(int index, Collection<? extends E> c)：将c集合的所有元素添加到指定到当前集合列表的[index]位置。

2、删除

  • public E remove(int index)：删除当前集合列表中[index]位置的元素，并返回被删除元素。

3、修改

  • public E set(int index, E ele)：替换当前集合列表中[index]位置的元素，并返回被替换的元素。
  • public default void replaceAll(UnaryOperator operator)：JDK8引入的。实现UnaryOperator接口时必须重写public E apply(E oldValue) 方法。在replaceAll方法中会遍历集合的所有元素，并将每一个元素作为实参传给apply方法，然后用apply方法的返回值作为newValue替换该元素。
  • pubilc default void sort(Comparator<? super E> c)：使用定制比较器对象c，对当前集合列表的元素排序。

4、查询

  • public E get(int index)：返回当前集合列表中[index]位置的元素
  • public List subList(int fromIndex, int toIndex)：返回当前集合列表中[fromIndex, toIndex)范围的元素
  • public int indexOf(Object obj)：在当前集合列表中查询obj元素的位置，如果存在多个obj，则返回第1次出现的位置。
  • int lastIndexOf(Object obj)：在当前集合列表中查询obj元素的位置，如果存在多个obj，则返回最后1次出现的位置。

5、遍历

  • foreach循环遍历
  • public Iterator iterator()：返回一个Iterator迭代器对象，用于遍历容器中的元素。
  • 普通for循环+list.size()+list.get(下标)
  • public ListIterator listIterator()：返回一个ListIterator迭代器对象。用于遍历容器中的元素。一开始ListIterator迭代器游标默认在集合的第一个元素位置。
  • public ListIterator listIterator(int index)：返回一个ListIterator迭代器对象。用于遍历容器中的元素。一开始ListIterator迭代器游标默认[index]位置。

10.8 java.util.ListIterator接口

ListIterator是Iterator的子接口。

  • public boolean hasNext()：以正向遍历列表，往后仍有元素可以迭代，则返回 true。

  • public E next() ：以正向遍历列表，返回迭代器指向的当前元素，并让迭代器指向下一个元素。

  • public int nextIndex()：以正向遍历列表，返回迭代器指向的当前元素的索引。

  • public boolean hasPrevious()：以逆向遍历列表，往前仍有元素可以迭代，则返回true。

  • public Object previous()：以逆向遍历列表，返回迭代器前面的一个元素。

  • public int previousIndex()：以逆向遍历列表，返回迭代器前面一个元素的索引。

  • public void add(E e)：在迭代器当前位置添加元素e到对应集合。

  • public void set(Object obj)：通过迭代器替换迭代器最后返回的元素。

  • public void remove()：从当前列表迭代器指向的容器中移除迭代器最后返回的元素。

10.9 java.util.Stack类

Stack用以描述一个堆栈结构的容器，元素具有先进后出（FILO）的特点。

  • public E push(E item)：将元素添加到此堆栈的顶部。
  • public E pop()：删除此堆栈顶部的对象，并返回该对象
  • public E peek()：查看此堆栈顶部的对象，而不从堆栈中删除它。
  • public boolean empty()：测试此堆栈是否为空。
  • public int search(Object o)：返回对象o在此堆栈的位置。栈顶为1。

10.10 java.util.Queue接口

Queue用以描述一个队列结构的容器，元素具有先进先出（FIFO）的特点。Queue也是Collection接口的子接口，所以Queue接口也具有Collection接口的方法。

1、失败抛出异常

  • public boolean add(E e)：将指定的元素插入到此队列中，如果当前容器没有容量限制，添加成功则返回true，如果没有空间可用，则抛出IllegalStateException。
  • public E remove()：删除并返回队头元素。 如果队列没有元素，则抛出NoSuchElementException异常
  • public E element()：查看队头的元素，但不删除。 如果队列没有元素，则抛出NoSuchElementException异常。

2、失败返回特殊值

  • public boolean offer(E e)：如果在不违反容量限制的情况下将指定的元素插入到此队列中，并返回true，否则返回false。

  • public E poll()：删除并返回队头元素。 如果队列没有元素，则返回 null 。

  • public E peek()：查看队头的元素，但不删除。 如果队列没有元素，则返回 null 。

10.11 java.util.Deque接口

Deque用以描述一个双端队列结构的容器，元素既可以从队头添加和删除，也可以从队尾添加和删除。Deque也是Collection和Queue接口的子接口，所以Deque接口也具有Collection和Queue接口的方法。

1、失败抛出异常

  • public void addFirst(E e)：如果没有容量限制，将元素插入此双端队列的最前面。如果没有可用容量，则抛出IllegalStateException。
  • public void addLast(E e)：如果没有容量限制，将元素插入此双端队列的最后面。如果没有可用容量，则抛出IllegalStateException。
  • public E removeFirst()：返回并删除此双端队列最前面的元素。如果没有元素，则抛出NoSuchElementException异常。
  • public E removeLast()：返回并删除此双端队列最后面的元素。如果没有元素，则抛出NoSuchElementException异常
  • public E getFirst()：返回但不删除此双端队列最前面的元素。如果没有元素，则抛出NoSuchElementException异常。
  • public E getLast()：返回但不删除此双端队列最后面的元素。如果没有元素，则抛出NoSuchElementException异常。

2、失败返回特殊值

  • public boolean offerFirst(E e)：如果没有容量限制，将元素插入此双端队列的最前面，并返回true，否则返回false。
  • public boolean offerLast(E e)：如果没有容量限制，将元素插入此双端队列的最后面，并返回true，否则返回false。
  • public E pollFirst()：返回并删除此双端队列最前面的元素。如果没有元素，则返回null。
  • public E pollLast()：返回并删除此双端队列最后面的元素。如果没有元素，则返回null。
  • public boolean removeFirstOccurrence(Object o)：如果o存在于此双端队列中，则删除它第一次。如果不存在，什么也不干。
  • public boolean removeLastOccurrence(Object o)：如果o存在于此双端队列中，则删除它最后一次。如果不存在，什么也不干。
  • public E peekFirst()：返回但不删除此双端队列最前面的元素。如果没有元素，则返回null。
  • public E peekLast()：返回但不删除此双端队列最后面的元素。如果没有元素，则返回null。

10.12 java.util.Map<K,V>接口

java.util.Map<K,V>接口，是Map系列集合的根接口，这个系列的集合用于存储 键值对或 映射关系，(key,value)，即每一个key对应一个value,或者说每一个key会映射到一个value上。

Map系列的集合有一个共同特点：key不可重复。如果key重复了，后面的value会覆盖/替换原来的value。

1、添加

  • public V put(K key, V value)：添加一对键值对。如果是首次添加这个key的映射关系，那么返回值是null。如果这个key的映射关系已存在，返回被覆盖/替换的value值。
  • public void putAll(Map<? extends K,? extends V> m)：添加一组键值对。如果m集合中有key与当前map的key重复，会覆盖当前集合中的(key,value)。

2、删除

  • public void clear()：清空当前map。
  • public V remove(Object key)：根据key删除一对键值对。如果该key的映射关系存在，那么会移除一对映射关系，并且返回value值。如果该key的映射关系不存在，返回null。
  • public default boolean remove(Object key,Object value)：删除匹配的(key,value)键值对。该方法是JDK8引入的。

3、修改

  • 如果你是key不变，修改value，可以再次put一下新的(key,value)。
  • public default V replace(K key, V value)：找到目标key，替换value。
  • public default boolean replace(K key,V oldValue,V newValue)：找到目标(key,value)，替换value。
  • public default void replaceAll(BiFunction<? super K,? super V,? extends V> function)：实现BiFunction接口并重写R apply(T t, U u)方法（此时为public String apply(Integer key, String oldValue)形式）。在replaceAll方法中会遍历当前map，并将每一个(key,value)作为实参传给apply方法，然后将apply方法的返回值作为newValue覆盖当前oldValue。

4、查询

  • public V get(Object key)：根据key返回value。
  • public default V getOrDefault(Object key,V defaultValue)：如果根据key可以get到一个非null的value值，则返回value值，否则返回defaultValue。
  • public boolean containsKey(Object key)：判断key是否存在。
  • public boolean containsValue(Object value)：判断value是否存在。
  • public boolean isEmpty()：判断map是否为空。
  • public int size()：获取键值对的数量。

5、遍历

==注意==：Map接口并没有继承Iterarble接口，所以不能直接使用foreach或Iterator迭代器遍历。

（1）分开遍历：

  • public Set keySet()：返回当前map中的所有key构成的Set集合，然后可以遍历所有的key。
  • public Collection values()：返回当前map中的所有value构成的Collection集合，然后遍历所有value。

（2）成对遍历：

  • public default void forEach(BiConsumer<? super K,? super V> action)：实现BiConsumer接口的void accept(T t, U u)抽象方法（此时为public void accept(Integer key, String value)形式）。在forEach方法中会遍历当前map的所有键值对，并将每一对键值对(key,value)作为实参传给accept方法。
  • public Set<Map.Entry<K,V>> entrySet()：返回当前map中所有键值对Entry对象构成的Set集合，然后遍历所有键值对的Entry对象。
  • 遍历的是映射关系Map.Entry类型的对象，Map.Entry是Map接口的内部接口。每一种Map内部有自己的Map.Entry的实现类。在Map中存储数据，实际上是将Key---->value的数据存储在Map.Entry接口的实例中，再在Map集合中插入Map.Entry的实例化对象，如图示：

6、其他

  • public default V putIfAbsent(K key, V value)：先用该key从当前map中get到oldValue值。如果该oldValue值为null，那么将(key,value)映射关系==put==到当前map中。如果该oldValue值不为null，那么==不覆盖==value。最后putIfAbsent方法返回oldValue值。
  • public default V merge(K key,V value,BiFunction<? super V,? super V,? extends V> remappingFunction)：实现BiFunction接口并重写R apply(T t, U u)方法（此时为public String apply(String oldValue, String value) 形式）。在merge方法中，先用该key从当前map中查询oldValue值，如果oldValue为null，则将(key,value)映射关系==put==到当前map中，最后merge方法返回value值；如果oldValue不为null，则将(oldValue，value)作为实参传给apply方法，并用apply方法的返回值作为newValue覆盖oldValue，最后merge方法返回newValue值。
  • public default V computeIfPresent(K key,BiFunction<? super K,? super V,? extends V> remappingFunction)：实现BiFunction接口并重写R apply(T t, U u)方法（此时为public String apply(Integer key, String oldValue)形式）。在computeIfPresent，先用该key从当前map中查询oldValue值，如果oldValue为null，则什么也不干，最后computeIfPresent方法返回null；如果oldValue不为null，则将(key，oldValue)作为实参传给apply方法，并用apply方法的返回值作为newValue==覆盖==oldValue，最后computeIfPresent方法返回newValue。
  • public default V computeIfAbsent(K key,Function<? super K,? extends V> mappingFunction)：实现BiFunction接口并重写R apply(T t, U u)方法（此时为public String apply(Integer key)形式）。在computeIfPresent，先用该key从当前map中查询oldValue值，如果oldValue不为null，则什么也不干，最后computeIfAbsent方法返回oldValue；如果oldValue为null，则将(key)作为实参传给apply方法，并用apply方法的返回值作为newValue，将(key,newValue)映射关系==put==到当前map中，最后computeIfAbsent方法返回newValue。
  • public default V compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) ：实现BiFunction接口并重写R apply(T t, U u)方法（此时为public String apply(Integer key, String oldValue)形式）。在computeIfPresent，先用该key从当前map中查询oldValue值，再将(key, oldValue)作为实参传给apply方法，然后用apply方法的返回值作为newValue，并将(key, newValue)映射关系==put==到当前map中，最后compute方法返回newValue。

10.13 java.util.Map.Entry<E,V>接口

Map.Entry<E,V>接口是Map<K,V>接口的静态内部接口。

  • public K getKey()：返回与此键值对的key键。
  • public V getValue()：返回与此键值对的value值。
  • public V setValue(V value)：替换此键值对的value值。

10.14 java.util.SortedMap<K,V>接口

SortedMap<K,V>接口是Map<K,V>的子接口。Map接口的方法，它也有，如下是它新增的方法：

public Comparator<? super K> comparator()：返回用于当前map中的比较器。 如果此集合使用元素的自然比较顺序，则返回null。

public K firstKey()：返回当前map中当前的第一个（最低）键。

public SortedMap<K,V> headMap(K toKey)：返回当前map中key小于 toKey 的键值对。

public K lastKey()：返回当前map中的最后（最高）键。

public SortedMap<K,V> subMap(K fromKey, K toKey)：返回当前map中key在[fromKey ,toKey )范围的键值对。

public SortedMap<K,V> tailMap(K fromKey)：返回当前map中key大于 fromKey的键值对。

10.15 java.util.Collections类

Collections类似于Arrays，只是一个工具类，它是专门用于为各种集合服务的工具类。

Collections 是一个操作 Set、List 和 Map 等集合的工具类。Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制（线程安全）等方法：

  • public static boolean addAll(Collection<? super T> c,T... elements)：将所有指定元素添加到指定 collection 中。

  • public static int binarySearch(List<? extends Comparable<? super T>> list,T key)：在List集合中查找某个元素的下标，List的元素必须支持可比较大小，即支持自然排序。而且List集合也事先必须是有序的，否则结果不确定。

  • public static int binarySearch(List<? extends T> list,T key,Comparator<? super T> c)：在List集合中查找某个元素的下标，List的元素使用定制比较器c的compare方法比较大小。而且List集合也事先必须是有序的，否则结果不确定。

  • public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)在coll集合中找出最大的元素，集合中的对象必须是T或T的子类对象，而且支持自然排序

  • public static T max(Collection<? extends T> coll,Comparator<? super T> comp)在coll集合中找出最大的元素，集合中的对象必须是T或T的子类对象，按照比较器comp找出最大者

  • public static void reverse(List<?> list)反转指定列表List中元素的顺序。

  • public static void shuffle(List<?> list) List 集合元素进行随机排序，类似洗牌

  • public static <T extends Comparable<? super T>> void sort(List list)根据元素的自然顺序对指定 List 集合元素按升序排序

  • public static void sort(List list,Comparator<? super T> c)根据指定的 Comparator 产生的顺序对 List 集合元素进行排序

  • public static void swap(List<?> list,int i,int j)将指定 list 集合中的 i 处元素和 j 处元素进行交换

  • public static int frequency(Collection<?> c,Object o)返回指定集合中指定元素的出现次数

  • public static void copy(List<? super T> dest,List<? extends T> src)将src中的内容复制到dest中

  • public static boolean replaceAll(List list，T oldVal，T newVal)：使用新值替换 List 对象的所有旧值

  • Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题

  • Collections类中提供了多个unmodifiableXxx()方法，该方法返回指定 Xxx的不可修改的视图。

十一、Lambda表达式与StreamAPI

11.1 函数式接口

11.1.1 消费型接口

消费型接口的抽象方法特点：有形参，但是返回值类型是void

序号接口名抽象方法描述
1Consumervoid accept(T t)接收一个对象用于完成功能
2BiConsumer<T,U>void accept(T t, U u)接收两个对象用于完成功能
3DoubleConsumervoid accept(double value)接收一个double值
4IntConsumervoid accept(int value)接收一个int值
5LongConsumervoid accept(long value)接收一个long值
6ObjDoubleConsumervoid accept(T t, double value)接收一个对象和一个double值
7ObjIntConsumervoid accept(T t, int value)接收一个对象和一个int值
8ObjLongConsumervoid accept(T t, long value)接收一个对象和一个long值

11.1.2 供给型接口

供给型接口的抽象方法特点：无参，但是有返回值

序号接口名抽象方法描述
1SupplierT get()返回一个对象
2BooleanSupplierboolean getAsBoolean()返回一个boolean值
3DoubleSupplierdouble getAsDouble()返回一个double值
4IntSupplierint getAsInt()返回一个int值
5LongSupplierlong getAsLong()返回一个long值

11.1.3 判断型接口

判断型接口的抽象方法特点：有参，但是返回值类型是boolean结果。

序号接口名抽象方法描述
1Predicateboolean test(T t)接收一个对象
2BiPredicate<T,U>boolean test(T t, U u)接收两个对象
3DoublePredicateboolean test(double value)接收一个double值
4IntPredicateboolean test(int value)接收一个int值
5LongPredicateboolean test(long value)接收一个long值

11.1.4 功能型接口

功能型接口的抽象方法特点：既有参数又有返回值。

  • 以Operator单词结尾的函数式接口，它的抽象方法的形参类型与返回值类型是一样的。
  • 以Bi开头或中间包含Bi的函数式接口，它的抽象方法有两个形参
  • 以To开始或中间包含To的函数式接口，它的抽象方法的返回值类型是to后面的类型
序号接口名抽象方法描述
1Function<T,R>R apply(T t)接收一个T类型对象，返回一个R类型对象结果
2UnaryOperatorT apply(T t)接收一个T类型对象，返回一个T类型对象结果
3DoubleFunctionR apply(double value)接收一个double值，返回一个R类型对象
4IntFunctionR apply(int value)接收一个int值，返回一个R类型对象
5LongFunctionR apply(long value)接收一个long值，返回一个R类型对象
6ToDoubleFunctiondouble applyAsDouble(T value)接收一个T类型对象，返回一个double
7ToIntFunctionint applyAsInt(T value)接收一个T类型对象，返回一个int
8ToLongFunctionlong applyAsLong(T value)接收一个T类型对象，返回一个long
9DoubleToIntFunctionint applyAsInt(double value)接收一个double值，返回一个int结果
10DoubleToLongFunctionlong applyAsLong(double value)接收一个double值，返回一个long结果
11IntToDoubleFunctiondouble applyAsDouble(int value)接收一个int值，返回一个double结果
12IntToLongFunctionlong applyAsLong(int value)接收一个int值，返回一个long结果
13LongToDoubleFunctiondouble applyAsDouble(long value)接收一个long值，返回一个double结果
14LongToIntFunctionint applyAsInt(long value)接收一个long值，返回一个int结果
15DoubleUnaryOperatordouble applyAsDouble(double operand)接收一个double值，返回一个double
16IntUnaryOperatorint applyAsInt(int operand)接收一个int值，返回一个int结果
17LongUnaryOperatorlong applyAsLong(long operand)接收一个long值，返回一个long结果
18BiFunction<T,U,R>R apply(T t, U u)接收一个T类型和一个U类型对象，返回一个R类型对象结果
19BinaryOperatorT apply(T t, T u)接收两个T类型对象，返回一个T类型对象结果
20ToDoubleBiFunction<T,U>double applyAsDouble(T t, U u)接收一个T类型和一个U类型对象，返回一个double
21ToIntBiFunction<T,U>int applyAsInt(T t, U u)接收一个T类型和一个U类型对象，返回一个int
22ToLongBiFunction<T,U>long applyAsLong(T t, U u)接收一个T类型和一个U类型对象，返回一个long
23DoubleBinaryOperatordouble applyAsDouble(double left, double right)接收两个double值，返回一个double结果
24IntBinaryOperatorint applyAsInt(int left, int right)接收两个int值，返回一个int结果
25LongBinaryOperatorlong applyAsLong(long left, long right)接收两个long值，返回一个long结果

11.2 StreamAPI

Stream API ( java.util.stream) 把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。 使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

Stream是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是数据，负责存储数据，Stream流讲的是计算，负责处理数据！”

注意：

①Stream 自己不会存储元素。

②Stream 不会改变源对象。每次处理都会返回一个持有结果的新Stream。

③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

11.2.1 创建StreamAPI

1、创建 Stream方式一：通过集合

Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：

  • public default Stream stream() : 返回一个顺序流

  • public default Stream parallelStream() : 返回一个并行流

2、创建 Stream方式二：通过数组

Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：

  • public static Stream stream(T[] array): 返回一个流

重载形式，能够处理对应基本类型的数组：

  • public static IntStream stream(int[] array)：返回一个整型数据流
  • public static LongStream stream(long[] array)：返回一个长整型数据流
  • public static DoubleStream stream(double[] array)：返回一个浮点型数据流

3、创建 Stream方式三：通过Stream的of()

可以调用Stream类静态方法 of(), 通过显示值创建一个流。它可以接收任意数量的参数。

  • public static Stream of(T... values) : 返回一个顺序流

4、创建 Stream方式四：创建无限流

可以使用静态方法 Stream.iterate() 和 Stream.generate(), 创建无限流。

  • public static Stream iterate(final T seed, final UnaryOperator f):返回一个无限流
  • public static Stream generate(Supplier s) ：返回一个无限流

11.2.2 Stream中间操作API

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。

序号方 法描 述
1Stream filter(Predicate p)接收 Lambda ， 从流中排除某些元素
2Stream distinct()筛选，通过流所生成元素的equals() 去除重复元素
3Stream limit(long maxSize)截断流，使其元素不超过给定数量
4Stream skip(long n)跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
5Stream peek(Consumer action)接收Lambda，对流中的每个数据执行Lambda体操作
6Stream sorted()产生一个新流，其中按自然顺序排序
7Stream sorted(Comparator com)产生一个新流，其中按比较器顺序排序
8Stream map(Function f)接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
9Stream mapToDouble(ToDoubleFunction f)接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 DoubleStream。
10Stream mapToInt(ToIntFunction f)接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 IntStream。
11Stream mapToLong(ToLongFunction f)接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 LongStream。
12Stream flatMap(Function f)接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

11.2.3 终结Stream操作API

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void。流进行了终止操作后，不能再次使用。

序号方法的返回值类型方法描述
1booleanallMatch(Predicate p)检查是否匹配所有元素
2booleananyMatch(Predicate p)检查是否至少匹配一个元素
3booleannoneMatch(Predicate p)检查是否没有匹配所有元素
4OptionalfindFirst()返回第一个元素
5OptionalfindAny()返回当前流中的任意元素
6longcount()返回流中元素总数
7Optionalmax(Comparator c)返回流中最大值
8Optionalmin(Comparator c)返回流中最小值
9voidforEach(Consumer c)迭代
10Treduce(T iden, BinaryOperator b)可以将流中元素反复结合起来，得到一个值。返回 T
11Ureduce(BinaryOperator b)可以将流中元素反复结合起来，得到一个值。返回 Optional
12ListtoList()JDK16引入的，将流中元素收集到List集合中
13Object[]toArray()JDK16引入的，将流中元素收集到Object数组中
14Rcollect(Collector c)将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法

Collector 接口中方法的实现决定了如何对流执行收集的操作(如收集到 List、Set、Map)。Collector对象由Collectors工具的静态方法来创建。

11.2.4 java.util.stream.Collectors

Collectors 工具类提供了很多静态方法，可以方便地创建常见收集器实例。

序号方法描述
1static Collector<T,?,List> toList()返回一个Collector，用于将流中的数据收集到一个List集合中
2static Collector<T,?,Set> toSet()返回一个Collector，用于将流中的数据收集到一个Set集合中
3static <T,K,U> Collector<T,?,Map<K,U>> toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)返回一个Collector，用于将流中的数据收集到一个Map集合中
4static Collector<T,?,Optional> reducing(BinaryOperator op)基于op指定的操作对流中的数据进行归纳，最终得到一个对象结果
5static Collector<T,?,T> reducing(T identity, BinaryOperator op)基于op指定的操作对流中的数据进行归纳，最终得到一个对象结果，起始值是identity
6static Collector<T,?,Double> averagingDouble(ToDoubleFunction<? super T> mapper)返回一个 Collector ，用于将其他类型的对象流转换为double流，然后求它们的平均值。
7static Collector<T,?,Double> averagingInt(ToIntFunction<? super T> mapper)返回一个 Collector ，用于将其他类型的对象流转换为int流，然后求它们的平均值。
8static Collector<T,?,Double> averagingLong(ToLongFunction<? super T> mapper)返回一个 Collector ，用于将其他类型的对象流转换为long流，然后求它们的平均值。
9static Collector<T,?,Long> counting()返回一个 Collector ，用于统计流中元素的数量
10static Collector<T,?,Optional> maxBy(Comparator<? super T> comparator)返回一个Collector，用于对流中的数据基于定制比较器comparator查找最大值
11static Collector<T,?,Optional> minBy(Comparator<? super T> comparator)返回一个Collector，用于对流中的数据基于定制比较器comparato查找最小值
12static Collector<T,?,Double> summingDouble(ToDoubleFunction<? super T> mapper)返回一个Collector，用于将其他类型的对象流转换为double流，然后求它们的总和。
13static Collector<T,?,Integer> summingInt(ToIntFunction<? super T> mapper)返回一个Collector，用于将其他类型的对象流转换为int流，然后求它们的总和。
14static Collector<T,?,Long> summingLong(ToLongFunction<? super T> mapper)返回一个Collector，用于将其他类型的对象流转换为long流，然后求它们的总和。
15static Collector<T,?,DoubleSummaryStatistics> summarizingDouble(ToDoubleFunction<? super T> mapper)返回一个Collector，用于将其他类型的对象流转换为double流，然后求它们的总和、平均值、最大最小值、总数量。
16static Collector<T,?,IntSummaryStatistics> summarizingInt(ToIntFunction<? super T> mapper)返回一个Collector，用于将其他类型的对象流转换为int流，然后求它们的总和、平均值、最大最小值、总数量。
17static Collector<T,?,LongSummaryStatistics> summarizingLong(ToLongFunction<? super T> mapper)返回一个Collector，用于将其他类型的对象流转换为long流，然后求它们的总和、平均值、最大最小值、总数量。
18static <T,K> Collector<T,?,Map<K,List>> groupingBy(Function<? super T,? extends K> classifier)返回一个Collector，用于对流中的数据进行分组统计
19static <T,K,A,D> Collector<T,?,Map<K,D>> groupingBy(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)返回一个Collector，用于对流中的数据进行分组统计，然后基于分组再对流中的数据使用downstream进行统计
20static Collector<T,?,Map<Boolean,List>> partitioningBy(Predicate<? super T> predicate)返回一个Collector，用于对流中的数据进行分组统计，结果是Map<Boolean, List>
21static <T,D,A> Collector<T,?,Map<Boolean,D>> partitioningBy(Predicate<? super T> predicate, Collector<? super T,A,D> downstream)返回一个Collector，用于对流中的数据进行分组统计，然后基于分组结果Map<Boolean, List>再对流中的数据使用downstream进行统计

11.3、java.util.Optional类

Optional实际上是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。

序号构造器或方法描述
1static Optional empty()用来创建一个空的Optional
2static Optional of(T value)用来创建一个非空的Optional
3static Optional ofNullable(T value)用来创建一个可能是空，也可能非空的Optional
4T get()返回Optional容器中的对象。要求Optional容器必须非空。T get()与of(T value)使用是安全的
5T orElse(T other)如果Optional容器中非空，就返回所包装值，如果为空，就用orElse(T other)other指定的默认值（备胎）代替。一般orElse(T other) 与ofNullable(T value)配合使用
6T orElseGet(Supplier<? extends T> other)如果Optional容器中非空，就返回所包装值，如果为空，就用Supplier接口的Lambda表达式提供的值代替
7 T orElseThrow(Supplier<? extends X> exceptionSupplier)如果Optional容器中非空，就返回所包装值，如果为空，就抛出你指定的异常类型代替原来的NoSuchElementException
8boolean isPresent()判断Optional容器中的值是否存在
9void ifPresent(Consumer<? super T> consumer)判断Optional容器中的值是否存在，如果存在，就对它进行Consumer指定的操作，如果不存在就不做
10 Optional map(Function<? super T,? extends U> mapper)判断Optional容器中的值是否存在，如果存在，就对它进行Function接口指定的操作，如果不存在就不做

十二、多线程

12.1 java.lang.Runnable接口

公共的抽象方法：

void run()：线程要完成的任务代码需要写到run方法中。

12.2 java.lang.Thread类

12.2.1 构造器

  • public Thread() :分配一个新的线程对象。
  • public Thread(String name) :分配一个指定名字的新线程对象。
  • public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
  • public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

12.2.2 常用方法

  • public void run() :此线程要执行的任务在此处定义代码。

  • public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。

  • public ==static== Thread currentThread() :返回当前正在执行这句语句的线程对象的引用。

  • public String getName() :获取当前线程名称。默认是Thread-0，Thread-1，。。。。

  • public void setName(String name)：设置线程名称。

  • public final boolean isAlive()：测试线程是否处于活动状态。如果线程已经启动且尚未终止，则为活动状态。

  • public final int getPriority() ：返回线程优先级

  • public final void setPriority(int newPriority) ：改变线程的优先级

    • 每个线程都有一定的优先级，优先级高的线程将获得较多的执行机会。每个线程默认的优先级都与创建它的父线程具有相同的优先级。Thread类提供了setPriority(int newPriority)和getPriority()方法类设置和获取线程的优先级，其中setPriority方法需要一个整数，并且范围在[1,10]之间，通常推荐设置Thread类的三个优先级常量：
    • MAX_PRIORITY（10）：最高优先级
    • MIN _PRIORITY （1）：最低优先级
    • NORM_PRIORITY （5）：普通优先级，默认情况下main线程具有普通优先级。

  • public ==static== void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。

  • public ==static== void yield()：yield只是让当前线程暂停一下，让系统的线程调度器重新调度一次，希望优先级与当前线程相同或更高的其他线程能够获得执行机会，但是这个不能保证，完全有可能的情况是，当某个线程调用了yield方法暂停之后，线程调度器又将其调度出来重新执行。

  • void join() ：等待该线程终止。

    void join(long millis) ：等待该线程终止的时间最长为 millis 毫秒。如果millis时间到，将不再等待。

    void join(long millis, int nanos) ：等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。

  • public void interrupt()：中断线程。要通过这个方法制造InterrupttedException异常的话，前提是这个线程正在执行可能发生该异常的方法，例如：sleep，wait等。

  • public final void stop()：强迫线程停止执行。 该方法具有固有的不安全性，已经标记为@Deprecated==（已过时、已废弃）==不建议再使用，那么我们就需要通过其他方式来停止线程了，其中一种方式是使用变量的值的变化来控制线程是否结束。

  • public void setDaemon(true)：将指定线程设置为守护线程。必须在线程启动之前设置，否则会报IllegalThreadStateException异常。

  • public boolean isDaemon()：判断线程是否是守护线程。

avatar
文章
阅读
粉丝