1. 数组和集合的区别【理解】
-
相同点
都是容器,可以存储多个数据
-
不同点
-
数组的长度是不可变的,集合的长度是可变的
-
数组可以存基本数据类型和引用数据类型
集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类
-
public class Demo1 {
public static void main(String[] args) {
//1.数组存储基本数据类型和引用数据类型
int[] arr1 = {1, 2, 3};
String[] arr2 = {"a", "b", "c"};
System.out.println(Arrays.toString(arr1));
System.out.println(Arrays.toString(arr2));
//2.集合存储引用数据类型，要存储基本数据类型，则存储他们对应的包装类
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
System.out.println(list);
}
}
运行结果
2. 集合类体系结构
3. Collection 集合概述和使用
-
Collection集合概述
- 是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素
- JDK 不提供此接口的任何直接实现.它提供更具体的子接口(如Set和List)实现
-
创建Collection集合的对象
- 多态的方式
- 具体的实现类ArrayList
-
Collection集合常用方法
方法名 说明 boolean add(E e) 添加元素 boolean remove(Object o) 从集合中移除指定的元素 boolean removeIf(Object o) 根据条件进行移除 void clear() 清空集合中的元素 boolean contains(Object o) 判断集合中是否存在指定的元素 boolean isEmpty() 判断集合是否为空 int size() 集合的长度，也就是集合中元素的个数
public class Demo2 {
public static void main(String[] args) {
Collection collection = new ArrayList();
//1.添加元素
collection.add("社会龙");
collection.add("三藏哥");
collection.add("七头哥");
System.out.println(collection);
//2.从集合中移除指定元素
collection.remove("社会龙");
System.out.println(collection);
//3.清空集合中的元素
// collection.clear();
// System.out.println(collection);
//4.判断集合中是否存在指定元素
boolean result = collection.contains("社会龙");
System.out.println("集合中是否存在社会龙这个元素："+result);
//5.判断集合是否为空
boolean isEmpty = collection.isEmpty();
System.out.println("集合是否为空："+isEmpty);
//6.集合的长度
int size = collection.size();
System.out.println("集合的长度是："+ size);
}
}
运行结果
4. Collection集合的遍历
4. 1迭代器遍历
-
迭代器,集合的专用遍历方式
-
Iterator iterator(): 返回此集合中元素的迭代器,通过集合对象的 iterator() 方法得到
-
Iterator中的常用方法
boolean hasNext(): 判断当前位置是否有元素可以被取出
E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置
public class Demo3 {
public static void main(String[] args) {
Collection collection = new ArrayList();
//1.添加元素
collection.add("社会龙");
collection.add("社会姐");
collection.add("三藏哥");
collection.add("七头哥");
//2.用集合对象的iterator()方法获取集合元素的迭代器
Iterator iterator = collection.iterator();
while (iterator.hasNext()){//判断当前位置是否有元素可以被取出
String element = (String) iterator.next();//获取当前位置的元素,将迭代器对象移向下一个索引位置
System.out.println(element);
}
}
}
运行结果
4.2 增强for循环
-
介绍
- 它是JDK5之后出现的,其内部原理是一个Iterator迭代器
- 实现Iterable接口的类才可以使用迭代器和增强for
- 简化数组和Collection集合的遍历
-
格式
for(集合/数组中元素的数据类型 变量名 : 集合/数组名) {
// 已经将当前遍历到的元素封装到变量中了,直接使用变量即可
}
public class Demo4 {
public static void main(String[] args) {
Collection collection = new ArrayList();
String[] names = {"社会龙","社会姐","三藏哥","七头哥"};
//1.添加元素
collection.add("社会龙");
collection.add("社会姐");
collection.add("三藏哥");
collection.add("七头哥");
//2.增强for遍历集合
//数据类型一定是集合或者数组中元素的类型
for (Object elemenet : collection) {
System.out.println(elemenet);
}
System.out.println("===============================================");
//3.增强for遍历数组
for (String name : names) {
//name仅仅是一个变量名而已,在循环的过程中,依次表示集合或者数组中的每一个元素
//names就是要遍历的集合或者数组
System.out.println(name);
}
}
}
运行结果
5. List集合的特有方法【应用】
-
方法介绍
方法名 描述 void add(int index,E element) 在此集合中的指定位置插入指定的元素 E remove(int index) 删除指定索引处的元素，返回被删除的元素 E set(int index,E element) 修改指定索引处的元素，返回被修改的元素 E get(int index) 返回指定索引处的元素
5. List集合的实现类
5.1 List集合子类的特点
-
ArrayList集合
底层是数组结构实现，查询快、增删慢
-
LinkedList集合
底层是链表结构实现，查询慢、增删快
5.2 LinkedList集合的特有功能【应用】
-
特有方法
方法名 说明 public void addFirst(E e) 在该列表开头插入指定的元素 public void addLast(E e) 将指定的元素追加到此列表的末尾 public E getFirst() 返回此列表中的第一个元素 public E getLast() 返回此列表中的最后一个元素 public E removeFirst() 从此列表中删除并返回第一个元素 public E removeLast() 从此列表中删除并返回最后一个元素
public class Demo5 {
public static void main(String[] args) {
LinkedList<String> linkedList = new LinkedList<>();
//1.添加元素
linkedList.add("社会龙");
linkedList.add("社会姐");
linkedList.add("三藏哥");
linkedList.add("七头哥");
//2.在该列表开头插入指定的元素
linkedList.addFirst("霍景良");
System.out.println(linkedList);
System.out.println("==================================================");
//3.讲指定的元素追加到此列表的末尾
linkedList.addLast("坤坤");
System.out.println(linkedList);
System.out.println("==================================================");
//4.获取列表的第一个元素
String first = linkedList.getFirst();
System.out.println("集合的第一个元素："+first);
System.out.println("==================================================");
//5.获取列表的最后一个元素
String last = linkedList.getLast();
System.out.println("集合的最后一个元素："+first);
System.out.println("==================================================");
//6.删除列表的第一个元素，并返回
String removeFirst = linkedList.removeFirst();
System.out.println(linkedList);
System.out.println("==================================================");
//7.删除列表的最后一个元素并返回
String removeLast = linkedList.removeLast();
System.out.println(removeLast);
}
}
运行结果
6. Set集合
6.1 Set集合概述和特点
- 不可以存储重复元素
- 没有索引,不能使用普通for循环遍历
package com.zhang.collection.set;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
/**Set集合概述和特点
* 不可以存储重复元素
* 存取顺序不一致
* 没有索引,不能使用普通for循环遍历
*/
public class SetDemo1 {
public static void main(String[] args) {
Set<String> set = new TreeSet<>();
//1.添加元素
set.add("社会龙");
set.add("社会姐");
set.add("三藏哥");
set.add("七头哥");
set.add("七头哥");
System.out.println(set);
//1.迭代器遍历set集合
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()){
String next = iterator.next();
System.out.println(next);
}
System.out.println("============================================================");
//2.增强for遍历
for (String s : set) {
System.out.println(s);
}
}
}
运行结果
6.2 TreeSet集合概述和特点
-
不可以存储重复元素
-
没有索引
-
可以将元素按照规则进行排序
-
TreeSet()：根据其元素的自然排序进行排序
-
TreeSet(Comparator comparator) ：根据指定的比较器进行排序
存储Integer类型的整数并遍历
package com.zhang.collection.set.treeset; import java.util.TreeSet; public class TreeSetDemo1 { public static void main(String[] args) { TreeSet<Integer> treeSet = new TreeSet<>(); treeSet.add(90); treeSet.add(10); treeSet.add(70); treeSet.add(70); treeSet.add(80); System.out.println(treeSet); } }运行结果
-
6.3 自然排序Comparable的使用
-
案例需求
- 存储学生对象并遍历，创建TreeSet集合使用无参构造方法
- 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
-
实现步骤
- 使用空参构造创建TreeSet集合
- 用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
- 自定义的Student类实现Comparable接口
- 自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法
- 重写接口中的compareTo方法
- 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
- 使用空参构造创建TreeSet集合
-
代码实现；
自定义Student类
package com.zhang.collection.set.domain;
public class Studentimplements Comparable<Student> {
private String name;
private int age;
...空参构造，满参构造，geterseter方法，toString方法
@Override
public int compareTo(Student o) {
//按照对象的年龄进行排序
//主要判断条件: 按照年龄从小到大排序
//次要判断条件: 年龄相同时，按照姓名的字母顺序排序
int result = this.age - o.age;
result = result == 0 ?this.name.compareTo(o.name):result;
return result;
}
}
demo
package com.zhang.collection.set.treeset;
import com.zhang.collection.set.domain.Student;
import java.util.TreeSet;
/**
* 案例需求
*
* - 存储学生对象并遍历，创建TreeSet集合使用无参构造方法
* - 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
*/
public class SetDemo2 {
public static void main(String[] args) {
/**
* 自然排序Comparable的使用步骤
* 使用空参构造创建TreeSet集合
* 自定义的Student类实现Comparable
* 接口重写里面的compareTo方法
*
* 做完以上步骤，treeset集合就可以按照Student类里面的规则排序
*/
TreeSet<Student> students = new TreeSet<>();
Student student1 = new Student("zhangsan", 10);
Student student2 = new Student("lisi",30);
Student student3 = new Student("wangwu",20);
Student student4 = new Student("zhaoliu",20);
students.add(student1);
students.add(student2);
students.add(student3);
students.add(student4);
System.out.println(students);
}
}
运行结果
自然排序原理
6.4 比较器排序Comparator的使用
-
案例需求
- 存储老师对象并遍历，创建TreeSet集合使用带参构造方法
- 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
-
实现步骤
- 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
- 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法
- 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
老师类
package com.zhang.collection.set.domain;
public class Teacher {
private String name;
private int age ;
....
无参、满参构造，get、setter方法。tostring方法
}
demo
package com.zhang.collection.set.treeset;
import com.zhang.collection.set.domain.Teacher;
import java.util.Comparator;
import java.util.TreeSet;
public class TreeSetDemo2 {
public static void main(String[] args) {
/**
01表示现在要存入的那个元素
02表示已经存入到集合中的元素
**/
TreeSet<Teacher> teachers = new TreeSet<>(new Comparator<Teacher>() {
@Override
public int compare(Teacher o1, Teacher o2) {
//主要条件
int result = o1.getAge() - o2.getAge();
//次要条件
result = result == 0 ?o1.getName().compareTo(o2.getName()):result;
return result;
}
});
Teacher teacher1 = new Teacher("zhangsan",19);
Teacher teacher2 = new Teacher("lisi",18);
Teacher teacher3 = new Teacher("wangwu",20);
Teacher teacher4 = new Teacher("zhaoliu",20);
teachers.add(teacher1);
teachers.add(teacher2);
teachers.add(teacher3);
teachers.add(teacher4);
System.out.println(teachers);
}
}
运行结果
6.5 两种比较方式总结【理解】
- 两种比较方式小结
- 自然排序: 自定义类实现Comparable接口,重写compareTo方法,根据返回值进行排序
- 比较器排序: 创建TreeSet对象的时候传递Comparator的实现类对象,重写compare方法,根据返回值进行排序
- 在使用的时候,默认使用自然排序,当自然排序不满足现在的需求时,必须使用比较器排序
- 两种方式中关于返回值的规则
- 如果返回值为负数，表示当前存入的元素是较小值，存左边
- 如果返回值为0，表示当前存入的元素跟集合中元素重复了，不存
- 如果返回值为正数，表示当前存入的元素是较大值，存右边
7233
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
