面向对象进价2-集合

最新推荐文章于 2022-08-12 23:54:45 发布
最新推荐文章于 2022-08-12 23:54:45 发布
阅读量157 收藏 1
点赞数
分类专栏： 学习笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43676248/article/details/117816254
版权

集合

集合的概念
  • 集合是java对数据结构及算法的封装
  • 集合类（需要掌握的有Iterator、Collection、Set、List、HashSet、TreeSet、ArrayList、LinkedList、Map、HashMap、TreeMap )

在这里插入图片描述

List

  1. List是Collection的子接口。

  2. List中常用的抽象方法

    • add:添加元素的行为
    • addAll:添加一个集合到当前集合中来的行为
    • remove:移除元素的行为
    • clear:清空元素的行为
    • iterator:得到集合迭代器的行为，通过迭代器可以遍历元素
    • get:获取指定位置的元素
    • size:获取元素个数的行为

  3. List的实现类

    • ArrayList
    • LinkedList
ArrayList的使用
  1. ArrayList是一个泛型类，泛型约束了ArrayList的数据结构中存储的元素类型。
    ArrayList
  2. 创建ArrayList对象:
    -ArfaxListString> cities = new ArrayList()
  3. List中所有的抽象方法在ArrayList中都有实现，都可以直接调用
  4. ArrayList中元素插入的顺序和其存储顺序是一致的
  5. ArrayList在底层是使用数组往存储数据
//ArrayList的使用
	public void m1() {
		List<String> list=new ArrayList<String>();
		//向集合中添加元素
		list.add("abc");
		list.add("你好");
		list.add("123");
		list.add("abc");
		System.out.println("集合的大小是："+list.size());//获取集合的大小
		
		list.remove(2);//根据下标移除一个元素
		System.out.println("集合的大小是："+list.size());
		
		System.out.println(list.get(1));//根据下标获取一个元素
		
		list.clear();//清空集合
		System.out.println(list);
	}
	
	public void m2(){
		List<Integer> list=new LinkedList<Integer>();
		
		list.add(1);
		list.add(2);
		list.add(3);
		System.out.println(list);
		
		list.remove(2);
		System.out.println("移除元素后:"+list);
		
		list.clear();
		System.out.println("清空元素后："+list);
	}
Vector的使用(了解)
  • Vector的使用和ArrayList相同
  • Vector在底层也是使用数组来存储数据的
  • Vector对数据的操作( add或者get）都是同步方法
  • 但是，在现实的开发中，同步操作都是由程序员自己加上去的，一般使用ArrayList，然后自己决定同步的位置就可以了。
//Vector的使用
	public void m3(){
		List<Students> list=new Vector<Students>();
		//添加一个对象到集合中
		list.add(new Students(500, "孙悟空"));
		list.add(new Students(300, "max"));
		
		System.out.println(list);
	}

接口:List实现类:
（1) ArrayListC底层是数组，查询、修改元素时较快)
（2) LinkedList（底层是链表，增加、删除元素时速度较快>
(3) vector（底层也是数组，线程安全的》
1、使用防型指定集合中元擦的类型

2，可以添加任刘类型的蹶据，用Object表示，如果是基本骸据类型，则用时装类表示

3，添加元崇的顺序与集合中存储数据的藏序相同

4，便含中可以存在重复的元素

4，可以添加null值，但是排序时不能使用

List的遍历

ArrayList与LinkedList的异同

相同点

  • 方法名相同，处理结果相同（虽然实现不同)
  • 存取元素的顺序是一致的（存入0号元素，从0号也会取出相同元素)
  • 同一个元素可以多次加入
  • ―线程不安全（在操作数据结构时，没有线程保护机制)

区别

  • ArrayList使用数组保存元素
  • LinkedList使用双向链表保存元素

ArrayList是使用数组保存元素的，因此，在查询、修改元素时有优势，但是在元素增删时效率较低（动态扩容）。

LinkedList是使用双向链表保存元素的，因此，在增删元素时有优势，但是在查询元素时效率低（链表遍历）。

ArrayList与Vector的异同

相同点

  • 方法名相同，处理结果相同（虽然实现不同)
  • 存取元素的顺序是一致的（存入0号元素，从0号也会取出相同元素)
  • 同一个元素可以多次加入
  • 底层数据的存储方式相同（都是数组)

区别

  • ArrayList对数据的操作没有自带同步，因此是非线程安全的
  • Vector对数据的操作自带同步，因此是线程安全的

