列表（List）

线性表

1. List是一个接口

接口：没有字段的抽象类

• 类似于数组，但数组只能放统一类型的数据

• 而List可以在其中放对象，对象可以用于许多个不同类型的属性

  • 如Student的对象中可以包含name、age、hobby等等

• 直接new List()需要重写接口中的所有方法

  public class Test {
      public static void main(String[] args) {
          new List() {
              @Override
              public int size() {
                  return 0;
              }
  
              @Override
              public boolean isEmpty() {
                  return false;
              }
  
              @Override
              public boolean contains(Object o) {
                  return false;
              }
  
              @Override
              public Iterator iterator() {
                  return null;
              }
  
              @Override
              public Object[] toArray() {
                  return new Object[0];
              }
  
              @Override
              public boolean add(Object o) {
                  return false;
              }
  
              @Override
              public boolean remove(Object o) {
                  return false;
              }
  
              @Override
              public boolean addAll(Collection c) {
                  return false;
              }
  
              @Override
              public boolean addAll(int index, Collection c) {
                  return false;
              }
  
              @Override
              public void clear() {
  
              }
  
              @Override
              public boolean equals(Object o) {
                  return false;
              }
  
              @Override
              public int hashCode() {
                  return 0;
              }
  
              @Override
              public Object get(int index) {
                  return null;
              }
  
              @Override
              public Object set(int index, Object element) {
                  return null;
              }
  
              @Override
              public void add(int index, Object element) {
  
              }
  
              @Override
              public Object remove(int index) {
                  return null;
              }
  
              @Override
              public int indexOf(Object o) {
                  return 0;
              }
  
              @Override
              public int lastIndexOf(Object o) {
                  return 0;
              }
  
              @Override
              public ListIterator listIterator() {
                  return null;
              }
  
              @Override
              public ListIterator listIterator(int index) {
                  return null;
              }
  
              @Override
              public List subList(int fromIndex, int toIndex) {
                  return null;
              }
  
              @Override
              public boolean retainAll(Collection c) {
                  return false;
              }
  
              @Override
              public boolean removeAll(Collection c) {
                  return false;
              }
  
              @Override
              public boolean containsAll(Collection c) {
                  return false;
              }
  
              @Override
              public T[] toArray(Object[] a) {
                  return new T[0];
              }
          };
      }
  }
  

2. 通常使用ArrayList和LinkedList去实现List接口

• ArrayList通过数组实现，便于遍历查找
  • 追加元素，会新建一个把长度扩大一倍的数组，把原来的元素都拷贝新的数组中
• LinkedList通过链表实现，便于增删改

3. List不加泛型默认为Object类型的对象

public class Test01 {

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("!");
        for (Object s : list) {
            System.out.println(s);
        }
    }

}

• 但如果不规定泛型，当多个list出现，都是Object类型，难以区分，因此最好还是加上泛型约束

  public class Test01 {
  
      public static void main(String[] args) {
          List<String> list = new ArrayList();
          list.add("hello");
          list.add("world");
          list.add("!");
          for (String s : list) {
              System.out.println(s);
          }
      }
  
  }
  

4. List中都是引用对象，而不是在List中创建一个真实对象

• 8种基本数据类型不能创建对象，因此会用到对应的包装类

  //整型
  short ---> Short
  int ---> Integer
  long ---> Long
  //浮点型
  float ---> Float
  double ---> Double
  //字符型
  byte ---> Byte
  char ---> Character
  //布尔型
  boolean ---> Boolean
  

  • 包装类会进行自动装箱和拆箱

    //自动装箱
    Integer a = 10;//把10包装成Integer类型赋给Integer类型的a
    //自动拆箱
    int b = a;//把a拆包装后成为int类型赋值给int类型的b
    

    public class Test01 {
    
        public static void main(String[] args) {
            List<Integer> list = new ArrayList<>();
    
            list.add(10);
            list.add(100);
            list.add(1000);
    
            for (int num : list) {
                System.out.println(num);
            }
        }
    }
    

• 既然是引用对象需要满足三个条件

  • 自反——x.equals(x) == true
  • 对称性——x.equals(y) == y.equals(x)
  • 传递性——x.equals(y),y.equals(z),则x.equals(z)

public class Main {
    public static void main(String[] args) {
        List<Student> list = new ArrayList();
        list.add(new Student("小明",2345));
        list.add(new Student("小红",2347));


        Student man = new Student("小明", 2345);

        //因为不是一个对象,所有直接打印会出false，需要重写equals方法
        System.out.println(list.contains(man));//true
    }
}

class Student {
    String name;
    int age;

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

    @Override
    public boolean equals(Object obj) {
        boolean nameTF = false;
        boolean ageTF = false;

        if (obj instanceof Student) {
            Student stu = (Student) obj;
            if (this.name == null && stu.name == null) {
                nameTF =  true;
            } else if (this.name != null) {
                nameTF =  this.name.equals(stu.name);
            } else {
                nameTF =  false;
            }

            if (this.age == 0 && stu.age == 0) {
                ageTF =  true;
            } else if (this.age != 0) {
                ageTF =  (this.age ==stu.age);
            } else {
                ageTF =  false;
            }
        }

        return nameTF && ageTF;

    }
}

• 在java9中还提供创建不可改变的List创建方式

  List<String> list = List.of("哈哈","嘿嘿");
  
  //无法改变
  list.set(1, "呜呜"); // Fails
  //不支持null
  List.of("haha", "嘿嘿", null); // 异常：NullPointerException
  

列表（List）

原文：https://www.cnblogs.com/Sheltonz/p/14092010.html