集合

最新推荐文章于 2024-04-02 18:19:34 发布
最新推荐文章于 2024-04-02 18:19:34 发布
阅读量129 收藏
点赞数 1
分类专栏： 笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51626328/article/details/115581971
版权

Java中集合框架

一、集合的概念

  1. 概念：集合是一种容器，用于存储多个对象(集合中只能存储对象)
  2. 集合的分类：Collection和Map

二、Collection集合

  1. 概念：Collection是单列集合，用于存储对象类型的数据
  2. Collection中的常用方法：
    1. add方法：
      1. 声明：boolean add(Object o)
      2. 作用：向集合中添加一个对象
    2. addAll方法：
      1. 声明：boolean addAll(Collection c)
      2. 作用：将传入的c集合中所有的元素存入集合中
    3. clear方法：
      1. 声明：void clear()
      2. 作用：清空集合中所有的元素
    4. contains方法：
      1. 声明：boolean contains(Object o)
      2. 作用：判断集合中是否包含o元素
    5. remove方法：
      1. 声明：boolean remove(Object o)
      2. 作用：从集合中删除o元素，返回值表示删除是否成功
    6. .size方法：
      1. 声明：int size()
      2. 作用：返回此集合中的元素数
    7. toArray方法：
      1. 声明：Object[] toArray()
      2. 作用：将集合转换为数组

三、List接口

  1. List接口是Collection的子接口

  2. List的基本特点：元素有顺序,有下标,元素可以重复

  3. List的特有方法：

    1. add方法：
      1. 声明：void add(int index,Object o)
      2. 作用：在指定下标位置添加元素
      3. 注意：添加的下标值必须小于等于集合现有元素数
    2. get方法:
      1. 声明：Object get(int index)
      2. 作用：返回下标位置的元素
    3. indexOf方法：
      1. 声明：int indexOf(Object o)
      2. 作用：返回元素在集合中的下标，如果没有该元素，返回-1
    4. remove方法：
      1. 声明：Object remove(int index)
      2. 作用：删除下表位置的元素，并且将被移除的元素返回
    5. set方法：
      1. 声明：Object set(int index, Object o)
      2. 作用：将指定下标位置的对象替换，并将被替换的元素返回

  4. List的遍历方式

    1. 下标遍历

      package com.baizhi.testCollection;

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

public class TestCollection {
	public static void main(String[] args) {
		List list = new ArrayList();
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
	}
}

    2. 迭代器遍历

      package com.baizhi.testCollection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class TestCollection {
	public static void main(String[] args) {
		List list = new ArrayList();
		//获取迭代器
		Iterator it = list.iterator();
		//迭代器遍历
		while(it.hasNext()) {//hasNext 判断指针下是否还有元素
			Object o = it.next();//获取当前指针的元素
			System.out.println(o);
		}
	}
}

    3. for-each遍历

      package com.baizhi.testCollection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class TestCollection {
	public static void main(String[] args) {
		List list = new ArrayList();
		for (Object o : list) {
			System.out.println(o);
		}
	}
}

    4. 自遍历

      package com.baizhi.testCollection;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class TestCollection {
	public static void main(String[] args) {
		List list = new ArrayList();
		//匿名内部类的写法
		list.forEach(new Consumer() {
			@Override
			public void accept(Object o) {
				System.out.println(o);
			}
		});
		//配合Lambda表达式的写法
		list.forEach(o -> System.out.println(o));
	}
}

  5. List的实现类：

    1. ArrayList：利用数组实现，查询效率高，元素插入和删除效率低，线程不安全，并发效率高(JDK1.2)
    2. LinkedList:利用链表实现，查询效率低，元素插入和删除效率高，线程不安全，并发效率高(JDK1.2)
    3. Vector:利用数组实现，线程安全，并发效率低(JDK1.0)

  6. List的排序：

    使用List的sort方法，需要传入一个比较器对象

    package com.baizhi.test;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class TestListSort {
	public static void main(String[] args) {
		List<Person> list = new ArrayList<>();
		list.add(new Person("zhangs", 30));
		list.add(new Person("guox", 31));
		list.add(new Person("liuh", 18));
//		sort方法需要一个比较器作为参数
		Comparator<Person> c = new Comparator<Person>() {
			@Override
			public int compare(Person o1, Person o2) {
//				先根据姓名排序，如果姓名一致根据年龄排序
				int temp = o1.name.compareTo(o2.name);
				if(temp == 0) 
					return o1.age - o2.age;
				return temp;
			}
		};
//		传入比较器
		list.sort(c);
//		对结果进行遍历
		list.forEach(a -> System.out.println(a));
	}
	
}
class Person {
	public String name;
	public int age;
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
}

