List与Set的区别
List: 有序的，有下标的，元素可重复
Set: 无序，无下标，元素不可重复
LIst
List提供的方法
增
void add(int index, E element)
作用: 将元素添加到List的指定位置
参数:
index: 插入的位置
element: 添加的元素
boolean addAll(int index, Collection<E> c)
作用: 将一个集合的数据添加到当前集合指定位置
参数:
index: 插入的位置
c: 添加的集合
删
E remove(int index)
作用: 删除指定位置的元素
参数:
index: 指定的位置
返回值:
被删除的元素
改
E set(int index, E element)
作用: 修改指定位置的元素
参数:
index: 指定的位置
element: 修改后的元素
返回值:
修改前集合中该位置的元素
查
E get(int index)
作用: 获取指定位置的元素
参数:
index: 指定的位置
返回值:
指定位置的元素
注意: 取出元素后，该元素依旧在集合存在
int indexOf(Object o)
作用: 查询元素在集合中的位置
参数:
o: 查询的元素
返回值:
元素在集合中的位置
注意: 如果查询的元素在集合中不存在返回-1
int lastIndexOf(Object o)
作用: 查询元素在集合中最后一次出现的位置
参数:
o: 查询的元素
返回值:
元素在集合中最后一次出现的位置
注意: 如果查询的元素在集合中不存在返回-1
list<E> subList(int fromIndex, int toIndex)
作用: 截取集合中一段元素
参数:
fromIndex: 开始位置
toIndex: 结束位置
返回值:
截取的元素集合
注意:
1.截取的元素包含开始位置，不包含结束位置
2.不会影响原集合的数据
遍历List集合有3种方式
for
foreach
迭代器
使用List模拟栈与队列
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
栈: 后进先出
//判断集合是否为空
while(!list.isEmpty()){
//删除最后一个元素
Integer i = list.remove(list.size() - 1);
System.out.println(i);
}
System.out.println(list);
队列: 先进先出
while(!list.isEmpty()){
//删除第一个元素
Integer i = list.remove(0);
System.out.println(i);
}
System.out.println(list);
注意: 出去后数据就不在集合中存在了
常用子类
ArrayList
数据结构: 数组
特点: 查询速度快，增删速度慢，线程不安全
时间: JDK1.2
LinkedList
数据结构: 链表
特点: 查询速度慢，增删速度快
时间: JDK1.2
Vector
数据结构: 数组
特点: 查询速度快，增删速度慢，线程安全的
时间: JDK1.0
注意: List的子类没有提供特有的方法
Set
Set提供的方法
没有提供特有的方法，所有方法都来自Collection
特点
无序，无下标，元素不可重复
常用的子类
HashSet
特点: 数据按照对应的hash码值进行排序
数据结构:
1.8以前: 数组 + 链表
1.8及以后: 数组 + 红黑树
注意:
HashSet中数据前后顺序是根据存储的对象的hashCode值决定的
存储原理:
存储对象时，先调用对象的hashCode()方法，获取对象的hashCode值，使用该hashCode值与集合中已经存储的对象的hashCode值进行比较，如果不相同，直接存储(在红黑树的结构中).如果相同，再调用对象的equals()方法与相同的对象进行比较，如果不相同，存储到集合中(在数组中存储).如果equals()方法结果为true表示相同，那么HashSet集合认为两个对象相同，不再存储第二个对象
LinkedHashSet
数据结构:
1.8以前: 数组 + 链表 + 链表
1.8及以后: 数组 + 红黑树 + 链表
注意: LinkedHashSet多出的链表是用来记录数据的存储顺序，所以LinkedHashSet是有序的
TreeSet
数据结构: 红黑树
注意:
TreeSet存储数据时要么数据拥有比较性，要么创建TreeSet时指定比较器
让数据拥有比较性
就是让存储的数据所属的类实现Comparable接口
注意: 实现Comparable接口就要重写compareTo()方法
指定比较器
在创建TreeSet集合时，传入实现了Comparator的接口对象
数据结构
栈: 后进先出
队列: 先进先出
数组:
特点:
在内存中连续开辟一片空间，所以在寻找数据中所有数据计算机一次遍历内存即可，所以查询速度快
但是因为所有数据在同一片区域，此时如果给其中插入或删除一个数据，那么后面的数据位置都将需要修改，所以增删速度慢
链表:
单链表:
特点: 前一个数据中存储下一个数据的位置
双链表:
特点: 前一个数据中存储上一个与下一个数据的位置
红黑树:
特点: 左叉，右叉，节点
别名: 二叉树
经验
ArrayList: 查询
LinkedList: 修改
Vector: 古老的ArrayList
HashSet: 剔重
LinkedHashSet: 有序的HashSet
TreeSet: 排序
注意: 在实际开发中，数据管理主要是靠数据库，数据可以通过SQL实现对数据剔重与排序，SQL语句可以对数据直接进行修改
原因:
1.面试 2.考试 3.不操作数据库时可以快速实现对数据的剔重与排序
练习
1.将以下数据存储到ArrayList集合中
10,19,12,8,6,3,7,15
并使用冒泡排序对其进行排序
2.将以下数据存储到ArrayList集合中
Student s1 = new Student(10010, "德玛", 18);
Student s2 = new Student(10008, "蛮王", 13);
Student s3 = new Student(10014, "寒冰", 12);
Student s4 = new Student(10053, "剑圣", 18);
Student s5 = new Student(10001, "狗熊", 28);
Student s6 = new Student(10021, "狗头", 48);
Student s7 = new Student(10013, "锤石", 29);
并使用选择排序对其进行排序, 要求按照学号排序
3.使用TreeSet存储以下数据, 并进行排序
要求
1.用比较性与比较器两种方法完成
2.按照年龄排序, 年龄相同时按照学号排序
Student s1 = new Student(10010, "德玛", 18);
Student s2 = new Student(10008, "蛮王", 13);
Student s3 = new Student(10014, "寒冰", 12);
Student s4 = new Student(10053, "剑圣", 18);
Student s5 = new Student(10001, "狗熊", 28);
Student s6 = new Student(10021, "狗头", 48);
Student s7 = new Student(10013, "锤石", 29);
4.使用HashSet对以下数据进行剔重, 如果属性值相同, 就认为相同
Student s1 = new Student(10010, "德玛", 18);
Student s2 = new Student(10008, "蛮王", 13);
Student s3 = new Student(10010, "德玛", 18);
Student s4 = new Student(10053, "剑圣", 18);
Student s5 = new Student(10001, "狗熊", 28);
Student s6 = new Student(10021, "狗头", 48);
Student s7 = new Student(10021, "狗头", 48);
import java.util.ArrayList;
import java.util.List;
//对集合进行冒泡排序
public class Test01 {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
list.add(10);
list.add(19);
list.add(12);
list.add(8);
list.add(6);
list.add(3);
list.add(7);
list.add(15);
for (Integer i : list) {
System.out.print(i + " ");
}
System.out.println();
for(int i = 0; i < list.size() - 1; i++) {
for(int j = 0; j < list.size() - i - 1; j++) {
if(list.get(j) > list.get(j + 1)) {
int temp = list.get(j);
list.set(j, list.get(j + 1));
list.set(j + 1, temp);
}
}
}
for (Integer i : list) {
System.out.print(i + " ");
}
System.out.println();
}
}
运行结果
public class Student {
private int id;
private String name;
private int age;
public Student() {
}
public Student(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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 [id=" + id + ", name=" + name + ", age=" + age + "]";
}
}
import java.util.ArrayList;
import java.util.List;
//对集合进行选择排序
public class Test02 {
public static void main(String[] args) {
List<Student> list = new ArrayList<Student>();
Student s1 = new Student(10010, "德玛", 18);
Student s2 = new Student(10008, "蛮王", 13);
Student s3 = new Student(10014, "寒冰", 12);
Student s4 = new Student(10053, "剑圣", 18);
Student s5 = new Student(10001, "狗熊", 28);
Student s6 = new Student(10021, "狗头", 48);
Student s7 = new Student(10013, "锤石", 29);
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
list.add(s5);
list.add(s6);
list.add(s7);
for (Student s : list) {
System.out.println(s);
}
//选择排序, 按照学号排序
for(int i = 0; i < list.size() - 1; i++) {
int minIndex = i;
for(int j = i + 1; j < list.size(); j ++) {
if(list.get(j).getId() < list.get(minIndex).getId()) {
minIndex = j;
}
}
if(minIndex != i) {
Student s = list.get(i);
list.set(i, list.get(minIndex));
list.set(minIndex, s);
}
}
System.out.println("排序后: ");
for (Student s : list) {
System.out.println(s);
}
}
}
运行结果
package demo03;
public class Student implements Comparable<Student>{
private int id;
private String name;
private int age;
public Student() {
}
public Student(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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 [id=" + id + ", name=" + name + ", age=" + age + "]";
}
@Override
public int compareTo(Student o) {
if(age != o.age) {
return age - o.age;
}
if(id != o.id) {
return id - o.id;
}
return 1;
}
}
package demo03;
import java.util.Set;
import java.util.TreeSet;
//用比较性进行排序
public class Test {
public static void main(String[] args) {
Set<Student> set = new TreeSet<Student>();
Student s1 = new Student(10010, "德玛", 18);
Student s2 = new Student(10008, "蛮王", 13);
Student s3 = new Student(10014, "寒冰", 12);
Student s4 = new Student(10053, "剑圣", 18);
Student s5 = new Student(10001, "狗熊", 28);
Student s6 = new Student(10021, "狗头", 48);
Student s7 = new Student(10013, "锤石", 29);
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
set.add(s5);
set.add(s6);
set.add(s7);
for (Student s : set) {
System.out.println(s);
}
}
}
运行结果
package demo04;
public class Student {
private int id;
private String name;
private int age;
public Student() {
}
public Student(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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 [id=" + id + ", name=" + name + ", age=" + age + "]";
}
}
package demo04;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
import demo04.Student;
//用比较器进行排序
public class Test {
public static void main(String[] args) {
Set<Student> set = new TreeSet<Student>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
if(o1.getAge() != o2.getAge()) {
return o1.getAge() - o2.getAge();
}
if(o1.getId() != o2.getId()) {
return o1.getId() - o2.getId();
}
return 1;
}
});
Student s1 = new Student(10010, "德玛", 18);
Student s2 = new Student(10008, "蛮王", 13);
Student s3 = new Student(10014, "寒冰", 12);
Student s4 = new Student(10053, "剑圣", 18);
Student s5 = new Student(10001, "狗熊", 28);
Student s6 = new Student(10021, "狗头", 48);
Student s7 = new Student(10013, "锤石", 29);
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
set.add(s5);
set.add(s6);
set.add(s7);
for (Student s : set) {
System.out.println(s);
}
}
}
运行结果
package demo05;
public class Student {
private int id;
private String name;
private int age;
public Student() {
}
public Student(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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 [id=" + id + ", name=" + name + ", age=" + age + "]";
}
@Override
public int hashCode() {
return id + name.hashCode() + age;
}
@Override
public boolean equals(Object obj) {
if(this == obj) {
return true;
}
if(obj instanceof Student) {
Student stu = (Student)obj;
if(id == stu.id && name.equals(stu.name) && age == stu.age) {
return true;
}
}
return false;
}
}
package demo05;
import java.util.HashSet;
import java.util.Set;
import demo05.Student;
//使用HashSet对数据进行剔重
public class Test {
public static void main(String[] args) {
Set<Student> set = new HashSet<Student>();
Student s1 = new Student(10010, "德玛", 18);
Student s2 = new Student(10008, "蛮王", 13);
Student s3 = new Student(10010, "德玛", 18);
Student s4 = new Student(10053, "剑圣", 18);
Student s5 = new Student(10001, "狗熊", 28);
Student s6 = new Student(10021, "狗头", 48);
Student s7 = new Student(10021, "狗头", 48);
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
set.add(s5);
set.add(s6);
set.add(s7);
for (Student s : set) {
System.out.println(s);
}
}
}
运行结果
652
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
