Java---Collection单列集合详解
稻子永不倒
已于 2022-11-19 11:05:07 修改
阅读量951
收藏
6
点赞数
1
已于 2022-11-19 11:05:07 修改
阅读量951
收藏
6
点赞数
1
于 2022-11-15 10:32:16 首次发布
目录
二、单列集合的使用
1：关于Collection
（1）迭代器遍历
（2）增强for循环遍历
（3）Lambda表达式遍历
2：List的使用
（1）ArrayList的使用
（2）LinkedList的使用
2：Set的使用
（1）HashSet的使用
（2）LinkedHashSet的使用
（3）TreeSet的使用
一、单列集合的介绍
单列集合我们可以把它理解成是一个储存数据的容器，任何类型都可以。单列集合包括有两大类。一个是Set，，一个是List。它们共同继承了Collection接口，并且在他们之下还有ArraryList，LinkedList，Vector，HashSet和TreeSet子类。总的来说它们就是帮我们存储数据的容器而已。
List的特点：有序，可重复，有索引
Set的特点：无序，不重复，无索引
二、单列集合的使用
1：关于Collection
因为单列集合四是继承了Collection接口的，所以Collection的方法单列集合都是可以使用的。
Collection方法：
add（E e） 在末尾添加元素，返回值是boolean型，添加成功返回true
remove（E e） 删除指定的元素，注意是元素，而不是下标，返回值是boolean型，删除成功返回true
isEmpty（） 判断集合是否为空，返回值是boolean型
clear（） 清空集合，void类型无返回值
size（） 返回集合大小，返回值是int型
contains（E e） 判断元素是否存在于集合中，返回值是boolean型
我们知道了Set集合是无索引的，但是List集合是有索引的，遍历的话List可以通过索引，那么Set该如何遍历呢？所以我们就要学习通用的Collection遍历了。
Colletion的三种遍历方式：
（1）迭代器遍历
迭代器，什么是迭代器呢？如果学过C语言的话就可以将它理解成是指针。没学过的话不要紧，之前不是说集合就相当于是个容器吗，那么集合就是一个很大的容器，其中的元素我们当成是一个一个的小容器，放在大容器中。那么现在我们想找到其中一个小容器，这时候迭代器就有用处了，它就相当于是一个箭头，指着某一个小容器，当我们获取迭代器时，我们就可以获得迭代器指向的该小容器获得元素，想要遍历只要控制好迭代器就好了。
package article;
import java.util.Collection;
import java.util.*;
public class first {
public static void main(String[] args) {
Collection<String> s=new ArrayList<>();
s.add("123");
s.add("jkjk");
s.add("iuiui");
s.add("klk");
System.out.println(s);
System.out.println("遍历----------------");
Iterator<String> it=s.iterator();//创建迭代器对象
while(it.hasNext()) {
String h=it.next();//
System.out.println(h);
}
}
}
这里创建了Iterator的对象之后，我们遍历时用到了它的两种方法
hasNext（） 判断当前迭代器指向的位置是否有元素
next（） 获取迭代器当前指向的元素，并将迭代器往后移动一个位置
注意啊，使用迭代器遍历时是不能对集合进行增添和删除的（2）增强for循环遍历
增强for循环就是固定格式，大家记住就行了
package article;
import java.util.Collection;
import java.util.*;
public class first {
public static void main(String[] args) {
Collection<String> s=new ArrayList<>();
s.add("123");
s.add("jkjk");
s.add("iuiui");
s.add("klk");
System.out.println(s);
System.out.println("遍历----------------");
for(String h:s) {
//这里的s就是集合，而h就是一个替换的，也就是说将s集合中的每个元素都给了h
System.out.println(h);
}
}
}
（3）Lambda表达式遍历
Lambda也是固定格式，使用的是匿名内部类形式
package article;
import java.util.Collection;
import java.util.*;
public class first {
public static void main(String[] args) {
Collection<String> s=new ArrayList<>();
s.add("123");
s.add("jkjk");
s.add("iuiui");
s.add("klk");
System.out.println(s);
System.out.println("遍历----------------");
s.forEach(h->System.out.println(h));
}
}
2：List的使用
List继承了Collection，包括他的方法，当然我们也有一些List常用的方法来掌握
List中常见的方法：
void add(int index,E e) 在集合中指定的下标处添加元素
E remove(int intdex)删除指定下标处的元素，并返回
E set(int index,E e)修改指定下标出的元素，返回被修改的元素
E get(int index)返回指定下标处的元素package article;
import java.util.Collection;
import java.util.*;
public class first {
public static void main(String[] args) {
List<String> s=new ArrayList<>();
s.add("123");
s.add("opop");
s.add("sdsds");
System.out.println(s);
s.add(1,"mmmmmm");
System.out.println(s);
String ss=s.remove(3);
System.out.println("删除的元素是"+ss+" 现在集合："+s);
s.set(2,"klklkkkkk");
System.out.println(s);
for(int i=0;i<s.size();i++) {
String h=s.get(i);
System.out.println(h);
}
}
}
（1）ArrayList的使用
在之前我已经写过了关于ArrayList的文章 ：ArrayList的详解 。
使用ArrayList只要会用Collection的方法就够了
package article;
import java.util.Collection;
import java.util.*;
public class first {
public static void main(String[] args) {
Collection<String> s=new ArrayList<>();
s.add("123");
s.add("jkjk");
s.add("iuiui");
s.add("klk");
System.out.println("该集合的大小="+s.size());
System.out.println(s);
//boolean b=s.remove("123");
//System.out.println("删除:"+b);
System.out.println(s);
boolean bb=s.contains("123");
System.out.println("包含:"+bb);
}
}
（2）LinkedList的使用
LinkedList顶层是双链表实现的（其中学过数据结构的同学应该更加了解，一个节点中有元素值同时还有前后节点的地址值，这就是它增删改快的原因），查找慢，但是删增改快。因此它也出现了一些特有的方法
void addFirst(E e) 在该链表开头插入指定的元素
void addLast(E e) 将指定的元素插入到末尾
E getFirst() 获取当前链表中的第一个元素
E getLast() 获取当前链表中的最后一个元素
E removeFirst() 删除该链表中的第一个元素，并返回
E removeLast() 删除该链表中的最后一个元素，并返回package article;
import java.util.Collection;
import java.util.*;
import java.util.*;
public class first {
public static void main(String[] args) {
LinkedList<String> s=new LinkedList<>();
s.add("122");
s.add("shdj");
s.add(">>>>>>>");
s.addFirst("<<<<<<<-----");
System.out.println(s.getFirst());
}
}
2：Set的使用
Set集合的特点不要忘记了，无序（取出顺序和拿出顺序不一致），无索引（不可再用索引的方法遍历了），不重复（重复的元素，会去除）。Set的基本方法也是和Collection的方法是一致的（原因就是继承啊）
Set的实现类：
（1）HashSet：底层实现结构是哈希表，无序不重复，无索引
（2）LinkedHashSet：有序，不重复，无索引
（3）TreeSet：可排序，不重复，无索引
（1）HashSet的使用
关于HanshSet的特点在强调一遍是无序，不重复，无索引。因为它是无索引的，所以遍历可以用Collection的三种方法来遍历。
package article;
import java.util.Collection;
import java.util.function.Consumer;
import java.util.*;
import java.util.*;
public class first {
public static void main(String[] args) {
Set<String> s=new HashSet<>();
s.add("8989");
s.add("klkl");
s.add(">>>>");
Iterator<String> it=s.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
System.out.println("-------------");
//增强for
for(String h:s) {
System.out.println(h);
}
System.out.println("---------------");
//Lambda表达式
s.forEach(new Consumer<String>() {
public void accept(String st) {
System.out.println(st);
}
});
}
}
如果添加的类型是自写的，在自写类中需要重写equals和HashCode方法，因为equals比较的是地址值。
package article;
import java.util.Objects;
public class student {
String name;
int age;
public student(String name,int age) {
this.age=age;
this.name=name;
}
public void setname(String name) {
this.name=name;
}
public void setage(int age) {
this.age=age;
}
public String getname() {
return name;
}
public int getage() {
return age;
}
@Override
public int hashCode() {
return Objects.hash(age, name);
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
student other = (student) obj;
return age == other.age && Objects.equals(name, other.name);
}
}
package article;
import java.util.Collection;
import java.util.function.Consumer;
import java.util.*;
import java.util.*;
public class first {
public static void main(String[] args) {
Set<student> s=new HashSet<>();
student s1=new student("uiu",190);
student s2=new student("opop",200);
student s3=new student("klkl",1000);
student s4=new student("opop",200);
System.out.println("添加情况:");
System.out.println(s.add(s1));
System.out.println(s.add(s2));
System.out.println(s.add(s3));
System.out.println(s.add(s4));
//迭代器遍历
Iterator<student> it=s.iterator();
while(it.hasNext()) {
student ss=it.next();
System.out.println(ss.getname()+" "+ss.getage());
}
}
}
（2）LinkedHashSet的使用
LinkedHashSet的特点：有序，无重复，无索引。有序的话它的遍历输出就和放进去的元素是一样的，数据结构中的队列差不多吧。使用方法和前面说到的HahsSet是一样的。
package article;
import java.util.Collection;
import java.util.function.Consumer;
import java.util.*;
import java.util.*;
public class first {
public static void main(String[] args) {
Set<String> s=new LinkedHashSet<>();
s.add("klkl");
s.add("99999");
s.add(">>>");
s.add("+++++");
s.forEach(new Consumer<String>(){
public void accept(String ss) {
System.out.println(ss);
}
});
}
}
（）
（3）TreeSet的使用
TreeSet的特点：可排序，无重复，无索引。TreeSet的使用方法和其他集合还是一样的，不过最大的不同就是它可排序，它的底层是基于红黑树实现的，所以对于它，我们着重学习如何排序。它的排序方法有两种。一种是用Comparaable接口实现，一种是使用比较器进行排序。当然它是有着默认排序的，对于数字按照升序，对于字母按照ASCII升序。
1：Comparable接口排序：
这里的o代表的就是当前准备插入的元素，不明白排序规则，记住this在前就是升序就可以了
package article;
import java.util.Objects;
public class student implements Comparable<student>{
String name;
int age;
public student(String name,int age) {
this.age=age;
this.name=name;
}
public void setname(String name) {
this.name=name;
}
public void setage(int age) {
this.age=age;
}
public String getname() {
return name;
}
public int getage() {
return age;
}
@Override
public int compareTo(student o) {
// TODO 自动生成的方法存根
int t=this.name.compareTo(o.name);//先按年龄升序，相同按照年龄升序
if(t==0) {
return this.age-o.age;
}
return t;
}
}
package article;
import java.util.Collection;
import java.util.function.Consumer;
import java.util.*;
import java.util.*;
public class first {
public static void main(String[] args) {
Set<student> s=new TreeSet<>();
student s1=new student("abc",20);
student s2=new student("abk",30);
student s3=new student("dec",10);
student s4=new student("dbc",29);
student s5=new student("abc",30);
student s6=new student("abc",40);
s.add(s1);
s.add(s2);
s.add(s3);
s.add(s4);
s.add(s5);
s.add(s6);
s.forEach(new Consumer<student>() {
@Override
public void accept(student t) {
// TODO 自动生成的方法存根
System.out.println(t.getname()+" "+t.getage());
}
});
}
}
2：比较器排序
这里的排序规则可以理解成o1在前就是升序，o2在前就是降序
package article;
import java.util.Collection;
import java.util.function.Consumer;
import java.util.*;
import java.util.*;
public class first {
public static void main(String[] args) {
Set<student> s=new TreeSet<>(new Comparator<student>() {
@Override
public int compare(student o1, student o2) {
// TODO 自动生成的方法存根
//先按照名字升序,相同则按照年龄降序
int t=o1.name.compareTo(o2.name);
if(t==0) {
return o2.age-o1.age;
}
return t;
}
});
student s1=new student("abc",20);
student s2=new student("abk",30);
student s3=new student("dec",10);
student s4=new student("dbc",29);
student s5=new student("abc",30);
student s6=new student("abc",40);
s.add(s1);
s.add(s2);
s.add(s3);
s.add(s4);
s.add(s5);
s.add(s6);
s.forEach(new Consumer<student>() {
@Override
public void accept(student t) {
// TODO 自动生成的方法存根
System.out.println(t.getname()+" "+t.getage());
}
});
}
}
扫一扫
379
阜阳师范学院
到【灌水乐园】发言
冷静的平头哥: 笔记写的真好，章节目录小节，画图都很清晰。。加油
CSDN-Ada助手: MySQL入门 技能树或许可以帮到你：https://edu.csdn.net/skill/mysql?utm_source=AI_act_mysql
Cort Hsu: 好用好用
@斯坦索姆: 这段 <properties> XML 配置内容是针对某个支持扩展字典和停止词词典的文本处理或搜索工具（很可能是 IK Analyzer，一个中文分词器）的。这四个配置项分别有不同的作用和用途： ext_dict (扩展字典): 这是一个指向本地文件的路径，该文件包含用户自定义的词汇，这些词汇在分词过程中会被特别处理或加入分词结果中。 例如，某些专业术语、品牌名、人名等可能不在标准词典中，但用户希望它们能被正确地识别为一个完整的词汇，而不是被拆分成多个单词。这时，用户就可以将这些词汇添加到扩展字典中。 ext_stopwords (扩展停止词字典): 这是一个指向本地文件的路径，该文件包含用户定义的“停止词”或“停用词”。这些词在分词过程中通常会被忽略或不被包含在分词结果中。 停止词通常指那些非常常见但对文本意义贡献不大的词汇，如“的”、“是”、“在”等中文助词。在某些应用场景下，用户可能希望忽略这些词汇，以提高搜索效率或聚焦在更重要的词汇上。 remote_ext_dict (远程扩展字典): 这项配置被注释掉了，意味着它当前并未启用。如果启用，它将指向一个远程位置（如 URL 或网络路径），该位置包含用户自定义的词汇列表。 远程扩展字典允许用户在不修改本地配置文件的情况下，动态地添加或更新词汇。这在一些需要快速响应变化的应用场景中可能很有用。 remote_ext_stopwords (远程扩展停止词字典): 同样，这项配置也被注释掉了。如果启用，它将指向一个远程位置，该位置包含用户定义的停止词列表。 远程停止词字典允许用户在不修改本地配置文件的情况下，动态地添加或更新停止词。这对于需要快速适应新环境或新数据的应用场景可能很有用。 区别总结: ext_dict 和 ext_stopwords 是指向本地文件的配置项，分别用于添加自定义词汇和定义停止词。 remote_ext_dict 和 remote_ext_stopwords 是指向远程位置的配置项（通常被注释掉），分别用于动态地添加或更新自定义词汇和停止词。 本地配置通常更稳定，但更新可能需要修改配置文件并重启服务。远程配置则更灵活，可以动态地添加或更新词汇，但可能受到网络延迟或不稳定性的影响。
热心码民阿振: 发现一篇类似好帖子：https://blog.csdn.net/Da_zhenzai/article/details/133808545