Java集合框架(未完)

Collection

方法

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

public class A
{
    public static void main(String[] args)
    {
        Collection collection = new ArrayList();
        Collection collection1 = new ArrayList();
        collection.add("小张");
        collection.add(new Date());
        collection.add(12);
        collection1.add("小李");
        collection1.add("小王");
        collection.addAll(collection1);
        System.out.println(collection.isEmpty());
        System.out.println(collection.contains(12));
        System.out.println(collection.containsAll(collection1));

    }
}

迭代器
利用迭代器遍历

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

public class B
{
    public static void main(String[] args)
    {
        Collection collection = new ArrayList();
        collection.add("a");
        collection.add("b");
        collection.add("c");
        Iterator iterator = collection.iterator();
        /**
         * 利用迭代器遍历集合元素方式
         * *
         */
        //1.方式一

         for (int i = 0; i < collection.size(); i++)

         {

            System.out.println(iterator.next());

         }
        //2.方式二
        while(iterator.hasNext())
        {
            System.out.println(iterator.next());
        }
        //3.
         for(Object o:collection)
            System.out.println(o);
    }
}

ArrayList和HashSet

Collection(存放一个一个的值)

• List(存放有序，可重复的数)
  ArrayList(数组)
  LinkedList(链表)
• Set(存放无序，不可重复的数)

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

public class C
{
    public static void main(String[] args)
    {
        Collection arrayList = new ArrayList();
        Collection hashset = new HashSet();
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("a");
        System.out.println("arraylist中的元素为:");
        for(Object o : arrayList)
        {
            System.out.println(o);
        }
        hashset.add("a");
        hashset.add("b");
        hashset.add("a");
        System.out.println("hashset中的元素为:");
        for(Object o : hashset)
        {
            System.out.println(o);
        }
    }
}

结果:

arraylist中的元素为:
a
b
a
hashset中的元素为:
a
b

ArrayList(数组)和LinkList(链表)

ArrayList

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JIbp8KyD-1597489135835)(en-resource://database/540:0)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-f3OUrgUD-1597489135837)(en-resource://database/538:0)]

import java.util.ArrayList;

public class A
{
    public static void main(String[] args)
    {
        //构造一个初始容量为十的空列表。
        ArrayList arrayList = new ArrayList();
    }
}

源代码

public ArrayList() {
	this(10);
    }

(initialCapacity传入10)

 public ArrayList(int initialCapacity) {
	super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
	this.elementData = new Object[initialCapacity];//存入数组
    }

add方法:

import java.util.ArrayList;

public class A
{
    public static void main(String[] args)
    {
        //构造一个初始容量为十的空列表。
        ArrayList arrayList = new ArrayList();
        arrayList.add("a");
    }
}

源代码

public boolean add(E e) {
	ensureCapacity(size + 1);  // Increments modCount!!      //扩容操作
	elementData[size++] = e;                                        //加入元素
	return true;
    }

扩容方法

import java.util.ArrayList;

public class A
{
    public static void main(String[] args)
    {
        //构造一个初始容量为十的空列表。
        ArrayList arrayList = new ArrayList(2);
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("c");
    }
}

此时初始容量小于当前长度

 public boolean add(E e) {
	ensureCapacity(size + 1);  // Increments modCount!!
	elementData[size++] = e;
	return true;
    }

ensureCapacity();为扩容方法

 public void ensureCapacity(int minCapacity) {     
	modCount++;
	int oldCapacity = elementData.length;	//获取当前数组空间，即为2
	if (minCapacity > oldCapacity) {//判断数组是否需要扩容
	    Object oldData[] = elementData;
	    int newCapacity = (oldCapacity * 3)/2 + 1;//将数组扩容到原来的容量*3/2+1倍
    	    if (newCapacity < minCapacity)//判断新容量是否小于当前长度
		newCapacity = minCapacity;//不满足需要则将当前长度作为新容量
            // minCapacity is usually close to size, so this is a win:
            elementData = Arrays.copyOf(elementData, newCapacity);//数组拷贝
	}
    }