Java基础系列30-单列 Collection集合

x33g5p2x  于2021-12-18 转载在 其他  
字(18.3k)|赞(0)|评价(0)|浏览(477)

一.集合的概述

集合是一个容器,是用来存储和获取数据;

集合类的特点长度可变;

1.1 为什么会出现集合类

我们学习的是面向对象的编程语言,面向对象的编程语言对事物的描述都是通过对象体现的,为了方便对多个对象进行操作,我们就必须把这多个对象进行存储,而要想存储多个对象,就不能是基本的变量了,应该是一个容器类型的变量。回顾我们学过的知识,有哪些是容器类型的呢?

数组,StringBuilder,它的结果是一个字符串,不一定满足我们的需求,所以我们只能选择数组了,而数组的长度固定,不能适应变化的需求,在这种情况下,Java就提供了集合类供我们使用。

由此可见,集合类的长度是可变的。

1.2 集合类体系结构图

二.Collection集合

2.1 Collection集合入门

Collection是单列集合的顶层接口。

元素Collection 表示一组对象,这些对象也称为 collection 的

特点:

  1. 一些 collection 允许有重复的元素,而另一些则不允许。
  2. 一些 collection 是有序的,而另一些则是无序的。
  3. JDK 不提供此接口的任何直接 实现:它提供更具体的子接口(如 Set 和 List)实现。

ArrayList()是创建Collection集合的对象,我们采用的是多态的方式,使用的是具体的ArrayList类。因为这个类是最常用的集合类。

Collection:是一种特殊的数据类型,泛型。这里我们会使用就可以了。如何使用呢?

  1. 在出现E的地方用引用数据类型替换即可。
  2. 举例:Collection,Collection

代码:

  1. package Java_study;
  2. import java.util.ArrayList;
  3. import java.util.Collection;
  4. /**
  5. *
  6. * @author 只是甲
  7. * @date 2021-07-02
  8. * @remark 创建Collection集合对象并添加元素
  9. *
  10. */
  11. public class collection1 {
  12. public static void main(String[] args) {
  13. //创建Collection集合对象
  14. //下面这种写法是JDK7的新特性,看懂就可以,但不建议这种写法,最好还是补全<>中的类型
  15. //Collection<String> c = new ArrayList<>(); //多态的方式
  16. Collection<String> c = new ArrayList<>();
  17. c.add("hello");
  18. c.add("world");
  19. c.add("java");
  20. //输出集合对象
  21. //输出了集合中的元素按照指定格式拼接的内容,说明ArrayList重写了toString()方法
  22. /* [hello, world, java] */
  23. System.out.println(c);
  24. }
  25. }

测试记录:

  1. [hello, world, java]

2.2 Collection集合的成员方法

  1. //添加元素
  2. boolean add(E e);
  3. //从集合中移除元素
  4. boolean remove(Object o);
  5. //清空集合中的元素
  6. void clear();
  7. //判断集合中是否存在指定的元素
  8. boolean contains(Object o);
  9. //判断集合是否为空
  10. boolean isEmpty();
  11. //集合的长度,也就是集合中元素的个数
  12. int size();

代码:

  1. package Java_study;
  2. import java.util.Collection;
  3. import java.util.ArrayList;
  4. /**
  5. *
  6. * @author 只是甲
  7. * @date 2021-07-02
  8. * @remark Collection集合的成员方法
  9. *
  10. */
  11. public class collection2 {
  12. public static void main(String[] args) {
  13. //创建集合对象
  14. Collection<String> c = new ArrayList<>();
  15. //1.添加元素
  16. System.out.println("add:" + c.add("hello"));
  17. System.out.println("add:" + c.add("world"));
  18. System.out.println("----1------");
  19. //2.从集合中删除元素
  20. System.out.println("remove:" + c.remove("world"));
  21. System.out.println("remove:" + c.remove("haha"));
  22. System.out.println("-----2-----");
  23. //3.清空集合
  24. System.out.println(c);
  25. c.clear();
  26. System.out.println(c);
  27. System.out.println("-----3-----");
  28. //4.判断集合中是否存在指定的元素
  29. c.add("world");
  30. System.out.println("contains:" + c.contains("world"));
  31. System.out.println("contains:" + c.contains("haha"));
  32. System.out.println("-----4-----");
  33. //5. 判断集合是否为空
  34. System.out.println("isEmpty:" + c.isEmpty());
  35. System.out.println("-----5-----");
  36. //6. 集合的长度
  37. System.out.println("size:" + c.size());
  38. System.out.println("----6------");
  39. //输出集合对象
  40. System.out.println(c);
  41. }
  42. }

