一.Collection集合
1.集合概述
-
集合: 集合是Java中提供的一种容器,可以用来存储多个数据
-
数组和集合的区别:
1.数组的长度是固定的.集合的长度是可变的.
2.数组中存储的是同一种类型的元素,可以存储基本数据类型值.集合存储的都是对象.并且对象的的类型可以不一致.在开发中,一般当对象多的时候,使用集合进行存储.
2.Collection集合概述
- 单列集合类的根接口,用于存储一系列符合某种规则的元素.它有两个重要的子接口,java.util.List和java.util.Set.
- List的特点是元素有序,元素可重复
- Set的特点是元素无序,元素不可以重复.
3.Collection常用功能
- public boolean add(E e) ： 把给定的对象添加到当前集合中 。
- public void clear() :清空集合中所有的元素。
- public boolean remove(E e) : 把给定的对象在当前集合中删除。
- public boolean contains(E e) : 判断当前集合中是否包含给定的对象。
- public boolean isEmpty() : 判断当前集合是否为空。
- public int size() : 返回集合中元素的个数。
- public Object[] toArray() : 把集合中的元素，存储到数组中。
import java.util.ArrayList;
import java.util.Collection;
public class Demo1Collection {
public static void main(String[] args) {
// 创建集合对象
// 使用多态形式
Collection<String> coll = new ArrayList<String>();
// 使用方法
// 添加功能 boolean add(String s)
coll.add("小李广");
coll.add("扫地僧");
coll.add("石破天");
System.out.println(coll);
// boolean contains(E e) 判断o是否在集合中存在
System.out.println("判断 扫地僧 是否在集合中"+coll.contains("扫地僧"));
//boolean remove(E e) 删除在集合中的o元素
System.out.println("删除石破天："+coll.remove("石破天"));
System.out.println("操作之后集合中元素:"+coll);
// size() 集合中有几个元素
System.out.println("集合中有"+coll.size()+"个元素");
// Object[] toArray()转换成一个Object数组
Object[] objects = coll.toArray();
// 遍历数组
for (int i = 0; i < objects.length; i++) {
System.out.println(objects[i]);
}
// void clear() 清空集合
coll.clear();
System.out.println("集合中内容为："+coll);
// boolean isEmpty() 判断是否为空
System.out.println(coll.isEmpty());
// 注意事项:
// 由于ArrayList集合中remove方法有重载的方法:
// E remove(int index) 移除此列表中指定位置上的元素。
// boolean remove(Object o) 移除此列表中首次出现的指定元素（如果存在）。
// 当ArrayList集合的元素是Integer类型,那么remove()方法到底是根据索引删除,还是根据元素删除
// 结论: 默认根据索引删除
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
// 需求:删除元素 4
list.remove(4);// 删除索引为4的元素
// list.remove(new Integer(4));// 删除元素4
System.out.println("删除元素之后的集合:"+list);// [1, 2, 3, 4]
}
}
二.List集合
1.List集合概述
- java.util.List接口继承自Collection接口，是单列集合的一个重要分支，习惯性地会将实现了List接口的对象称为List集合。在List集合中允许出现重复的元素，所有的元素是以一种线性方式进行存储的，在程序中可以通过索引来访问集合中的指定元素。另外，List集合还有一个特点就是元素有序，即元素的存入顺序和取出顺序一致。
2.List集合特点
- 元素存取有序.
- 元素有索引.通过索引就可以精确地操作集合中的元素
- 元素可以重复.通过元素的contains方法,比较是否有重复的元素.
3.List的常用方法
- public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
- public E get(int index):返回集合中指定位置的元素。
- public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
- public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
public class ListDemo {
public static void main(String[] args) {
// 创建List集合对象
List<String> list = new ArrayList<String>();
// 往 尾部添加 指定元素
list.add("图图");
list.add("小美");
list.add("不高兴");
System.out.println(list);
// add(int index,String s) 往指定位置添加
list.add(1,"没头脑");
System.out.println(list);
// String remove(int index) 删除指定位置元素 返回被删除元素
// 删除索引位置为2的元素
System.out.println("删除索引位置为2的元素");
System.out.println(list.remove(2));
System.out.println(list);
// String set(int index,String s)
// 在指定位置 进行 元素替代（改）
// 修改指定位置元素
list.set(0, "三毛");
System.out.println(list);
// String get(int index) 获取指定位置元素
// 跟size() 方法一起用 来 遍历的
for(int i = 0;i<list.size();i++){
System.out.println(list.get(i));
}
//还可以使用增强for
for (String string : list) {
System.out.println(string);
}
}
}
三.List的子类
1.ArrayList集合
- java.util.ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。
- 许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。
2.LinkedList集合
java.util.LinkedList集合数据存储的结构是双向链表结构。元素增删快,查找慢。
- public void addFirst(E e):将指定元素插入此列表的开头。
- public void addLast(E e):将指定元素添加到此列表的结尾。
- public E getFirst():返回此列表的第一个元素。
- public E getLast():返回此列表的最后一个元素。
- public E removeFirst():移除并返回此列表的第一个元素。
- public E removeLast():移除并返回此列表的最后一个元素。
- public E pop():从此列表所表示的堆栈处弹出一个元素。
- public void push(E e):将元素推入此列表所表示的堆栈。
- public boolean isEmpty()：如果列表不包含元素，则返回true。
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList<String> link = new LinkedList<String>();
//添加元素
link.addFirst("abc1");
link.addFirst("abc2");
link.addFirst("abc3");
System.out.println(link);
// 获取元素
System.out.println(link.getFirst());
System.out.println(link.getLast());
// 删除元素
System.out.println(link.removeFirst());
System.out.println(link.removeLast());
while (!link.isEmpty()) { //判断集合是否为空
System.out.println(link.pop()); //弹出集合中的栈顶元素
}
System.out.println(link);
}
}
四.Set集合
1.Set集合概述
-
java.util.Set接口和java.util.List接口一样，同样继承自Collection接口，它与Collection接口中的方法基本一致，并没有对Collection接口进行功能上的扩充，只是比Collection接口更加严格了。与List接口不同的是，Set接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。
-
Set集合有多个子类，常用的是的java.util.HashSet、java.util.LinkedHashSet这两个集合。
Set集合取出元素的方式可以采用：迭代器、增强for。
2.Set集合特点
- 元素存取无序
- 元素无索引
- 元素不可以重复
五.Set集合的子类
1.HashSet集合
- java.util.HashSet是Set接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不一致)。
public class HashSetDemo {
public static void main(String[] args) {
//创建 Set集合
HashSet<String> set = new HashSet<String>();
//添加元素
set.add(new String("cba"));
set.add("abc");
set.add("bac");
set.add("cba");
//遍历
for (String name : set) {
System.out.println(name);
}
}
}
/**
输出结果:
cba
abc
bac
*/
2.Hashset保证元素唯一的原理
- 保证元素唯一的原理:
1.当HashSet集合存储元素,会调用该元素的hashCode()方法,计算该元素的哈希值
2.判断该哈希值对应的位置是否有相同哈希值的元素
3.如果该位置没有相同哈希值的元素,那么就直接存储
4.如果该位置有相同哈希值的元素,那么就产生了哈希冲突
5.如果产生了哈希冲突,就会调用元素的equals()方法,和该位置上的所有元素进行一 一比较,
如果这些元素中有任意一个元素与该元素相等,那么就不存储
如果这些元素中没有一个元素与该元素相等,那么就存储
3.HashSet存储自定义类型元素
- 给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一
/**
自定义学生类
*/
public class Student {
private String name;
private int age;
public Student() {
}
public Student(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;
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
/**
测试类
*/
public class HashSetDemo2 {
public static void main(String[] args) {
//创建集合对象 该集合中存储 Student类型对象
HashSet<Student> stuSet = new HashSet<Student>();
//存储
Student stu = new Student("于谦", 43);
stuSet.add(stu);
stuSet.add(new Student("郭德纲", 44));
stuSet.add(new Student("于谦", 43));
stuSet.add(new Student("郭麒麟", 23));
stuSet.add(stu);
for (Student stu2 : stuSet) {
System.out.println(stu2);
}
}
}
执行结果：
Student [name=郭德纲, age=44]
Student [name=于谦, age=43]
Student [name=郭麒麟, age=23]
4.LinkedHashSet集合
- 在HashSet下面有一个子类java.util.LinkedHashSet，它是链表和哈希表组合的一个数据存储结构。
- HashSet保证元素唯一，可是元素存放进去是没有顺序的,LinkedHashSet可以保证元素存取有序.
- LinkedHashSet集合的特点:
存储的元素是不可重复的
元素都是有序的(即存取顺序一致)
public class LinkedHashSetDemo {
public static void main(String[] args) {
Set<String> set = new LinkedHashSet<String>();
set.add("bbb");
set.add("aaa");
set.add("abc");
set.add("bbc");
Iterator<String> it = set.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
结果：
bbb
aaa
abc
bbc
365
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
