java集合框架
集合就是存放数据的载体，放的对象的引用，而不是对象本身。
Collection 和 Collections 的区别：
Connection是一个集合类的上级接口，它提供了对集合对象进行基本操作的通用接口方法，继承它的接口主要有Set、List和Queue。
Connections是针对集合类的一个帮助类，它包含sort()，copy()，shuffce()，binarySearch()等关于集合的静态方法。此类不能实例化，服务于java的Connection框架。
一、List接口：元素按进入先后有序保存，可重复。以下是实现List接口的常用集合：
1.ArrayList
import collection.User;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* 元素按插入先后有序保存
* 底层实现为数组，随机访问，线程不安全
* 元素可重复，可存放null值
* 可通过数组下标的形式查找，在查询方面效率较高，插入较慢
*/
public class ArrayListDemo {
public static void main(String[] args) {
User user1 = new User("tom", "男", 22);
User user2 = new User("alan", "女", 21);
User user3 = new User("make", "男", 20);
User user4 = new User("john", "男", 19);
User user5 = new User("mali", "女", 24);
List<User> userList = new ArrayList<>();
userList.add(user1);
userList.add(user2);
userList.add(user3);
userList.add(user4);
userList.add(user5);
//在遍历list的同时删除元素
Iterator<User> iterator = userList.iterator();
while(iterator.hasNext()){
User user = iterator.next();
if(user.getName().equals("make")){
iterator.remove();
}else{
System.out.println(user.toString());
}
}
}
}
2.LinkedList
import collection.User;
import java.util.Iterator;
import java.util.LinkedList;
/**
* 按原始插入先后顺序保存
* 底层实现为链表，插入删除，线程不安全
* 元素可重复，可存放null值
* 由于底层实现为链表，所以插入删除较快，查询较慢
*/
public class LinkedListDemo {
public static void main(String[] args) {
User user1 = new User("tom", "男", 22);
User user2 = new User("alan", "女", 21);
User user3 = new User("make", "男", 20);
User user4 = new User("john", "男", 19);
User user5 = new User("mali", "女", 24);
LinkedList<User> userList = new LinkedList<>();
userList.add(user1);
userList.add(user2);
userList.add(user3);
userList.add(user4);
userList.add(user5);
//遍历list
Iterator<User> iterator = userList.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next().toString());
}
System.out.println("************************************************************");
//将元素插入到list的头部和尾部
User userF = new User("xioahu","男",25);
User userL = new User("zhangsan","男",25);
userList.addFirst(userF);
userList.addLast(userL);
//在list的指定位置插入
userList.addAll(3,userList);
//遍历list
Iterator<User> iterator1 = userList.iterator();
while(iterator1.hasNext()){
System.out.println(iterator1.next().toString());
}
//获取list的头部和尾部元素
System.out.println(userList.getFirst().toString());
System.out.println(userList.getLast().toString());
}
}
3.Vector
import collection.User;
import java.util.Iterator;
import java.util.Vector;
public class VectorDemo {
/**
* 与ArrayList相同，低层都由数组实现，但Vector是线程安全的（同步的）；
*/
public static void main(String[] args) {
User user1 = new User("tom", "男", 22);
User user2 = new User("alan", "女", 21);
User user3 = new User("make", "男", 20);
User user4 = new User("john", "男", 19);
User user5 = new User("mali", "女", 24);
Vector<User> userVector = new Vector<>();
userVector.add(user1);
userVector.add(user2);
userVector.add(user3);
userVector.add(user4);
userVector.add(user5);
//遍历list
Iterator<User> iterator = userVector.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next().toString());
}
}
}
二、Set接口：仅接收一次，不可重复（唯一）。以下是实现Set接口的常用集合：
1.HashSet
import collection.User;
import java.util.*;
public class HashSetDemo {
/**
* 底层数据结构为哈希表，线程不安全，底层实现是HashMap，并把数据作为HashMap中的key值，因此不能有重复值。
* 内存存储位置由hashCode()决定，由equals()判断是否重复，所以需要重写hashCode()和equals()。
* 若相对hashSet进行排序，可进行以下操作：
* HashSet没有排序的功能，创建一个TreeSet集合，将HashSet集合添加到此TreeSet集合中
* 可以通过Comparator<T>接口和Compatable<T>接口重写compar()和comparTo()方法去改写排序规则
*/
public static void main(String[] args) {
User user1 = new User("tom", "男", 22);
User user2 = new User("alan", "女", 21);
User user3 = new User("make", "男", 20);
User user4 = new User("john", "男", 19);
User user5 = new User("mali", "女", 24);
User user6 = new User("mali", "女", 24);
HashSet<User> hashSet = new HashSet<>();
hashSet.add(user1);
hashSet.add(user1);
hashSet.add(user1);
hashSet.add(user1);
hashSet.add(user2);
hashSet.add(user3);
hashSet.add(user4);
hashSet.add(user5);
hashSet.add(user6);
//对hashSet进行排序，将hashSet放入TreeSet中
TreeSet<User> treeSet = new TreeSet<>(new Comparator<User>() {
@Override
public int compare(User u1, User u2) {
if(u1.getAge() > u2.getAge()){
return 1;
}else if(u1.getAge() < u2.getAge()){
return -1;
}else{
if(u1.getName().compareTo(u2.getName()) > 0){
return 1;
}else if(u1.getName().compareTo(u2.getName()) < 0){
return -1;
}else{
return 0;
}
}
}
});
treeSet.addAll(hashSet);
//遍历hashSet
Iterator<User> iterator = hashSet.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next().toString());
}
System.out.println("----------------------------------------------------------");
//遍历TreeSet
Iterator<User> it = treeSet.iterator();
while(it.hasNext()){
System.out.println(it.next().toString());
}
}
}
2.LinkedHashSet
LinkedHashSet是直接继承了HashSet，与HashSet不同的是，LinkedHashSet会维护元素的插入顺序。
import collection.User;
import java.util.Iterator;
import java.util.LinkedHashSet;
public class LinkedHashSetDemo {
/**
*维护了元素的插入顺序，元素唯一，不可重复
*/
public static void main(String[] args) {
User user1 = new User("tom", "男", 22);
User user2 = new User("alan", "女", 21);
User user3 = new User("make", "男", 20);
User user4 = new User("john", "男", 19);
User user5 = new User("mali", "女", 24);
User user6 = new User("mali", "女", 24);
LinkedHashSet<User> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add(user1);
linkedHashSet.add(user1);
linkedHashSet.add(user2);
linkedHashSet.add(user2);
linkedHashSet.add(user3);
linkedHashSet.add(user4);
linkedHashSet.add(user5);
linkedHashSet.add(user6);
Iterator<User> iterator = linkedHashSet.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next().toString());
}
}
}
3.TreeSet
import collection.User;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
/**
* 底层数据为红黑树，元素排好序
* 实现了SortedSet接口
* Tree如何进行排序：
* 通过Comparable和Comparator接口
* Comparable自然排序，重写compareTo()
* Comparator比较器排序，重写compare()
* 当Comparable排序方式和Comparator排序方式同时存在时，以Comparator的比较方式为主。
*/
public class TreeSetDemo {
public static void main(String[] args) {
User user1 = new User("tom", "男", 22);
User user2 = new User("alan", "女", 21);
User user3 = new User("make", "男", 20);
User user4 = new User("john", "男", 19);
User user5 = new User("mali", "女", 24);
User user6 = new User("mali", "女", 24);
TreeSet<User> treeSet = new TreeSet<>(new MyComparator());
treeSet.add(user1);
treeSet.add(user1);
treeSet.add(user2);
treeSet.add(user2);
treeSet.add(user3);
treeSet.add(user4);
treeSet.add(user5);
treeSet.add(user6);
treeSet.add(user6);
//遍历TreeSet
Iterator<User> it = treeSet.iterator();
while(it.hasNext()){
System.out.println(it.next().toString());
}
}
//实现Comparator接口，重写compare()方法
static class MyComparator implements Comparator<User>{
@Override
public int compare(User u1, User u2) {
if(u1.getAge() > u2.getAge()){
return 1;
}else if(u1.getAge() < u2.getAge()){
return -1;
}else{
if(u1.getName().compareTo(u2.getName()) > 0){
return 1;
}else if(u1.getName().compareTo(u2.getName()) < 0){
return -1;
}else{
return 0;
}
}
}
}
}
三、Map接口：以Key-Value的形式存入数据，其中Key不允许有重复值，Value允许有重复值。以下是实现Map接口的常用集合。
Map接口并没有继承Collection接口。
1.HashMap
import java.util.*;
public class HashMapDemo {
/**
* 底层数据结构：数组+链表+红黑树
* 线程不安全，无序，效率高
* 允许null键和null值，但键只能允许一个为null
* 键具有唯一性
*/
public static void main(String[] args) {
HashMap<String,Integer> map = new HashMap<>();
map.put("alan",18);
map.put("john",12);
map.put("make",13);
map.put("tom",15);
map.put("mali",21);
map.put("mali",22);
map.put("tom",22);
//Map的四种遍历方式。
System.out.println("通过Map.keySet遍历key和value：");
for (String key:map.keySet()) {
System.out.println("key:"+key+",value："+map.get(key));
}
System.out.println("*******************************************");
System.out.println("通过Map.entrySet使用iterator遍历key和value：");
Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();
while(iterator.hasNext()){
Map.Entry<String,Integer> map1 = iterator.next();
System.out.println("key:"+map1.getKey()+",value："+map1.getValue());
}
System.out.println("*******************************************");
System.out.println("通过Map.entrySet遍历key和value");
for (Map.Entry<String,Integer> map2:map.entrySet()) {
System.out.println("key:"+map2.getKey()+",value："+map2.getValue());
}
System.out.println("*******************************************");
System.out.println("通过Map.values()遍历所有的value，但不能遍历key");
for (Integer value:map.values()) {
System.out.println("value:"+value);
}
//对HashMap进行排序，将map.entrySet转成list：
ArrayList<Map.Entry<String,Integer>> arrayList = new ArrayList<>(map.entrySet());
Collections.sort(arrayList, new Comparator<Map.Entry<String, Integer>>() {
@Override
public int compare(Map.Entry<String, Integer> m1, Map.Entry<String, Integer> m2) {
if(m1.getValue() > m2.getValue()){
return 1;
}else if(m1.getValue() < m2.getValue()){
return -1;
}else{
return 0;
}
}
});
System.out.println("对map按value进行排序后：");
for (Map.Entry<String,Integer> map3:arrayList) {
System.out.println(map3.getKey()+":"+map3.getValue());
}
}
}
2.HashTable
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
public class HashTableDemo {
public static void main(String[] args) {
/**
* 与HashMap相似，但是HashTable不允许null键和null值且HashTable是线程安全的。
* 底层数据结构：哈希表
* 效率低，无序
*/
Hashtable<String,Integer> map = new Hashtable<>();
map.put("alan",18);
map.put("john",12);
map.put("make",13);
map.put("tom",15);
map.put("mali",21);
map.put("mali",22);
map.put("tom",22);
Iterator<Map.Entry<String,Integer>> iterator = map.entrySet().iterator();
while(iterator.hasNext()){
Map.Entry<String,Integer> map1 = iterator.next();
System.out.println(map1.getKey()+":"+map1.getValue());
}
}
}
3.LinkedHashMap
继承了hashMap，实现了Map接口
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
public class LinkedHashMapDemo {
public static void main(String[] args) {
/**
* 线程安全，维护插入顺序，效率低
* 不允许null键null值，key唯一
*/
LinkedHashMap<String,Integer> map = new LinkedHashMap<>();
map.put("make",13);
map.put("tom",15);
map.put("mali",21);
map.put("alan",18);
map.put("john",12);
Iterator<Map.Entry<String,Integer>> iterator = map.entrySet().iterator();
while(iterator.hasNext()){
Map.Entry<String,Integer> map1 = iterator.next();
System.out.println(map1.getKey()+":"+map1.getKey());
}
}
}
4.TreeMap
import java.util.*;
public class TreeMapDemo {
/**
*有序，根据key来排序，底层数据结构：红黑树
* 线程不安全
*/
public static void main(String[] args) {
TreeMap<String,Integer> map = new TreeMap<>(new Comparator<String>() {
@Override
public int compare(String k1, String k2) {
return k2.compareTo(k1);
}
});
map.put("make",13);
map.put("mali",22);
map.put("tom",25);
map.put("alan",6);
map.put("john",18);
Iterator<Map.Entry<String,Integer>> iterator = map.entrySet().iterator();
while(iterator.hasNext()){
Map.Entry<String,Integer> map1 = iterator.next();
System.out.println(map1.getKey()+"："+map1.getValue());
}
}
}
1812
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
