java.util 包 Collection、Map、Objects、Optional、Base64、Iterator、Comparator、Collections、Arrays

lercent

已于 2023-07-31 15:30:53 修改

阅读量198

点赞数

分类专栏： Java 文章标签： java 数据结构

于 2020-06-26 17:32:53 首次发布

本文链接：https://blog.csdn.net/lercent/article/details/106943171

版权

Java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

1. Collection 集合

1.1 层次结构

Collection<E> （I）集合
	|
	|-- List<E> （I）有序的 Collection （与元素插入顺序一致），也称为序列。
    |    |		 可以对元素的插入位置进行精确地控制，可以根据元素的整数索引访问元素。
    |    |
    |    |-- Vector<E> （C）使用数组实现，索引数据快，插入数据慢；
	|    |	   |           线程安全，性能比ArrayList要差，实现线程安全的方式是在方法上添加 synchronized 关键字。
	|    |	   |
	|    |	   |-- Stack<E> （C）后进先出（LIFO）的对象堆栈。
    |    |
    |    |-- ArrayList<E> （C）使用数组实现，索引数据快，插入数据慢。
    |    |					  非线程安全；
    |    |
    |    |-- LinkedList<E> （C）使用双向链表实现，索引数据慢，插入数据快。
    |    |					   非线程安全；
    |
    |-- Set<E> （I）不含重复元素的 Collection 。
    |    |		即 Set 不含满足 e1.equals(e2) 的元素对，并且最多包含一个 null 元素。
    |    |
    |    |-- HashSet<E> （C）使用屏蔽了value部分的Map实现；无序的，与元素插入顺序无关。
    |    |	   |
    |    |	   |-- LinkedHashSet<E> （C）使用HashSet实现；有序的，与元素插入顺序一致。
    |    |
    |    |-- TreeSet<E> （C）使用屏蔽了value部分的Map实现；
    |    			 使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序。
    |
    |-- Queue<E> （I）队列，先进先出（FIFO）；从队列尾部添加元素，从队列头部删除元素。
    |    |
    |    |-- Deque<E> （I）双向队列,支持在队列两端插入和删除元素。
	|	   	   |
	|	       |-- LinkedList<E> （C）使用双向链表实现；索引数据慢，插入数据快。
	|	       |
	|	       |-- ArrayDeque<E> （C）使用数组实现，同样是双向的；索引数据快，插入数据慢。

2. Map 键值对

2.1 层次结构

Map<K,V> （I）键值对(key-value)。
 |
 |-- Hashtable<K,V> （C）线程安全，效率比 HashMap 低，实现线程安全的方式是在方法上添加 synchronized 关键字。
 |					    不允许 key 或者 value 为 null；
 |				        无序的，与元素插入顺序无关。
 |
 |-- HashMap<K,V> （C）非线程安全；
 |    |			      最多只允许一条记录的 key 为 null；
 |    |	              无序的，与元素插入顺序无关。
 |    |
 |    |-- LinkedHashMap<K,V> （C）有序的，与元素插入顺序一致。  
 |
 |-- TreeMap<K,V> （C）非线程安全；
 |					  最多只允许一条记录的 key 为 null；
 |					  根据键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序。
 |
 |-- ConcurrentHashMap<K,V> （C）线程安全的HashMap，比 Hashtable 及 synchronizedMap 获取的同步对象效率高；
 |								使用 synchronized 对链表头结点和红黑树根结点加锁来实现；
 |						        不允许 key 或者 value 为 null；
 |							    无序的，与元素插入顺序无关。

3. Objects 类

定义：
public final class Objects extends Object

API：
static <T> int compare(T a, T b, Comparator<? super T> c) 
如果参数相同，则返回0，否则返回 c.compare(a, b)。

static boolean equals(Object a, Object b) 
如果参数彼此相等，则返回true；否则返回false。

static int hash(Object... values) 
为一系列输入值生成哈希码。

static int hashCode(Object o) 
返回非空参数的哈希码，对于空参数返回0。

static boolean isNull(Object obj) 
如果提供的引用为null，则返回true，否则返回false。

static String toString(Object o) 
针对非空参数返回调用toString的结果以及针对null参数返回字符串“null”的结果。
 
static String toString(Object o, String nullDefault) 
如果第一个参数不为null，则返回在第一个参数上调用toString的结果，否则返回第二个参数，第二个参数可以为null。

4. Optional 类

Optional 类是一个可以包含或不包含非null值的容器。如果存在值，则 isPresent() 将返回 true，而 get() 将返回该值。。
Optional 类是一个基于值的类；在Optional实例上使用标识敏感的操作（包括引用等于（==），标识哈希码或同步）可能会产生不可预测的结果，应避免使用。