测试记录:

  1. add:true
  2. add:true
  3. ----1------
  4. remove:true
  5. remove:false
  6. -----2-----
  7. [hello]
  8. []
  9. -----3-----
  10. contains:false
  11. contains:false
  12. -----4-----
  13. isEmpty:false
  14. -----5-----
  15. size:1
  16. ----6------
  17. [world]

2.3 Collection集合的遍历

Collection集合的遍历:

  1. Iterator iterator() : 返回在此 collection 的元素上进行迭代的迭代器;
  2. 通过集合对象调用iterator()方法得到迭代器对象;

Iterator:

  1. E next():返回迭代的下一个元素;
  2. boolean hasNext():如果仍有元素可以迭代,则返回 true;

代码:

  1. package Java_study;
  2. import java.util.ArrayList;
  3. import java.util.Collection;
  4. import java.util.Iterator;
  5. import java.util.NoSuchElementException;
  6. /**
  7. *
  8. * @author 只是甲
  9. * @date 2021-07-02
  10. * @remark Collection集合的遍历
  11. *
  12. */
  13. public class collection3 {
  14. public static void main(String[] args) {
  15. //创建集合对象
  16. Collection<String> c1 = new ArrayList<String>();
  17. //添加元素
  18. c1.add(new String("hello"));
  19. c1.add("world");
  20. c1.add("java");
  21. //Iterator<E> iterator()
  22. Iterator<String> it1 = c1.iterator();//返回的是跌抬起接口的实现类的对象
  23. try {
  24. System.out.println(it1.next());//hello
  25. System.out.println(it1.next());//world
  26. System.out.println(it1.next());//java
  27. System.out.println(it1.next());//NoSuchElementException:没有这样的元素异常
  28. } catch (NoSuchElementException e) {
  29. System.out.println("NoSuchElementException:没有这样的元素异常");
  30. }
  31. /* 遍历方式一:iterator.hasNext()
  32. boolean hasNext 如果还有下一个元素则返回true 否则跳出循环,避免NoSuchElementException
  33. */
  34. System.out.println("===========方式一:iterator.hasNext()===============");
  35. Iterator<String> it2 = c1.iterator();
  36. while (it2.hasNext()) {
  37. String s = it2.next();
  38. System.out.println(s);
  39. }
  40. /* 遍历方式二: try catch 获取NoSuchElementException异常 */
  41. System.out.println("===========方式二:try catch===============");
  42. Iterator<String> it3 = c1.iterator();
  43. iter:
  44. while (true) {
  45. try {
  46. System.out.println(it3.next());
  47. } catch (NoSuchElementException e) {
  48. System.out.println("遍历结束");
  49. break iter;
  50. }
  51. }
  52. /* 遍历方式三: 增强for循环 c1.for根据提示自动生成*/
  53. System.out.println("===========方式三:增强for循环===============");
  54. for (String s : c1) {
  55. System.out.println(s);
  56. }
  57. }
  58. }

测试记录:

  1. hello
  2. world
  3. java
  4. NoSuchElementException:没有这样的元素异常
  5. ===========方式一:iterator.hasNext()===============
  6. hello
  7. world
  8. java
  9. ===========方式二:try catch===============
  10. hello
  11. world
  12. java
  13. 遍历结束
  14. ===========方式三:增强for循环===============
  15. hello
  16. world
  17. java

2.4 集合使用步骤图解

三. List集合

3.1 List集合特点

