Java中常用集合分类及其常用方法

发表于 |

Collection

Collection 继承图

List(有序,可重复)

ArrayList

​ ArrayList集合(详细转向Array/ArrarList 常用方法)

​ 特点：

​ 1.数字长度可以任意变化

​ 2.代表泛型，泛型也就是装在集合中的所有元素，全部都是统一的某种类型

​ 注意：泛型只能是引用类型不能是基本类型

​ 3.对于ArrayList来说直接打印的得到的不是地址值而是内容，如果内容为空则打印[]

​ ArrayList 底层是数据存储结构是数组，元素增删慢，查询快；

LinkedList

​ java.util.LinkList 集合 implements List
​ LinkList 集合 存储的结构是链表结构，查询慢，增删快
​ 包含大量操作首尾元素方法：
​ public void addFirst(E e):将指定元素插入此列表的开头
​ public void addLast(E e):将指定元素插入此列表的结尾
​ public void push(E e):将此元素推入此列表表示的堆栈

​ public E getFirst():返回列表的第一个元素
​ public E getLast():返回列表的最后一个元素

​ public E removeFirst(E e):移除列表的第一个元素，并返回该元素
​ public E removeLast(E e):移除列表的最后一个元素，并返回该元素
​ public E pop():从此列表表示的堆栈处返回一个元素

​ public boolean isEmpty(): 如果此列表为空返回true

​ 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
LinkedList<String> linkedList=new LinkedList<>();
linkedList.addFirst("a"); //将指定元素插入此列表的开头
linkedList.addLast("d"); //将指定元素插入此列表的结尾
linkedList.push("c"); //等效于addFirst
System.out.println(linkedList);  //[c,a,d] 并不是地址值，重写了toString方法
String str1=linkedList.getFirst(); //返回列表的第一个元素
System.out.println(str1); //c
String str2=linkedList.getLast(); //返回列表的最后一个元素
System.out.println(str2); //d

String str3=linkedList.removeFirst(); //移除列表的第一个元素，并返回该元素
System.out.println(str3); //c
String str4=linkedList.removeLast(); //移除列表的最后一个元素，并返回该元素
System.out.println(str4); //d
String str5=linkedList.pop(); //从此列表表示的堆栈处返回一个元素，本质出栈(移除)是第一个
System.out.println(str5); //a
System.out.println(linkedList.isEmpty()); //true

​

Set（无序,唯一）

java.util.Set extends Collection
Set接口的特点:
1.不允许重复元素
2.没有索引，没有带索引的方法，不能用for循环

HashSet

java.util.HashSet extends Set
特点:
包含set特点
1.是一个无序元素集合，存储元素和取出元素的顺序可能不一致
2.底层是一个哈希结构表(存取速度快)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Set<Integer> hashSet = new HashSet<>();
//通过add添加元素
hashSet.add(54);
hashSet.add(45);
hashSet.add(88);
//通过迭代器遍历set集合元素
Iterator<Integer> iterator = hashSet.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());// 54 45 88
}
//增强for遍历set集合(底层还是迭代器)
for (Integer integer : hashSet) {
    System.out.println(integer); // 54 45 88
}

HashCode

哈希值:是一个十进制的整数，由系统随机给出。(就是对象的地址值，是一个逻辑地址，是模拟出来得到地址，不是实际的物理地址)
在Object类有一个方法可以获得对象的哈希值
int hashCode(); 返回对象的哈希值码
HashCode方法的源码:
public native int hashCode();
native 代表该方法调用的是本地操作系统的方法
Object的toString()输出的也是哈希值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
bject object=new Object();
System.out.println(object.hashCode());//22307196

//String类重写了hashCode() 方法
String s1="abc";
String s2="abc";
System.out.println(s1.hashCode()); //96354
System.out.println(s2.hashCode()); //96354
System.out.println("重地".hashCode()); //1179395
System.out.println("通话".hashCode()); ////1179395

//HashSet使用HashCode对比元素，不允许重复
HashSet<String> hashSet=new HashSet();
hashSet.add(s1);
hashSet.add(s2);
hashSet.add("通话");
hashSet.add("重地");
System.out.println(hashSet); //[通话, 重地, abc]

