JAVA-常用工具---集合的基础介绍 -List集合-Set集合-Map集合等的基础介绍

于 2020-12-08 21:51:27 发布
阅读量151 收藏
点赞数 1
分类专栏： JAVA 文章标签： java 集合 set map iterator
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52479012/article/details/110671266
版权

什么是集合？ 简称集，是用来存储多个元素的容器 

  注意：本次博客只包含一些简单的使用方法，如果想要深处的了解，可以直接打开API直接查询。

在Java中除了集合能够存储元素还有一个常见的那就是 数组

集合和数组的区别

1：元素类型：

                  集合：引用类型（存储基本类型时自动装箱成为包装类）

                  数组：基本类型，引用类型

2：元素个数：

                  集合：不固定，可以任用扩容

                  数组：固定，不能改变容量

3：集合的好处：

                  不受容器大小的限制，可以随时添加，删改元素，提供了大量操作的方法（判断。获取等）

Java的集合体系

1：单列集合（Collection（接口）） 

                   一：List（接口）

                            接口不能实例化，必须通过子类进行实现（ArrayList)

                   二：Set   (接口）

                            接口不能实例化，必须通过子类进行实现（HashSet)

2：双列集合（Map：key，value）

                  Map   

                         接口不能实例化，必须通过子类进行实现（HashSet)

List (单列集合）

特点：可重复有序（存取顺序相同）

实现应用

            List   list = new ArrayList（）；

为了了解List的使用方法做一个案例：List集合的简单使用

     需求：向List集合中添加三个元素，并遍历打印。

案例分析：a:向集合添加元素的方法：add（）

                  b:遍历集合的方式：for循环

                  c:获取集合中元素的个数的方法：size（）；

案例步骤：

                  1：创建集合对象

                           List   list = new ArrayList（）；

                  2：分别创建三个Str对象

                  3：使用add方法将str对象添加到集合中

                  4：使用for循环遍历集合并打印

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

public class list {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建实现类的对象
		List  list = new ArrayList();
		//创建元素对象
		str st1 = new str("海绵宝宝",15);
		str st2 = new str("海绵宝宝",15);
		str st3 = new str("派大星",18);
		str st4 = new str("章鱼哥",20);
		//把对象添加到集合中
		list.add(st1);
		list.add(st2);
		list.add(st3);
		list.add(st4);
		//直接输出整个集合
		System.out.println(list);
		//使用get通过索引去输出需要的对象，两种不同的写法，同样的结果
		Object o1=list.get(2);
		System.out.println(list.get(2));
		System.out.println(o1);
		//获取集合的长度值
		System.out.println(list.size());
		
		//通过遍历的方法去打印集合
		for(int i=0;i<list.size();i++) {
			System.out.println(list.get(i));
		}
	}

}
class str{      //创建一个新的类，一个完整的JavaBean类
	private String name;
	private int age;
	public str(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public str() {
		super();
		// TODO Auto-generated constructor stub
	}
	@Override
	public String toString() {
		return "str [name=" + name + ", age=" + age + "]";
	}
	
}
-------------------------------------------------------------
输出结果：
[str [name=海绵宝宝, age=15], str [name=海绵宝宝, age=15], str [name=派大星, age=18], str [name=章鱼哥, age=20]]
str [name=派大星, age=18]
str [name=派大星, age=18]
4
str [name=海绵宝宝, age=15]
str [name=海绵宝宝, age=15]
str [name=派大星, age=18]
str [name=章鱼哥, age=20]

拓展延伸：

一：迭代器：对过程的重复，是遍历Collection集合的通用方式可以对集合遍历的同时进行添加，删除等操作。

1：迭代器的使用方法：

       List one = new ArrayList();    //创建对象
		one.add("e");                 //向集合中添加信息
		one.add("v");
		one.add("w");
		one.add("g");
		//System.out.println(one);
		Iterator on = one.iterator();      //根据集合对象获取其对象的迭代器对象
		while (on.hasNext()) {
			String oo = (String)on.next();      //类型的转换
			System.out.println(oo);
				
			}

 

2：进行添加操作：注意当使用迭代器进行添加时必须使用列表迭代器来实现操作

