JAVA集合

最新推荐文章于 2024-06-23 15:08:50 发布

～狗子～

最新推荐文章于 2024-06-23 15:08:50 发布

阅读量653

点赞数 4

分类专栏： java

本文链接：https://blog.csdn.net/programmer_dog/article/details/114104650

版权

java 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

概述

集合只能存放对象。比如你存一个 int 型数据 1放入集合中，其实它是自动转换成 Integer类后存入的(装箱操作)，Java中每一种基本类型都有对应的引用类型。
集合存放的是多个对象的引用，对象本身还是放在堆内存中。
集合可以存放不同类型，不限数量的数据类型。定义集合变量时如果不指定数据类型，则默认数据类型为Object。

数组和集合的比较
针对Java中的数组定长，Java提出了集合框架，实现了一种变长存储数据的容器—集合【容积和当前元素个数】

数组不是面向对象的，存在明显的缺陷，集合弥补了数组的缺点，比数组更灵活更实用，而且不同的集合框架类可适用不同场合。如下：

数组能存放基本数据类型和对象，而集合类存放的都是对象的引用，而非对象本身
数组容量固定无法动态改变，集合类容量动态改变
数组无法判断其中实际存有多少元素，length只告诉了数组的容量，而集合的size()可以确切知道元素的个数
集合有多种实现方式和不同适用场合，不像数组仅采用顺序表方式
集合以类的形式存在，具有封装、继承、多态等类的特性，通过简单的方法和属性即可实现各种复杂操作，大大提高了软件的开发效率
集合框架中的接口
**

Collection接口

顶级接口，继承Iterable接口
无序、允许重复

常见方法：

size():int获取元素个数
contains(Object):boolean 判断集合中是否有指定对象使用的是equals方法进行判断，不是==
toArray():Object[] 将集合中的所有元素以数组方式进行返回
add(Object):boolean 向集合中添加元素
remove(Object):boolean 从集合中删除指定的元素使用的是equals方法进行判断，不是==
clear():void 删除集合中的所有元素，清空集合
isEmpty():boolean 判断元素个数是否为0，不判断null

迭代器

用于遍历集合中的所有元素

Collection接口继承于Iterable接口，所以所有的Collection接口的实现类都可以进行遍历访问

