1、数据结构

      1.1栈 ：先进后出，进去abc出来c先出

      1.2队列：先进先出，a先进然后bc，出来a先出

      1.3数组：查询快，增删慢

      1.4链表：查询慢，增删快

2、List的三个儿子

      2.1 ArrayList

         ●底层数据结构是数组，特点是增删慢，查询快，线程不安全，效率高。

      ●在不需要线程安全时，查询多的情况下使用

●案例：

        A:ArrayList存储字符串并遍历。

           方式1

import java.util.ArrayList;

import java.util.Iterator;

public class ArrayListTest1 {

    public static void main(String[] args) {

        ArrayList<String> al=new ArrayList<String>();

        al.add("道");

        al.add("法");

        al.add("自");

        al.add("然");

        Iterator<String> it=al.iterator();

        while (it.hasNext()) {

            String s=it.next();

            System.out.println(s);

        }

        

    }

}

方式2：使用增强for循环

import java.util.ArrayList;

public class ArrayListTest1 {

    public static void main(String[] args) {

        ArrayList<String> al=new ArrayList<String>();

        al.add("道");

        al.add("法");

        al.add("自");

        al.add("然");

        for (String s : al) {

            System.out.println(s);

        }

    }

}

         B:ArrayList存储自定义对象并遍历。

           方式1：

import java.util.ArrayList;

import java.util.Iterator;

public class ArrayListTest1 {

    public static void main(String[] args) {

        ArrayList<Person> al = new ArrayList<Person>();

        Person p1 = new Person("人", 15);

        Person p2 = new Person("法", 17);

        Person p3 = new Person("地", 19);

        al.add(p1);

        al.add(p2);

        al.add(p3);

        Iterator<Person> it = al.iterator();

        while (it.hasNext()) {

            Person p = it.next();

            System.out.println(p.getName() + "---" + p.getAge());

        }

    }

}

方式2：使用增强for循环

import java.util.ArrayList;

public class ArrayListTest1 {

    public static void main(String[] args) {

        ArrayList<Person> al = new ArrayList<Person>();

        Person p1 = new Person("人", 15);

        Person p2 = new Person("法", 17);

        Person p3 = new Person("地", 19);

        al.add(p1);

        al.add(p2);

        al.add(p3);

        for (Person p : al) {

            System.out.println(p.getName() + "---" + p.getAge());

        }

    }

}

         C:去除重复值

           a:字符串

           方式1：（方式2在自定义对象）

import java.util.ArrayList;

public class GetOnly {

    public static void main(String[] args) {

        ArrayList<String> al=new ArrayList<String>();

        al.add("道");

        al.add("法");

        al.add("自");

        al.add("然");

        al.add("法");

        al.add("法");

        al.add("法");

        al.add("自");

        ArrayList<String> al1=new ArrayList<String>();

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

            while (!al1.contains(al.get(i))) {

                al1.add(al.get(i));

            }

        }

        for (String s : al1) {

            System.out.println(s);

        }

        

    }

}

b:自定义对象

方式2：

import java.util.ArrayList;

public class GetOnly1 {

    public static void main(String[] args) {

        ArrayList<Person> al = new ArrayList<Person>();

        Person p1 = new Person("人", 15);

        Person p2 = new Person("法", 16);

        Person p3 = new Person("道", 17);

        Person p4 = new Person("法", 16);

        Person p5 = new Person("法", 16);

        Person p6 = new Person("道", 18);

        al.add(p1);

        al.add(p2);

        al.add(p3);

        al.add(p4);

        al.add(p5);

        al.add(p6);

        // 选择排序方法

        for (int i = 0; i < al.size() - 1; i++) {

            for (int j = i + 1; j < al.size(); j++) {

                Person p = al.get(i);

                Person p11 = al.get(j);

                if (p.getName().equals(p11.getName())

                        && p.getAge() == p11.getAge()) {

                    al.remove(j);

                    // 因为每次删除一个元素，索引会往前移位，

                    // 所以j--，让移到前一位的元素得以跟其比较

                    j--;

                }

            }

        }

        for (Person p : al) {

            System.out.println(p.getName() + "---" + p.getAge());

        }

    }

}

总结的不错啊