List的遍历方式有3种:

  • 使用for循环遍历使用
  • foreach遍历
  • 使用iterator遍历
	public void m5(){
		List<String> list=new ArrayList<String>();
		
		list.add("abc");
		list.add("123");
		list.add("你好");
		list.add("hello");
		
		//for循环遍历
		System.out.println("for循环遍历");
		for(int i=0;i<list.size();i++){
			System.out.print(list.get(i)+"\t");
		}
		//foreach循环遍历
		System.out.println("\nforeach循环遍历");
		for (String string : list) {
			System.out.print(string+"\t");
		}
		
		//使用iterator遍历
		System.out.println("\n使用iterator遍历");
		Iterator<String> lt=list.iterator();
		while(lt.hasNext()){
			System.out.print(lt.next()+"\t");
		}	
	}

List的排序（从小到大)

对基本数据类型或String类排序∶

  • Collections.sort(mArrayList)

  • 对自定义数据类型排序

  • 自定义数据类型需要实现Comparable接口，并实现compareTo方法来自定义排序规则。

  • class Data implements Comparable:泛型类型表示需要被比较的数据类型。

  • compareTo方法返回正数表示当前对象大于比较对象

package cn.iceson;

public class Students implements Comparable<Students>{
	private int age;
	private String name;
	
	public Students(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "Students [age=" + age + ", name=" + name + "]";
	}
	
	//指定排序规则
	@Override
	public int compareTo(Students o){
		/*//根据age进行排序
		int r=this.age-o.age;
		if (r>0) {
			return 1;//升序排序
		}else if(r<0){
			return -1;
		}else {
			return 0;
		}*/
		
		//根据name进行排序
		int r=this.name.compareTo(o.name);
		if (r>0) {
			return -1;//降序排序
		}else if(r<0){
			return 1;
		}else {
			return 0;
		}
		
	}

}

package cn.iceson;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ListDemo {
	
	//对整型数据（基本类型）排序
	public void m1(){
		List<Integer> list=new ArrayList<Integer>();
		
		list.add(32);
		list.add(23);
		list.add(27);
		list.add(9);
		list.add(15);
		list.add(45);
		
		System.out.println("排序前："+list);
		//升序排序
		Collections.sort(list);
		
		System.out.println("排序后："+list);
		
		Collections.reverse(list);
		
		System.out.println("倒置后："+list);
		
		Collections.shuffle(list);
		System.out.println("洗牌后："+list);
	}
	
	//对String类型进行排序
	public void m2(){
		List<String> list=new ArrayList<String>();
		
		list.add("abc");
		list.add("hello");
		list.add("good");
		list.add("stone");
		list.add("date");
		list.add("void");
		
		System.out.println("排序前:"+list);
		
		Collections.sort(list);
		
		System.out.println("排序后:"+list);
	}
	
	public void m3(){
		List<Students> list=new ArrayList<Students>();
		
		list.add(new Students(23, "max"));
		list.add(new Students(32, "abc"));
		list.add(new Students(22, "mara"));
		
		System.out.println("排序前："+list);
		
		Collections.sort(list);
		
		System.out.println("排序后："+list);
	}
	public static void main(String[] args) {
		new ListDemo().m3();
	}
}

Set的使用

Set是Collection的子接口。

Set用来存储元素（数据结构），并提供操作元素的方法（算法）。

Set中常用的抽象方法和List中的差不多

  • add:添加元素的行为
  • remove:移除元素的行为
  • clear :清空元素的行为
  • iterator:得到集合迭代器的行为，通过迭代器可以遍历元素
  • size:获取元素个数的行为

HashSet存储数据的特点

  • 元素顺序不可测

  • HashSet底层使用Hash算法决定元素的存储位置。

    Hash算法又叫散列算法，其核心思想就是一个萝卜一坑。在一定的区域内，为每一个元素的存储计算出唯一

    的地址。如果元素存放太满，重新规划区域，每一个元素的存储地址也会被重新计算。

  • 存储元素不可重复

  • 元素没有序号，不能通过下标获取元素

