ht-2 arrayList特性

一、arrayList对象创建

当调用无参构造方法来构造一个ArrayList对象时，它会在内部分配一个初始大小为10的一个Object类型数组， 当添加的数据容量超过数组大小的时候，会产生一个新的数组，新的数组大小为原来数组大小的1.5倍+1， 接着把原数组中的数据拷贝到新的素组中，并让原来的引用变量指向这个新数组，参见ArrayList源代码 ；

二、arrayList相关方法：

添加元素：add(E e)   

指定位置添加：add(int index, E element) 

获取指定位置的元素：public E get(int index)  

设置指定位置的元素：  public E set(int index, E element)   返回该位置原来存储的元素

删除指定位置的元素 public E remove(int index)  返回被删除的元素

删除指定元素： public boolean remove(Object o)   如果指定元素在集合中存在，返回true 否则返回false

是否包指定元素：public boolean contains(Object o)  @return <tt>true</tt> if this list contains the specified element

 数组大小： public int size()

list转数组： public Object[] toArray() {   return Arrays.copyOf(elementData, size); }

 查找元素在list中的索引值： int indexOf(Object o); 返回此列表中首次出现的指定元素的索引，或如果此列表不包含该指定元素，则返回-1

三、arraylist遍历：

1. for循环

 2.foreach

3.迭代器遍历 list实现了 Collection接口，collection接口实现了 Iterable 接口，因此list 可以使用Iterable接口的iterator()方法获得一个迭代器对象

package com.iotek.list;

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

public class ArrayListDemo {

    public static void main(String[] args) {
        List<String> nlist = new ArrayList<String>(); // 接口的引用变量指向子类对象
        nlist.add("null"); // 向容器中添加元素
        nlist.add("lucy");
        nlist.add("jack");
        nlist.add("tom");
        nlist.add("john");
        nlist.add("jack");
        // foreach遍历
        for (String s : nlist) {
            System.out.print(s + " ");
        }

        nlist.add(1, "jay"); // 将元素“jay”插入到下标1的位置处
        nlist.set(0, "chengang"); // 将下标0位置处的元素替换成“chengang”

        // 使用迭代器遍历
        System.out.println();
        Iterator<String> it = nlist.iterator();
        while (it.hasNext()) { // it.hashNext()判断下一个元素是否为空
            String name = it.next();
            System.out.print(name + " ");
        }

        System.out.println();
        System.out.println("获取下标：" + nlist.indexOf("lucy")); // 输出元素“lucy”的索引值(在容器数组中的下标值)
        System.out.println("删除元素：" + nlist.remove("jack"));// 删除，如果列表中有这个元素，返回true
        System.out.println("删除指定位置元素：" + nlist.remove(0)); // 返回被删除位置的元素
        System.out.println("是否包含某个元素：" + nlist.contains("chengang")); // 已删除该元素，故返回false
        nlist.clear(); // 清空容器
        System.out.println("判断容器是否为空：" + nlist.isEmpty());

    }

}

四 、indexof(Object o) 以及Contains(Object o)原理：

indexof(Object o) 方法本质上是调用对象o的equals()方法去list里查找，找到了就返回这个元素的下标，没有找到则返回-1； 

而equals 本质比较的是两个对象的引用地址，而非对象的内容：

   public boolean equals(Object obj) {
    return (this == obj);
    }

  /**
     * Returns the index of the first occurrence of the specified element
     * in this list, or -1 if this list does not contain the element.
     * More formally, returns the lowest index <tt>i</tt> such that
     * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
     * or -1 if there is no such index.
     */
    public int indexOf(Object o) {
    if (o == null) {
        for (int i = 0; i < size; i++)
        if (elementData[i]==null)
            return i;
    } else {
        for (int i = 0; i < size; i++)
        if (o.equals(elementData[i]))
            return i;
    }
    return -1;
    }