List:

  1. 有序的 collection(也称为序列);
  2. 此接口的用户可以对列表中每个元素的插入位置进行精确地控制;
  3. 用户可以根据元素的整数索引(在列表中的位置)访问元素,并搜索列表中的元素;
  4. 与 set 不同,列表通常允许重复的元素;

List集合的特点:

  1. 有序(存储和取出元素的顺序一致);
  2. 存储的元素可以重复;

代码:

  1. package Java_study;
  2. import java.util.ArrayList;
  3. import java.util.Iterator;
  4. import java.util.List;
  5. /**
  6. *
  7. * @author 只是甲
  8. * @date 2021-07-02
  9. * @remark List集合的特点
  10. *
  11. */
  12. public class list1 {
  13. public static void main(String[] args) {
  14. //创建集合对象
  15. List<String> list = new ArrayList<String>();
  16. //存储元素
  17. list.add("hello");
  18. list.add("world");
  19. list.add("java");
  20. //遍历集合
  21. Iterator<String> it = list.iterator();
  22. while (it.hasNext()) {
  23. String s = it.next();
  24. System.out.println(s);
  25. }
  26. }
  27. }

测试记录:

  1. hello
  2. world
  3. java

3.2 List集合的特有成员方法

  1. //在指定位置添加元素
  2. void add(int index,E element);
  3. //删除指定位置的元素
  4. E remove(int index);
  5. //获取指定位置的元素
  6. E get(int index);
  7. //修改指定位置的元素
  8. E set(int index,E element);

代码:

  1. package Java_study;
  2. import java.util.ArrayList;
  3. import java.util.List;
  4. /**
  5. *
  6. * @author 只是甲
  7. * @date 2021-04-19
  8. * @remark List集合的特有成员方法
  9. *
  10. */
  11. public class list2 {
  12. public static void main(String[] args) {
  13. //创建集合对象
  14. List<String> list = new ArrayList<String>();
  15. //使用集成Collection的添加功能
  16. list.add("hello");
  17. list.add("world");
  18. list.add("java");
  19. // 1. void add(int index,E element):在指定位置添加元素
  20. System.out.println("==========1. void add(int index,E element):在指定位置添加元素==========");
  21. try {
  22. list.add(1, "javaee");
  23. list.add(11, "javase");//IndexOutOfBoundsException,索引超出边界异常,list中没有这个数据
  24. } catch (IndexOutOfBoundsException e) {
  25. System.out.println("IndexOutOfBoundsException,索引超出边界异常,list中没有这个数据");
  26. }
  27. System.out.println(list);//[hello, javaee, world, java]
  28. //2. E remove(int index):删除指定位置的元素,返回被删除的元素
  29. System.out.println("==========2. E remove(int index):删除指定位置的元素,返回被删除的元素==========");
  30. try {
  31. System.out.println("remove: " + list.remove(2));
  32. System.out.println("remove: " + list.remove(11));//IndexOutOfBoundsException,索引超出边界异常,list中没有这个数据
  33. } catch (IndexOutOfBoundsException e) {
  34. System.out.println("IndexOutOfBoundsException,索引超出边界异常,list中没有这个数据");
  35. }
  36. System.out.println(list);//[hello, javaee, java]
  37. //3. E get(int index):获取指定位置的元素
  38. System.out.println("==========3. E get(int index):获取指定位置的元素==========");
  39. try {
  40. System.out.println("get:" + list.get(1));
  41. System.out.println("get:" + list.get(11));//IndexOutOfBoundsException,索引超出边界异常,list中没有这个数据
  42. } catch (IndexOutOfBoundsException e) {
  43. System.out.println("IndexOutOfBoundsException,索引超出边界异常,list中没有这个数据");
  44. }
  45. }
  46. }

测试记录:

  1. ==========1. void add(int index,E element):在指定位置添加元素==========
  2. IndexOutOfBoundsException,索引超出边界异常,list中没有这个数据
  3. [hello, javaee, world, java]
  4. ==========2. E remove(int index):删除指定位置的元素,返回被删除的元素==========
  5. remove: world
  6. IndexOutOfBoundsException,索引超出边界异常,list中没有这个数据
  7. [hello, javaee, java]
  8. ==========3. E get(int index):获取指定位置的元素==========
  9. get:javaee
  10. IndexOutOfBoundsException,索引超出边界异常,list中没有这个数据