//HasSet的使用
	public void m1(){
		Set<Character> set=new HashSet<Character>();
		set.add('a');
		set.add('c');
		set.add('b');
		set.add('t');
		set.add('f');
		
		System.out.println(set);

TreeSet可以存储基本类型的数据，也可以存储自定义类型的数据

存储基本类型数据时元素会自动排序

存储自定义类型数据时∶

  • 元素必须实现Comparable接口，指定排序规则
  • 元素的顺序和排序规则有关
  • 插入到TreeSet中的元素自动排序
/**
 * 接口：Set
 * 实现类：HasSet TreeSet(排序)
 * 1.元素的添加次序与存储次序无关
 * 2.元素不重复
 * 3.TreeSet在添加元素时，会对元素进行排序
 */
public void m2(){
		Set<String> set=new TreeSet<String>(); 
		set.add("abc");
		set.add("hello");
		set.add("world");
		set.add("data");
		set.add("creat");
		set.add("hi");
		
		System.out.println(set);//结果：[abc, creat, data, hello, hi, world]
	}
//TreeSet的使用：对自定义类型排序，要求自定义类实现Comparable接口，并重写方法定义排序规则
	public void m4(){
		Set<Student> set=new TreeSet<Student>();
		set.add(new Student(1, "孙悟空", '男'));
		set.add(new Student(4, "唐僧", '男'));
		set.add(new Student(2, "沙僧", '男'));
		set.add(new Student(5, "猪八戒", '男'));
		set.add(new Student(3, "白龙马", '男'));
		
		System.out.println(set);
}

Set的遍历

public void m1(){
		Set<Character> set=new HashSet<Character>();
		set.add('a');
		set.add('c');
		set.add('b');
		set.add('t');
		set.add('f');
		
		System.out.println("foreach遍历：");
		for (Character character : set) {
			System.out.println(character);
		}
		
		System.out.println("-----------------------");
		System.out.println("Iterator遍历：");
		Iterator<Character> iterator=set.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
	}
HashSet和TreeSet的异同
相同点
  • 元素不可重复
  • 元素没有下标，只能通过迭代器和foreach遍历
  • 不支持手动排序（不能修改元素间的位置关系)
  • 元素顺序和加入顺序无关
不同点
  • HashSet底层使用Hash算法，元素的顺序不可预知，保存的元素没有特殊要求，可以插入null。
  • TreeSet底层使用树的算法，元素的顺序和元素的排序规则有关，加入元素必须实现Comparable接口，不能插入null。

Map的使用

Map

  • Map是表示用来存储键值对的接口，Map中的键不可以重复，每一个键最多对应一个值。

  • Map中常用的抽象方法

    • put:存放键值对

    • remove :移除指定键值对

    • clear :清空所有键值对

    • get:获取键对应的值

    • keySet:获取所有键组成的Set

  • Map中的元素没有下标，只能通过键获取对应的值

  • Map接口常用的实现类

    • HashMap
    • TreeMap
HashMap
  • HashMap存储数据的特点
    • 键值对存储顺序不可测
    • HashMap底层使用Hash算法决定键的存储位置。
    • 键不可重复
    • 只能通过键获取值
public void m1(){
		Map<String, Object> map=new HashMap<String,Object>();
		//添加键值对
		map.put("int", 123);
		map.put("String", "abc");
		map.put("char", 'f');
		map.put("obj", new Student());
		
		System.out.println(map);
		map.remove("obj");//按照键移除元素
		System.out.println("移除元素后："+map);
		
		System.out.println(map.get("String"));
		
		map.clear();//清空map中的所有元素
		System.out.println("清空map后："+map);
	}
TreeMap
  • TreeMap存储数据的特点
    • 键必须实现Comparable接口，指定排序规则
    • 键的顺序和排序规则有关
    • 插入到TreeMap中的元素自动排序
package cn.iceson;

public class Student implements Comparable<Student>{
	private int id;
	private String name;
	private char sex;
	public Student(int id, String name, char sex) {
		super();
		this.id = id;
		this.name = name;
		this.sex = sex;
	}
	public Student() {
		
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public char getSex() {
		return sex;
	}
	public void setSex(char sex) {
		this.sex = sex;
	}
	@Override
	public String toString() {
		return id+":"+name+":"+sex;
	}
	@Override
	public int compareTo(Student o) {
		int r=this.name.compareTo(o.name);
		if (r>0) {
			return 1;//升序排序
		}else if (r<0) {
			return -1;
		}else {
			return 0;
		}
	}
	
}

//TreeMap的使用:对自定义类型进行排序
	public void m3(){
		Map<Student,Object> map=new TreeMap<Student,Object>();
		
		map.put(new Student(4,"d",'男'), 12);
		map.put(new Student(3,"c",'男'), "abc");
		map.put(new Student(1,"a",'男'), true);
		map.put(new Student(2,"b",'男'), 'X');
		
		System.out.println(map);
	}

Map遍历

集合Map遍历

  • Map的遍历方式有两种︰

    • foreach遍历
    • Iterator遍历