四、泛型

  1. 作用：

    1. 确定集合存储对象的类型
    2. 在使用集合的时候不必确认和强制类型转换
    3. 集合的类型安全

  2. 泛型语法：

    1. 集合中的泛型，要求前后完全一致，并且没有多态

    2. 泛型方法

      public <T> void m1(T t) {}//泛型应用在参数列表
public <T> T m1() {return null;}//泛型应用在返回值类型

    3. 泛型接口

    interface Test{//约定在本接口中出现的都是这个类型
    public void m1(T t);
    public T m1();
    }

    
4. 泛型类

~~~java
class Test<T>{//约定在本类中出现的都是这个类型
	public void m1(T t) {}
	public T m1() {return null;}
}

    1. 泛型的通配符

      interface Test{
//	根据实参的类型确定集合的泛型
	public void m1(List<?> list);
//	要求传入实参的泛型必须是Animal或者Animal的子类
	public void m2(List<? extends Animal> list);
//	要求传入实参的泛型必须是Animal或者Animal的父类
	public void m3(List<? super Animal> list);
}

五、Set接口

  1. Set接口是Collection的子接口

  2. Set的基本特点：元素无下标，元素的内容不能重复, 元素内容唯一

  3. Set的特有方法：没有

  4. Set的遍历方式：

    1. 迭代器遍历：

      package com.baizhi.testCollection;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class TestCollection {
	public static void main(String[] args) {
		Set<String> set = new HashSet<>();
		Iterator<String> it = set.iterator();
		while(it.hasNext()) {
			String s = it.next();
			System.out.println(s);
		}
	}
}

    2. for-each遍历：

      package com.baizhi.testCollection;

import java.util.HashSet;
import java.util.Set;

public class TestCollection {
	public static void main(String[] args) {
		Set<String> set = new HashSet<>();
		for (String s : set) {
			System.out.println(s);
		}
	}
}

    3. 自遍历：

      package com.baizhi.testCollection;

import java.util.HashSet;
import java.util.Set;
import java.util.function.Consumer;

public class TestCollection {
	public static void main(String[] args) {
		Set<String> set = new HashSet<>();
//		匿名内部类的写法
		set.forEach(new Consumer<String>() {
			@Override
			public void accept(String s) {
				System.out.println(s);
			}
		});
//		配合Lambda表达式的写法
		set.forEach(s -> System.out.println(s));
	}
}

  5. Set的实现类：

    1. HashSet：元素无序，无下标，不能重复
    2. LinkedHashSet:HashSet的子类，维护元素进入集合的顺序
    3. TreeSet：SortedSet接口(Set的子接口)的实现类，自动对元素进行排序，如果是自定义类型，需要提供比较规则

  6. 自定义对象的不重复性：通过覆盖hashCode()方法和equals()方法

    1. 覆盖hashCode()方法的原则：

      1. 必须保证相同的元素返回相同的哈希值
      2. 尽量保证不同的元素返回不同的哈希值

    2. 覆盖equals()方法的原则：

      保证内容相同的元素返回true

六、Map集合

  1. 概念：Map是双列集合，使用键值对的方式存储元素，键不可重复

  2. Map中的常用方法：

    1. put方法：
      1. 声明：V put(K key,V value)
      2. 作用：将键值对存入集合，并且将被替换的元素返回，如果没有替换，返回null
    2. get方法：
      1. 声明：V get(Object key)
      2. 作用：通过key查询value，如果key不存在，返回null
    3. size方法：
      1. 声明：int size()
      2. 作用：返回集合中元素的数量
    4. remove方法：
      1. 声明：V remove(Object key)
      2. 作用：用过key移除键值对
    5. containsKey方法：
      1. 声明：boolean containsKey(Object key)
      2. 作用：检查集合中是否包含该key
    6. containsValue方法：
      1. 声明：boolean containsValue(Object value)
      2. 作用：检查集合中是否包含该value
    7. clear方法：
      1. 声明：void clear()
      2. 作用：清空集合
    8. isEmpty方法：
      1. 声明：boolean isEmpty()
      2. 作用：检查集合内是否没有键值对
      3. 注意：集合为null和集合isEmpty为true是不同的

  3. Map的遍历方式：

    1. 键遍历：

      package com.baizhi.testMap;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class TestMap {
	public static void main(String[] args) {
		Map<String,String> map = new HashMap<String, String>();
		
		Set<String> keys = map.keySet();
		for (String key : keys) {
			String value = map.get(key);
			System.out.println("key:"+key+"  value:"+value);
		}
	}
}

    2. 值遍历：

      package com.baizhi.testMap;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

