java 集合

Java集合框架详解

最新推荐文章于 2024-08-17 21:23:19 发布

原创最新推荐文章于 2024-08-17 21:23:19 发布 · 218 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言 #后端

java 专栏收录该内容

15 篇文章

订阅专栏

概述

Collection
- Set
  - HashSet类
  - TreeSet类
- Queue
  - priorityQueue
  - Deque接口
    - ArrayDeque类
    - LinkedLIst类：同时时List和Deque的接口实现类
- List
  - ArrayList类
  - vector
  - LinkedLIst类：同时时List和Deque的接口实现类
Map
- HashMap类
- Hashtable类
- linkedHashMap类
- TreeMap类

在这里插入图片描述
涉及到的非抽象类就这几个：
Stack(Vector), ArrayList, LinkedList
HashSet, LinkedHashSet, TreeSet,
HashMap, LInkedHashMap, TreeMap, IdentityHashMap, WeakHashMap HashTable

Collection接口

方法

  boolean add(Object o)
  boolean addAll(Collection c)
  void clear();
  boolean contains(Object o);
  boolean containsAll(Collection c);
  boolean isEmpty();
  boolean remove(Object 0);
  boolean removeAll(Collection c);
  boolean retainAll(Collection c);
  int size();
  Object[] toArray();//转为数组
  Iterator interator();

总结：

增加，是否包含，移除六个方法
清空，判断为空，只留一部分，获得尺寸，变成数组，获取Inerator迭代

遍历输出

-----只能输出，不能再其中改变集合。

直接输出：会自动调用toString()方法；
lambda表达式遍历;

books.foreach(obj -> System.out.println(obj));

增强的Iterator遍历：
Iterator用于遍历集合，且依赖于集合，必须有一个集合才能有一个iterator对象；
Iterator方法：

boolean hasNext();
Object next();
void remove();//删除上一次next的元素
void forEachRemaining(lambda);

示例

Iterator it = books.iterator();
whlile(it.hasNext){
	String book = it.next();
	System.out.println(book);
	if(book == "数学书"){
		it.remove();
	}
}

使用iterator的lambda表达式

it.forEachRemaining(obj -> System.out.print(obj));

使用foreach循环
不能在里面改变集合的元素:books.remove(book);

操作集合

使用Predicate：

方法：

removeIf(Predicate的lambda)

删除长度小于 10的字符串元素

books.removeIf(ele -> ((String)ele).length() <10) ;

Stream操作

books.stream()返回一个流对象
中间方法：执行后流仍然开启，允许直接调用后面的方法，也就是返回的还是一个流；
末端方法：执行后流终止。
中间方法：

filter(Predicate prediacate);
mapToXxx(ToXxxFunction mapper);
peek(Consumer action);用于调试
distinct();排序重复元素
sorted();排序
limit(long maxSize);限制后面最大访问的元素个数

末端方法：

forEach(Consumer action);
toArray();
reduce()
min()
max();
count();
anyMatch(Prediacate prediacate)
allMatch(Prediacate prediacate)
noneMatch(Prediacate prediacate)
findFirst()
findAny()

Set集合

set集合就是一个罐子，无序，不能重复
当加入一个已经存在的元素，add()方法返回false；

HashSet

按照哈希算法存储集合中的元素，存取，查找性能好。
特点：

无序，顺序可能变化
不同步，多线程修改时，必须通过代码保证其同步；
元素可以是null

判断元素相等的方法是：equals方法true，且hashcode相同
所以重写对象的equals方法时，也要重写hashCode方法，以便判断为同一个元素，
具体重写hashcode方法略。

LinkedHashSet

使用链表维护元素的次序，看起来有序，性能略差，迭代访问全部元素时性能好；
输出顺序时根据加入的顺序来，先加入的先输出。

TreeSet

有序，比如存放integer类型，自动根据数值大小排序。

提供了一些方法：访问前一个，后一个，第一个，最后一个，截取子TreeSet。

Comparator comparator();//获取排序方法
Object first();//返回第一个元素
Object last()
Object lower(Object o);//返回前一个元素，稍小的那个
Object higher(Object o);
SortedSet subSet(Object from , Object to);//截取
SortedSet headSet(Object to);
SortedSet tailSet(Object from);

排序方法：

自然排序：
默认是自然排序；
调用元素的compareTo()方法，升序排序，被排序的类要实现Comparable接口，并实现这个方法；
已经实现了这个接口的类有：
- BigDecimal, Integer
- Character
- Boolean； True大于false；
- String
- Date,Time
  其他类要自己实现Comparable接口，否则不能添加到TreeSet
  一个集合只能存放同一种类型的对象；
  当存放引用元素时，如果改变引用元素的值，这个元素的位置不会调整，而且不能被删除了
定制排序：
比如降序，可以通过Comparator接口的帮助。里面有个方法输入两个对象，返回int，可以用lambda表达式：

TreeSet books = new TreeSet((o1, o2) ->
{
	M m1 = (M)o1;
	M m2 = (M)o2;
	return m1.age >m2.age ? -1:m1.age<m2.age? 1:0;
});
//然后可以向books集合中添加多个M类的元素，
books.add(new M(10));

EnumSet类

以向量存储，紧凑，搞笑，内存小，效率好，尤其进行批量操作时；
不能添加删除null元素
具体方法略，创建示例：

Enum es1 = EnumSet.allof(Season.class);

Set实现类性能分析：

HashSet性能好于TreeSet，要保持排序时选择TreeSet，否则HashSet。
LInkedHashSet相比于HashSet：普通插入，删除更慢，但是遍历更快
Enum性能最好；
都是线程不安全的，通常使用collections工具类的synchornizedSortedSet方法包装set集合，最好在创建时包装。