3.3 List集合的普通for循环遍历

List集合的遍历方式:

  1. 迭代器
  2. 普通for循环
  3. 增强for循环

代码:

  1. package Java_study;
  2. import java.util.ArrayList;
  3. import java.util.List;
  4. /**
  5. *
  6. * @author 只是甲
  7. * @date 2021-07-02
  8. * @remark List集合的普通for循环遍历
  9. *
  10. */
  11. public class list3 {
  12. public static void main(String[] args) {
  13. //创建集合对象
  14. List<String> list = new ArrayList<String>();
  15. //添加循环
  16. list.add("hello");
  17. list.add("world");
  18. list.add("java");
  19. // E get(int index):获取指定位置的元素
  20. try {
  21. System.out.println(list.get(0));
  22. System.out.println(list.get(1));
  23. System.out.println(list.get(2));
  24. System.out.println(list.get(3));//IndexOutOfBoundsException,索引超出边界异常,list中没有这个数据
  25. } catch (IndexOutOfBoundsException e) {
  26. System.out.println("IndexOutOfBoundsException,索引超出边界异常,list中没有这个数据");
  27. }
  28. }
  29. }

测试记录:

  1. hello
  2. world
  3. java
  4. IndexOutOfBoundsException,索引超出边界异常,list中没有这个数据

3.4 List集合练习

自定义一个学生类,给出成员变量name和age。
遍历集合的时候,在控制台输出学生对象的成员变量值。

两种方式遍历:

  1. 迭代器
  2. 普通for
  3. 增强for

代码:
list4

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-07-05
  6. * @remark 实体学生类 List集合的练习存储自定义对象并遍历
  7. *
  8. */
  9. public class list4 {
  10. private String name;
  11. private int age;
  12. public list4(String name, int age) {
  13. this.name = name;
  14. this.age = age;
  15. }
  16. public String getName() {
  17. return name;
  18. }
  19. public void setName(String name) {
  20. this.name = name;
  21. }
  22. public int getAge() {
  23. return age;
  24. }
  25. public void setAge(int age) {
  26. this.age = age;
  27. }
  28. /**
  29. * @remark 重写Object类的toString方法
  30. * @return 学生类的姓名,年龄信息
  31. */
  32. @Override
  33. public String toString() {
  34. return "Student{" +
  35. "name='" + name + '\'' +
  36. ", age=" + age +
  37. '}';
  38. }
  39. }

list5

  1. package Java_study;
  2. import java.util.ArrayList;
  3. import java.util.Iterator;
  4. import java.util.List;
  5. /**
  6. *
  7. * @author 只是甲
  8. * @date 2021-07-05
  9. * @remark 测试类 List集合的练习存储自定义对象并遍历
  10. *
  11. */
  12. public class list5 {
  13. public static void main(String[] args) {
  14. //创建集合对象
  15. List<list4> list = new ArrayList<list4>();
  16. //创建元素对象
  17. list4 s1 = new list4("杜兰特",33);
  18. list4 s2 = new list4("库里",33);
  19. list4 s3 = new list4("詹姆斯",37);
  20. //把元素添加到集合
  21. list.add(s1);
  22. list.add(s2);
  23. list.add(s3);
  24. // a.迭代器
  25. System.out.println("=====a.迭代器=====");
  26. Iterator<list4> it = list.iterator();
  27. while (it.hasNext()) {
  28. list4 s = it.next();
  29. System.out.println(s.toString());
  30. }
  31. //b.普通for
  32. System.out.println("=====b.普通for=====");
  33. for (int i = 0; i < list.size(); i++) {
  34. list4 s = list.get(i);
  35. System.out.println(s.toString());
  36. }
  37. //c.增强for
  38. System.out.println("=====c.增强for=====");
  39. for (list4 s : list) {
  40. System.out.println(s.toString());
  41. }
  42. }
  43. }

