Java集合-List接口

Collection接口：单列集合，用来存储一个一个的对象
*      子接口List：存储有序的、可重复的数据    “动态”数组
*              ArrayList：作为List接口的主要实现类，线程不安全的，效率高；底层使用Object[]存储
*              LinkedList：对于频繁地插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
*              Vector：古老的List实现类；线程安全的，效率较低；底层使用Object[]存储
* List(动态数组)

ArrayList、LinkedList、Vector的异同？
 * 同：三个类都是实现了List接口，存储数据的特点相同：存储有序的、可重复的数据
 * 异：
 *     ArrayList：作为List接口的主要实现类，线程不安全的，效率高；底层使用Object[]存储
 *     LinkedList：对于频繁地插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
 *     Vector：古老的List实现类；线程安全的，效率较低；底层使用Object[]存储
 


 * List接口中常用方法
 * 加索引
 *void add(int index, Object obj):在index位置插入元素obj
 *boolean addAll(int index, Collection c):在index位置开始，将集合c中的所有元素添加到当前集合
 *get(int index):获取指定index位置的元素
 *int indexOf(Object o):返回o在集合中首次出现的位置
 * int lastIndexOf(Object o):返回o在集合中最后出现的位置
 *Object remove(int index):移除指定index位置的元素，并返回此元素
 *Object set(int index, Object obj):设置指定index位置的元素为obj
 * List subList(int fromIndex,int toIndex):返回从fromIndex到toIndex位置的子集和(左闭右开)
 *
 *
 *
 * 常用方法：
 * 增：add(Object obj)
 * 删：remove(int index)/remove(Object obj)
 * 改：set(int index, Object obj)
 * 查：get(int index)
 * 插： add(int index, Object obj)
 * 长度：size()
 * 遍历：①Iterator迭代器
 *      ②foreach（增强for循环）
 *      ③普通for循环

import org.junit.Test;

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

/**
 *  Collection接口：单列集合，用来存储一个一个的对象
 *      子接口List：存储有序的、可重复的数据    “动态”数组
 *              ArrayList：作为List接口的主要实现类，线程不安全的，效率高；底层使用Object[]存储
 *              LinkedList：对于频繁地插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
 *              Vector：古老的List实现类；线程安全的，效率较低；底层使用Object[]存储
 * List(动态数组)
 *
 *
 * @author orz
 */
public class ListTest {

    /**
     * ArrayList、LinkedList、Vector的异同？
     * 同：三个类都是实现了List接口，存储数据的特点相同：存储有序的、可重复的数据
     * 异：
     *     ArrayList：作为List接口的主要实现类，线程不安全的，效率高；底层使用Object[]存储
     *     LinkedList：对于频繁地插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
     *     Vector：古老的List实现类；线程安全的，效率较低；底层使用Object[]存储
     */


    /**
     * List接口中常用方法
     * 加索引
     *void add(int index, Object obj):在index位置插入元素obj
     *boolean addAll(int index, Collection c):在index位置开始，将集合c中的所有元素添加到当前集合
     *get(int index):获取指定index位置的元素
     *int indexOf(Object o):返回o在集合中首次出现的位置
     * int lastIndexOf(Object o):返回o在集合中最后出现的位置
     *Object remove(int index):移除指定index位置的元素，并返回此元素
     *Object set(int index, Object obj):设置指定index位置的元素为obj
     * List subList(int fromIndex,int toIndex):返回从fromIndex到toIndex位置的子集和(左闭右开)
     *
     *
     *
     * 常用方法：
     * 增：add(Object obj)
     * 删：remove(int index)/remove(Object obj)
     * 改：set(int index, Object obj)
     * 查：get(int index)
     * 插： add(int index, Object obj)
     * 长度：size()
     * 遍历：①Iterator迭代器
     *      ②foreach（增强for循环）
     *      ③普通for循环
     *
     */
    @Test
    public void test1()
    {

        ArrayList list = new ArrayList();
        list.add("hello");
        list.add("AA");
        list.add(123);
        list.add(new Person(21,"tom"));

        System.out.println(list);

        list.add(1,"BB");
        System.out.println(list);

        System.out.println("**********");
        ArrayList list1 = new ArrayList();
        list1.add("Jack");
        list1.add("Cat");
        System.out.println(list1);
        list1.addAll(1,list);
        System.out.println(list1);


        System.out.println("***********");
        System.out.println(list);
        System.out.println(list.get(1));

        System.out.println("*************");
        System.out.println(list);
        System.out.println(list.indexOf("AA"));

        System.out.println("*************");
        list.add("AA");
        System.out.println(list);
        System.out.println(list.lastIndexOf("AA"));


        System.out.println("**********");
        System.out.println(list);
        Object remove = list.remove(1);
        System.out.println(remove);
        System.out.println(list);

        System.out.println("**********");
        System.out.println(list);
        Object man = list.set(1, "Man");
        System.out.println(list);

        System.out.println("******");
        List list2 = list.subList(1, 3);
        System.out.println(list);
        System.out.println(list2);


    }


    /**
     * List遍历
     */
    @Test
    public void test2()
    {
        ArrayList list = new ArrayList();
        list.add("hello");
        list.add("AA");
        list.add(123);
        list.add(new Person(21,"tom"));



        // ①Iterator迭代器
        Iterator iterator = list.iterator();
        while (iterator.hasNext())
        {
            System.out.println(iterator.next());
        }

        // ②foreach（增强for循环）
        System.out.println();
        for (Object obj:list)
        {
            System.out.println(obj);
        }
        // ③普通for循环
        System.out.println();
        for (int i = 0; i <list.size() ; i++) {
            System.out.println(list.get(i));
        }

    }

    /**
     * 面试题
     */

    @Test
    public void test3()
    {
        List list=new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list);
        updateList(list);
        System.out.println(list);
        updateList2(list);
        System.out.println(list);

    }
    private static void updateList(List list)
    {
        list.remove(2);
    }
    private static void updateList2(List list)
    {
        list.remove((Integer) 2);
    }

}

 

import java.util.Objects;

public class Person implements Comparable{

    private int age;
    private String name;

    public Person() {
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(age, name);
    }

    //按照姓名从小到大排序,年龄从小到大

   @Override
   public int compareTo(Object o)
   {
       if(o instanceof Person)
       {
           Person person=(Person)o;
          // return this.name.compareTo(person.name);
           int compare=this.name.compareTo(person.name);
           if(compare!=0)
           {
               return compare;
           }
           else
           {
               return Integer.compare(this.age,person.age);
           }

       }
       else
       {
           throw new RuntimeException("输入的类型不匹配");
       }
   }
}