• Java---单列集合详解

    目录

    一、单列集合的介绍

    二、单列集合的使用

    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方法：

    1. add（E e）       在末尾添加元素，返回值是boolean型，添加成功返回true
    2.  
    3. remove（E e）    删除指定的元素，注意是元素，而不是下标，返回值是boolean型，删除成功返回true
    4.  
    5. isEmpty（）      判断集合是否为空，返回值是boolean型
    6.  
    7. clear（）        清空集合，void类型无返回值
    8.  
    9. size（）         返回集合大小，返回值是int型
    10.  
    11. contains（E e）  判断元素是否存在于集合中，返回值是boolean型
    12.  
    13.

    我们知道了Set集合是无索引的，但是List集合是有索引的，遍历的话List可以通过索引，那么Set该如何遍历呢？所以我们就要学习通用的Collection遍历了。

    Colletion的三种遍历方式：

    （1）迭代器遍历

    迭代器，什么是迭代器呢？如果学过C语言的话就可以将它理解成是指针。没学过的话不要紧，之前不是说集合就相当于是个容器吗，那么集合就是一个很大的容器，其中的元素我们当成是一个一个的小容器，放在大容器中。那么现在我们想找到其中一个小容器，这时候迭代器就有用处了，它就相当于是一个箭头，指着某一个小容器，当我们获取迭代器时，我们就可以获得迭代器指向的该小容器获得元素，想要遍历只要控制好迭代器就好了。

    1. package article;
    2.  
    3. import java.util.Collection;
    4. import java.util.*;
    5.  
    6. public class first {
    7.    public static void main(String[] args) {
    8. 	   Collection s=new ArrayList<>();
    9. 	   s.add("123");
    10. 	   s.add("jkjk");
    11. 	   s.add("iuiui");
    12. 	   s.add("klk");
    13. 	   
    14. 	   System.out.println(s);
    15. 	   System.out.println("遍历----------------");
    16. 	   Iterator it=s.iterator();//创建迭代器对象
    17. 	   while(it.hasNext()) {
    18. 		   String h=it.next();//
    19. 		   System.out.println(h);
    20. 	   }
    21.    }
    22. }

     

    1. 这里创建了Iterator的对象之后，我们遍历时用到了它的两种方法
    2.  
    3. hasNext（）  判断当前迭代器指向的位置是否有元素
    4.  
    5. next（）     获取迭代器当前指向的元素，并将迭代器往后移动一个位置
    6.  
    7. 注意啊，使用迭代器遍历时是不能对集合进行增添和删除的

    （2）增强for循环遍历

    增强for循环就是固定格式，大家记住就行了

    1. package article;
    2.  
    3. import java.util.Collection;
    4. import java.util.*;
    5.  
    6. public class first {
    7.    public static void main(String[] args) {
    8. 	   Collection s=new ArrayList<>();
    9. 	   s.add("123");
    10. 	   s.add("jkjk");
    11. 	   s.add("iuiui");
    12. 	   s.add("klk");
    13. 	   
    14. 	   System.out.println(s);
    15. 	   System.out.println("遍历----------------");
    16. 	   for(String h:s) {
    17. //这里的s就是集合，而h就是一个替换的，也就是说将s集合中的每个元素都给了h
    18. 		   System.out.println(h);
    19. 	   }
    20.    }
    21. }

    （3）Lambda表达式遍历 

    Lambda也是固定格式，使用的是匿名内部类形式

    1. package article;
    2.  
    3. import java.util.Collection;
    4. import java.util.*;
    5.  
    6. public class first {
    7.    public static void main(String[] args) {
    8. 	   Collection s=new ArrayList<>();
    9. 	   s.add("123");
    10. 	   s.add("jkjk");
    11. 	   s.add("iuiui");
    12. 	   s.add("klk");
    13. 	   
    14. 	   System.out.println(s);
    15. 	   System.out.println("遍历----------------");
    16. 	   s.forEach(h->System.out.println(h));
    17.    }
    18. }

    2：List的使用

    List继承了Collection，包括他的方法，当然我们也有一些List常用的方法来掌握

    1. List中常见的方法：
    2. void add(int index,E e) 在集合中指定的下标处添加元素
    3. E remove(int intdex)删除指定下标处的元素，并返回
    4. E set(int index,E e)修改指定下标出的元素，返回被修改的元素
    5. E get(int index)返回指定下标处的元素
    1. package article;
    2.  
    3. import java.util.Collection;
    4. import java.util.*;
    5.  
    6. public class first {
    7.    public static void main(String[] args) {
    8. 	 List s=new ArrayList<>();
    9. 	 s.add("123");
    10. 	 s.add("opop");
    11. 	 s.add("sdsds");
    12. 	 
    13. 	 System.out.println(s);
    14. 	 
    15. 	 s.add(1,"mmmmmm");
    16. 	 
    17. 	 System.out.println(s);
    18. 	 
    19. 	 String ss=s.remove(3);
    20. 	 System.out.println("删除的元素是"+ss+" 现在集合："+s);
    21. 	 
    22. 	 s.set(2,"klklkkkkk");
    23. 	 System.out.println(s);
    24. 	 
    25. 	 for(int i=0;i
    26. 		 String h=s.get(i);
    27. 		 System.out.println(h);
    28. 	 }
    29.    }
    30. }
    31.

    （1）ArrayList的使用

    在之前我已经写过了关于ArrayList的文章：ArrayList的详解 。

    使用ArrayList只要会用Collection的方法就够了

    1. package article;
    2.  
    3. import java.util.Collection;
    4. import java.util.*;
    5.  
    6. public class first {
    7.    public static void main(String[] args) {
    8. 	   Collection s=new ArrayList<>();
    9. 	   s.add("123");
    10. 	   s.add("jkjk");
    11. 	   s.add("iuiui");
    12. 	   s.add("klk");
    13. 	   
    14. 	   System.out.println("该集合的大小="+s.size());
    15. 	   System.out.println(s);
    16. 	   //boolean b=s.remove("123");
    17. 	   //System.out.println("删除:"+b);
    18. 	   
    19. 	   System.out.println(s);
    20. 	   boolean bb=s.contains("123");
    21. 	   System.out.println("包含:"+bb);
    22.    }
    23. }

    （2）LinkedList的使用

    LinkedList顶层是双链表实现的（其中学过数据结构的同学应该更加了解，一个节点中有元素值同时还有前后节点的地址值，这就是它增删改快的原因），查找慢，但是删增改快。因此它也出现了一些特有的方法

    1. void addFirst(E e) 在该链表开头插入指定的元素
    2. void addLast(E e)  将指定的元素插入到末尾
    3. E getFirst()       获取当前链表中的第一个元素
    4. E getLast()        获取当前链表中的最后一个元素
    5. E removeFirst()    删除该链表中的第一个元素，并返回
    6. E removeLast()     删除该链表中的最后一个元素，并返回
    1. package article;
    2.  
    3. import java.util.Collection;
    4. import java.util.*;
    5. import java.util.*;
    6. public class first {
    7.    public static void main(String[] args) {
    8. 	 LinkedList s=new LinkedList<>();
    9. 	 s.add("122");
    10. 	 s.add("shdj");
    11. 	 s.add(">>>>>>>");
    12. 	 s.addFirst("<<<<<<<-----");
    13. 	 System.out.println(s.getFirst());
    14. 	 
    15.    }
    16. }
    17.

     

     

    2：Set的使用

    Set集合的特点不要忘记了，无序（取出顺序和拿出顺序不一致），无索引（不可再用索引的方法遍历了），不重复（重复的元素，会去除）。Set的基本方法也是和Collection的方法是一致的（原因就是继承啊）

    Set的实现类：

    （1）HashSet：底层实现结构是哈希表，无序不重复，无索引

    （2）LinkedHashSet：有序，不重复，无索引

    （3）TreeSet：可排序，不重复，无索引

    （1）HashSet的使用

    关于HanshSet的特点在强调一遍是无序，不重复，无索引。因为它是无索引的，所以遍历可以用Collection的三种方法来遍历。

    1. package article;
    2.  
    3. import java.util.Collection;
    4. import java.util.function.Consumer;
    5. import java.util.*;
    6. import java.util.*;
    7. public class first {
    8.    public static void main(String[] args) {
    9. 	 Set s=new HashSet<>();
    10. 	 s.add("8989");
    11. 	 s.add("klkl");
    12. 	 s.add(">>>>");
    13. 	 
    14. 	 Iterator it=s.iterator();
    15. 	 while(it.hasNext()) {
    16. 		 System.out.println(it.next());
    17. 	 }
    18. 	 System.out.println("-------------");
    19. 	 //增强for
    20. 	 for(String h:s) {
    21. 		 System.out.println(h);
    22. 	 }
    23. 	 
    24. 	 System.out.println("---------------");
    25. 	 //Lambda表达式
    26. 	 
    27. 	 s.forEach(new Consumer() {
    28. 		 public void accept(String st) {
    29. 			 System.out.println(st);
    30. 		 }
    31. 	 });
    32.    }
    33. }
    34.

    如果添加的类型是自写的，在自写类中需要重写equals和HashCode方法，因为equals比较的是地址值。 

    1. package article;
    2.  
    3. import java.util.Objects;
    4.  
    5. public class student {
    6.    String name;
    7.    int age;
    8.    public student(String name,int age) {
    9. 	   this.age=age;
    10. 	   this.name=name;
    11.    }
    12.    public void setname(String name) {
    13. 	   this.name=name;
    14.    }
    15.    public void setage(int age) {
    16. 	   this.age=age;
    17.    }
    18.    public String getname() {
    19. 	   return name;
    20.    }
    21.    public int getage() {
    22. 	   return age;
    23.    }
    24. @Override
    25. public int hashCode() {
    26. 	return Objects.hash(age, name);
    27. }
    28. @Override
    29. public boolean equals(Object obj) {
    30. 	if (this == obj)
    31. 		return true;
    32. 	if (obj == null)
    33. 		return false;
    34. 	if (getClass() != obj.getClass())
    35. 		return false;
    36. 	student other = (student) obj;
    37. 	return age == other.age && Objects.equals(name, other.name);
    38. }
    39.    
    40. }
    1. package article;
    2.  
    3. import java.util.Collection;
    4. import java.util.function.Consumer;
    5. import java.util.*;
    6. import java.util.*;
    7. public class first {
    8.    public static void main(String[] args) {
    9. 	 Set s=new HashSet<>();
    10. 	 student s1=new student("uiu",190);
    11. 	 student s2=new student("opop",200);
    12. 	 student s3=new student("klkl",1000);
    13. 	 student s4=new student("opop",200);
    14. 	 
    15. 	 System.out.println("添加情况:");
    16. 	 System.out.println(s.add(s1));
    17. 	 System.out.println(s.add(s2));
    18. 	 System.out.println(s.add(s3));
    19. 	 System.out.println(s.add(s4));
    20. 	 
    21. 	 //迭代器遍历
    22. 	 Iterator it=s.iterator();
    23. 	 while(it.hasNext()) {
    24. 		 student ss=it.next();
    25. 		 System.out.println(ss.getname()+" "+ss.getage());
    26. 	 }
    27.    }
    28. }
    29.

     （2）LinkedHashSet的使用

    LinkedHashSet的特点：有序，无重复，无索引。有序的话它的遍历输出就和放进去的元素是一样的，数据结构中的队列差不多吧。使用方法和前面说到的HahsSet是一样的。

    1. package article;
    2.  
    3. import java.util.Collection;
    4. import java.util.function.Consumer;
    5. import java.util.*;
    6. import java.util.*;
    7. public class first {
    8.    public static void main(String[] args) {
    9. 	 Set s=new LinkedHashSet<>();
    10. 	 s.add("klkl");
    11. 	 s.add("99999");
    12. 	 s.add(">>>");
    13. 	 s.add("+++++");
    14. 	 
    15. 	 s.forEach(new Consumer(){
    16. 		 
    17. 		 public void accept(String ss) {
    18. 			 System.out.println(ss);
    19. 		 }
    20. 	 });
    21.    }
    22. }
    23.

    （）

    （3）TreeSet的使用

    TreeSet的特点：可排序，无重复，无索引。TreeSet的使用方法和其他集合还是一样的，不过最大的不同就是它可排序，它的底层是基于红黑树实现的，所以对于它，我们着重学习如何排序。它的排序方法有两种。一种是用Comparaable接口实现，一种是使用比较器进行排序。当然它是有着默认排序的，对于数字按照升序，对于字母按照ASCII升序。

    1：Comparable接口排序：

    这里的o代表的就是当前准备插入的元素，不明白排序规则，记住this在前就是升序就可以了

    1. package article;
    2.  
    3. import java.util.Objects;
    4.  
    5. public class student implements Comparable{
    6.    String name;
    7.    int age;
    8.    public student(String name,int age) {
    9. 	   this.age=age;
    10. 	   this.name=name;
    11.    }
    12.    public void setname(String name) {
    13. 	   this.name=name;
    14.    }
    15.    public void setage(int age) {
    16. 	   this.age=age;
    17.    }
    18.    public String getname() {
    19. 	   return name;
    20.    }
    21.    public int getage() {
    22. 	   return age;
    23.    }
    24. @Override
    25. public int compareTo(student o) {
    26. 	// TODO 自动生成的方法存根
    27. 	int t=this.name.compareTo(o.name);//先按年龄升序，相同按照年龄升序
    28. 	if(t==0) {
    29. 		return this.age-o.age;
    30. 	}
    31. 	return t;
    32. }
    33.    
    34.    
    35. }
    1. package article;
    2.  
    3. import java.util.Collection;
    4. import java.util.function.Consumer;
    5. import java.util.*;
    6. import java.util.*;
    7. public class first {
    8.    public static void main(String[] args) {
    9. 	 Set s=new TreeSet<>();
    10. 	 student s1=new student("abc",20);
    11. 	 student s2=new student("abk",30);
    12. 	 student s3=new student("dec",10);
    13. 	 student s4=new student("dbc",29);
    14. 	 student s5=new student("abc",30);
    15. 	 student s6=new student("abc",40);
    16. 	 s.add(s1);
    17. 	 s.add(s2);
    18. 	 s.add(s3);
    19. 	 s.add(s4);
    20. 	 s.add(s5);
    21. 	 s.add(s6);
    22. 	 
    23. 	 s.forEach(new Consumer() {
    24. 		@Override
    25. 		public void accept(student t) {
    26. 			// TODO 自动生成的方法存根
    27. 			System.out.println(t.getname()+" "+t.getage());
    28. 		}
    29. 	 });
    30. 	 
    31.    }
    32. }
    33.

    2：比较器排序

    这里的排序规则可以理解成o1在前就是升序，o2在前就是降序

    1. package article;
    2.  
    3. import java.util.Collection;
    4. import java.util.function.Consumer;
    5. import java.util.*;
    6. import java.util.*;
    7. public class first {
    8.    public static void main(String[] args) {
    9. 	 Set s=new TreeSet<>(new Comparator() {
    10.  
    11. 		@Override
    12. 		public int compare(student o1, student o2) {
    13. 			// TODO 自动生成的方法存根
    14. 			//先按照名字升序,相同则按照年龄降序
    15. 			int t=o1.name.compareTo(o2.name);
    16. 			if(t==0) {
    17. 				return o2.age-o1.age;
    18. 			}
    19. 			return t;
    20. 		}
    21. 		 
    22. 	 });
    23. 	 student s1=new student("abc",20);
    24. 	 student s2=new student("abk",30);
    25. 	 student s3=new student("dec",10);
    26. 	 student s4=new student("dbc",29);
    27. 	 student s5=new student("abc",30);
    28. 	 student s6=new student("abc",40);
    29. 	 s.add(s1);
    30. 	 s.add(s2);
    31. 	 s.add(s3);
    32. 	 s.add(s4);
    33. 	 s.add(s5);
    34. 	 s.add(s6);
    35. 	 
    36. 	 s.forEach(new Consumer() {
    37. 		@Override
    38. 		public void accept(student t) {
    39. 			// TODO 自动生成的方法存根
    40. 			System.out.println(t.getname()+" "+t.getage());
    41. 		}
    42. 	 });
    43. 	 
    44.    }
    45. }
    46.

     

  • 相关阅读:
    NEFU数字图像处理（1）绪论
    LVS 负载均衡集群
    m基于PSO粒子群优化的第四方物流的作业整合算法matlab仿真,对比有代理人和无代理人两种模式下最低运输费用、代理人转换费用、运输方式转化费用和时间惩罚费用
    软件测试面试题集锦--持续汇总更新
    五、鼎捷T100月加权平均成本计算流程篇
    如何清理C盘
    爪哇，我初窥门径
    免费版Typora的使用
    Git实操学习笔记（跟着步骤来，命令行就会了）
    【JavaEE精炼宝库】网络原理基础——UDP详解
  • 原文地址：https://blog.csdn.net/gaoqiandr/article/details/127833431