SortedSet s = Collecrtions.synchornizedSortedSet(new TreeSet(..));

List集合

有序，可重复，默认有索引
可以存放不同对象？
方法：

void add(int index, Object element)//插入后，后面的元素下标+1；
boolean add(int index, Collection c)
Object get(int index);//获取元素
int indexOf(Object o);//返回第一次出现的位置
int lastIndexOf(Object o);//从后往前寻找元素，返回下标
Object remove(int index);
Object set(int index, Object element);//更改元素，返回旧元素
List subList(int fromIndex, int toIndex);//构成子集合

List判断相等时通过equals方法。查找删除等都会判断是否相等。
排序和替换整个数组的方法：

books.sort((o1,o2) -> (String)o1.length() - (String)o1.length() )//长度从小到大排序。
books.replaceAll(ele -> (String)ele.length())

迭代器：

可以正向和反向迭代；

ListIterator lit = bookslist.listIterator();
while(lit.hasNext()){
	System.out.print(lit.next());
	lit.add("----")//可以在迭代的时候添加元素
}
while(lit.hasPrevious()){
	System.out.print(lit.previous());
}

ArrayList和Vector：

Vector线程安全，但是古老，性能差，少用。用ArrayList加Collections线程安全更好
其子类Stack也一样，要少用，后面可以用ArrayDeque；

固定长度的Lsit：

List list = Arrays.asList("str1","str2");

不能增删元素；

Queue集合

先进先出
方法：

void add(Object o);
boolean offer(Object e);//添加元素，对于有限容量的队列，比add好
Object element();//获取头
Object peek();//返回头
Object poll();//获取删除头，没有则返回null
Object remove();//获取删除头

PriorityQueue实现类

不允许null元素
并不是严格的队列，弹出的时候弹出最小的那个数。
两种排序方式：
自然排序
定制排序

Deque和ArrayDeque实现类

Deque接口的方法：

void addFirst(Obj);
void addLast(Obj);
Iterator decendingIterator();//获取逆向的迭代器，
//正向还是Iterator（）；
Obj getFirst();
Obj getLast();
boolean offerFirst(Obj);//插入到开头位置
boolean offerLast(Obj);
Object peekFirst();//获取并不删除头
Object peekLast();
Object pollFirst()
Object pollLast()
Object pop();//等于removefirst
void push(Obj);//等于addFirst
Object removeFirst();//移除头
Object removeLast();//移除尾巴
boolean removeLastOccurence();//删除两端最后一次出现的元素

总结：获取，删除，添加到两端，
当成栈来用：push pop peek方法；peek看头
当成队列用：直接用父亲Qeque的方法offer ,poll,peek就可以了；
当成双向队列用：上面的方法；

LinkedList实现类：

同时时List和Deque的接口实现类，所以可以当成队列和栈使用，还有索引
内部和ArrayList，ArrayQueue完全不同，是链表
随机访问（get(5)）差，插入删除好

线性表的性能分析：

ArrayList:随机访问性能好，使用get方法访问元素
LinkedList：使用迭代器迭代，插入，删除性能好

Map集合

所有的key就像set集合，不能重复，没有顺序。
value就像List，可以重复，可以根据索引查找（索引是key）
事实上，Set和Map集合非常类似，set就是value为null的Map

void clear();
boolean containsKey(Obj key);
boolean contiansValue(Obj value);
Set entrySet();//
Object get(Object key);
boolean isEmpty();
Set keySet();//返回key构成的set集合，
Object put(Object key, Object value)//添加，已有会覆盖
void putAll(Map map);
Object remove(Object key);
boolean remove(Object key, Object value);
int size();
Collection value();//返回value构成的集合

遍历：

for(Object key:map.keySet()){		
	System.out.print(key+""+map.get(key));
}

java8新增方法：

foreach()
Object compute(key,lambda);计算新值并覆盖
replace(key, value)
merge(key , value, lambda);
//等等，还有好多

HashMap和Hashtable实现类

Hashtable和Vector一样，太老了，线程安全，多线程可以使用但是不用。 null不能做为key和value；
HashMap最多一个key为null，多了会覆盖。
key对象必须实现hashCode()方法和equals()方法；判断是否包含value时比较equals()方法。
尽量不要使用可变对象作为key，或者不要改变key对象

linkedHashMap实现类

双向链表维持次序，可以记住添加顺序，先加的先输出；

使用Properties读写文件

Properties时Hashtable的子类，相当于一个key，value都是string的Map；
方法：

String getProperty(String key);
String getProperty(String key,String value);//没有key时，指定默认值
Object setProperty(String key,String value);//put

SortMap接口和Treemap实现类

太多，略

WeakHashMap实现类

和HashMap类似
只有弱引用，key可能会被回收

IdentityHashMap实现类

和HashMap类似
只有在key严格相等==时，才判断为相等

EnumMap实现类

略

各Map性能分析

多用HashMap，要排序LinkedHashMap，要从小到大排序：TreeMap；

Colections集合操作工具类

排序，查询，修改，设置为不可变，同步控制
排序：

void reverse(list)//反转
void shuffle(list)//洗牌，随机排
void sort(list)
void sort(list, Comparator c)
void swap(list,i,j)
void rotate(list, int distance)//整体向前（后）移动distance

查找、替换：

binarysearch(list,key)//必须有序
max(c)
min(c)
fill(list,obj)
frequency();
indexOfSubList(List source, List target)
replaceAll(list,oldvalue, newvalue)

同步控制：
多个方法：synchronizedXxx()

Collection cc = Collections.synchronizedCollection(new ArrayList());

设置不可变集合：

添加删除将会异常；

```java
emptyList();
singletonList("str1");//只含一个元素的不可变集合
unmodifiableList(map1);