Java基础教程

文章36 |   阅读 18630 |   点赞0

来源：https://blog.csdn.net/u010520724/category_11240199.html

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

测试记录:

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

测试记录:

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

测试记录:

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

测试记录:

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

测试记录:

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

测试记录:

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

3.4 List集合练习

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

两种方式遍历:

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

代码:
list4

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

list5

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

测试记录:

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

测试记录:

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

测试记录:

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

测试记录:

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

测试记录:

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

测试记录:

  1. world
  2. java
  3. hello

6.2.2 HashSet集合存储实体类

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

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

代码:
hashset2

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

hashset3

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

测试记录:

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

hashset5

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

测试记录:

  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

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/u010520724/article/details/120013689

内容来源于网络，如有侵权，请联系作者删除！

Java集合单列集合

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com