        List one = new ArrayList();
		one.add("e");
		one.add("v");
		one.add("w");
		one.add("g");
        ListIterator nn = one.listIterator() ;   //列表迭代器
		while (nn.hasNext()) {
				String s = (String)nn.next();
				if ("e".equals(s)) {
					nn.add("java");  //在e后添加一个字符串
					
				}System.out.println(s);
			
		
			
		}System.out.println(one);

 

二：泛型：即泛指任意类型，又叫参数化类型，对具体类型的使用起到辅助作用，类似与方法的参数。

     集合类泛型的解释：表示该集合中存放指定类型的元素

     代码格式：List <类型> list = new ArrayList <>();

好处：确保了使用类型的安全

           减少了类型转换的环节

注意：这里提到了新的遍历输出方式：增强for的使用      格式：for （类型（或者是类名）  名称 ：对象名）{//最后输出s即可}

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

public class fanxing {      //泛型的使用
    

	public static void main(String[] args) {
		// TODO Auto-generated method stub
        //使用泛型与不使用泛型的对比。
		
		
	    //不使用泛型
		//创建对象
		List one = new ArrayList();
		//添加
		one.add("a");
		one.add("b");
		one.add("c");
		one.add("d");
		//one.add(10);              // 当集合添加数字是报ClassCastException的错误，但是泛型则不会让添加
		//遍历输出集合的内容 
		for (Object obj : one) {                    //这种输出方式为增强for的使用方式
			String s = (String)obj;
			System.out.println(s);
		}
		//使用泛型                         
		System.out.println("-----------------------------------");
		List<String> two = new ArrayList<>();
		two.add("w");
		two.add("s");
		two.add("o");
		two.add("wo");
		for (String s : two) {
			System.out.println(s);
			
		}
	}

}
-------------------------------------------------------
输出结果：
a
b
c
d
-----------------------------------
w
s
o
wo

三：集合的常用工具 Collections类      ：可以对集合进行操作

以下代码只讲解部分Collections类   的方法

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

public class connect {     //针对与集合的Collections 工具

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<Integer> list = new ArrayList<>();
		list.add(5);
		list.add(2);
		list.add(4);
		list.add(3);
		list.add(5);
		System.out.println("默认的输出格式:"+list);
		//获取集合中最大的数据
		Integer max = Collections.max(list);
		System.out.println("最大的数为:"+max);
		
		//对集合进行升序的操作
		Collections.sort(list);
		System.out.println(list);
		//为了防止影响下面操作进行注释  输出结果为[2, 3, 4, 5, 5]
		
		//对于集合的对象进行反转操作
		Collections.reverse(list);
		System.out.println(list);   
		//为了防止影响下面操作进行注释  输出结果为[5, 3, 4, 2, 5]
		
		//进行降序操作
		//Collections.sort(list);
		Collections.reverse(list);
		System.out.println(list);
		//为了防止影响下面操作进行注释  输出结果为输出结果[5, 5, 4, 3, 2]
		
		//随机置换，相当于洗牌
		Collections.shuffle(list);
		System.out.println(list);
		//输出结果;默认的输出格式:[5, 2, 4, 3, 5]
		//          随机产生的格式[2, 4, 3, 5, 5]

		
	}

}

单列集合（Collection)之Set集合

特点：无序（存放元素的位置与打印的位置不同），存放的元素具有唯一性

通过以下代码可知：Set的唯一性依赖的是equals（），hashCode（）两个方法。注意：只有在类中添加了两个方法的重写就保证了打印的唯一性。

代码案例：向set集合添加五个元素对象，并遍历打印。

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

public class set {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建集合对象
		Set<stu> set = new HashSet<stu>();
		//创建元素对象
		stu s1 = new stu("小李",20);
		stu s2 = new stu("小籽",20);
		stu s3 = new stu("小赵",20);
		stu s4 = new stu("小李",20);
		stu s5 = new stu("小赵",20);
		set.add(s1);
		set.add(s2);
		set.add(s3);
		set.add(s4);
		set.add(s5);
		System.out.println(set);
		//输出结果：[stu [name=小赵, age=20], stu [name=小赵, age=20], stu [name=小李, age=20], stu [name=小李, age=20], stu [name=小籽, age=20]]
		/*
		 * 为什么Set集合并没有去重
		 * 因为Set集合保证元素的唯一依赖性：equals() 和 hashcode()两个方法
		 * 但是在stu类中并没有重写者两种方法，导致调用的是Object类中的两个方法
		 * 而Object类中equals（）方法默认的是比较的是地址值是否相同
		 * 重写完输出结果为：[stu [name=小籽, age=20], stu [name=小李, age=20], stu [name=小赵, age=20]]

		 */
		
