EchoDemo's Blogs

Java中的List

发表于 | 分类于 | | 阅读次数 ℃
字数统计 1,560 | 阅读时长 7

1、List容器特点

List容器是有序的collection(也称之为序列)，此接口的用户可以对List容器中每个元素的插入位置进行精准地控制。用户可以根据元素的整数索引(在列表中的位置)访问元素，并搜索列表中的元素。List容器允许插入重复的值，包括null。

2、ArrayList(动态数组)及常用API

(1)ArrayList类扩展了AbstractList并实现了List接口。

(2)支持可随需增长的动态数组。(以1.5倍的倍率进行扩容)

(3)ArrayList构造方法。ArrayList();ArrayList(Collection c);ArrayList(int capacity);

(4)除继承的方法之外，ArrayList常用方法。E get(int index)方法：返回此列表中指定位置上的元素；int intdexOf(Object o)：返回此列表中首次出现的指定元素的索引，或如果此列表不含该元素，则返回-1。

(5)ArrayList的常用方法举例

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

public class ArrayListDemo1 {

    public static void main(String[] args) {
        /*
         * 当我们调用无参构造方法来构造一个ArrayList对象的时候，它会在内部分配一个初始大小为10的一个Object类型数组。
         * 
         * 当添加的数据容量超过数组大小的时候，会产生一个新的数组，新的数组的大小是原来数组大小的1.5倍。接着把原数组
         * 中的数据拷贝到新的数组中。
         */
        List<String> nList=new ArrayList<String>();
        nList.add("chenhao");//添加元素
        nList.add("lisi");
        nList.add("lisi");
        nList.add("wangwu");
        nList.add(1, "jay");//在指定的位置添加元素
        nList.add("jack");
        nList.set(0, "chengang");//修改指定位置的元素值

        System.out.println("使用迭代器对象来进行统一的遍历");
        Iterator<String> iterator=nList.iterator(); 
        while (iterator.hasNext()) {
            String name = iterator.next();
            System.out.println(name);
        }

        System.out.println("使用增强for循环进行遍历");
        for(String name:nList){
            System.out.println(name);
        }

        System.out.println("********************************");
        System.out.println(nList.indexOf("lisi"));//查找指定元素的位置
        System.out.println(nList.remove("lisi"));//删除元素
        System.out.println(nList.remove(0));//删除某个位置的元素
        System.out.println(nList.size());//动态数组的大小
        System.out.println(nList.contains("chenhao"));//是否包含某个元素
        System.out.println(nList.get(1));//获取指定位置的元素值
        System.out.println(nList.isEmpty());//判断动态数组是否为空
        nList.clear();//清空动态数组
        System.out.println(nList.isEmpty());
        System.out.println("********************************");
    }
}

(6)ArrayList方法的重载举例

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

public class ArrayListDemo2 {

    public static void main(String[] args) {
        List<Student> stuList=new ArrayList<Student>();//以学生类对象作为泛型的具体化
        Student stu1=new Student("zhangsan", 10);
        Student stu2=new Student("lisi", 20);
        Student stu3=new Student("jack", 30);
        Student stu4=new Student("mandy", 10);
        Student stu5=new Student("mary", 20);
        stuList.add(stu1);
        stuList.add(stu2);
        stuList.add(stu3);
        stuList.add(stu4);
        stuList.add(stu5);
        Student stu6=new Student("mary", 20);

        //可以通过按住Ctrl键再点击相应的方法名来查看方法的具体实现。从而搞清楚下列方法在修改equals方法之后的变化。
        System.out.println(stuList.indexOf(stu6));
        System.out.println(stuList.contains(stu6));
        System.out.println(stuList.remove(stu6));
        System.out.println(stuList.indexOf(stu5));
        System.out.println(stuList.size());
    }

}

