Java集合一(List和Set)

概念

目前存储数据的方式有哪些

数组;

基于数组模拟的容器类;

基于链表结构的容器类;

在Java中已经设计好了一些类和接口,和我们之前模拟的容器类功能一样。像这样的类和接口,在Java中已经写好了,我们叫做集合

List和Set的区别

List和Set的区别

相同点:都继承了Collection接口,都是Java中的集合,都可以存放任意类型任意多个元素

不同点:

List:有序可重复

​ ArrayList和LinkedList

Set:无序不可重复

​ HashSet:去重是通过hashCode()和equals()共同决定

​ TreeSet:去重是通过自然排序(实现Comparable接口)或者定制排序(创建对象时传入的比较器)来实现

List集合

ArrryaList(基于数组)

底层是由数组实现

ArrayList基于数组的容器类实现

调用容器类方法增删改查数据

Demo

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
package com.ifueen.classtest._01ArrayList;
import java.util.ArrayList;
import java.util.Iterator;

import javafx.print.Collation;

public class _01ArrayList {

public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList list = new ArrayList(); //实例化ArrayList对象
list.add(15); //给集合添加元素
list.add(0,"我今年"); //add(int index, E element):在此列表中指定的位置插入指定的元素
list.clear(); //clear():从此列表中移除所有元素
list.add("你离开了南京");
list.add("从此没人陪我说话");
System.out.println(list); //打印集合中的元素
ArrayList list1 = new ArrayList();
list1.add("我不想说");
list1.add(34);
list1.add(1,"我今年");
list1.add("了");
System.out.println(list1);
Iterator iterator = list.iterator();
while(iterator.hasNext()){ //hasNext()方法作用:如果仍有元素可以迭代,则返回 true
System.out.println(iterator.next()); //next()方法作用:返回迭代的下一个元素,用Object类型的变量接收
}
}

}

LinkedList(基于链表)

基于链表结构的容器类实现

LinkedList 属于java.util包下面,也实现Iterable接口,说明可以使用迭代器遍历;

Demo

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
package com.ifueen.classtest._02LinkedList;

import java.util.Iterator;
import java.util.LinkedList;

public class _02LinkedList {
/*
* LinkList集合:底层由链表实现
* */
public static void main(String[] args) {
// TODO Auto-generated method stub
LinkedList list = new LinkedList();
list.add(15); //给集合添加元素
list.add(0,"我今年"); //add():在此列表中指定的位置插入指定的元素
list.clear(); //clear():从此列表中移除所有元素
list.add("你离开了南京");
list.add("从此没人陪我说话");

//for循环来遍历
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i)); //get方法作用:返回此列表中指定位置处的元素
}

//foreach来遍历
for (Object object : list) {
System.out.println(object);
}

//用迭代器来遍历
Iterator iterator = list.iterator(); //新建迭代器
while (iterator.hasNext()) { //利用迭代器进行遍历
Object object = (Object) iterator.next(); //返回迭代的下一个元素,用Object类型的变量接收
System.out.println(object); //输出元素
}
}

}

面试题:ArrayList和LinkedList区别

两者都是实现List接口,都可以存放任意多个任意类型的数据

ArrayList底层是由数组来实现,在数据量多的时候,查询起来较快,但是新增的时候需要不停创建新的数组,速度就会变慢

LinkList底层是由链表实现,在数据量大的时候,需要去到每一个节点去挨个查找,所以查询起来的速度比较慢,但是在新增的时候就比较快

Set集合

HashSet

存储任意多个类型不同的元素,但是是无序(添加顺序和输出顺序不一致),且不能重复,如果有重复元素,会自动去重

Demo

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
package com.ifueen.classtest._03HashSet;

import java.util.HashSet;
import java.util.Iterator;

public class _03HashSet {
/*
* HashSet:存储任意多个类型不同的元素,但是是无序(添加顺序和输出顺序不一致)
* 且不能重复,如果有重复元素,会自动去重
* */
public static void main(String[] args) {
// TODO Auto-generated method stub
HashSet hst = new HashSet(); //实例化HashSet对象
hst.add("你离开了南京"); //往集合里面添加元素
hst.add("从此没有人和我说话");

System.out.println(hst);
HashSet hst1 = new HashSet(); //实例化HashSet对象
hst1.add("A");
hst1.add("C");
hst1.add("B");
hst1.add("E");
hst1.add("D");
//System.out.println(hst1); //输出[A, B, C, D, E],不会按照添加的顺序输出
hst1.clear(); //清除元素

hst1.add("A");
hst1.add("A");
hst1.add("B");
System.out.println(hst1); //输出[A, B],自动去重

_03Test test1 = new _03Test("我想");
_03Test test2 = new _03Test("我想");
hst1.add(test1);
hst1.add(test2);
System.out.println(hst1); //此时只会打印一个我想,实现了去重功能
}

}

}

TreeSet

支持存储任意多个类型不同的元素,无序(添加顺序和输出顺序不一致)不可重复,但是同时只能放同一种类型,想要添加自定义类型就需要在自定义类里面实现自由排序(自然排序就是实现Comparable接口)

定制排序和自然排序的区别:

自然排序:所有排序都按照统一的规则

定制排序:按照自定义的规则来进行排序

Demo

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
package com.ifueen.classtest._04TreeSet;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class _04TreeSet {
public static void main(String[] args) {
// TODO Auto-generated method stub
TreeSet tst = new TreeSet(); //实例化TreeSet对象
tst.add("我们不能失去信仰"); //添加元素
tst.add("查拉图斯特拉如是说");
System.out.println(tst);

TreeSet tst1 = new TreeSet();
tst1.add("木卫三");
tst1.add("远航");
//tst1.add(46);
tst1.add("远航");
System.out.println(tst1); //报错:java.lang.String cannot be cast to java.lang.Integer同时只能存放同一类型


_04Person p1 = new _04Person("开心");
_04Person p2 = new _04Person("开心");
_04Test test = new _04Test();
TreeSet tst2 = new TreeSet(test); //实例化Tree对象并传入test类对象
tst2.add(p1);
tst2.add(p2);
System.out.println(tst2); //输出一个开心,说明我们自定义去重成功

//遍历方式
//forearch
for (Object object : tst2) {
System.out.println(object);
}
//利用迭代器遍历
Iterator iterator = tst2.iterator();
while (iterator.hasNext()) {
Object object = (Object) iterator.next(); //返回迭代的下一个元素,用Object类型的变量接收
System.out.println(object);
}

}

}
❤赏点钱让我买杯快乐水8❤