定义：
public final class Optional<T> extends Object  
源码：
public final class Optional<T> {
     // 如果非空，则为该值；如果为null，则表示不存在任何值
    private final T value;

	// 构造函数为私有构造函数
}


API:
static <T> Optional<T> empty() 返回一个空的Optional实例。
示例：
Optional optional = Optional.empty();
System.out.println(optional); // Optional.empty


boolean	equals(Object obj) 表示其他某个对象是否“等于”此Optional。
源码：
Objects.equals(value, other.value) // 实际equals的是Optional实例的value。


static <T> Optional<T> ofNullable(T value) 返回描述指定值的Optional，如果为null，则返回一个空Optional。
示例：
Optional o1 = Optional.ofNullable(new String("a"));
Optional o2 = Optional.ofNullable(null);
System.out.println(o1); // Optional[a]
System.out.println(o2); // Optional.empty


T orElse(T other) 如果存在，返回该值，否则返回other。
示例：
String str = null;
str = Optional.ofNullable(str).orElse("a");
System.out.println(str); // a


T orElseGet(Supplier<? extends T> other) 如果存在，返回该值，否则调用other，然后返回该调用的结果。
示例：
String str = null;
str = Optional.ofNullable(str).orElseGet(() -> "other");
System.out.println(str); // other


String toString() 返回此Optional的字符串表示。
源码：
public String toString() {
    return value != null ? String.format("Optional[%s]", value) : "Optional.empty";
}


Optional<T> filter(Predicate<? super T> predicate) 
根据传入的 predicate 对 Optional 中的值进行过滤，满足条件则返回该 Optional 对象，否则返回一个空的 Optional。
示例：
Optional optional = Optional.ofNullable(1);
Predicate<Integer> predicate= num -> num > 1;
System.out.println(optional.filter(predicate)); // Optional.empty
predicate = num -> num <= 1;
System.out.println(optional.filter(predicate)); // Optional[1]


<U> Optional<U>	map(Function<? super T,? extends U> mapper) 
如果 Optional 存在值，则执行 mapper 映射函数返回结果，否则返回一个空的 Optional。
示例：
String str = null;
Optional optional = Optional.ofNullable(str).map((s) -> "ab");
System.out.println(optional); // Optional.empty
Optional optional2 = Optional.ofNullable("a").map((s) -> "ab");
System.out.println(optional2); // Optional[ab]


int	hashCode() 如果存在值，返回当前值的哈希码值，如果没有值，则返回0（零）。

boolean	isPresent() 如果存在值，则返回true，否则返回false。


void ifPresent(Consumer<? super T> consumer) 如果存在值，执行 consumer 的具体操作，否则不执行任何操作。
示例：
Optional optional = Optional.ofNullable("a");
optional.ifPresent(System.out::println); // a

5. Base64、Base64.Decoder、Base64.Encoder

5.1 Base64工具提供的编码器

Base64工具类提供了一套静态方法获取下面三种BASE64编解码器：

基本：使用RFC 4648和RFC 2045表1中指定的“Base64字母”进行编码和解码操作。编码器不添加任何换行符，解码器拒绝包含base64字母之外的字符的数据。
URL和文件名安全：使用RFC 4648表2中指定的“URL和文件名安全的Base64字母”进行编码和解码。编码器不添加任何换行符，解码器拒绝包含base64字母之外的字符的数据。
MIME：使用RFC 2045表1中指定的“Base64字母”进行编码和解码操作。编码后的输出必须以不超过76个字符的行表示，并使用回车符’\r’和紧跟换行符’\n’作为行分隔符，编码输出的末尾没有行分隔符。在base64字母表中找不到的所有行分隔符或其他字符在解码操作中将被忽略。

5.2 获取Base64编码器或解码器

1、获取Base64编码器
Base64.Encoder encoder = Base64.getEncoder();
Base64.Encoder urlEncoder = Base64.getUrlEncoder();
Base64.Encoder mimeEncoder = Base64.getMimeEncoder();

2、获取Base64解码器
Base64.Decoder decoder = Base64.getDecoder();
Base64.Decoder urlDecoder = Base64.getUrlDecoder();
Base64.Decoder mimeDecoder = Base64.getMimeDecoder();

5.3 Base64编码解码示例

