目录
List集合
1.List接口特点
A. 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
B. 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
C. 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。
2.常用方法
List接口作为Collection接口的子类，继承了Collection接口的全部方法，而且还增加了一些根据索引对集合进行操作的方法。
下面只介绍这四种带索引值的方法：
-
public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。 -
public E get(int index):返回集合中指定位置的元素。 -
public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。 -
public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
实例：
package demo1_List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/*
java.util.List接口extends Collection接口
特点：
1.存取有序的集合
2.是一个带索引的集合
3.允许重复元素
四种带索引的方法：
- public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
- public E get(int index):返回集合中指定位置的元素。
- public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
- public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
三种遍历方式：1.普通for循环 2.迭代器 3.增强for循环
注意：防止索引越界
*/
public class Test01_List {
public static void main(String[] args) {
//创建集合对象
List<String> list=new ArrayList<>();
list.add("小太阳");
list.add("小太阳");
list.add("小月亮");
list.add("小星星");
//允许带有重复的元素
System.out.println(list); //[小太阳, 小太阳, 小月亮, 小星星]
//添加元素到指定位置
list.add(2,"就是我");
System.out.println(list); //[小太阳, 小太阳, 就是我, 小月亮, 小星星]
//移除指定位置元素，返回值是被移除的元素
String str=list.remove(1);
System.out.println("我是被移除的元素："+str); //我是被移除的元素：小太阳
System.out.println(list); //[小太阳, 就是我, 小月亮, 小星星]
//替换指定位置的元素，返回值是旧元素
String str2=list.set(1,"小行星");
System.out.println("我是被替换的元素："+str2); //我是被替换的元素：就是我
System.out.println(list); //[小太阳, 小行星, 小月亮, 小星星]
//1.普通for循环遍历
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
System.out.println("===============");
//2.迭代器遍历
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("================");
//3.增强for遍历
for (String s : list) {
System.out.println(s);
}
}
}
3.List子类
A. ArrayList集合
B. LinkedList集合：java.util.LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合，但查询慢。
实例：
package demo1_List;
import java.util.LinkedList;
/*
java.util.LinkedList集合 implements List接口
LinkedList集合特点：
1.底层是一个链表结构：查询慢，增删快
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 E pop():从此列表所表示的堆栈处弹出一个元素。
- public void push(E e):将元素推入此列表所表示的堆栈。
- public boolean isEmpty()：如果列表不包含元素，则返回true。
*/
public class Test02_LinkedList {
public static void main(String[] args) {
// method1_AddGet();
// method2_Remove();
method3_PopPush();
}
public static void method3_PopPush(){
LinkedList<String> liked=method1_AddGet();
System.out.println("=================");
// - public E pop():从此列表所表示的堆栈处弹出一个元素。
//LinkedList底层是一个链表解构首先弹出的是第一个元素
String str1=liked.pop();
System.out.println(str1);
System.out.println(liked);
//将元素推入此列表所表示的堆栈
liked.push("小月亮");
System.out.println(liked);
}
public static void method2_Remove(){
LinkedList<String> liked=method1_AddGet();
System.out.println("=================");
String str1=liked.removeFirst();
String str2=liked.removeLast();
System.out.println(str1+str2);
System.out.println(liked);
}
public static LinkedList<String> method1_AddGet(){
LinkedList<String> liked=new LinkedList<>();
liked.addFirst("会发光的");
liked.add("打不过我吧");
liked.addLast("小太阳");
System.out.println(liked); // [会发光的, 打不过我吧, 小太阳]
String str1=liked.getFirst();
String str2=liked.getLast();
System.out.println(str1+str2); // 会发光的小太阳
return liked;
}
}
Set接口
Set 接口 extends Collection接口
特点：1.不允许存储重复的元素，无序
2.没有索引，没有带索引的方法，不能用普通for循环遍历
1.HsahSet集合 implements Set接口
1.不允许存储重复的元素
2.没有索引，没有带索引的方法，不能用普通for循环遍历
3.是一个无序的集合，存储元素和取出元素顺序可能不一致
4.底层是一个哈希表结构(查询速度非常快)，具有良好的查询和存取性能。
实例：
package demo2_Set;
import java.util.HashSet;
/*
Set接口 extends Collection接口
特点 ：1.不允许存储重复的元素
2.没有索引，也没有带索引的方法，不能用普通for循环遍历
HashSet集合 implements Set接口
特点; 1.不允许存储重复的元素
2.没有索引，没有带索引的方法，不能用普通for循环遍历
3.是一个无序的集合，存储元素和取出元素顺序可能不一致
4.底层是一个哈希表结构(查询速度非常快)
*/
public class Test01_HashSet {
public static void main(String[] args) {
method();
}
public static void method(){
//创建集合
HashSet<String> hs=new HashSet<>();
hs.add("太阳");
hs.add("月亮");
hs.add("星星");
hs.add("太阳");
System.out.println(hs); //[太阳, 月亮, 星星],没有重复元素
}
}
HashSet 存储自定义类型元素
哈希值：是一个十进制的整数，有系统随机给出，就是对象的地址值，是一个逻辑地址， 是模拟出来的地址，不是实际存储的物理地址。
在Object类中有一个方法，可以获取对象的哈希值
public native int hashCode() 返回该对象的哈希值给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象不重复。
在IDEA中有重写hashCode和equals方法的快捷方式：鼠标右键--->Generate--->equals and hashCode().
定义Person类并重写hashCode和equals方法：
/*
总而言之，JDK1.8引入红黑树大程度优化了HashMap的性能，那么对于我们来讲
保证HashSet集合元素的唯一，其实就是根据对象的hashCode和equals方法来决定的。
如果我们往集合中存放自定义的对象，那么保证其唯一，就必须复写hashCode和equals方法
建立属于当前对象的比较方式。
*/
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}测试类：添加四个对象元素，其中两个为重复，测试能否添加成功重复元素
package demo2_Set;
import java.util.HashSet;
/*
HashSet存储自定义类型元素
set集合报错元素唯一：
存储的元素(String,Integer,...Student,Person...),需要重写对象中的hashCode和equals方法，
建立自己的比较方式，才能保证HashSet集合中的对象唯一
要求：
同名同年龄的人视为一个人。
*/
public class Test02_HashSet {
public static void main(String[] args) {
//创建集合 存储Personl类型对象
HashSet<Person> stu=new HashSet<>();
stu.add(new Person("太阳",18));
stu.add(new Person("月亮",19));
stu.add(new Person("星星",22));
stu.add(new Person("太阳",18));
//增强for遍历
for (Person person : stu) {
System.out.println(person);
}
}
}
2.LinkedHashSet
注意：HashSet 与 LinkedHashSet 的区别就是前者是无序的，后者是有序的。但是我们在测试时可能会出现这种现象：比如我现在创建一个HashSet，调用add()方法，一词添加字符‘A’，‘C’，‘B’，然后输出则为【A，B，C】，我们换一种测试：依次添加A，B，C或者依次添加C,B,A，然后输出结果都是【A,B,C】,有的小伙伴就会说这不是有序的吗？。。。请注意：这里的无序指的是往内存中存放元素的顺序和取出时的顺序不一致，比如你存进去时是ACB，取出时是ABC，这不是无序吗。
而LinkedHashSet可以保证存放元素的顺序和取出时的顺序一致，这就是有序。
实例：
package demo2_Set;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.LinkedList;
/*
java.utilLinkedHashSet集合 extends HashSet集合
LinkedHashSet特点：
底层是一个哈希表(数组+链表/红黑树)+链表：多了一条链表(记录元素的存储顺序)，保证元素有序
*/
public class Test04_LinkedHashSet {
public static void main(String[] args) {
HashSet<String> hs=new HashSet<>();
hs.add("bcs");
hs.add("abc");
hs.add("abc");
hs.add("vfd");
hs.add("wdc");
System.out.println(hs); // 无序（指的是存放的顺序和取出的顺序不一致），不重复
LinkedHashSet<String> lhs=new LinkedHashSet<>();
lhs.add("太阳");
lhs.add("月亮");
lhs.add("太阳");
lhs.add("星星");
System.out.println(lhs);// 有序，不重复
}
}
Collections
Collections是集合工具类，用来对集合进行操作。
1.常用方法
-
public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素。 -
public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。 -
public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。 -
public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。
实例：
package demo3_Collections;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
/*
- public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素。
- public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。
- public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
- public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。
*/
public class Test01 {
public static void main(String[] args) {
method();
}
public static void method(){
ArrayList<Integer> list=new ArrayList<>();
//添加
Collections.addAll(list,2,43,5,16,23,90,1,13);
System.out.println(list); //[2, 43, 5, 16, 23, 90, 1, 13]
//打乱顺序输出
Collections.shuffle(list);
System.out.println(list); //[23, 16, 2, 1, 13, 43, 90, 5]
//默认排序输出
Collections.sort(list);
System.out.println(list); //[1, 2, 5, 13, 16, 23, 43, 90]
//按照指定规则排序输出---假设为倒序
Collections.sort(list, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
});
System.out.println(list);
}
}