Iterator it=list.iterator();
while(it.hasNext()){ //判断是否还有没有遍历访问的元素
Object tmp=it.next(); //指针后移，同时获取一个元素

List接口

List接口是Collection接口的子接口

特点：有序、允许重复

注意：凡是使用下标参数的，要求下标必须在[0,list.size())

E get(int index);按照下标获取指定位置上的元素，index就是下标值，要求index的值不能超过[0,list.size())，否则IndexOutOfBoundsException
E set(int index, E element) 修改指定位置index上的元素为新元素element，并返回原始位置上的元素
修改操作
void add(int index, E element) 在指定位置index上添加新元素element
E remove(int index)删除指定下标index位置上的元素，并返回删除的元素
int indexOf(Object o) 从前向后查找o在集合中的第一个下标位置，如果查找不到则返回-1
int lastIndexOf(Object o);
default void sort(Comparator<? super E> c)
使用自定义的比较器对象对数据元素进行排序，按照升序进行排序

Set接口

Set接口是Collection接口的子接口

特点：无序、不允许重复[重复元素的添加会产生覆盖]

boolean add(E e);向集合中追加元素e对象，如果出现重复则后盖前

如何判断两个元素相等？

首先比较两个对象的hashcode值是否相等，如果hashcode值不相等则不会调用equals，认为两个对象不相等
如果hashcode值相等才调用equals进行比较，否则不相等

潜规则【不是语法】：SUN要求当两个对象的equals为true时，hashcode值应该相等

常见的List接口的实现类

ArrayList：数组实现，查询快，增删慢，轻量级；(线程不安全)
LinkedList：双向链表实现，增删快，查询慢 (线程不安全)
Vector：数组实现，重量级 (线程安全、使用少)

ArrayList实现类

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable

内部实现：

transient Object[] elementData;  用于存储数据，体现ArrayList采用的是数组的方式提供实现

构造器：

//new ArrayList(1000);
public ArrayList(int initialCapacity) {  //参数是初始化容积
      if (initialCapacity > 0) { 如果容积初始值大于0则创建对应的对象
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) { 如果容积值位0则创建一个空数组
            this.elementData = EMPTY_ELEMENTDATA;
        } else { 如果小于0则抛出一个运行时异常
            throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
        }
}
//new ArrayList();
 public ArrayList() {  没有初始化参数值，则自动创建一个0个长的空数组
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

add的方法实现：

/向存储数据的elementData添加新元素
public boolean add(E e) {
     ensureCapacityInternal(size + 1);  //确保内部容量,处理数组elementData的长度，确保可以存放数据，如果当前数组长度不足，则需要增加数组长度。参数的含义是满足条件的最小容积
     elementData[size++] = e;
     return true;   //如果添加过程中不出异常，则返回一定是true
}

ensureCapacityInternal方法：

private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
    
  private void ensureExplicitCapacity(int minCapacity) {
        modCount++;  //修改次数加1
        if (minCapacity - elementData.length > 0)  如果所需要的最小容积大于实际存储数据的数组长度，则需要进行扩容处理
            grow(minCapacity);
    }
    
    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;  获取实际数组的长度
        //符号>>表示二进制向右移位计算，>>1表示除以2,>>2表示除以4(2的平方).如果<<表示乘以2的多少次方
        int newCapacity = oldCapacity + (oldCapacity >> 1);  //新的容积值=旧有容器*1.5
        if (newCapacity - minCapacity < 0)  新容器如果小于所需要的最小容积，则新容积为最小容积值
            newCapacity = minCapacity;
            
        //int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
        if (newCapacity - MAX_ARRAY_SIZE > 0)   如果新容积值大于所允许的最大容积值
            newCapacity = hugeCapacity(minCapacity);  获取满足最小容积需求的合法的容积值
        //从elementData拷贝所有的数组元素，Arrays是工具类，提供了常见的针对数组的操作方法
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0)   如果最小容积值小于0则抛出错误，表示OOM内存溢出
            throw new OutOfMemoryError();
            //例如获取的最小容积值为Integer.MAX_VALUE-7
        return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

add方法用于向集合中添加元素，如果ArrayList中真正存放数据的数组长度不足，则新建一个数组，新数组的长度为原始长度1.5倍，并拷贝原始数组中的数据到新数组中，最后再追加新元素

Vector

Vector类定义：属于老版本提供的，从1.0，而ArrayList比较新，从1.2。属于线程安全的类，大部分方法上都有synchronized，一般用于要求线程安全的属性定义。

protected Object[] elementData;  // 采用也是数组的方式存储数据

构造器方法：

public Vector() {
	 this(10); //表示调用当前类的其它构造器，初始化容积为10，增长的步长值为0 }
	public Vector(int initialCapacity) {
		 this(initialCapacity, 0);
	}
	public Vector(int initialCapacity, int capacityIncrement) { //参数1是初始化容积，参数2是容积增长的步长值
		 super();
		 if (initialCapacity < 0)
			 throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
			 this.elementData = new Object[initialCapacity]；//按照初始化容积值构建对应的数组
			 this.capacityIncrement = capacityIncrement; }

add方法-新增元素的实现：

public synchronized boolean add(E e) {//线程安全的方法
	modCount++; //修改次数+1
	 ensureCapacityHelper(elementCount + 1); //处理容积
 	elementData[elementCount++] = e; //在数组中存储元素
	 return true;
	}
private void ensureCapacityHelper(int minCapacity) {
 // overflow-conscious code
	 if (minCapacity - elementData.length > 0) //需要储存的数据超出数组可以存放的数据格式，则需要进行增长
	 grow(minCapacity);
 }
private void grow(int minCapacity) {
	 int oldCapacity = elementData.length; //当前数组的长度，也就是可以存放的元素	个数
	 int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement :oldCapacity); //新长度为原始长度的2倍或者原始长度+步长值
	 if (newCapacity - minCapacity < 0) //如果新长度不满足最小长度要求，则新长度为最小要求的长度
		 newCapacity = minCapacity;
	 if (newCapacity - MAX_ARRAY_SIZE > 0) //如果新长度大于最大数组长度进行长度处理
		 newCapacity = hugeCapacity(minCapacity);
		 elementData = Arrays.copyOf(elementData, newCapacity); //将原始数组中的数据拷贝到新数组中,并替换原始数组
 }
private static int hugeCapacity(int minCapacity) { //和ArrayList处理一致
	 if (minCapacity < 0) //OOM 内存溢出
		 throw new OutOfMemoryError();
 	return (minCapacity > MAX_ARRAY_SIZE) ?
 	Integer.MAX_VALUE :
 	MAX_ARRAY_SIZE;
 }

remove方法–删除元素：

public boolean remove(Object o) {
	 return removeElement(o);
}
public synchronized boolean removeElement(Object obj) {
	 modCount++;
	 int i = indexOf(obj); //查找元素的索引值
	 if (i >= 0) {
		 removeElementAt(i); //按照索引删除指定元素
 	return true;
	 }
 return false;
 }
 public synchronized void removeElementAt(int index) {
		modCount++;
 //针对index索引值进行合法性验证
	 if (index >= elementCount) {
		 throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
	 } else if (index < 0) {
		 throw new ArrayIndexOutOfBoundsException(index);
	 }
 
	 int j = elementCount - index - 1; //获取需要移动的元素个数
	 if (j > 0) { //通过拷贝的方式将数据的后续移动元素向前移动一位
		 System.arraycopy(elementData, index + 1, elementData, index, j);
		 }
		 elementCount--; //元素个数-1
		 elementData[elementCount] = null; //将数组末尾的元素值赋null

LinkedList

类定义：

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>,Cloneable, java.io.Serializable
//Deque是队列接口，提供一个双端队列的访问方法实现

底层实现是双向链表

private static class Node<E> { //节点定义
	 E item; //具体存储的数据
	 Node<E> next; //向后的指针
	 Node<E> prev; //向前的指针
}

LinkedList

transient Node<E> first; //头指针,指向链表的第一个元素
transient Node<E> last； //尾指针,指向链表的最后一个元素

对应的构造器

public LinkedList() { //没有初始化容积
 }

LinkedList中的 add方法：
1、创建Node对象，其中包含需要添加的元素值
2、Node对象的next为null
3、prev指向last
4、last对象的next为新建对象Node
5、last指向新建的Node对象
List 总结：

在这里插入图片描述
修改同时并发迭代访问的问题
需求：一个线程使用Iterator迭代访问集合中的元素，另外一个线程修改集合中的元素。临界资源为集合

public class T4 {
 	public static void main(String[] args)throws Exception {
		 List list = new ArrayList();
 		for(int i=0;i<5;i++)
			 list.add(i);
		 new Thread(()->{
			 System.out.println(Thread.currentThread().getName()+",begin....");
			 Iterator it=list.iterator();
			 while(it.hasNext()) {
				 Object tmp=it.next();
				 System.out.println(tmp);
				 try {
 					Thread.sleep(50);
				 } catch (InterruptedException e) {
					 e.printStackTrace();
				 }
			 }
 		System.out.println(Thread.currentThread().getName()+",end....");
		 }).start();
		 Thread.sleep(100);
		 System.out.println(Thread.currentThread().getName()+",begin modify....");
 		list.remove(0);
 		System.out.println(Thread.currentThread().getName()+",end modify...."); 
 } }

对象的克隆与复制

对象赋值 Date now2=now；
两个变量now2和now中存放是同一个对象的地址，不管操作那个变量两个都受影响，因为now2和now是同一个对象。
如果希望两个变量相互不影响，则只能通过克隆实现。Java中的克隆可以分为深克隆和浅克隆。

如果需要支持克隆操作要求必须实现Cloneable接口，Object类中提供了clone()方法，这个方法是一个本地方法，是由虚拟机提供实现的

protected native Object clone() throws CloneNotSupportedException;

Cloneable接口属于标志性接口，没有具体的实现，具体实现实际上是Object类中提供的
1、自定义类上要求实现Cloneable接口
2、自定义类中要求实现clone方法，这个方法只需要调用父类的clone方法即可，一般不需要额外的处理。

浅克隆

public class Colone1 {
	public static void main(String[] args) throws Exception {
		stu s1 = new stu();
		s1.setId(12L);
		s1.setBirth(new Date());
		stu s2 = (stu)s1.clone();
		s2.getBirth().setYear(200);
		System.out.println(s1);
		System.out.println(s2);
	}
}

class stu implements Cloneable{
	private Long id;
	private Date birth;
	
	public Object clone() throws CloneNotSupportedException{
		return super.clone();
	}

	public Long getId() {
		return id;
	}

	public void setId(Long id) {
		this.id = id;
	}

	public Date getBirth() {
		return birth;
	}

	public void setBirth(Date birth) {
		this.birth = birth;
	}

	@Override
	public String toString() {
		return "stu [id=" + id + ", birth=" + birth + "]";
	}
}

深克隆(一般采用对象流实现。自定义类要求实现Serializable接口)

public class clone2 {
	public static void main(String[] args) {
		student11 ss1 = new student11();
		ss1.setId(20L);
		ss1.setBirth(new Date());
		student11 ss2 = (student11)ss1.deepClone();
		ss1.getBirth().setYear(330);
		System.out.println(ss1);
		System.out.println(ss2);
	}
}

class student11 implements Serializable{
	private Long id;
	private Date birth;
	
	public student11 deepClone() {
		student11  res= null;
			try {
				ByteArrayOutputStream baos  =new ByteArrayOutputStream();
				ObjectOutputStream oos = new ObjectOutputStream(baos);
				oos.writeObject(this);
				ObjectInputStream  ois = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()));
				res = (student11)ois.readObject();
				oos.close();
				ois.close();
			} catch (Exception e) {
				e.printStackTrace();
			}
		return res;
		
	}
	
	public Long getId() {
		return id;
	}
	public void setId(Long id) {
		this.id = id;
	}
	public Date getBirth() {
		return birth;
	}
	public void setBirth(Date birth) {
		this.birth = birth;
	}
	@Override
	public String toString() {
		return "student11 [id=" + id + ", birth=" + birth + "]";
	}
}

～狗子～

关注

4
点赞
踩
20

收藏

觉得还不错? 一键收藏
1
评论
JAVA集合

概述集合只能存放对象。比如你存一个 int 型数据 1放入集合中，其实它是自动转换成 Integer类后存入的(装箱操作)，Java中每一种基本类型都有对应的引用类型。集合存放的是多个对象的引用，对象本身还是放在堆内存中。集合可以存放不同类型，不限数量的数据类型。定义集合变量时如果不指定数据类型，则默认数据类型为Object。数组和集合的比较针对Java中的数组定长，Java提出了集合框架，实现了一种变长存储数据的容器—集合【容积和当前元素个数】数组不是面向对象的，存在明显的缺陷，集合弥补了
复制链接

扫一扫