class Student{//学生类
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public boolean equals(Object obj) {//重写equals方法，只要姓名和年龄一致则是相同的对象。
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
}

3、LinkedList及常用API

(1)LinkedList类扩展AbstractSequentialList并实现List接口。

(2)LinkedList提供了一个链表数据结构。(其中含有Node对象，并且有前引用和后引用)

(3)LinkedList有两个构造方法：LinkedList();LinkedList(Collection c);

(4)除了继承的方法之外，LinkedList类还定义了一些有用的方法用于操作和访问容器中的数据。void addFirst(E e);void addLast(E e);E removeFirst();E removeLast();

(5)由于Deque接口扩展了Queue接口，成为双端队列，而LinkedList继承了Deque接口。所以它可以提供add、poll先进先出队列的操作，以及其他堆栈和双端队列操作。

(6)LinkedList常用方法举例

import java.util.Iterator;
import java.util.LinkedList;

public class LinkedListDemo1 {

    public static void main(String[] args) {
        /*
         * LinkedList内部封装的是双向的链表数据结构，每个节点是一个Node对象，Node对象中封装的是你要
         * 添加的元素，还有一个指向上一个Node对象的引用和下一个Node对象的引用。
         * 
         * 不同的容器有不同的数据结构，不同的数据结构操作起来的性能是不一样的。链表数据结构做插入、删除
         * 的效率较高，但查询的效率比较低。数组结构做查询的时候效率高，因为可以通过下标直接找到元素，但
         * 插入和删除效率比较低，因为要做移位操作。
         */
        LinkedList<String> sList=new LinkedList<String>();
        sList.add("zhangsan");//添加
        sList.add("lisi");
        sList.add("wangwu");
        sList.add("rose");
        sList.add("mary");
        sList.add("jack");
        sList.addFirst("chenhao");//添加至开头
        sList.addLast("mandy");//添加至末尾

        /*Iterator<String> iterator=sList.iterator();
        while (iterator.hasNext()) {
            String name = iterator.next();
            System.out.println(name);
        }*/

        /*for(String name:sList){
            System.out.println(name);
        }*/

        for(Iterator<String> iterator=sList.iterator();iterator.hasNext();){
            String name=iterator.next();
            System.out.println(name);
        }

        System.out.println(sList.removeFirst());//为空时返回异常
        System.out.println(sList.size());
        sList.clear();
        System.out.println(sList.pollFirst());//为空时返回null
    }
}

(7)使用LinkedList来实现栈和队列的功能

import java.util.Iterator;
import java.util.LinkedList;

public class LinkedListDemo2 {

    public static void main(String[] args) {

        /*Mystack<String> mystack=new Mystack<String>();
        mystack.push("zhangsan");
        mystack.push("lisi");
        mystack.push("wangwu");
        mystack.push("zhaoliu");
        mystack.pop();
        mystack.pop();
        Iterator<String> iterator = mystack.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }*/

        MyQueue<Integer> myQueue=new MyQueue<Integer>();
        myQueue.push(1);
        myQueue.push(2);
        myQueue.push(3);
        myQueue.push(4);
        myQueue.push(5);
        myQueue.pop();
        myQueue.pop();
        Iterator<Integer> iterator=myQueue.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }

}

class Mystack<T>{//使用LinkedList来模拟栈的数据结构
    private LinkedList<T> data=null;
    public Mystack(){
        data=new LinkedList<T>();
    }

    //压栈的方法
    public void push(T obj){
        data.addFirst(obj);
    }

    //出栈的方法
    public T pop(){
        return data.removeFirst();
    }

    public Iterator<T> iterator(){
        return data.iterator();
    }
}

class MyQueue<T>{//使用LinkedList来模拟队列的数据结构
    private LinkedList<T> data=null;
    public MyQueue(){
        data=new LinkedList<T>();
    }

    //入队
    public void push(T obj){
        data.addLast(obj);
    }

    //出队
    public T pop(){
        return data.removeFirst();
    }

    public Iterator<T> iterator(){
        return data.iterator();
    }
}
🐶 您的支持将鼓励我继续创作 🐶
-------------本文结束感谢您的阅读-------------