• Java入门 集合框架、泛型和Collection(一)(第二十三天)

    集合的使用：

    如果并不知道程序运行时会需要多少对象，或者需要更复杂方式存储对象——可以使用Java集合框架

    java集合框架：

    在java中数据结构是以某种形式将数据组织在一起的集合。他们不仅存储数据，还支持访问以及处理数据的操作。这些数据结构通常称为java集合框架。

    1、容器：一种能够存储其他数据或者元素的数据结构。

    2、java集合框架支持的两种类型的容器：
          1)、一种是为了存储一个元素集合，简称为集合(collection)。
          2)、另一种是为了存储键/值对，称为图(map)。

    1）准备数据：创建NewsTitle类对象
        NewsTitle nt1 = new NewsTitle(对象(即数据));

    2）准备容器：创建集合对象，创建ArrayList对象
        ArrayList al = new ArrayList();//集合名：al

    准备容器：创建集合对象，创建LinkedList对象
           List list = new LinkedList();

    集合包含的内容

    Java集合框架提供了一套性能优良、使用方便的接口和类，它们位于java.util包中
    1）接口：Collection、Map
           Collection包含了List和Set两大分支。
    2）具体类
    3）算法

    Collection提供了对集合进行排序、遍历等多种算法实现

    1）List集合中元素的特点：
            不唯一（可重复）、有序
    2）Set集合中元素的特点
            唯一（不可重复）、无序
    3）Map集合中元素的特点
            键唯一、值不唯一

    遍历集合的方法

    遍历集合的方法有三种：
        1）List集合：普通for循环、增强for循环、迭代器
        2）Set集合：增强for循环、迭代器
        3）Map集合：增强for循环、迭代器、键值对遍历

    ArrayList和LinkedList集合的区别

       ArrayList集合底层是长度可变的数组，遍历和查询集合中的元素效率高
       LinkedList集合底层是链表结构，删除和插入元素效率高

    List接口

    List三种遍历方法都可采用

    确定存储方式
            ArrayList类是List接口的一个具体实现类
            ArrayList对象实现了可变大小的数组
            随机访问和遍历元素时，它提供更好的性能
    确定存储对象
            创建类型：新闻标题
            包含属性： ID、名称、创建者
    具体实现

    代码：

    类

    1. package GatherDemo01;
    2.  
    3. public class NewsTitle {
    4.  
    5. 	private int id;//编号
    6. 	private String name;//标题名称
    7. 	private String author;//作者
    8.  
    9. 	public NewsTitle() {
    10. 		super();
    11. 	}
    12.  
    13. 	public NewsTitle(int id, String name, String author) {
    14. 		super();
    15. 		this.id = id;
    16. 		this.name = name;
    17. 		this.author = author;
    18. 	}
    19.  
    20. 	public int getId() {
    21. 		return id;
    22. 	}
    23.  
    24. 	public void setId(int id) {
    25. 		this.id = id;
    26. 	}
    27.  
    28. 	public String getName() {
    29. 		return name;
    30. 	}
    31.  
    32. 	public void setName(String name) {
    33. 		this.name = name;
    34. 	}
    35.  
    36. 	public String getAuthor() {
    37. 		return author;
    38. 	}
    39.  
    40. 	public void setAuthor(String author) {
    41. 		this.author = author;
    42. 	}
    43.  
    44. 	@Override
    45. 	public String toString() {  
    46. 		return "NewsTitle [id=" + id + ", name=" + name + ", author=" + author
    47. 				+ "]";
    48. 	}
    49.  
    50. }

    对象： 

    1. package GatherDemo01;
    2.  
    3. import java.util.ArrayList;
    4.  
    5. public class ArrayListDemo01 {
    6.  
    7. 	public static void main(String[] args) {
    8.  
    9. 		// 准备数据：创建5个NewsTitle类对象
    10. 		NewsTitle nt1 = new NewsTitle(1001, "三亚新增本土480+774", "百度");
    11. 		NewsTitle nt2 = new NewsTitle(1002, "中国成功发射一箭十六星", "中国航天");
    12. 		NewsTitle nt3 = new NewsTitle(1003, "男子救落水5人后遇难 同伴讲述经过", "民间观察");
    13. 		NewsTitle nt4 = new NewsTitle(1004, "苏氏祖祠：苏炳添是苏东坡第29代孙", "生活观察");
    14. 		NewsTitle nt5 = new NewsTitle(1005, "家长花200万给娃集奥特曼卡没集齐", "合肥观察");
    15.  
    16. 		// 准备容器：创建集合对象，创建ArrayList对象
    17. 		ArrayList al = new ArrayList();
    18.  
    19. 		// 将数据存储到集合中，向集合中添加元素不是通过元素下标来赋值，而是通过集合对象调用方法实现
    20. 		al.add(nt1);
    21. 		al.add(nt3);
    22. 		al.add(nt4);
    23. 		al.add(nt2);
    24. 		al.add(nt4);
    25.  
    26. 		// 可以通过集合对象调用方法实现对集合中元素的操作
    27. 		// 获取集合中的元素个数
    28. 		int size = al.size();
    29. 		System.out.println("al集合中元素个数：" + size);
    30.  
    31. 		/*// 获取集合中指定位置的元素
    32. 		 Object obj0=al.get(0);
    33. 		 NewsTitle nwt0 = (NewsTitle)obj0;
    34. 		 System.out.println(nwt0);
    35. 		
    36. 		 Object obj1=al.get(1);
    37. 		 NewsTitle nwt1 = (NewsTitle)obj1;
    38. 		 System.out.println(nwt1);
    39. 		
    40. 		 Object obj2=al.get(2);
    41. 		 NewsTitle nwt2 = (NewsTitle)obj2;
    42. 		 System.out.println(nwt2);
    43. 		
    44. 		 Object obj3=al.get(3);
    45. 		 NewsTitle nwt3 = (NewsTitle)obj3;
    46. 		 System.out.println(nwt3);
    47. 		
    48. 		 Object obj4=al.get(4);
    49. 		 NewsTitle nwt4 = (NewsTitle)obj4;
    50. 		 System.out.println(nwt4);*/
    51.  
    52. 		/*	// 遍历集合
    53. 		for (int i = 0; i < al.size(); i++) {
    54. 			Object object = al.get(i);
    55. 			NewsTitle ntw = (NewsTitle) object;
    56. 			System.out.println(ntw);
    57. 		}*/
    58.  
    59. 		System.out.println("--------------------");
    60.  
    61. 		// 增强for循环遍历集合
    62. 		/*for (Object object : al) {
    63. 			NewsTitle ntw = (NewsTitle) object;
    64. 			System.out.println(ntw);
    65. 		}*/
    66.  
    67. 		System.out.println("--------------------");
    68.  
    69. 		 // 使用迭代器遍历集合
    70. 		/* 
    71. 		 * 集合对象调用iterator()方法将集合中的所有元素按照顺序取出来放入到迭代器容器里面
    72. 		 * 然后通过迭代器对象调用hasNext()方法判断迭代器中是否有元素，有元素就通过next()方法取出这个元素
    73. 		 * 判断一个就取出一个，判断一个就取出一个，所以可以使用循环来取出里面所有的元素
    74. 		 */
    75. 	    /*Iterator it = al.iterator();
    76. 		while (it.hasNext()) {
    77. 			Object object = it.next();
    78. 			NewsTitle nt = (NewsTitle) object;
    79. 			System.out.println(nt);
    80. 		}*/
    81.  
    82. 		System.out.println("--------------------");
    83.  
    84. 		//将数据存储到集合中的指定位置
    85. 		al.add(1, nt5);//将元素nt5插入到下标为1的位置
    86. 		// 增强for循环遍历集合
    87. 		for (Object object : al) {
    88. 			NewsTitle ntw = (NewsTitle) object;
    89. 			System.out.println(ntw);
    90. 		}
    91. 		
    92. 		System.out.println("---------------------");
    93. 		
    94. 		//删除集合中的某个元素
    95. //		Object ob=al.remove(1);//刪除下标为1的元素
    96. 		/*al.remove(nt3);
    97. 		for (Object object : al) {
    98. 			NewsTitle ntw = (NewsTitle) object;
    99. 			System.out.println(ntw);
    100. 		}*/
    101. 		
    102. 		//判断集合中是否包含指定的元素
    103. 		/*boolean result =al.contains(nt3);
    104. 		System.out.println("集合中包含nt3元素："+result);*/
    105. 		
    106. 		//判断集合是不是空的
    107. 		/*System.out.println("集合是空的："+al.isEmpty());*/
    108. 		
    109. 		//清空集合
    110. 		/*al.clear();
    111. 		System.out.println("集合是空的："+al.isEmpty());
    112. 		System.out.println(al.size());*/
    113. 		
    114. 		System.out.println("****************************");
    115. 		//将集合转换成数组
    116. 		Object[] objects=al.toArray();
    117. 		for (int i = 0; i < objects.length; i++) {
    118. 			System.out.println(objects[i]);
    119. 		}
    120. 		
    121. 		System.out.println("****************************");
    122. 		/*//清空集合
    123. 		al.clear();
    124. 		System.out.println("集合是空的："+al.isEmpty());
    125. 		System.out.println(al.size());*/
    126. 		
    127. 	}
    128.  
    129. }

    对象 

    1. package GatherDemo01;
    2.  
    3. import java.util.Iterator;
    4. import java.util.LinkedList;
    5. import java.util.List;
    6.  
    7. public class LinkedListDemo01 {
    8.  
    9. 	public static void main(String[] args) {
    10. 		// 准备数据：创建5个NewsTitle类对象
    11. 		NewsTitle nt1 = new NewsTitle(1001, "三亚新增本土480+774", "百度");
    12. 		NewsTitle nt2 = new NewsTitle(1002, "中国成功发射一箭十六星", "中国航天");
    13. 		NewsTitle nt3 = new NewsTitle(1003, "男子救落水5人后遇难 同伴讲述经过", "民间观察");
    14. 		NewsTitle nt4 = new NewsTitle(1004, "苏氏祖祠：苏炳添是苏东坡第29代孙", "生活观察");
    15. 		NewsTitle nt5 = new NewsTitle(1005, "家长花200万给娃集奥特曼卡没集齐", "合肥观察");
    16.  
    17. 		// 准备容器：创建集合对象，创建LinkedList对象
    18. 		// List是一个接口，LinkedList是List接口的实现类，将List接口引用指向了实现类的实例，
    19. //		向上转型：父类（接口）的引用指向子类的实例，父类引用无法调用子类特有的方法
    20. 		List list = new LinkedList();
    21. 		list.add(nt1);
    22. 		list.add(nt3);
    23. 		list.add(nt2);
    24. 		list.add(nt2);
    25. 		
    26. 		System.out.println(list.size());
    27. 		
    28. 		//使用迭代器将list集合进行遍历
    29. 		Iterator it =list.iterator();
    30. 		while(it.hasNext()){
    31. 			Object object =it.next();
    32. 			NewsTitle nt = (NewsTitle)object;
    33. 			System.out.println(nt);
    34. 		}
    35. 		
    36. 		System.out.println("-------------------------");
    37. 		
    38. 		/*向下转型：子类的引用指向父类的对象  需要进行向下转型的原因是父类
    39.           引用无法调用子类中特有的方法，子类特有的方法只能通过子类对象调用*/
    40. 		LinkedList link = (LinkedList)list;
    41. 		link.addFirst(nt5);
    42. 		link.addLast(nt4);
    43. 		for (Object object : link) {
    44. 			System.out.println(object);
    45. 		}
    46. 		
    47. 		System.out.println("-------------------------");
    48. 		
    49. 		//获取集合中的第一个元素和最后一个元素
    50. 		System.out.println(link.getFirst());
    51. 		System.out.println(link.getLast());
    52. 		
    53. 		/*System.out.println("-------------------------");
    54. 		//删除集合中的第一个元素和最后一个元素
    55. 		link.removeFirst();
    56. 		link.removeLast();
    57. 		for (Object object : link) {
    58. 			System.out.println(object);
    59. 		}*/
    60. 	}
    61.  
    62. }

    Set接口

    1）Set接口存储一组唯一，无序的对象
    2）HashSet是Set接口常用的实现类
            Set接口不存在get()方法
    3）Set中存放对象的引用

    判断加入对象是否已经存在：
    采用对象的equals()方法比较两个对象是否相等

    遍历Set集合：

    方法1：通过迭代器Iterator实现遍历 
         1）获取Iterator ：Collection 接口的iterator()方法
         2）Iterator的方法
               boolean hasNext(): 判断是否存在另一个可访问 
               的元素 
              Object next(): 返回要访问的下一个元素

    方法2：增强型for循环

    1. package GatherDemo03;
    2.  
    3. import java.util.Collection;
    4. import java.util.HashMap;
    5. import java.util.Iterator;
    6. import java.util.Map;
    7. import java.util.Set;
    8.  
    9. public class HashMapDemo01 {
    10.  
    11. 	public static void main(String[] args) {
    12. 		//准备容器：创建HashMap对象
    13. 		HashMap hm = new HashMap();
    14. 		
    15. 		//准备元素并将元素存储到集合中
    16. 		hm.put("CN", "中华人民共和国");
    17. 		hm.put("JP", "小日本");
    18. 		hm.put("RU", "俄罗斯联邦");
    19. 		hm.put("USA", "美利坚合众国");
    20. 		hm.put("UK", "大不列颠及北爱尔兰联合王国");
    21. 		System.out.println(hm.size());
    22. 		
    23. 		//根据键获取对应的值
    24. 		Object obj1=hm.get("CN");
    25. 		String str1=(String)obj1;
    26. 		System.out.println(str1);
    27. 		System.out.println(hm.get("CNN"));
    28. 		
    29. 		//删除集合中的元素
    30. 		Object obj2=hm.remove("JP");
    31. 		String str2=(String)obj2;
    32. 		System.out.println(str2);
    33. 		
    34. 		
    35. 		System.out.println(hm.size());//删除元素JP，还有4个元素
    36. 		
    37. 		//获取HashMep集合中所有键值对的键
    38. 		Set keys=hm.keySet();
    39. 		for (Object object : keys) {
    40. 			String key=(String)object;
    41. 			System.out.println(key);
    42. 		}
    43. 		
    44. 		//获取HashMep集合中所有键值对的值
    45. 		Collection values= hm.values();
    46. 		for (Object object : values) {
    47. 			String value=(String)object;
    48. 			System.out.println(value);
    49. 		}
    50. 		
    51. 		//查询集合中是否存在指定键对应的键值对
    52. 		System.out.println(hm.containsKey("RU"));//true
    53. 		System.out.println(hm.containsKey("JP"));//false
    54. 		
    55. 		
    56. 		//遍历键值对的3种方式
    57. 		//方式一：获取键的集合，然后在遍历键的集合过程中调用get()方法获取值
    58. 		Set keys2 = hm.keySet();
    59. 		for (Object object : keys2) {
    60. 			//获得键
    61. 			String key=(String)object;
    62. 			//根据键获取值
    63. 			Object obj=hm.get(key);
    64. 			String value = (String)obj;
    65. 			System.out.println(key+"---"+value);
    66. 		}
    67. 		
    68. 		System.out.println("********************************");
    69. 		
    70. 		//方式二：获取键的集合，然后在遍历键的集合过程中调用get()方法获取值
    71. 		Set keys3=hm.keySet();
    72. 		Iterator it = keys3.iterator();
    73. 		while (it.hasNext()) {
    74. 			Object object = it.next();
    75. 			String key=(String)object;
    76. 			//获得键
    77. 			Object obj=hm.get(key);
    78. 			String value=(String)obj;
    79. 			System.out.println(key+"---"+value);
    80. 		}
    81. 		
    82. 		System.out.println("********************************");
    83. 		
    84. 		//方式三：键值对遍历，将hm集合中的键值对整体取出来后放入到Set集合中
    85. 		/*
    86. 		 *1)使用entrySet( )方法将hm集合中的键值对整体取出来放在Set集合中  
    87. 		 *
    88. 		 *2)然后使用增强for循环或者迭代器取出Set集合中的键值对元素，取出来的
    89. 		 *  是Object类型，实际，上键值对的真正类型是Map. Entry类型
    90. 		 *
    91. 		 *3)所以将取出来的元素强制转换为Map. Entry类型，Map. Entry类中有getKey( )
    92. 		 *  方法获取键值对的键，有getValue( )方法获取键值对的值
    93. 		 */
    94. 		Set keyValues=hm.entrySet();
    95. 		for (Object object : keyValues) {
    96. 			Map.Entry me = (Map.Entry)object;
    97. 			//获取键
    98. 			Object object1=me.getKey();
    99. 			String key = (String)object1;
    100. 			//根据键获取值
    101. 			Object object2=me.getValue();
    102. 			String value = (String)object2;
    103. 			System.out.println(key+"---"+value);
    104. 		}	
    105. 	}
    106.  
    107. }

  • 相关阅读:
    Linux 基础命令&进阶
    【Web安全】文件上传漏洞
    【PM专用】快速统计团队还有谁没有登记上报信息，快速筛选出属于自己项目组的成员，未完成XXX工作事项的名单
    IDEA中创建Java Web项目方法1
    元素的盒子模型+标签的尺寸大小和偏移量+获取页面滚动距离+JS直接修改标签样式 + 让页面滚动到指定位置
    特征工程特征预处理归一化与标准化、鸢尾花种类预测代码实现
    消息中间件-面试题
    【Java 基础】5、通过 Java 官方文档学习一下 Java 的类和对象
    Android jetpack ： Navigation 导航 路由 、 单个Activity嵌套多个Fragment的UI架构方式
    13.Jenkins的使用
  • 原文地址：https://blog.csdn.net/m0_70516782/article/details/126347092