  • 无论使用哪种遍历方式，都需要先得到Key所对应的Set对象，然后使用foreach ,iterator来遍历这个Set对象，并根据遍历的Key获取对应的值。

public void m1(){
		Map<String, Object> map=new HashMap<String,Object>();
		//添加键值对
		map.put("int", 123);
		map.put("string", "abc");
		map.put("char", 'f');
		map.put("obj", true);
		
		System.out.println("foreach遍历:");
		Set<String> set=map.keySet();//得到一个Set集合，这个集合中装了所有的键名
		for (String key : set) {
			System.out.println(key+":"+map.get(key));
		}
		
		System.out.println("-------------------------");
		
		System.out.println("Iterator遍历:");
		Set<String> set2=map.keySet();//得到一个Set集合，这个集合中装了所有的键名
		Iterator<String> it=set2.iterator();//通过iterator得到一个Iterator对象
		while(it.hasNext()){//判断是否有下一个键名存在
			System.out.println(it.next()+"----"+map.get(it.next()));
		}
	}
HashMap和TreeMap的异同

  • 相同点

    • 键不可重复
    • 只能通过迭代器和foreach遍历键，然后获取值
    • 不支持手动排序（不能修改元素间的位置关系)
    • 元素顺序和加入顺序无关

  • 不同点

  • HashMap底层使用Hash算法计算键的存储位置，键的顺序不可预知，保存的键没有特殊要求，可以插入null。

  • TreeMap底层使用二叉树存储键，键的顺序和键的排序规则有关，加入的键必须实现Comparable接口，不能插入null。

List ,Set ,Map比较
  • List
    • 存储的元素可以重复。
    • 可以通过下标查询元素。
    • 可以手动修改元素的顺序（可以排序，逆序，洗牌等操作）。
    • 通过for , foreach , iterator遍历
  • Set
    • 存储的元素不可以重复
    • 不能通过下标访问元素
    • 不可以手动修改元素的顺序
    • 通过foreach和iterator遍历
  • Map
    • 保存键值对信息-键不可以重复
    • 不可以手动修改顺序
    • 通过foreach和iterator遍历
