java 集合 Collection List

最新推荐文章于 2023-04-15 13:12:55 发布

黄泽锋820

最新推荐文章于 2023-04-15 13:12:55 发布

阅读量258

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/weixin_48788281/article/details/120884275

版权

一 Collection

1.1 概述

java集合是使程序能够存储和操纵元素不固定的一组数据,所有java集合都位于java.util包中。

1.2 集合和数组的区别

注意:集合中不能直接存放基本类型 , 需要转为对应的基本类型包装类才可以 eg: int->Integer

1.3 集合继承体系

2. Map的继承层次结构

由以上两图我们可以看出Java集合类有清晰的继承关系，有很多子接口和实现类。但是，并不是所有子接口或实现类都是最常用的。

下面我们列举出最常用的几个子接口和实现类：

Collection ——> List ——> ArrayList类

Collection ——> List ——> LinkedList类

Collection ——> Set ——> HashSet类

Collection ——> Set ——> SortedSet接口 ——> TreeSet类

Map ——> HashMap类

Map ——> SortedMap ——> TreeMap类

1.4 集合使用方法

Collection接口定义的方法

方法	描述
boolean add(Object o)	该方法用于向集合里添加一个元素，添加成功返回true
void clear()	清除集合里的所有元素，将集合长度变为0
boolean contains(Object o)	返回集合里是否包含指定元素
boolean containsAll(Collection c)	返回集合里是否包含集合c里的所有元素
int hashCode()	返回此collection的哈希码值
boolean isEmpty()	返回集合是否为空，当集合长度为0时，返回true
Iterator iterator()	返回一个Iterator对象，用于遍历集合里的元素
boolean remove(Object o)	删除集合中指定元素o，当集合中包含了一个或多个元素o时，这些元素将被删除，该方法将返回true
boolean removeAll(Collection c)	从集合中删除集合c里包含的所有元素，如果删除了一个或一个以上的元素，返回true
boolean retainAll(Collection c)	从集合中删除不在集合c里包含的元素，如果删除了一个或一个以上的元素，返回true
int size()	返回集合中的元素个数
Object[] toArray()	该方法把集合转换成一个数组，所有集合元素变成对应的数组元素

Collection是父类,所以里面的方法子类都有

例子:

package com;

import java.util.ArrayList;
import java.util.Collection;

public class Collection_01 {
public static void main(String[] args) {
	//创建集合对象
	Collection c=new ArrayList();
	//判断集合是否为空(个数是否为0)
	System.out.println(c.isEmpty());//true
	// 集合中是不能保存基本类型的,需要转换为对应包装类才可以
	// 这里会进行自动装箱为Integer类型,然后发生多态转型为Object类型 进行存储
	c.add(123);
	c.add(new Integer(1));
	c.add(new Integer(180));
	System.out.println("删除:"+c.remove(new Integer(180)));//删除:true
	c.add(new Collection_01());
	//判断集合的大小
	System.out.println(c.size());//3  分别是:123 , 1 ,  com.Collection_01@15db9742(对象地址)
	System.out.println(c.isEmpty());//false
	// 删除,会调用要删除元素的equals方法,但是Integer覆写了,所以可以把1删掉
	c.remove(1);
	
	A a = new A("张三");
	A a1 = new A("张三");
	c.add(a);// 所以使用集合保存自定义类型的时候,要注意,是否要覆写equals方法,定义怎么算相等
	
	c.remove(a1);
	//遍历
	//把集合转换为数组
	System.out.println("==================");
	Object [] arr=c.toArray();
	for(Object ele:arr){
		System.out.println(ele);
	}
	

}
}
class A{
	private String name;

	public A(String name) {
		super();
		this.name = name;
	}