测试记录:

  1. =====a.迭代器=====
  2. Student{name='杜兰特', age=33}
  3. Student{name='库里', age=33}
  4. Student{name='詹姆斯', age=37}
  5. =====b.普通for=====
  6. Student{name='杜兰特', age=33}
  7. Student{name='库里', age=33}
  8. Student{name='詹姆斯', age=37}
  9. =====c.增强for=====
  10. Student{name='杜兰特', age=33}
  11. Student{name='库里', age=33}
  12. Student{name='詹姆斯', age=37}

3.5 List.ListIterator();

ListIterator:

  1. ListIterator listIterator():返回此列表元素的列表迭代器
  2. public interface ListIteratorextends Iterator

特有功能:

  1. E previous():返回列表中的前一个元素。
  2. boolean hasPrevious():如果以逆向遍历列表,列表迭代器有多个元素,则返回 true。

注意:

  1. ListIterator可以实现逆向遍历,但是要求先正向遍历,才能逆向遍历。

代码:

  1. package Java_study;
  2. import java.util.ArrayList;
  3. import java.util.List;
  4. import java.util.ListIterator;
  5. /**
  6. *
  7. * @author 只是甲
  8. * @date 2021-07-05
  9. * @remark 列表迭代器的特有功能ListIterator
  10. *
  11. */
  12. public class list6 {
  13. public static void main(String[] args) {
  14. //创建集合对象
  15. List<String> list = new ArrayList<String>();
  16. //添加元素
  17. list.add("hello");
  18. list.add("world");
  19. list.add("java");
  20. ListIterator<String> lit = list.listIterator();
  21. System.out.println("=====a.直接逆向遍历list数组=====");
  22. while (lit.hasPrevious()) {
  23. String s = lit.previous();
  24. System.out.println(s);
  25. }
  26. System.out.println("=====b.先正向遍历list数组再逆向遍历list数组=====");
  27. while (lit.hasNext()) {
  28. String s = lit.next();
  29. }
  30. while (lit.hasPrevious()) {
  31. String s = lit.previous();
  32. System.out.println(s);
  33. }
  34. }
  35. }

测试记录:

  1. =====a.直接逆向遍历list数组=====
  2. =====b.先正向遍历list数组再逆向遍历list数组=====
  3. java
  4. world
  5. hello

3.6 List并发修改异常

需求:

  1. 有一个集合List list = new ArrayList();
  2. 里面有三个元素list.add(“hello”);list.add(“world”);list.add(“java”);
  3. 我想判断里面有没有"world"这个元素,如果有,我就添加一个"javaee"元素,请写代码实现。

ConcurrentModificationException:

  1. 当方法检测到对象的并发修改,但不允许这种修改时,抛出此异常。

产生的原因:

  1. 迭代器依赖于集合而存在,在判断成功后,集合中添加了新的元素,而迭代器并不知道,所有就报错了。
  2. 其实这个问题说的是:迭代器遍历集合中的元素的时候,不要使用集合对象去修改集合中的元素。

如何解决?
A : 迭代器遍历的时候,我可以通过迭代器修改集合中的元素
元素是跟在刚才迭代的元素后面的
B : 集合遍历的时候,我可以通过集合对象修改集合中的元素
元素是在最后添加的

代码:

  1. package Java_study;
  2. import java.util.*;
  3. /**
  4. *
  5. * @author 并发修改异常产生的原因及解决方案只是甲
  6. * @date 2021-07-05
  7. * @remark
  8. *
  9. */
  10. public class list7 {
  11. public static void main(String[] args) {
  12. // 创建集合对象
  13. List<String> list = new ArrayList<String>();
  14. // 添加元素
  15. list.add("hello");
  16. list.add("world");
  17. list.add("java");
  18. System.out.println(list);
  19. //我想判断里面有没有"world"这个元素,如果有,我就添加一个"javaee"元素
  20. Iterator<String> it = list.iterator();
  21. //ConcurrentModificationException:添加失败,当方法检测到对象的并发修改,但不允许这种修改时,抛出此异常。
  22. /*while (it.hasNext()) {
  23. String s = it.next();
  24. if (s.equals("world")) {
  25. list.add("javaee");
  26. }
  27. System.out.println(s);
  28. }*/
  29. //A:迭代器遍历的时候,我可以通过迭代器修改集合中的元素(元素是跟在刚才迭代的元素后面的)
  30. ListIterator<String> lit = list.listIterator();
  31. while (lit.hasNext()) {
  32. String s = lit.next();
  33. if (s.equals("world")) {
  34. lit.add("javaee");
  35. }
  36. }
  37. System.out.println(list);
  38. //B:集合遍历的时候,我可以通过集合对象修改集合中的元素(元素是在最后添加的)
  39. for (int x = 0; x < list.size(); x++) {
  40. String s = list.get(x);
  41. if (s.equals("world")) {
  42. list.add("javaee");
  43. }
  44. }
  45. System.out.println(list);
  46. }
  47. }