try {
    byte[] bt = "A-Za-z0-9+/_编码".getBytes("utf-8");
    // 编码
    Base64.Encoder encoder = Base64.getEncoder();
    Base64.Encoder urlEncoder = Base64.getUrlEncoder();
    Base64.Encoder mimeEncoder = Base64.getMimeEncoder();

    String encoderStr = encoder.encodeToString(bt); // QS1aYS16MC05Ky9f57yW56CB
    String urlEncoderStr = urlEncoder.encodeToString(bt); // QS1aYS16MC05Ky9f57yW56CB
    String mimeEncoderStr = mimeEncoder.encodeToString(bt); // QS1aYS16MC05Ky9f57yW56CB
    
    
 	// 解码
    Base64.Decoder decoder = Base64.getDecoder();
    Base64.Decoder urlDecoder = Base64.getUrlDecoder();
    Base64.Decoder mimeDecoder = Base64.getMimeDecoder();

    String decoderStr = new String(decoder.decode(encoderStr), "utf-8"); // A-Za-z0-9+/_编码
    String urlDecoderStr = new String(urlDecoder.decode(urlEncoderStr), "utf-8"); // A-Za-z0-9+/_编码
    String mimeDecoderStr = new String(mimeDecoder.decode(mimeEncoderStr), "utf-8"); // A-Za-z0-9+/_编码

} catch (UnsupportedEncodingException e) {
    e.printStackTrace();
}

6. Iterator 迭代器

定义：
public interface Iterator<E> 对 collection 进行迭代的迭代器。

API：
boolean hasNext() 如果仍有元素可以迭代，则返回 true。
E next() 返回迭代的下一个元素。 
void remove() 从集合中删除迭代器最后访问的元素（可选操作）。

7. Comparator 比较函数

定义：
public interface Comparator<T> 强制对某些对象集合进行总排序的比较函数。

API：
int compare(T o1, T o2) 比较用来排序的两个参数。 注：o1 - o2 是升序。
boolean equals(Object obj) 指示某个其他对象是否“等于”此 Comparator。 

示例：
List<Integer> list = new ArrayList<>();
list.add(3); list.add(2); list.add(1);

Collections.sort(list, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1 - o2;
    }
});

System.out.println(list); // [1, 2, 3]

8. Collections 类

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

static <T> void copy(List<? super T> dest, List<? extends T> src) 
将所有元素从一个列表复制到另一个列表。 

static boolean disjoint(Collection<?> c1, Collection<?> c2) 
如果两个指定 collection 中没有相同的元素，则返回 true。 

static <T> void fill(List<? super T> list, T obj) 
使用指定元素替换指定列表中的所有元素。 

static <T extends Comparable<? super T>> void sort(List<T> list) 
根据元素的自然顺序 对指定列表按升序进行排序。 

static <T> void sort(List<T> list, Comparator<? super T> c) 
根据指定比较器产生的顺序对指定列表进行排序。 

static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) 
根据元素的自然顺序，返回给定 collection 的最大元素。 

static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp) 
根据指定比较器产生的顺序，返回给定 collection 的最大元素。 

static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll) 
根据元素的自然顺序 返回给定 collection 的最小元素。 

static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp) 
根据指定比较器产生的顺序，返回给定 collection 的最小元素。 

static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) 
使用另一个值替换列表中出现的所有某一指定值。 

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

static <T> List<T> synchronizedList(List<T> list) 
返回指定列表支持的同步（线程安全的）列表。 

static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) 
返回由指定映射支持的同步（线程安全的）映射。

9. Arrays 类

Arrays 类常用API:
static int[] copyOf(int[] original, int newLength) 
复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。 如果数组是对象数组，复制的是引用不是对象本身。

static int[] copyOfRange(int[] original, int from, int to) 
将指定数组的指定范围复制到一个新数组。 

static boolean equals(int[] a, int[] a2) 
如果两个指定的 int 型数组彼此相等，则返回 true。 

static void fill(int[] a, int val) 
将指定的 int 值分配给指定 int 型数组的每个元素。 

static void fill(int[] a, int fromIndex, int toIndex, int val) 
将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。 

static void sort(int[] a) 
对指定的 int 型数组按数字升序进行排序。

static void sort(int[] a, int fromIndex, int toIndex) 
对指定 int 型数组的指定范围按数字升序进行排序。 

static <T> void sort(T[] a, Comparator<? super T> c) 
根据指定比较器产生的顺序对指定对象数组进行排序。 

static <T> void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c) 
根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。 

static String toString(int[] a) 
返回指定数组内容的字符串表示形式。

参考：https://docs.oracle.com/javase/8/docs/api/

lercent

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java.util 包 Collection、Map、Objects、Optional、Base64、Iterator、Comparator、Collections、Arrays

1. Collection 集合1.1 层次结构Collection<E> （I）集合 | |-- List<E> （I）有序的 collection （与元素插入顺序一致），也称为序列。 | | 可以对元素的插入位置进行精确地控制，可以根据元素的整数索引访问元素。 | | | |-- Vector<E> （C）使用数组实现；线程安全，性能比ArrayList要差；索引数据快，插入数据慢。 | | |
复制链接

扫一扫