	@Override
	public String toString() {
		return "A [name=" + name + "]";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override//覆写equals方法,规定,只要名字相同就相等
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		A other = (A) obj;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
}

1.5 迭代器

1.5.1 迭代器概念

在面向对象编程里，迭代器模式是一种设计模式，是一种最简单也最常见的设计模式。
它可以让用户透过特定的接口巡访容器中的每一个元素而不用了解底层的实现。

1.5.2 迭代器的使用

方法	描述
Boolean hasNext()	如果被迭代的集合有下一个元素，则返回true,没有就返回false
Object next()	获取下一个元素,并指向下一个元素
void remove()	删除集合里上一次next方法返回的元素(删除当前指向的元素)

三个方法的使用步骤 , 就是 1,2,3 按照这个顺序调用

    获取该集合的迭代器对象 : Iterator it = 集合对象.iterator();
  注意 : 迭代器一旦创建,集合中就不能添加和删除元素(长度不能更改了)
   如果添加或者删除了元素,那么迭代器必须重新生成
增强for循环就是为了让用iterator循环访问的方式简单,写起来更方便,当然功能不太全,比如删除,还是要用iterator来删除

例子:

public class Collection_02_Iterator {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Collection c1=new ArrayList();
		c1.add(1);
		c1.add("abc");
		// 创建迭代器
		Iterator it=c1.iterator();
		//遍历,判断下面是否有元素
		while(it.hasNext()){
			// 获取并指向下一个元素
			Object object=it.next();
			System.out.println(object);	
		}//迭代器里面元素有:1,abc 也就是集合c1里面的元素
		System.out.println("============");
		// 使用完之后,想再次使用,需要重新创建
		// 迭代器创建之后,不能添加和删除 , 必须重新生成迭代器
		c1.add(100);
		it=c1.iterator();
		while(it.hasNext()){
			// 获取并指向下一个元素
			Object object=it.next();
			System.out.println(object);	
			// 使用迭代器的时候,不能更改集合个数,所以删除数据的时候不能使用集合的删除,应该使用迭代器的删除
			 it.remove();
		}
		//遍历,判断下面是否有元素		
		System.out.println("======================");
		 it=c1.iterator();
		 //集合列表为空,size=0,所以it.hasNext()==false,输出的元素为空
		while(it.hasNext()){
			// 获取并指向下一个元素
			Object object=it.next();
			System.out.println(object);
		}
		System.out.println(c1.size());//0
	}

}

1.6 List

1.6.1 list特点

1 list是一个有序集合,即存入集合的顺序和取出集合的顺序是一样的

2 list集合允许添加的元素重复

1.6.2 list常用的方法

List不单单继承了Collection的方法，还增加了一些新的方法。

方法	描述
void add(int index, Object element)	将元素element插入到List的index处
boolean addAll(int index, Collection c)	将集合c所包含的所有元素都插入在List集合的index处
Object get(int index)	返回集合index处的元素
int indexOf(Object o)	返回对象o在List集合中出现的位置索引
int lastIndexOf(Object o)	返回对象o在List集合中最后一次出现的位置索引
Object remove(int index)	删除并返回index索引处的元素
Object set(int index, Object element)	将index索引处的元素替换成element对象，返回新元素
List subList(int fromIndex, int toIndex)	返回从索引fromIndex(包含)到索引toIndex(不包含)处所有集合元素组成的子集合

1.6.3 ArrayList

ArrayList : 底层是个Object数组 , 随机查询和更改效率高, 随机添加和删除效率低

import java.util.ArrayList;