测试记录:

  1. [hello, world, java]
  2. [hello, world, javaee, java]
  3. [hello, world, javaee, java, javaee]

四.数据结构

什么是数据结构?
  数据的组织方式;

4.1 常见数据结构【栈】【队列】

栈 :FIFO(First In First Out) 先进先出
队列 :FILO(First In Last Out) 先进后出

4.2 常见数据结构【数组】【链表】

数组 :存储同一种数据类型的多个元素的容器,有索引,方便我们获取元素;
  应用 : ArrayList ;

链表 :由一个链子把多个节点连接起来的数据;
  结点 :由 数据 和 下一个元素的地址 组成;
  应用 : LinkedList ;

五. ArrayList案例

5.1 ArrayList集合存储字符串

List
  ArrayList : 底层数据结构是数组,查询快,增删慢
  LinkedList : 底层数据结构是链表,查询慢,增删快

ArrayList存储字符串并遍历
  A : 迭代器
  B : 普通for
  C : 增强for

代码:

  1. package Java_study;
  2. import java.util.ArrayList;
  3. import java.util.Iterator;
  4. /**
  5. *
  6. * @author 只是甲
  7. * @date 2021-07-05
  8. * @remark ArrayList集合存储字符串
  9. *
  10. */
  11. public class arraylist1 {
  12. public static void main(String[] args) {
  13. //创建集合对象
  14. ArrayList<String> arr = new ArrayList<String>();
  15. //添加元素
  16. arr.add("hello");
  17. arr.add("world");
  18. arr.add("java");
  19. //a.迭代器 arr.iterator
  20. System.out.println("a.迭代器 arr.iterator");
  21. Iterator<String> it = arr.iterator();
  22. while (it.hasNext()) {
  23. System.out.println(it.next());
  24. }
  25. //b.普通for arr.fori
  26. System.out.println("b.普通for arr.fori ");
  27. for (int i = 0; i < arr.size(); i++) {
  28. System.out.println(arr.get(i));
  29. }
  30. //c.增强for
  31. for (String s: arr) {
  32. System.out.println(s);
  33. }
  34. }
  35. }

测试记录:

  1. a.迭代器 arr.iterator
  2. hello
  3. world
  4. java
  5. b.普通for arr.fori
  6. hello
  7. world
  8. java
  9. hello
  10. world
  11. java

六.Set集合特点和HashSet集合类

Collection接口 – List(接口,可重复,存取顺序一致) 、 Set(接口,唯一,存取顺序不一致)
  List接口 – ArrayList(实现类,数据结构为数组)、LinkedList(实现类,数据结构为链表)
  Set接口 – HashSet(实现类)

Set
  元素唯一,存储元素无序 ;
  一个不包含重复元素的 collection;

HashSet
  它不保证 set 的迭代顺序,特别是它不保证该顺序恒久不变;

代码:

  1. package Java_study;
  2. import java.util.HashSet;
  3. import java.util.Set;
  4. /**
  5. *
  6. * @author 只是甲
  7. * @date 2021-07-05
  8. * @remark Set集合的特点
  9. *
  10. */
  11. public class set1 {
  12. public static void main(String[] args) {
  13. //创建集合对象
  14. Set<String> set = new HashSet<>();
  15. //添加元素
  16. set.add("hello");
  17. set.add("world");
  18. set.add("java");
  19. //set集合的唯一性: 再次添加相同的元素,但集合该元素唯一
  20. set.add("world");
  21. //遍历集合 set.for
  22. for (String s : set) {
  23. System.out.println(s);
  24. }
  25. }
  26. }