		//打印的方式有两种
		//通过迭代器打印内容
		System.out.println("迭代器打印------------------------------------------------------------------");
		Iterator<stu> ss =set.iterator() ;
		while (ss.hasNext()) {
		stu s=ss.next();
		System.out.println(s);
		}
		//使用增强for来打印集合的内容
		System.out.println("增强for------------------------------------------------");
		for(stu Stu:set) {
			System.out.println(Stu);
		}
	}

}
class stu{                 //添加一个完整的类，并拥有自己的私有方法。
	private String name;
	private int age;
	public stu(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public stu() {
		super();
		// TODO Auto-generated constructor stub
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "stu [name=" + name + ", age=" + age + "]";
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		stu other = (stu) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
	
}

 

Map集合：

         双列集合，元素由键值对（Entry）构成

                    key-----------value

       key不可以重复，value可以重复

注意：/*
         * 添加元素（通过键值对的方式）
         * 元素第一次添加返回的是null
         * 重复添加，会通过新值覆盖旧值，返回的是旧值
         */

代码格式：Map<t1,t2> map = new Hashmap<>0;  注意：t1表示键的数据类型   t2表示值的数据类型

以下代码案例：向Map集合中添加数据，并通过不同的方式去遍历打印

方法：

添加  ：put（）；

获取所有key：keySet（）；

遍历keyset，通过key获取value：get（）方法

遍历keyset的方法：iterator（）：注意：这些方法在以下代码都有体现，请注意


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


public class mapdaima {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建集合对象  Integer表示键的数据类型     student表示值的数据类型 
		Map<Integer, student> map = new HashMap<Integer, student>();
		//创建元素对象
		student s1=new student("小马",19);
		student s2=new student("小何",19);
		student s3=new student("小王",19);
		student s4=new student("小赵",19);
		student s5=new student("小马",19);
		//将元素对象添加到集合中 （1）
		/*
		 * 添加元素（通过键值对的方式）
		 * 元素第一次添加返回的是null
		 * 重复添加，会通过新值覆盖旧值，返回的是旧值
		 */
//		student stu1= map.put(1, s1);    
//		System.out.println("stu1:"+stu1);//第一添加：输出：stu1:null
//		student stu2= map.put(1, s2);    
//		System.out.println("stu2:"+stu2); //重复添加返回的是第一次添加的内容
		//将元素对象添加到集合中 （2）通常的方法
		map.put(1, s1);
		map.put(2, s2);
		map.put(3, s3);
		map.put(4, s4);
		map.put(5, s5);
		
		//根据键去获取值
		student ss1=map.get(2);
		System.out.println("key:"+2+" value:"+ss1);
		
		//打印集合
		System.out.println(map);
		
		//遍历集合
		
		//1:获取键的集合     keyset();
		Set<Integer> keys= map.keySet();         //把双列集合变成单列集合
		//2：遍历所有的键 获取每一个键        迭代器   或者  增强for的使用
		//获取迭代器对象
		 Iterator<Integer> ss = keys.iterator();       
		while(ss.hasNext()) {
			Integer n =ss.next();
			student ns = map.get(n);
			System.out.println("key"+n+"::::value   "+ns);
		}
		System.out.println("----------------------------------------------");
		
		//增强for的使用遍历集合
		Set<Integer> key = map.keySet();
		for(Integer keyss: key) {
			student student1 = map.get(keyss);
			System.out.println("key"+keyss+"::::value   "+student1);
		}
		
	}

}
class student{       //完整的类，拥有自己的方法
	private String name;
	private int age;
	@Override
	public String toString() {
		return "student [age=" + age + ", name=" + name + "]";
	}
	public student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	
	
}

注意：此博客代码最后可以实现模拟斗地主（发牌，买牌，洗牌）关注我吧/

既然看到这了 点个赞再走吧！！！谢谢你的支持

不想睡醒的梦
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不想睡醒的梦

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值