public class TestMap {
	public static void main(String[] args) {
		Map<String,String> map = new HashMap<String, String>();
		
		Collection<String> values = map.values();
		for (String value : values) {
			System.out.println("value:"+value);
		}
	}
}

    3. 键值对遍历：

      package com.baizhi.testMap;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class TestMap {
	public static void main(String[] args) {
		Map<String,String> map = new HashMap<String, String>();
//		获取所有的Entry对象 -- 通过entrySet方法 -- 该方法返回所有Entry对象的Set集合	
		Set<Entry<String, String>> es = map.entrySet();
//		遍历set集合，获取所有的Entry对象
		for (Entry<String, String> e : es) {
//			从Entry对象中获取key和value的数据
			String key = e.getKey();
			String value = e.getValue();
			System.out.println("key:"+key+"  value:"+value);
		}
	}
}

    4. 自遍历：

      package com.baizhi.testMap;

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;

public class TestMap {
	public static void main(String[] args) {
		Map<String,String> map = new HashMap<String, String>();
//		使用匿名内部类的方式
		map.forEach(new BiConsumer<String, String>() {
			@Override
			public void accept(String key, String value) {
				System.out.println("key:"+key+"  value:"+value);				
			}
		});
//		配合Lambda表达式
		map.forEach((key,value) -> 
			System.out.println("key:"+key+"  value:"+value));
	}
}

  4. Map的实现类：

    1. HashMap：线程不安全，并发效率高，允许使用null作为键和值（JDK1.2）
    2. Hashtable：线程安全，并发效率低，不允许使用null作为键和值，（JDK1.0）
    3. Properties：Hashtable的子类，只允许String类型的键和值，通常用于读取配置文件
    4. TreeMap：可以对键进行排序(SortedMap接口的实现类，Map的子接口)
    5. LinkedHashMap:可以维护键值对添加到集合的顺序
