列表（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中创建一个真实对象

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

4.2 引用对象

这里的2个"world"显然不是同一个对象，但是在结果中还是删除了world

public class Test01 {

    public static void main(String[] args) {
        List<String> list = new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("!");
        list.remove(new String("world"));

        for (String s : list) {
            System.out.println(s);
        }
    }
}
/*
    hello
    !
*/

因此可以判断不是比较地址 == ，因为2个"world"不是同一个对象
而是使用了 equals() 方法进行比较数值
而在String里实现了对equals的重写，所以会删除"world"

那么不使用提供的系统类，如String、Integer等，而是使用自定义的类，如Student、Person等，该如何去实现同样的操作呢？

判断两个对象的数值是否相等需要满足三个条件

自反——x.equals(x) == true
对称性——x.equals(y) == y.equals(x)

传递性——x.equals(y),y.equals(z),则x.equals(z)

//把自定义类作为泛型
public class Test03 {
    public static void main(String[] args) {
        List<Player> list = new ArrayList();
        list.add(new Player("小明",15));
        list.add(new Player("小红",14));
        list.add(new Player("小刘",18));
        list.add(new Player("小王",20));

        //删除不了，因为不是同一个对象，需要重写equals比较方法
        Player man = new Player("小明", 15);
        list.remove(man);
        //直接打印为false，重写equals后为true
        System.out.println(list.contains(man));
    }
}

class Player{
    String name;
    int age;

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

    @Override
    public String toString() {
        String result = String.format("%d岁的%s",age ,name);
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        boolean nameTF = false;
        boolean ageTF = false;
        //把obj类型强转为Player类型，从而可以拥有name和age属性
        Player player = (Player) obj;

        //如果两个player的name和age都相等则视为同一个对象
        if (player.name==null) {
            nameTF = false;
        }else if (this.name.equals(player.name)) {
            nameTF = true;
        }else {
            nameTF = false;
        }

        if (player.age<=0 || player.age>120) {
            ageTF = false;
        } else if (this.age == player.age) {
            ageTF = true;
        }else {
            ageTF = false;
        }

        return nameTF && ageTF;
    }
}

5.创建不可改变的List

通常我们创建一个含有元素的List需要有，先创建List，再add元素进去

List<String> list = new ArrayList();
String[] s = "哈哈，嘿嘿，吼吼，呵呵".split("，");
for (String temp : s) {
    list.add(temp);
}

而在java9中提供的List.of方法创建List，但这个list是不可改变的

List<String> list = List.of("哈哈","嘿嘿");

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

posted @ 2020-12-06 09:58 球球z 阅读(438) 评论(0) 收藏举报

刷新页面返回顶部

球球z