ArrayList集合

ArrayList

Collection[接口]:
        List[接口]: 元素有序，可以发生重复，有索引的概念
            ArrayList[具体的子类]: 底层数据结构是数组，查询快，增删慢，线程不安全，效率高。

        Set[接口]: 元素无序且唯一，没有索引

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

public class ArrayListDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList list1 = new ArrayList();

        //创建元素对象
        //将元素添加到集合中
        list1.add("hello");
        list1.add("world");
        list1.add("java");
        list1.add("hadoop");
        list1.add("hello");
        list1.add("world");

        //遍历集合
        //1. 转数组遍历
        Object[] objects = list1.toArray();
        for(int i=0;i<objects.length;i++){
            System.out.println(objects[i]);
        }
        System.out.println("========================");

        //2. 使用迭代器的方式遍历
        Iterator iterator = list1.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("========================");

        //3. 使用size()和get(i) 只有List集合才拥有的遍历方式
        for(int i=0;i<list1.size();i++){
            System.out.println(list1.get(i));
        }

    }
}

Test1

import java.util.ArrayList;

/*
    ArrayList
        去除集合中字符串的重复值(字符串的内容相同)

 */
public class ArrayListTest1 {
    public static void main(String[] args) {
        ArrayList list1 = new ArrayList();

        //创建元素对象
        //将元素添加到集合中
        list1.add("hello");
        list1.add("world");
        list1.add("java");
        list1.add("hadoop");
        list1.add("hello");
        list1.add("world");
        System.out.println("list1: " + list1);
        System.out.println("-----------------------------");

        //创建一个新的集合
        ArrayList list2 = new ArrayList();

        for (int i = 0; i < list1.size(); i++) {
            String str = (String) list1.get(i);
            if (!list2.contains(str)) {
                list2.add(str);
            }
        }

        System.out.println("list2: " + list2);
    }
}

Test2

import java.util.ArrayList;

/*
    去除集合中自定义对象的重复值(对象的成员变量值都相同)
    我们按照实现去重字符串的逻辑去重自定义对象，发现自定义对象并没有去重
    我们要去看contains的源码，底层判断元素是否存在新集合的逻辑是：
    挨个使用待插入的元素与新集合中的元素使用equals方法比较，我们元素Student类中并没有重写equals方法
    所以使用的是父类Object中的equals方法，而父类Object中的equals方法比较的是地址值
    又因为每一个学生都是new出来的，所以地址值都不一样，比较的结果永远为false
    要想比较内容值，需要元素类型重写equals方法，自动生成即可


 */
public class ArrayListTest2 {
    public static void main(String[] args) {
        ArrayList list1 = new ArrayList();

        Student s1 = new Student("李刚", 15);
        Student s2 = new Student("钱志强", 16);
        Student s3 = new Student("江川", 30);
        Student s4 = new Student("李刚", 15);
        Student s5 = new Student("祝帅", 15);

        list1.add(s1);
        list1.add(s2);
        list1.add(s3);
        list1.add(s4);
        list1.add(s5);
        System.out.println("list1: " + list1);

        System.out.println("=================================");
        ArrayList list2 = new ArrayList();

        for(int i=0;i<list1.size();i++){
            Student s = (Student) list1.get(i);

            /*
                //Student s1 = new Student("李刚", 15);
                public boolean contains(Object o) {
                    return indexOf(o) >= 0;
                }

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

            if(!list2.contains(s)){
                list2.add(s);
            }
        }
        System.out.println("list2: " + list2);

    }
}