目录
1、集合的体系结构
2、Collection常用方法
boolean add() 向集合中添加元素
boolean remove() 将元素从集合中删除
void clear() 清空集合所有的元素
boolean contains() 判断集合中是否包含指定的元素
boolean isEmpty() 判断集合是否为空
int size() 获取集合元素的长度
Collections.addAll(); 一次添加多个value值
public class Test1 {
public static void main(String[] args) {
Collection<String> list = new ArrayList<>();
//添加
list.add("女孩");
list.add("男孩");
list.add("苏沐橙");
list.add("君莫笑");
System.out.println(list);
//清空
list.clear();
//删除
list.remove("男孩");
System.out.println(list);
//判断是否为空
boolean empty = list.isEmpty();
System.out.println(empty);
//判断是否有这个元素
boolean contains = list.contains("男孩");
System.out.println(contains);
//判断哈希值
int code = list.hashCode();
System.out.println(code);
//判断list集合里的元素有多少
int size = list.size();
System.out.println(size);
}
}3、迭代器的使用
3.1、通过迭代器遍历Collection集合的步骤
1、通过集合对象获取迭代器对象
2、通过hasNext()方法循环判断迭代器对象中是否还有元素
3、如果有元素，通过next()方法获取迭代器中的元素
public class Test2 {
public static void main(String[] args) {
Collection<String> list = new ArrayList<>();
//添加
list.add("女孩");
list.add("男孩");
list.add("苏沐橙");
list.add("君莫笑");
//返回此集合中元素的迭代器，通过集合的iterator()方法得到
Iterator<String> iterator = list.iterator();
//用while循环改进元素的判断和获取
while (iterator.hasNext()){
String next = iterator.next();
System.out.println(next);
}
}
}3.2、迭代器原理分析
①. Iterator<E> iterator(): 获取迭代器对象,默认指向0索引
②. boolean hasNext():判断当前位置是否有元素可以被取出
③. E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置
4、增强for遍历集合
增强for循环定义格式
for(数组/集合中元素的数据类型 变量名 : 数组/集合对象) {
循环体;
}
public class Test2 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
//添加
list.add("女孩");
list.add("男孩");
list.add("苏沐橙");
list.add("君莫笑");
//for
for (String s : list) {
System.out.println(s);
}
}
}4.1、三种遍历方式使用场景
增强for: 对集合进行遍历时使用,遍历过程中若要增删元素则不能使用
普通fori: 遍历过程中需要增删元素或操作索引时使用
public class Test2 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
//添加
list.add("女孩");
list.add("男孩");
list.add("苏沐橙");
list.add("君莫笑");
//fori
for (int i = 0; i < list.size(); i++) {
String s = list.get(i);
System.out.println(s);
}
}
}
迭代器: 遍历过程中需要删除元素时使用
5、list集合
1、list集合的概述
List集合是单列集合体系之一
2、list集合的特点
1、list集合及其实现类全部都是有索引
2、list集合及其实现类全部都是可以重复元素
3、list集合及其实现类全部都是元素存取有序
3、list集合的特有方法
1、 add() 向集合中指定的索引位置添加元素
2、remove() 删除指定索引处的元素并返回
3、set() 修改指定索引处的元素，返回被修改的元素
4、get() 获取指定索引处的元素
public class Test3 {
public static void main(String[] args) {
List<Object> list = new ArrayList<>();
//添加
list.add("女孩");
list.add("男孩");
list.add("苏沐橙");
list.add("君莫笑");
System.out.println(list);
//修改
list.set(1,"爱你");
System.out.println(list);
//获取指定元素
Object o = list.get(1);
System.out.println(o);
//删除指定元素
list.add("男女");
System.out.println(list);
list.remove("君莫笑");
System.out.println(list);
list.remove(3);
System.out.println(list);
}
}6、数据结构
数据结构是计算机存储，组织数据的方式，是指相互之间存在一种或多种特定关系的数据元素的集合。
通过情况下，精心选择的数据结构可以带来更高的运行和存储效率。
1、栈结构
数据先进后出
2、队列结构
数据先进先出
3、数组结构
特点: 查询快，增删慢
4、链表结构
特点：查询慢，增删快
7、AaaryList特点
底层数据结构是数组，查询快，增删慢
8、linkedList特点
底层数据结构是链表，查询慢，增删快
1、linkedList集合特有功能
void addFirst(E e) 向集合中第一个位置添加元素
void addLast(E e) 向集合中最后一个位置添加元素
E getFirst() 获取集合中第一个元素
E getLast() 获取集合中最后一个元素
E removeFirst() 删除集合中第一个元素
E removeLast() 删除集合中最后一个元素
public class Test4 {
public static void main(String[] args) {
LinkedList<Object> list = new LinkedList<>();
//添加
list.add("女孩");
//添加在第一个
list.addFirst("你好世界");
//添加在集合元素的最后一个
list.addLast("你的名字");
//获取集合第一个元素
Object first = list.getFirst();
System.out.println(first);
//获取集合最后一个元素
Object last = list.getLast();
System.out.println(last);
//删除第一个元素
list.removeFirst();
//删除集合最后一个元素
list.removeLast();
System.out.println(list);
}
}2、LinkedList源码解析
LinkedList添加和查找元素的过程
①.LinkedList底层数据结构是链表,查询慢,增删快
②.查询慢: 因为需要从一侧开始依次查询
③.增删快:增删元素后,不需要动元素的位置,只需要修改元素指向即可
9、set集合
1、set集合的概述和特点
底层数据结构是哈希表
对集合的迭代顺序不作任何保证,也就是说不保证存储和取出的元素顺序一致
没有索引,所以不能使用普通for循环遍历
由于是Set集合,所以是不包含重复元素的集合(去重)
1、不能存储重复元素
2、没有索引
2、哈希值
哈希值:是jdk根据对象的地址或者字符串或者数字计算出来的int类型的数值
Object类中有一个方法可以获取对象的哈希值
int hashCode() 返回对象的哈希值
3、hashSet集合存储元素
当调用add()方法向集合中存入对象的时候，先比较此对象与原有对象的哈希值有 没 有 一样的，如果都不一样就直接存入；如果有与之相同的哈希值，则要继续比较这
两个对象是否为同一个对象，此时就要调用对象的equals()方法了 要保证元素唯一性,需
要重写hashCode()和equals()
hashCode()相同，equals()不一定相同
equals()相同 ，hashCode()一定相同
4、TreeSet集合
1、概述和特点:
1.元素有序,这里的顺序不是指存储和取出的顺序,而是按照一定的规则进行排序,具体排序方式取决于构造方法 TreeSet() :
根据其元素的自然顺序进行排序
TreeSet (Comparator<? super E> comparator) : 根据其指定的比较器进行排序
2. 没有带索引的 方法,所以不能使用普通for遍历循环
3. 由于是Set集合,所以不包含重复元素的集合
2、比较器
1、自然排序-Comparable
1.使用TressSet集合存储自定义对象,无参构造方法使用的是自然排序对元素进行排序的
2.自然排序就是让元素所属的类实现Comparable接口,重写compareTo(T o)方法
3. 重写方法时,一定要注意排序规则,必须按照要求的主要条件和次要条件来写 4.在方法中定义排序的规则:
0:表示两个对象相同 1:升序 -1:降序
package com.hpf;
/**
* @author 86136
* Comparable:自然排序
*/
public class Student implements Comparable<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 String toString() {
return "Student{" +
"name='" + name + '\'' +
", age='" + age + '\'' +
'}';
}
@Override
public int compareTo(Student o) {
int res = this.age - o.age;
//依次判断条件:年龄相同时，按照姓名的字母顺序排序
res = res == 0 ? this.name.compareTo(o.getName()) : res;
return res;
}
}
package com.hpf;
import java.util.TreeSet;
/**
* @author 86136
*/
public class StudentTest {
public static void main(String[] args) {
TreeSet<Student> set = new TreeSet<>();
Student s1 = new Student("张三", 25);
Student s2 = new Student("苏沐橙", 21);
Student s3 = new Student("君莫笑", 22);
set.add(s1);
set.add(s2);
set.add(s3);
for (Student student : set) {
System.out.println(student);
}
}
}
2、选择排序-Comparator
1.使用TreeSet集合存储自定义对象,带参构造方法使用的是比较器排序对元素进行排序
2.比较器排序,就是让集合构造方法接收Comparator的实现类对象,重新compare(T o1,T o2)方法
3.重写方法时,一定要注意排序规则,必须按照要求的主要条件和次要条件来写 4.在方法中定义排序的规则: o1 - o2 : 升序 o2 - o1 : 降序
3、 两种比较方式的对比
自然排序 1. 自定义类实现Comparable接口
2. 重写compareTo方法,根据返回值进行排序
选择排序 1. 创建TreeSet对象的时候传递Comparator的实现类对象
2. 重写compare方法,根据返回值进行排序
在使用的时候
默认使用自然排序,当自然排序不满足现在的需求时,必须使用比较器排序
package com.hpf;
/**
* @author 86136
*/
public class Teacher {
private String name;
private int age;
public Teacher() {
}
public Teacher(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 String toString() {
return "Teacher{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package com.hpf;
import java.util.Comparator;
import java.util.TreeSet;
/**
* @author 86136
*/
public class TeacherTest {
public static void main(String[] args) {
TreeSet<Teacher> se = new TreeSet<>(new Comparator<Teacher>() {
@Override
public int compare(Teacher o1, Teacher o2) {
//o1表示现在要存入的那个元素
//o2表示已经存入到集合中的元素
//主要条件
int res = o1.getAge() - o2.getAge();
res = res == 0 ? o1.getName().compareTo(o2.getName()) : res;
return res;
}
});
Teacher s1 = new Teacher("张三", 25);
Teacher s2 = new Teacher("苏沐橙", 21);
Teacher s3 = new Teacher("君莫笑", 22);
se.add(s1);
se.add(s2);
se.add(s3);
for (Teacher teacher : se) {
System.out.println(teacher);
}
}
}
10、map集合
1、map集合的特点
1.双列集合，一个键对应一个值
2.键不可以重复，值可以重复
2、Map集合的基本功能
1、方法介绍
| 方法名 | 说明 |
|---|---|
| put() | 添加元素 |
| remove() | 根据键删除键值对元素 |
| clear() | 移除所有键值对元素 |
| containsKey() | 判断集合是否包含指定的键 |
| containsValue() | 判断集合是否包含指定的值 |
| isEmpty() | 判断集合是否是空 |
| size | 集合的长度，也就是集合中键值对的个数 |
2、代码演示
public class Test {
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
//添加元素
map.put("你好","女孩");
map.put("aa","bb");
//删除元素
map.remove("aa");
//判断集合是否包含指定的键
boolean aa = map.containsKey("aa");
//判断集合是否包含指定的值
boolean nh = map.containsValue("女孩");
//判断集合是否是空
boolean empty = map.isEmpty();
//集合的长度
int size = map.size();
//清空集合里所有元素
map.clear();
}
}3、Map合的获取功能
1、方法介绍
| 方法名 | 说明 |
| get() | 根据键获取值 |
| KeySet() | 获取所有键的集合 |
| Values() | 获取所有值的集合 |
| entrySet() | 获取所有键值对对象的集 |
2、代码演示
public class Test2 {
public static void main(String[] args) {
HashMap<Integer, String> map = new HashMap<>();
map.put(1,"女孩");
map.put(2,"bb");
map.put(3,"苏沐橙");
//根据键获取值
String s = map.get(1);
//获取所有键的集合
Set<Integer> key = map.keySet();
System.out.println(key);
//获取所有值的集合
Collection<String> values = map.values();
System.out.println(values);
//获取所有键值对的集合
Set<Entry<Integer, String>> entries = map.entrySet();
System.out.println(entries);
}
}4、Map集合的遍历（方式一）
1、步骤
1.获取所有键的集合，用keySet()方法实现
2.遍历键的集合，获取每一个键。用增强for实现
3.根据键去找值，用get()方法实现
2、代码演示
public class Test {
public static void main(String[] args) {
HashMap<Integer, String> map = new HashMap<>();
map.put(1,"女孩");
map.put(2,"bb");
map.put(3,"苏沐橙");
//获取所有键的集合
Set<Integer> key = map.keySet();
for (Integer integer : key) {
String value = map.get(integer);
System.out.println(value);
}
}
}5 、Map集合遍历（方式二）
1、步骤
-
获取所有键值对对象的集合
-
Set<Map.Entry<K,V>> entrySet()：获取所有键值对对象的集合
-
-
遍历键值对对象的集合，得到每一个键值对对象
-
用增强for实现，得到每一个Map.Entry
-
-
根据键值对对象获取键和值
-
用getKey()得到键
-
2、代码演示
public class Test {
public static void main(String[] args) {
HashMap<Integer, String> map = new HashMap<>();
map.put(1,"女孩");
map.put(2,"bb");
map.put(3,"苏沐橙");
//获取所有键值对对象的集合
Set<Entry<Integer, String>> entries = map.entrySet();
//遍历键值对对象获取键值
for (Entry<Integer, String> entry : entries) {
//根据键值对获取键和值
Integer key = entry.getKey();
String value = entry.getValue();
System.out.println(key+":"+value);
}
}11、HashMap集合
1、HashMap集合概述和特点
1、hashMap底层是哈希表结构的
2、依赖hashCode方法和equals方法保证键的唯一
3、如果键要存储的是自定义对象，需要重写hashCode和equals方法
2、TreeMap集合概述和特点
1.TreeMap底层是红黑树结构
2.依赖自然排序或者比较器排序，对键进行排序
3.如果键存储的是自定义对象，需要实现Comparable接口或者在创建TreeMap对象时候给出比较器排序规则
3、代码实现
public class Test3{
public static void main(String[] args) {
TreeSet<Student> set = new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
//前面(o1)减后(o2)面=升序 || 后面减前面=降序
int res = o1.getAge() - o2.getAge();
res = res == 0 ? o1.getName().compareTo(o2.getName()):res;
return res;
}
});
Student s1 = new Student("张三", 25);
Student s2 = new Student("苏沐橙", 19);
Student s3 = new Student("君莫笑", 19);
Student s4 = new Student("莫凡", 25);
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
System.out.println(set);
}
}
4713
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
