集合丶迭代器

1 数组封装

数组操作,相对还是比较复杂的,也不能做添加和删除操作,当需要添加和删除的时候需要新建数组,复制数组,或者元素移位,比较麻烦所以 我们对这些添加和删除操作进行封装

用法

package day_1;

public class Array {
    /**
     * 封装数组
     * 
     */
    private Object[] elements;
//    数组中已经有的元素个数
    private int size = 0;
    
    public Array(){
//        数组初始化  数组长度为10
        elements = new Object[10];
    }
    /**
     * 获取元素个数
     */
    public int size(){
        return size;
    }
    public Object get(int index){
        if(index>=size){
            throw new ArrayIndexOutOfBoundsException(index);
            
        }
        return elements[index];
    }
    /**
     * 更改      
     */
    public void set(int index, Object element) {
        // 如果index >= size 说明 不存在
        if (index >= size) {
            throw new ArrayIndexOutOfBoundsException(index);
        }
        elements[index] = element;
        }
    /**
     * 向数组中添加元素
     */
    public void add(Object element){
        if(size==elements.length){
//            数组满了就扩容，复制数组 在放进去
//            扩容为原来的二倍
            Object[] newArr = new Object[size<<1];
//            数组复制
            System.arraycopy(elements, 0, newArr, 0, size);
//            赋值
            elements = newArr;
            
        }
        elements[size] = element;
        size++;
    }
    /**
     * 删除指定元素
     */
    public void remove(int index){
//        如果index>=size 说明不存在
        if(index>=size){
            throw new ArrayIndexOutOfBoundsException(index);
        }
//        移位
        for(int i = index;i<size-1;i++){
            elements[index] = elements[index + 1];
        }
//        最后一位赋值为null
        elements[size-1] = null;
        size--;
    }
}

测试

2集合

继承体系

 

迭代器

 

 

package day_1;

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

/**
 * contains(Object o) : 判断是否包含某个元素
 * 
 * remove(Object o ) : 删除指定元素
 * 
 * 这两个方法,底层都会去调用equals方法进行比较
 * 
 */
public class Collection_3 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        Integer i1 = new Integer(1235);
        Integer i2 = new Integer(1235);
        c.add(i1);
        // true
        System.out.println(c.contains(i1));
        // true 因为 Integer 覆写了equals方法 比较的值
        System.out.println(c.contains(i2));
        
        // 当我们保存的自定义类对象的时候,需要使用contains和remove的时候要注意覆写equals方法
         c = new ArrayList();
         Manager m1 = new Manager(1, "ABC");
         Manager m2 = new Manager(1, "ABC");
         c.add(m1);
         System.out.println(c.contains(m1));
         System.out.println(c.contains(m2));
         System.out.println(c);
    }
}

class Manager{
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj instanceof Manager) {
            Manager m1 = (Manager) obj;
            if (m1.no == this.no && this.name.equals(m1.name)) {
                return true;
            }
        }
        return false;
    }
    int no;
    String name;
    public Manager(int no, String name) {
        super();
        this.no = no;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Manager [no=" + no + ", name=" + name + "]";
    }
    
}

forEach

List