编程小白(=_=)
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python编程——集合的定义和操作
橘子女侠
01-05 1391
集合是Python的基本数据类型，在下面这篇文章中，我将简单介绍一下集合的定义和常见的操作。 1. 集合的定义 集合是无序的，所以不支持下标索引来查找元素。 在python中，集合和字典一样，都使用大括号，而且集合中的每个元素都是唯一的。 集合的创建很简单，只需要在大括号中添加元素，并使用逗号隔开即可。 集合是一种可变的数据类型。 集合的格式：集合名 = {元素1，元素2，元素3......
实验05 Java集合.doc
06-27
掌握集合的概念、体系结构、分类及使用场景 2）了解Set接口及主要实现类（HashSet、TreeSet） 3）了解List接口及主要实现类（ArrayList、LinkedList、Vector） 4）了解Map接口及主要实现类（HashMap、TreeMap、...
第十四章 Java集合
你好, 我在学java的博客
11-13 4558
创建TreeSet对象时如果传入了一个Comparator对象，就用实现的compare方法去除重复元素，如果方法返回0，就认为不应该添加；如果没有传入Comparator对象，则以添加对象的实现的Comparable接口的compareTo方法去除重复元素；原因：创建TreeSet对象时如果传入了一个Comparator对象，就用实现的compare方法比较；如果没有传入Comparator对象，则以添加对象的实现的Comparable接口的compareTo方法比较；第二次添加时，遍历所有的key。
集合是编程中最常用的数据结构
geduke4150的博客
02-27 873
集合是编程中最常用的数据结构。而谈到并发，几乎总是离不开集合这类高级数据结构的支持。比如两个线程需要同时访问一个中间临界区（Queue），比如常会用缓存作为外部文件的副本（HashMap）。这篇文章主要分析jdk1.5的3种并发集合类型（concurrent，copyonright，queue）中的ConcurrentHashMap，让我们从原理上细致的了解它们，能够让我们在深度项目开发中获益非浅
Java核心编程总结(六、常用API与集合）
最新发布
2401_84046645的博客
04-02 313
查询多而增删少 用ArrayListt集合查询少而增删首尾多 用LinkedList集合4.5 总结如果希望元素可以重复，又有索引，查询要快，用ArrayList集合（用的最多）如果希望元素可以重复，又有索引，增删要快，用LinkedList集合(适合查询元素比较少，经常要首尾操作元素的情况)如果希望增删改查都很快，但是元素不重复以及无序无索引，那么用HashSet集合如果希望增删改查都很快且有序，但是元素不重复无索引，那么用集合4.6 Collections工具类。
Java集合编程
someby的博客
10-03 611
    1.在实际企业生产环境下编程，我们通常是用数据结构来封装具体的，代码是直接操作数据结构来完成具体的业务功能；     2.Java中提供的众多的数据结构具体就表现为Java的集合，例如List、Set、Collection、Map、Iterator、Queue等都是Java中至关重要的内容；     3.大数据中到处可见集合的使用，因为大数据处理的是数据集！     4.LinkedLi...
集合的基本入门概念
霹雳牛爸爸___
12-29 211
#集合的值不能是可变数据类型 集合的格式 set(可迭代内容) list,str,(),字典 字典只能取key 变量名={元素，元素2，元素3} set1={0,False,'hello'} print(set1) 注意： True会转化成1 进行比较，如果集合里面有1，将会只有保存1个 False 代表的是0 2，集合的添加 .add .update ————————————————————...
Java集合
06-13
Java的集合类是一种特别有用的工具类，它可以用于存储数量不等的多个对象，并可以实现常用数据结构，如栈，队列等，除此之外，Java集合还可用于保存具有映射关系的关联数组。 Java的集合大致上可分为：Set,List和...
java实现高效的枚举元素集合示例
09-04
Set是Java集合类的重要组成部分，它用来存储不能重复的对象。枚举类型也要求其枚举元素各不相同。看起来枚举类型和集合是很相似的。然而枚举类型中的元素不能随意的增加、删除，作为集合而言，枚举类型非常不实用。...
Collection集合
08-17
Collection集合
Java集合框架
12-22
Java集合框架 集合：集合就是一个容器，可以存储很多东西，可以添加，可以删除，可以修改。 Collection接口 Collection接口式Java集合的根接口，是所有集合的父接口。该接口里面提供了很多操作集合的抽象方法。 ...
.Net编程常用类集合
07-21
集合了数据库操作(增删改查及资源释放),集成了自定义数据加密(不可逆运算),集成了常用js脚本,集成了图片自动添加水印,根据设定大小自动调整图片大小功能,集成了软件根据硬件序列号进行加密注册功能,集成了自动生成唯一ID号功能(可用于数据库和文件名)等等....其他自己下载之后测试使用.作者开发均使用此控件. 此版本有部分bug，请在作者主页上下载最新优化版本（.Net编程常用类集合（最新））。
面向对象编程：集合
zheng199902的博客
10-13 166
集合
编写程序实现两个集合的交、并集
weixin_40392920的博客
01-04 8934
编写程序实现两个集合的交、并集 #include <stdio.h> #define N 100int main() { int a[N],b[N],c[N],d[N],e[N],f[N]; int m,n,i,j; int k=1,x=1,y=1; int flag; printf("请确定集合A中的个数:\n"); scanf("%d",&m);
Java编程中常用的集合详解 对你非常有用
weixin_44040460的博客
01-03 995
Java中的集合概述 集合是一个容器，用来存放引用类型的数据，在java.util包下。 Java中的集合主要有3种类型： List接口： 是一个有序集合，可以放重复的数据。 Set接口： 是一个无序集合，不允许放重复的数据。 Map接口： 是一个无序集合，集合中包含一个键对象，一个值对象，键对象不允许重复，值对象可以重复。 Java中Collection集合的继承实现关系 ...
Java高级应用编程——集合
qq_37067955的博客
08-21 2279
一、Java中的集合类 集合概述 Java中集合类是用来存放对象的 集合相当于一个容器，里面包容着一组对象 ————容器类 其中的每个对象作为集合的一个元素出现 Java API提供的集合位于java.util包内 java中数组与集合的比较 数组也是容器，它是定长的，访问较快，但是数组不会自动扩充 数组可以包含基本数据类型或者引用类型的...
几个集合编程
leapenemc的专栏
12-14 413
 static void Main(string[] args)        {                        Console.WriteLine("==================哈希表(先进后出)=======================");            Hashtable hashTable = new Hashtable();            f
编程常用合集，List集合使用详解掌握啦吗
关注我！带你一路 "狂飙" 到底！
03-21 617
我们知道，List是Java编程中经常使用的集合之一，但List到底有哪些不为人知的地方，List为什么被使用得这么多？今天索尔就为大家分析一下关于List的那点事儿。 List本身其实是一个接口，继承自Collection接口，所以List存储元素的特点是单元素，区别于Map（双元素集合），JDK8为List接口提供了10个实现类，供开发人员使用。 为什么提供那么多的实现类呢？因为在实际开发场景下需要根据业务的不同选择不同的实现类来使用，这就要求大家对实现类的特点都要加以掌握，才能在实际的开发..

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值