//HashSet 存储自定义类型 要求重写equals()和hashCOde() 方法
HashSet<Persion> hashSet1=new HashSet();
Persion p1=new Persion("安徒生",20);
Persion p2=new Persion("安徒生",20);
Persion p3=new Persion("安徒生",22);
hashSet1.add(p1);
hashSet1.add(p2);
hashSet1.add(p3);
System.out.println(hashSet1);
//[Persion{name='安徒生', age=20},Persion{name='安徒生', age=22}, Persion{name='安徒生', age=20}]
//没有重写equals() 和 hashcode()方法
System.out.println(p1.hashCode()); //10568834
System.out.println(p2.hashCode()); //21029277
System.out.println(p3.hashCode()); //24324022
System.out.println(p1.equals(p2)); //false
//在Persion类中重写equals和hashCode方法后
System.out.println(p1.equals(p2)); //true
System.out.println(p1.hashCode()); //722533822
System.out.println(p2.hashCode()); //722533822
System.out.println(p3.hashCode()); //722533824
System.out.println(hashSet1); //[Persion{name='安徒生', age=22}, Persion{name='安徒生', age=20}]


//persion 类
public class Persion {
    private String name;
    private  int age;
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Persion persion = (Persion) o;

        if (age != persion.age) return false;
        return name != null ? name.equals(persion.name) : persion.name == null;
    }
    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
    @Override
    public String toString() {
        return "Persion{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    public Persion(){
    }
    public Persion(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

LinkedHashSet

java.util.linkedHashSet 集合 extend HashSet集合

LinkedHashSet: 底层是一个哈希表(数组+链表/红黑树)+链表:多了一条链表(记录元素的存储顺序),保证元素有序。

1
2
3
4
5
6
HashSet<String> linkedSet=new LinkedHashSet<>();
linkedSet.add("www");
linkedSet.add("iiswho");
linkedSet.add("www"); //重复添加www
linkedSet.add("com");
System.out.println(linkedSet);//[www, iiswho, com] 有序不允许重复 HashSet是无序的不循序重复

Map(键值对)

Map集合特点

java.util.map<k,v>集合
​ 1.Map集合中元素是一个双列集合,一个元素可以包含两个值(一个key,一个值)；
​ 2.Map集合中的元素,key和value的数据类型可以相同，亦可以不同
​ 3.Map集合中的元素,key是不允许重复的，value是允许重复的
​ 4.Map集合中，key和value是一一对应的

HashMap集合的特点:

java.util.HashMap<k,v>集合 implements Map<k,v> 接口
​ 1.HashMap集合的底层是哈希表:查询速度快
​ jdk1.8之前:数组+单向链表
​ jdk1.8之前:数组+单向链表/红黑树(链表的长度超过8);提高查询速度
​ 2.HashMap集合是一个无序的集合，存储元素和取出元素的顺序有可能不一致

LinkedHashMap特点:

java.util.linkedHashMap<k,v> extends HashMap<k,v> 集合
​ 1.linkedHashMap底层是哈希表+链表
​ 2.linkedHashMap集合是一个有序集合，存储元素和取出元素是一致的

Map集合常用方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
/*
*	public V put(K key,V value) -将指定的键和指定的值添加到map集合中
*   当存储键值对时,key不重复返回V时null,key重复时,会使用新的value替换重复的value值,返回被替换的value
* */
Map<String,String> map=new HashMap();
String str=map.put("1","hello");
System.out.println(str);  //null
str=map.put("1","world");
System.out.println(str);  //hello
str=map.put("2","!!!");
System.out.println(map); //{1=world, 2=!!!}
/*
 * public V remove(object key)
 *   把指定的键对应的键值对元素在map集合中删除，返回被删除的元素，key存在V返回被删除的值，不存在返回null
* */
str=map.remove("!!!");
System.out.println(str); //null
str=map.remove("2");
System.out.println(str); //!!!
/*
* public V get(K key): 根据指定值键在map集合中获取对应的值
*    key存在返回对应的的值，不存在返回nul
* */
str=map.get("1");
System.out.println(str); //world
//public boolean containsKey(Object key)  判断集合中是否包含指定的键
System.out.println(map.containsKey("1"));//true

 /*
 * 遍历Map集合 将Map集合中的Key取出放到Set集合中，使用迭代器遍历Set集合获取每一个key对应的值
 * */
map.put("遍历","set");
map.put("键","值");
 //keySet() 将Map集合中的Key取出放到Set集合中
Set set=map.keySet();
Iterator<String> iterator=set.iterator();
while (iterator.hasNext()){
        String key=iterator.next();
     System.out.println(key+":"+map.get(key));//1:world 遍历:set  键:值
}
看都看了，不说来点什么！