本文详细介绍了Java中的List、Set集合及其常用数据结构，如栈、队列、数组和链表。重点讲解了List接口及其子类ArrayList和LinkedList的特点和使用场景，Set接口及HashSet的实现原理，包括哈希表和红黑树。同时，还提及了Collections工具类提供的常用功能，如添加元素、打乱顺序和排序。
List、Set、数据结构、Collections
数据结构
常见的数据结构
栈
队列
数组
链表
红黑树
List集合
List接口介绍
java.util.List接口继承自Collection接口，是单列集合的一个重要分支，习惯性地会将实现了List 接口的对象称为List集合。在List集合中允许出现重复的元素，所有的元素是以一种线性方式进行存储的，在程序中可以通过索引来访问集合中的指定元素。另外，List集合还有一个特点就是元素有序，即元素的存入顺序和取出顺序一致。
看完API，我们总结一下
List接口特点
-
它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的
存储就是按照11、22、33的顺序完成的)。
-
它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素(与数组的索引是一个
道理)。
-
集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。
tips：List接口的子类java.util.ArrayList类，该类中的方法都是来自List中定义的
List接口中常用方法
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/*
java.util.List接口 extends Collection接口
List接口的特点：
1.有序的集合，存储元素和取出元素的顺序是一致的（存储123 取出123）
2.有索引，包含了一些带索引的方法
3.允许存储重复的元素
List接口中带索引的方法(特有)
- public void add(int index,Eelement):将指定的元素，添加到该集合中的指定位置上
- public E get(int index):返回集合中指定位置的元素。
- public E remove(int index):移除列表中指定位置的元素，返回的是被移除的元素。
- public E set(int index, Eelement):用指定元素替换集合中指定位置的元素，返回值的更新前的元素。
注意:
操作索引的时候，一定要防止索引越界异常
IndexOut0fBoundsException:索引越界异常，集合会报
ArrayIndexOutOfBoundsException:数组索引越界异常
StringIndexOutofBoundsException:字符串索引越界异常
*/
public class Demo01List{
public static void main(String[] args){
//创建一个List集合对象，多态
List<String> list = new ArrayList<String>();
//使用add方法往集合中添加元素
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("a");
//打印集合
System.out.println(list);//[a,b,c,d,a] 不是地址重写了toString方法
//public void add(int index,Eelement):将指定的元素，添加到该集合中的指定位置上
//在c和d之间添加一个itzhu
list.add(3,"itzhu");
System.out.println(list);//[a,b,c,itzhu,d,a]
//public E remove(int index):移除列表中指定位置的元素，返回的是被移除的元素
//移除c元素
String reomoveE = list.remove(2);
System.out.println("被移除的元素：" + reomoveE);//被移除的元素：c
System.out.println(list);//[a,b,itzhu,d,a]
// public E set(int index, Eelement):用指定元素替换集合中指定位置的元素，返回值的更新前的元素
//把最后一个a，替换成A
String setE = list.set(4,"A");
System.out.println("被替换的元素：" + setE);//被替换的元素：a
System.out.println(list);//[a,b,itzhu,d,A]
//List集合遍历有3中方式
//使用普通的for循环
for(int i = 0; i < list.size(); i++){
//public E get(int index):返回集合中指定位置的元素
System.out.println(list.get(i));
}
System.out.println("=====================");
//使用迭代器
Iterator<String> it = list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
System.out.println("=====================");
//使用增强for
for(String s:list){
System.out.println(s);
}
}
}
List的子类
ArrayList集合
java.util.Arraylist集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。
许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。
LinkedList集合
java.util.LinkedList集合数据存储的结构是链表结构。方便元素添加、 删除的集合
LinkedList是一个双向链表，那么双向链表是什么样子的呢，我们用个图了解下
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JzuLLB1a-1621579581934)(D:\朱相龙\java学习\笔记\图片\LinkedList双向链表.png)]
import java.util.LinkedList;
/*
java.util.LinkedList集合 implements List接口
LinkedList集合的特点：
1.底层是一个链表结构：查询慢，增删快
2.里边包含了大量操作首尾元素的方法
注意：
使用LinkedList集合特有的方法，不能使用多态
- public void addFirst(E e):将指定元素插入此列表的开头
- public void addLast(E e):将指定元素添加到此列表的结尾
- public void push(E e):将元素推入此列表所表示的堆栈
- public E getFirst():返回此列表的第一个元素
- public E getLast():返回此列表的最后一个元素
- public E removeFirst():移除并返回此列表的第一个元素
- public E removeLast():移除并返回此列表的最后一个元素
- public E pop():从此列表所表示的堆栈处弹出一个元素
- public boolean isEmpty():如果列表不包含元素，则返回true
*/
public class Demo02LinkedList {
public static void main(String[] args) {
show03();
}
/*
- public void addFirst(Ee):将指定元素插入此列表的开头
- public void addLast(Ee):将指定元素添加到此列表的结尾
- public void push(Ee):将元素推入此列表所表示的堆栈
*/
private static void show01(){
//创建LinkedList集合对象
LinkedList<String> linked = new LinkedList<String>();
//使用add方法往集合中添加元素
linked.add("a");
linked.add("b");
linked.add("c");
System.out.println(linked);//[a, b, c]
//public void addFirst(E e):将指定元素插入此列表的开头
//linked.addFirst("wwww");
linked.push("wwww");
System.out.println(linked);//[wwww, a, b, c]
//public void addLast(E e):将指定元素添加到此列表的结尾.此方法等效于add()
linked.addLast("com");
System.out.println(linked);//[wwww, a, b, c, com]
}
/*
- public E getFirst():返回此列表的第一个元素
- public E getLast():返回此列表的最后一个元素
*/
private static void show02(){
//创建LinkedList集合对象
LinkedList<String> linked = new LinkedList<String>();
//使用add方法往集合中添加元素
linked.add("a");
linked.add("b");
linked.add("c");
System.out.println(linked);//[a, b, c]
//linked.clear(); //清空集合中的元素 在获取集合中的元素会抛出NoSuchElementException
//public boolean isEmpty():如果列表不包含元素，则返回true
if(!linked.isEmpty()){
String first = linked.getFirst();
System.out.println(first);//a
String last = linked.getLast();
System.out.println(last);//c
}
}
/*
- public E removeFirst():移除并返回此列表的第一个元素
- public E removeLast():移除并返回此列表的最后一个元素
- public E pop():从此列表所表示的堆栈处弹出一个元素
*/
private static void show03() {
//创建LinkedList集合对象
LinkedList<String> linked = new LinkedList<String>();
//使用add方法往集合中添加元素
linked.add("a");
linked.add("b");
linked.add("c");
System.out.println(linked);//[a, b, c]
//String first = linked.removeFirst();
String first = linked.pop();
System.out.println("被移除的第一个元素：" + first);
String last = linked.removeLast();
System.out.println("被移除的最后一个元素：" + last);
System.out.println(linked);//[b]
}
}
Set接口
java.util.Set接口和java.util.List接口一样，同样继承自Collection接口，它与Collection接口中的方法基本一致，并没有对Collection接口进行功能上的扩充，只是比Collection接口更加严格了。与List接口不同的是，Set接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。
Set集合有多个子类，这里我们介绍其中的java.util.Hashset、java.util.LinkedHashSet这两个集合。
tips:Set集合取出元素的方式可以采用:迭代器、增强for。
HashSet集合介绍
java.util.HashSet是Set接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不一致)。java.util.HashSet底层的实现其实是一个java.util.HashMap支持，由于我们暂时还未学习，先做了解。
HashSet是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。保证元素唯一性的方式依赖于:hashCode与equals方法。
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
/*
java.util.Set接口 extends Collection接口
Set接口的特点：
1.不允许存储重复的元素
2.没有索引，没有带索引的方法，也不能使用普通的for循环遍历
java.util.HashSet集合 implements Set接口
HashSet特点：
1.不允许存储重复的元素
2.没有索引，没有带索引的方法，也不能使用普通的for循环遍历
3.是一个无序的集合，存储元素和取出元素的顺序有可能不一致
4.底层是一个哈希表结构（查询的速度非常的快）
*/
public class Demo01Set {
public static void main(String[] args) {
Set<Integer> set = new HashMap<>();
//使用add方法往集合中添加元素
set.add(1);
set.add(3);
set.add(2);
set.add(1);
//使用迭代器遍历set集合
Iterator<Integer> it = set.iterator();
while(it.hasNext()){
Integer n = it.next();
System.out.println(n);//1,2,3
}
//使用增强for遍历set集合
System.out.println("===============");
for(Integer i : set){
System.out.println(i);
}
}
}
HashSet集合存储数据的结构（哈希表）
什么是哈希表呢?
在JDK1.8之前，哈希表底层采用数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，哈希表存储采用数组+链表+红黑树实现，当链表长度超过阈值( 8 )时，将链表转换为红黑树，这样大大减少了查找时间。
简单的来说，哈希表是由数组+链表+红黑树(JDK1.8增加了红黑树部分)实现的
提到哈希表必须先提到哈希值：
/*
哈希值:是一个十进制的整数，由系统随机给出(就是对象的地址值，是一个逻辑地址，是模拟出来得到地址，不是数据实际存储的物理地址)
在Object类有一个方法，可以获取对象的哈希值
int hashCode()返回该对象的哈希码值。
hashCode方法的源码:
public native int hashcode();
native:代表该方法调用的是本地操作系统的方法
*/
public class Demo01HashCode {
public static void main(stringll args){
//Person类继承了Object类，所以可以使用Object类的hashCode方法
Person p1 = new Person0;
int h1 = p1.hashCode();
system.out.println(h1);
Person p2 = new Person();
int h2 = p2.hashcode);
System.out.println(h2);
/*
toString方法的源码：
return getClass.getNmae() + "@" + Integer.toHexString(hashCode());
*/
System.out.println(p1);
System.out.println(p2);
/*
String类的哈希值
String类重写Object类的hashCode方法
*/
String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1.hashCode());//96354
System.out.println(s2.hashCode());//96354
System.out.println("重地".hashCode());//1179395
System.out.println("通话".hashCode());//1179395
}
}
Set集合存储元素不重复的原理
import java.util.HashSet
/*
Set集合不允许存储重复元素的原理
*/
public class Demo02HashSetSaveString{
public static void main(String[] args){
//创建HashSet集合对象
HashSet<String> set = new HashSet<>();
String s1 = new String( "abc");
String s2 = new string("abc");
set.add(s1);
set.add(s2);
set.add("重地");
set.add("通话");
set.add("abc");
System.out.println(set);//[重地，通话，abc]
}
}
HashSet存储自定义类型元素
给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，简历自己的比较方式，才能保证HashSet集合中的对象唯一
import java.util.HashSet;
/*
HashSet存储自定义类型元素
set集合报错元素唯一:
存储的元素(String,Integer,...Student,Person...)，必须重写hashCode方法和equals方法
要求:
同名同年龄的人，视为同一个人，只能存储一次
*/
public class Demo03HashSetSavePerson {
public static void main(String[] args) {
//创建HashSet集合存储Person
HashSet<Person> set = new HashSet<>();
Person p1 = new Person("小美女",18);
Person p2 = new Person("小美女",18);
Person p3 = new Person("小美女",18);
System.out.println(p1.hashCode());
System.out.println(p2.hashCode());
System.out.println(p1==p2);
System.out.println(p1.equals(p2));
set.add(p1);
set.add(p2);
set.add(p3);
System.out.println(set);
}
}`
LinkedHashSet
我们知道HashSet保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序，怎么办呢?在HashSet下面有一个子类java.util.LinkedHashSet 它是链表和哈希表组合的一个数据存储结构。
import java.util.HashSet;
import java.util.LinkedHashSet;
/*
java.util.LinkedHashSet集合 extends HashSet集合
LinkedHashSet集合特点：
底层是一个哈希表（数组＋链表/红黑树）+链表：多了一条链表（记录元素的存储顺序），保证元素有序
*/
public class Demo04LinkedHashSet {
public static void main(String[] args) {
HashSet<String> set = new HashSet<>();
set.add("www");
set.add("abc");
set.add("abc");
set.add("itcast");
System.out.println(set);//[abc, www, itcast] 无序，不允许重复
LinkedHashSet<String> linked = new LinkedHashSet<>();
linked.add("www");
linked.add("abc");
linked.add("abc");
linked.add("itcast");
System.out.println(linked);//[www, abc, itcast] 有序，不允许重复
}
}
可变参数
/*
可变参数：是JDK1.5之后出现的新特性
使用前提：
当方法的参数列表数据类型已经确定，但是参数的个数不确定，就可以使用可变参数
使用格式：定义方法时使用
修饰符 返回值类型 方法名{数据类型...变量名}{}
可变参数的原理：
可变参数底层就是一个数组，根据传递参数个数不同，会创建不同长度的数组，来存储这些参数
传递的参数个数，可以是0个（不传递），1，2...多个
*/
public class Demo01VarArgs {
public static void main(String[] args) {
//int i = add();
//int i = add(10);
int i = add(10,20);
System.out.println(i);
method("abc",5.5,10,1,2,3,4);
}
/*
可变参数的注意事项
1.一个方法的参数裂变，只能有一个可变参数
public static void method(int...a,String...b){}//错误写法
2.如果方法的参数有多个，那么可变参数必须写在参数列表的末尾
public static void method(String b,double b,int...a){}//正确写法
*/
//可变参数的特殊（终极）写法
public static void method(Object...obj){
}
/*
定义计算（0-n）个整数和的方法
已知：计算整数的和，数据类型已经确定int
但是参数的个数不确定，不知道要计算几个整数的和，就可以使用可变参数
add(10);就会创建一个长度为1的数组，new int[]{10}
add(10,20);就会创建一个长度为2的数组，new int[]{10,20}
*/
public static int add(int...arr){
//System.out.println(arr);//[I@3f99bd52 底层是数组
//System.out.println(arr.length);//0
//定义一个初始化的变量，记录累加求和
int sum = 0;
//遍历数组，获取数去中的每一个元素
for(int i : arr){
//累加求和
sum += i;
}
//把求和结果返回
return sum;
}
/*
//定义一个方法，计算两个int类型整数的和
public static int add(int a,int b){
return a+b;
}
//定义一个方法，计算三个int类型整数的和
public static int add(int a,int b,int c){
return a+b+c;
}
*/
}
Collections
常用功能
java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下
-
public static <T> boolean addAll(Collection<T>c,T... elements):往集合中添加一些元素 -
public static void shuffle(List<?> list)打乱顺序:打乱集合顺序。/* java.util.Collections是集合工具类，用来对集合进行操作。部分方法如下： - public static <T> boolean addAll(Collection<T>c,T... elements):往集合中添加一些元素 - public static void shuffle(List<?> list)打乱顺序:打乱集合顺序。 */ public class Demo01Collections { public static void main(String[] args) { ArrayList<String> list = new ArrayList<>(); //往集合中添加多个元素 // list.add("a"); // list.add("b"); // list.add("c"); // list.add("d"); // list.add("e"); //public static <T> boolean addAll(Collection<T>c,T... elements):往集合中添加一些元素 Collections.addAll(list,"a","b","c","d","e"); System.out.println(list);//[a, b, c, d, e] //public static void shuffle(List<?> list)打乱顺序:打乱集合顺序 Collections.shuffle(list); System.out.println(list);//[e, b, c, a, d] } } -
public static <T> void sort(List<T> list):将集合中元素按照默认规则排序Demo02Collections.java
package com.company.pratise; import java.util.ArrayList; import java.util.Collections; /* java.util.Collections是集合工具类，用来对集合进行操作。部分方法如下： - public static <T> void sort(List<T> list):将集合中元素按照默认规则排序 注意： sort(List<T> list)使用前提 被排序的集合里边存储的元素，必须实现Comparable，重写接口中的方法compareTo定义排序规则 Comparable接口的排序规则： 自己(this)-参数：升序 参数-自己(this)：降序 */ public class Demo02Collections { public static void main(String[] args) { ArrayList<Integer> list01 = new ArrayList<>(); list01.add(1); list01.add(3); list01.add(2); System.out.println(list01);//[1, 3, 2] //public static <T> void sort(List<T> list):将集合中元素按照默认规则排序 Collections.sort(list01);//默认是升序 System.out.println(list01);//[1, 2, 3] ArrayList<String> list02 = new ArrayList<>(); list02.add("a"); list02.add("c"); list02.add("b"); System.out.println(list02);//[a, c, b] Collections.sort(list02);//默认是升序 System.out.println(list02);//[a, b, c] ArrayList<Person> list03 = new ArrayList<>(); list03.add(new Person("张三",18)); list03.add(new Person("李四",20)); list03.add(new Person("王五",15)); System.out.println(list03);//[Person{name='张三', age=18}, Person{name='李四', age=20}, Person{name='王五', age=15}] Collections.sort(list03); System.out.println(list03);//[Person{name='李四', age=20}, Person{name='张三', age=18}, Person{name='王五', age=15}] } }Person.java
import java.util.Objects; public class Person implements Comparable<Person>{ private String name; private int age; public Person() { } public Person(String name, int age) { this.name = name; this.age = age; } //重写排序规则 @Override public int compareTo(Person o) { //return 0;//认为元素都是相同的 //自定义比较的规则，比较两个人的年龄(this,参数Person) //return this.getAge() - o.getAge();//年龄升序排序 return o.getAge() - this.getAge();//年龄降序排序 } @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", 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; } } -
public static <T> void sort(List<T> list,Comparator<? super T>):将集合中元素按照指定规则排序。Demo03Collections.java
import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; /* java.util.Collections是集合工具类，用来对集合进行操作。部分方法如下： - public static <T> void sort(List<T> list,Comparator<? super T>):将集合中元素按照指定规则排序 Comparator和Comparable的区别 Comparable：自己(this)和别人(参数)比较，自己需要实现Comparable接口，重写比较规则compareTo方法 Comparator：相当于找一个第三方的裁判，比较两个 Comparator的排序规则 o1 - o2:升序 o2 - o1:降序 */ public class Demo03Collections { public static void main(String[] args) { ArrayList<Integer> list01 = new ArrayList<>(); list01.add(1); list01.add(3); list01.add(2); System.out.println(list01);//[1, 3, 2] Collections.sort(list01, new Comparator<Integer>() { //重写比较的规则 @Override public int compare(Integer o1, Integer o2) { //return o1 - o2;//升序 return o2 - o1;//降序 } }); System.out.println(list01); ArrayList<Student> list02 = new ArrayList<>(); list02.add(new Student("a迪丽热巴 ",18)); list02.add(new Student("古力娜扎 ",20)); list02.add(new Student("玛尔扎哈 ",17)); list02.add(new Student("b玛尔扎哈 ",18)); /*Collections.sort(list02, new Comparator<Student>() { @Override public int compare(Student o1, Student o2) { //按照年龄升序排序 return o1.getAge() - o2.getAge(); } });*/ //扩展了解 Collections.sort(list02, new Comparator<Student>() { @Override public int compare(Student o1, Student o2) { //按照年龄升序排序 int result = o1.getAge() - o2.getAge(); //如果两个人年龄 相同，再使用姓名的第一个字比较 if(result == 0){ result = o1.getName().charAt(0) - o2.getName().charAt(0); } return result; } }); System.out.println(list02); } }Student.java
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; } }
扫一扫
985
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