public class Collection_04_List_02 {
public static void main(String[] args) {
	List list=new ArrayList();//创建对象
	// add(E e ) : 尾部添加
	list.add(1);//[1]
	list.add(2);//[1,2]
	list.add(3);//[1,2,3] 覆写了toString方法
	// add(int index , E e ) : 添加到指定位置
	list.add(2, 0);//[1, 2, 0, 3]
	// 更改指定位置上的元素值
	list.set(1, 0);//[1, 0, 0, 3]
	//	根据元素内容删除(必须新建一个对象,否则会被当成是下标)
	//ArrayList中存放对象,在判断包含或者删除元素时，通过equals比较是否为同一个对象，然后进行操作
	list.remove(new Integer(3));//[1, 0, 0]
//	根据索引删除
	list.remove(1);//[0, 0]
	//获取指定位置的数据
	System.out.println(list.get(1));//0
	
	System.out.println(list);
	System.out.println("传统遍历");
	//传统遍历
	for (int i = 0; i < list.size(); i++) {
		System.out.println(list.get(i));
	}
	System.out.println("foreach遍历");
	// foreach遍历
	for (Object object : list) {
		System.out.println(object);
	}
	System.out.println("迭代器遍历");
	// 迭代器遍历
	Iterator it = list.iterator();
	while (it.hasNext()) {
		System.out.println(it.next());
	}

	
}
}

Arraylist排序:Collections.sort(list)方法

public class Collection_05_SortList {
public static void main(String[] args) {
	List list = new ArrayList();
	list.add(4);
	list.add(1);
	list.add(2);
	list.add(14);
	list.add(6);
	System.out.println(list);//[4, 1, 2, 14, 6]
//	调用系统方法进行排序
	Collections.sort(list);
	System.out.println(list);//[1, 2, 4, 6, 14]
}
}

1.6.4 LinkList

LinkedList : 底层是一个双向链表,随机查询更改效率低,随机添加和删除效率高

【LinkedList新增方法】

方法	描述
void addFirst(Object e)	将指定元素插入该集合的开头
void addLast(Object e)	将指定元素插入该集合结尾
boolean offerFirst(Object e)	将指定元素插入该集合的开头,成功返回true
boolean offerLast(Object e)	将指定元素插入该集合结尾
boolean offer(Object e)	将指定元素插入该集合结尾
Object getFirst()	获取,但不删除集合第第一个元素
Object getLast()	获取,但不删除集合最后一个元素
Object peekFirst()	获取,但不删除该集合第一个元素,如果集合为空,则返回null
Object peekLast()	获取,但不删除该集合最后一个元素,如果集合为空,则返回null
Object pollFirst()	获取,并删除该集合第一个元素,如果集合为空,则返回null
Object pollLast()	获取,并删除该集合最后一个元素,如果集合为空,则返回null
Object removeFirst()	获取,并删除该集合的第一个元素
Object removeLast()	获取,并删除该集合的最后一个元素
Object pop()	pop出该集合的第一个元素
void push(Object e)	将一个元素push到集合

例子:

public class Collection_06_LinkedList_01 {
	public static void main(String[] args) {
	LinkedList list = new LinkedList();
	// add(E e ) : 尾部添加
			// add(int index , E e ) : 添加到指定位置
			// set(int index, E e ) : 更改指定位置上的元素值
			// remove(Object object) : 根据元素内容删除
			// remove(int index) : 根据索引删除
			// get(int index) : 获取指定位置的数据
			// 首部添加
			list.addFirst(1);
			// 首部添加
			list.push(11);
			// 首部添加 成功返回true
			list.offerFirst(111);
			System.out.println(list.offerFirst(111));//true
			// 尾部添加
			list.addLast(2);
			// 尾部添加 成功返回true
			list.offerLast(22);
			// 尾部添加 成功返回true
			System.out.println(list.offer(222));
			// 上面这几个方法 没啥区别,本质就是 linkLast 和 linkFirst
			list.add(1);
			list.add(2);
			list.add(3);
			list.add(0, 4);
			list.set(3, 33);
			System.out.println(list.get(2));//111
			// 这是根据索引删除
			list.remove(1);
			// 删除元素值为1
			list.remove(new Integer(1));
			System.out.println(list);//[4, 111, 33, 2, 22, 222, 1, 2, 3]
			System.out.println("迭代器遍历");
			// 迭代器遍历
			Iterator it = list.iterator();
			while (it.hasNext()) {
				System.out.println(it.next());
			}
		}
}