心灵笔记
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java集合的算法
Ayhan_huang的博客
08-21 619
集合算法 java的Collections类以静态方法的形式提供了一些多态算法。 这些算法绝大多数处理List实例，也有个别能处理任意集合的实例。下面我们简要的介绍下。 排序 sort算法对列表的元素按升序进行排序。它有两种处理形式： 一种是接收一个列表，并根据其元素的自然顺序进行排序。 第二种是接收一个列表，以及额外的一个Comparator对象，用该对象对元素进行排序。 sort方法使用优化后的归并排序（merge sort）算法，不仅快，而且稳定： 快：它能保证运行的时间复杂度是O(nlog(n
管家婆辉煌8.XSQL数据字典-2
08-08
"管家婆辉煌8.XSQL数据字典-2" 本文档是管家婆辉煌8.XSQL数据字典的第二部分，主要介绍了数据库中的各种表结构和字段信息。以下是相关知识点的总结： 1. 数据库表结构：管家婆辉煌8.XSQL数据库中有多种表结构，...
Java 集合框架 算法
Life runs on code
03-14 2163
这里描述的多态算法是Java平台提供的可重用功能的一部分。它们都来自集合类，它们都采用静态方法的形式，其第一个参数是要执行操作的集合。Java平台提供的绝大多数算法都是在列表实例上操作的，但是其中一些算法是在任意的集合实例上操作的。本节简要介绍以下算法: 排序 洗牌(打乱顺序) 常规数据操作 搜索 构成 找到极值 排序 排序算法重新排序一个列表，使其元素按照排序关系按升序排列。提供了...
为什么要学习HashMap的底层原理？
码农翻身
12-01 856
上周发了一篇文章《什么是HashMap》，引起了不少人的讨论，有一个人的留言引发了我的思考：“作为一个程序员， 真的有必要学习这些底层原理吗？ 我会用了不就行了吗？ 为什...
javaday17-集合框架(HashSet存储字符串并遍历)
First 007的博客
12-09 6267
注意:从今天开始我们笔记里的代码码中,所有的实体类都不在写空参有参构造,还有set和get方法,将代码拷贝到Eclipse后,需要自己添加17.01_集合框架(HashSet存储字符串并遍历) A:Set集合概述及特点 通过API查看即可 B:案例演示HashSet存储字符串并遍历 HashSet<String> hs = new HashSet<>(); boolean b1 = hs.add(
C++面向对象程序设计实践——任务与指导书(3)
热门推荐
GodOuO
01-20 3万+
实验4：继承与多态 目的 (1)加深对封装、继承与派生概念的理解，了解在程序设计中的应用场合； (2)熟悉派生类的语法规则，掌握在继承关系下，派生类应承担的工作和对各种成员的访问方法； (3)了解在类层次中，基类与派生类的构造与析构次序； (4)掌握虚函数的定义方法和多态性的概念，理解虚函数引起的动态联编特性； (5)初步掌握利用基类指针和引用直接访问派生类虚函数的程序设计方法。 步骤 对于任务...
Java类进价
moonlightpeng的博客
05-25 366
目录 01-成员变量和局部变量的区别 02_形式参数是类名的问题 03_匿名对象 04_封装和private关键字 05_this关键字 06_构造方法 07_成员方法 08_创建对象做了哪些事情 09_面向对象练习 10_static关键字 总结 01-成员变量和局部变量的区别 /* 成员变量和局部变量的区别? A:在类中的位置不同 成员变量：...
软件操作指南-店长、核算必读.doc
11-15
2. 价签打印功能 价签打印功能是基本档案模块的另一个重要组成部分。该功能允许店长和核算快速地打印商品的价格签，以便在店铺中展示商品的价格信息。使用该功能时，店长和核算需要在“货号”列中输入要打印的商品...
SV-Cart网店系统 v1.2 Beta1.zip
07-07
·采购管理：新增供应商管理，供应商商品管理，可按关键字等查询供应商资料商品进价等信息  另外：SV-Cart团队针对一些特殊的高端用户群体，特别研发了高级综合版ALL-IN-ONE V1.2 网店系统，以满足企业在业务上的...
韭菜盒子——VSCode里也可以看股票＆基金实时数据，做最好用的投资插件:front-facing_baby_chick:
02-06
leek-fund（韭菜盒子） 韭菜盒子——VSCode里也可以看股票＆基金实时数据，做最好用的投资插件。 韭菜盒-VSCode还可以查看股票和基金的实时数据，做最有用的投资插件 论坛交流：，电报群和每个人一起沟通交流 ...
基于C++语言开发的商品销售系统完整源码
最新发布
09-21
填写货物名称，进价，售价，库存数量。货物编号由系统自主按序分配。接下来，采购部门需 要经常查看是否缺货。及时进货。 3--经理只需要抽时间查看一下销售报表。了解每一种货物的销售情况，以及总的销售利润。
[JAVA题目.基础]HashSet&循环&字符串
CSL201816080304的博客
12-01 366
领扣771. 宝石与石头：https://leetcode-cn.com/problems/jewels-and-stones/ 重点不是题目，题目是简单题目。 class Solution { public int numJewelsInStones(String J, String S) { HashSet<Character> set=new HashS...
Flutter下载图片和视频
qq_43676248的博客
04-25 1590
AndroidManifest.xml <!--用于访问网络，网络定位需要上网--> <uses-permission android:name="android.permission.INTERNET"/> <!--用于写入缓存数据到扩展存储卡--> <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/> <!--文件读取-
MySql基本操作
qq_43676248的博客
06-15 1194
1.数据库的介绍 1.数据库的优点 –存储数据也是存储到磁盘上 –结构化查询 2.数据库中的相关名词 DB:database–数据库：用来保存数据 DBMS:database management system–数据库管理系统：用来创建和管理数据库 SQL:structure query language–结构化查询语言：用来操作数据库中的数据 3.数据库如何保存数据 1.表用来保存数据，每个数据库可以有多张表 2.表中的每一列称为字段，类似于java中的属性 3.表中每一列的字段值构成了表中的一行，类似于
flutter_blue解决分包问题
qq_43676248的博客
04-09 782
flutter_blue 发送包长度大于20时 解决分包问题
flutter 倒计时组件
qq_43676248的博客
08-12 732
代码】flutter 倒计时组件。
Linux的快速使用_jdk安装_tomcat安装_mysql安装-尚学堂~百战程序员学习笔记
qq_43676248的博客
08-15 648
一.Linux 简介 1.发展历史 丹尼斯·里奇 肯·汤普逊 系统内核汇编. B 语言. C 语言做为内核语言,发明 unix linus 召集 unix 原班人马.发明了系统 linus 后更名为 linux 2.所谓的 linux 都是统称,具体版本都叫做发行版. 3.著名的发行版 3.1 red hat : 目前全球最大的 linux 发行厂商.(收费) 3.2 ubuntu:免费版本.界面比较好 3.3 麒麟. 3.5 Cent OS:免费.由 red hat 分支. 4.定位 4.1 操作系统.
java实现1 模拟进销存。要求： （1）面向对象 实体类 DAO接口（增删改查） DAO实现类 （2）进货
04-06
通过面向对象的方式，实现了模拟进销存的功能，并使用MySQL数据库存储数据，使得数据的管理更加方便和高效。同时，通过DAO接口和DAO实现类的分离，实现了数据访问与业务逻辑的分离，使得程序的可维护性更高。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值