测试记录:

  1. world
  2. java
  3. hello

6.2 HashSet集合类

HashSet它不保证 set 的迭代顺序,特别是它不保证该顺序恒久不变;

6.2.1 HashSet元素唯一性原理

HashSet保证元素唯一性的原理?
  通过查看add方法的源码,我们知道了添加功能的执行过程中,是进行了数据的判断的。
  这个判断的流程是:
    首先比较对象的哈希值是否相同,这个哈希值是根据对象的hashCode()计算出来的。
    如果哈希值不同,就直接添加到集合中
    如果哈希值相同,继续执行equals()进行比较,
      返回的是true,说明元素重复,不添加。
      返回的是false,说明元素不重复,就添加。
  如果我们使用HashSet集合存储对象,你要想保证元素的唯一性,就必须重写hashCode()和equals()方法。

代码:

  1. package Java_study;
  2. import java.util.HashSet;
  3. /**
  4. *
  5. * @author 只是甲
  6. * @date 2021-07-05
  7. * @remark HashSet保证元素唯一性的原理
  8. *
  9. */
  10. public class hashset1 {
  11. public static void main(String[] args) {
  12. //创建集合对象
  13. HashSet<String> hs = new HashSet<>();
  14. //添加元素
  15. hs.add("hello");
  16. hs.add("world");
  17. hs.add("java");
  18. //set集合的唯一性: 再次添加相同元素,但集合内该元素只有一个
  19. hs.add("world");
  20. //遍历集合
  21. for (String h : hs) {
  22. System.out.println(h);
  23. }
  24. }
  25. }

测试记录:

  1. world
  2. java
  3. hello

6.2.2 HashSet集合存储实体类

需求
  自定义一个学生类,给出成员变量name和age。
  遍历集合的时候,在控制台输出学生对象的成员变量值。

遍历方式
  a.迭代器
  b.增强for

代码:
hashset2

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-07-05
  6. * @remark 实体学生类 HashSet集合存储实体类
  7. *
  8. */
  9. public class hashset2 {
  10. private String name;
  11. private int age;
  12. public hashset2(String name, int age) {
  13. this.name = name;
  14. this.age = age;
  15. }
  16. public String getName() {
  17. return name;
  18. }
  19. public void setName(String name) {
  20. this.name = name;
  21. }
  22. public int getAge() {
  23. return age;
  24. }
  25. public void setAge(int age) {
  26. this.age = age;
  27. }
  28. @Override
  29. public String toString() {
  30. return "{name='" + name + "'" + ", age=" + age + '}';
  31. }
  32. }

hashset3

  1. package Java_study;
  2. import java.util.HashSet;
  3. import java.util.Iterator;
  4. /**
  5. *
  6. * @author 只是甲
  7. * @date 2021-07-05
  8. * @remark 测试类 HashSet集合存储实体类
  9. *
  10. */
  11. public class hashset3 {
  12. public static void main(String[] args) {
  13. //创建集合对象
  14. HashSet<hashset2> hs = new HashSet<>();
  15. //创建元素对象
  16. hashset2 s1 = new hashset2("杜兰特",33);
  17. hashset2 s2 = new hashset2("库里",33);
  18. hashset2 s3 = new hashset2("詹姆斯",37);
  19. //把元素添加到集合
  20. hs.add(s1);
  21. hs.add(s2);
  22. hs.add(s3);
  23. //a.迭代器遍历 hs.iterator()
  24. Iterator<hashset2> it = hs.iterator();
  25. System.out.println("a.迭代器遍历 hs.iterator()");
  26. while (it.hasNext()) {
  27. hashset2 s = it.next();
  28. System.out.println(s.toString());
  29. }
  30. //b.增强for遍历 it.next()
  31. System.out.println("b.增强for遍历 it.next()");
  32. for (hashset2 s:hs) {
  33. System.out.println(s);
  34. }
  35. }
  36. }