contains方法源码如下，本质上是调用indexof来判断是否包含指定对象的，如果用contains方法判断list里面是否包含自定义的对象，那么也需要重写该对象的类的equals方法

  /**
     * Returns <tt>true</tt> if this list contains the specified element.
     * More formally, returns <tt>true</tt> if and only if this list contains
     * at least one element <tt>e</tt> such that
     * <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>.
     *
     * @param o element whose presence in this list is to be tested
     * @return <tt>true</tt> if this list contains the specified element
     */
    public boolean contains(Object o) {
    return indexOf(o) >= 0;
    }

测试示例，不重写对象的equals方法时：

package com.iotek.list;

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

public class ArrayListDemo2_1 {

    /**
     * 用ArrayList容器存放对象数据
     * 
     * @param args
     */
    public static void main(String[] args) {
        List<Student> stuList = new ArrayList<Student>(); // 通过泛型限定数组元素的数据类型为Student
        Student stu1 = new Student("zhangsan", 10);
        Student stu2 = new Student("lisi", 20);
        Student stu3 = new Student("jack", 30);
        Student stu4 = new Student("mandy", 10);
        Student stu5 = new Student("mary", 20); // 创建5个Student对象
        stuList.add(stu1);
        stuList.add(stu2);
        stuList.add(stu3);
        stuList.add(stu4);
        stuList.add(stu5); // 将5个Student对象添加到容器中
        Student stu6 = new Student("mary", 20);

        // 如果使用默认的equals方法，由于indexOf(Object
        // o)方法的实现原理，stu6还未添加到容器中，因此找不到stu6的地址，返回-1
        System.out.println("stu6下标:" + stuList.indexOf(stu6));
        System.out.println("判断容器中是否包含stu6：" + stuList.contains(stu6));
        System.out.println("删除stu6结果："+stuList.remove(stu6)); // 删除stu6,不含stu6，返回false
        System.out.println("stu5下标(list中包含stu5,则返回下标值，否则返回-1)："+stuList.indexOf(stu5)); 
        System.out.println("容器中剩余元素个数为：" + stuList.size());
    }

}

class Student {
    private String name;
    private int age;

    public Student(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;
    }

}

结果如下：

重写对象的equals方法后：

package com.iotek.list;

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

public class ArrayListDemo2_2 {

    /**
     * 用ArrayList容器存放对象数据
     * 
     * @param args
     */
    public static void main(String[] args) {
        List<Student1> stuList = new ArrayList<Student1>(); // 通过泛型限定数组元素的数据类型为Student
        Student1 stu1 = new Student1("zhangsan", 10);
        Student1 stu2 = new Student1("lisi", 20);
        Student1 stu3 = new Student1("jack", 30);
        Student1 stu4 = new Student1("mandy", 10);
        Student1 stu5 = new Student1("mary", 20);
        stuList.add(stu1);
        stuList.add(stu2);
        stuList.add(stu3);
        stuList.add(stu4);
        stuList.add(stu5);
        Student1 stu6 = new Student1("mary", 20);//重复元素
        System.out.println("stu6下标:" + stuList.indexOf(stu6));
        System.out.println("判断容器中是否包含stu6：" + stuList.contains(stu6));
        System.out.println("删除stu6结果：" + stuList.remove(stu6)); // 删除stu6,不含stu6，返回false,如果包含，返回该元素
        System.out.println("stu5下标：" + stuList.indexOf(stu5)); // 删除stu6后再查看,返回-1
        System.out.println("容器中剩余元素个数为：" + stuList.size());

    }

}

class Student1 {
    private String name;
    private int age;

    public Student1(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true; // 如果2个指针指向同一对象，返回true
        if (obj == null)
            return false;
        if (getClass() != obj.getClass()) // 如果2个类型不一样，返回false
            return false;
        Student1 other = (Student1) obj; // 接下来将obj转换成Student对象
        if (age != other.age) // 如果年龄或者姓名有一个不相等，返回false，都相等，返回true
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

    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;
    }

}

结果如下：

 对自定义的类，需要比较该类的两个对象是否相等时，需要比较这两个对象的属性是否相等,(而不是通过比较这两个对象的引用变量，因为2个对象的引用变量的地址永远不相同，除非这两个引用变量指向了同一个对象)， 那么此时，需要重写equals方法，默认的Object类中的equals方法比较的是2个对象的地址