测试记录:

  1. a.迭代器遍历 hs.iterator()
  2. {name='詹姆斯', age=37}
  3. {name='杜兰特', age=33}
  4. {name='库里', age=33}
  5. b.增强for遍历 it.next()
  6. {name='詹姆斯', age=37}
  7. {name='杜兰特', age=33}
  8. {name='库里', age=33}

6.2.3 HashSet重写hashCode();equals();

要求
  如果对象的成员变量值相同,就认为是同一个元素。

提示
  自定义一个学生类,给出成员变量name和age。遍历集合的时候,在控制台输出学生对象的成员变量值。

遍历方式
  a.迭代器
  b.增强for

因为我们存储的元素所属的类没有重写hashCode()和equals()方法,所以保证不了元素的唯一性。
  而我想保证,怎么办呢?重写这两个方法就可以了。
  如何重写呢?自动生成就可以了。

代码:
hashset4

  1. package Java_study;
  2. import java.util.Objects;
  3. /**
  4. *
  5. * @author 只是甲
  6. * @date 2021-07-06
  7. * @remark 实体学生类 HashSet重写hashCode();equals();
  8. *
  9. */
  10. public class hashset4 {
  11. private String name;
  12. private int age;
  13. public hashset4(String name, int age) {
  14. this.name = name;
  15. this.age = age;
  16. }
  17. public String getName() {
  18. return name;
  19. }
  20. public void setName(String name) {
  21. this.name = name;
  22. }
  23. public int getAge() {
  24. return age;
  25. }
  26. public void setAge(int age) {
  27. this.age = age;
  28. }
  29. @Override
  30. public String toString() {
  31. return "{name='" + name + "'" + ", age=" + age + '}';
  32. }
  33. /**
  34. * @remark 因为我们存储的元素所属的类没有重写hashCode()和equals()方法,所以保证不了元素的唯一性。
  35. * 而我想保证,怎么办呢?重写这两个方法就可以了。
  36. * 如何重写呢?自动生成就可以了。alt+insert
  37. * @param o
  38. * @return
  39. */
  40. @Override
  41. public boolean equals(Object o) {
  42. if (this == o) return true;
  43. if (o == null || getClass() != o.getClass()) return false;
  44. hashset4 that = (hashset4) o;
  45. return age == that.age && name.equals(that.name);
  46. }
  47. /**
  48. * @remark 因为我们存储的元素所属的类没有重写hashCode()和equals()方法,所以保证不了元素的唯一性。
  49. * 而我想保证,怎么办呢?重写这两个方法就可以了。
  50. * 如何重写呢?自动生成就可以了。alt+insert
  51. * @return
  52. */
  53. @Override
  54. public int hashCode() {
  55. return Objects.hash(name, age);
  56. }
  57. }

hashset5

  1. package Java_study;
  2. import java.util.HashSet;
  3. /**
  4. *
  5. * @author 只是甲
  6. * @date 2021-07-06
  7. * @remark 测试类 HashSet重写hashCode();equals();
  8. *
  9. */
  10. public class hashset5 {
  11. public static void main(String[] args) {
  12. HashSet<hashset4> hs = new HashSet<>();
  13. hashset4 s1 = new hashset4("杜兰特",33);
  14. hashset4 s2 = new hashset4("库里",33);
  15. hashset4 s3 = new hashset4("詹姆斯",38);
  16. hashset4 s4 = new hashset4("东契奇",22);
  17. //把元素添加到集合
  18. hs.add(s1);
  19. hs.add(s2);
  20. hs.add(s3);
  21. hs.add(s4);
  22. //增强for遍历集合 hs.for
  23. for (hashset4 h:hs) {
  24. System.out.println(h);
  25. }
  26. }
  27. }

测试记录:

  1. {name='杜兰特', age=33}
  2. {name='詹姆斯', age=38}
  3. {name='库里', age=33}
  4. {name='东契奇', age=22}

参考:

  1. https://blog.csdn.net/qq_43529621/article/details/115954338

相关文章