List集合-Java

List

List集合概述

（1）有序集合（也称为序列），用户可以精确地控制列表中每个元素的插入位置，用户可以通过整数索引访问元素，并搜索列表中的元素；

（2）与Set集合不同，列表通常允许重复的元素。

List集合的特点

有序：存储和取出的元素顺序一致；

可重复：存储的元素可以重复

package List_practice;

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

public class List_1 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("pjh");
        list.add("sjl");
        list.add("tjs");
        list.add("pjh");//可重复
        System.out.println(list);
        //继承自Collection，可采用迭代器遍历
        Iterator it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

List集合的特有方法

方法名	说明
void add(int index,E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索引处的元素

package List_practice;

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

public class List_1 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("pjh");
        list.add("sjl");
        list.add("tjs");
        list.add("pjh");//可重复
        System.out.println(list);
        list.add(1,"dzy");
        System.out.println(list);
        list.remove(2);
        System.out.println(list);
        list.set(1,"wsy");
        System.out.println(list);
        //通过get遍历
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);
        }

    }
}

实例：

package List_practice;

public class student {
    private String name;
    private int age;
    private String number;
    private String address;
    public student(){}
    public student(String name, int age, String number, String address){
        this.name = name;
        this.age = age;
        this.number = number;
        this.address = address;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
    public void show(){
        System.out.println("姓名："+this.name+" ,学号："+this.number+" ,年龄："+this.age+" ,居住地："+this.address);
    }
}





package List_practice;

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

public class List_2 {
    public static void main(String[] args) {
        List stu = new ArrayList();
        student stu1 = new student("pjh",23,"S200101205","chongqing");
        student stu2 = new student("tjs",21,"S200101206","shanghai");
        student stu3 = new student("sjl",24,"S200101207","changsha");
        stu.add(stu1);
        stu.add(stu2);
        stu.add(stu3);
        //迭代器遍历
        Iterator it = stu.iterator();
        while (it.hasNext()){
            student Stu = it.next();
            Stu.show();
        }
        //get遍历
        for (int i = 0; i < stu.size(); i++) {
            student Stu = stu.get(i);
            Stu.show();
        }


    }
}

并发修改异常：ConcurrentModificationException

产生原因：迭代器遍历的过程中，通过集合对象修改了集合中元素的长度，造成了迭代器获取元素中判断预期修改值和实际修改值不一致。

注：不能在迭代器遍历元素时修改元素

解决方案：在if后面添加break或者用for循环遍历，然后用集合对象做对应的操作即可。

package List_practice;

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

public class List_3 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("pjh");
        list.add("sjl");
        list.add("tjs");
       
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            if (s.equals("pjh")){
                list.add("qcx");
            }
        }
        System.out.println(list);
    }
}

ListIterator:列表迭代器

（1）通过List集合的ListLterator()方法得到，是List集合的特有的迭代器；

（2）用于允许程序员沿任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置。

方法名	说明
E next()	返回迭代中的下一个元素
boolean hasNext()	如果迭代具有更多元素，则返回true
E previous()	返回列表中的上一个元素
boolean hasPrevious()	如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
void add(E e)	将指定的元素插入列表

增强for循环：简化数组和Collection集合的遍历

（1）实现Iterator接口的类允许其对象成为增强型for语句的目标；

（2）增强for循环的内部原理是一个Iterator迭代器

（3）增强for循环的格式

for（元素数据类型变量名：数组或者Collection集合）{

//在此处使用变量即可，该变量就是元素

//注意，迭代器中只能遍历元素，不能修改元素

}

package List_practice;

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

public class List_for {
    public static void main(String[] args) {
        //增强for的内部是迭代器
        int[] a = {1,2,3,4,5};
        for(int i:a){
            System.out.println(i);
        }
        System.out.println("==========");
        List stu = new ArrayList();
        student stu1 = new student("pjh",23,"S200101205","chongqing");
        student stu2 = new student("tjs",21,"S200101206","shanghai");
        student stu3 = new student("sjl",24,"S200101207","changsha");
        stu.add(stu1);
        stu.add(stu2);
        stu.add(stu3);
        for (student s:stu){
            s.show();
        }
    }
}

案例：

package List_practice;

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

public class List_4 {
    public static void main(String[] args) {
        List stu = new ArrayList();
        student stu1 = new student("pjh",23,"S200101205","chongqing");
        student stu2 = new student("tjs",21,"S200101206","shanghai");
        student stu3 = new student("sjl",24,"S200101207","changsha");
        stu.add(stu1);
        stu.add(stu2);
        stu.add(stu3);
        Iterator it = stu.iterator();
        while (it.hasNext()){
            student s = it.next();
            s.show();
        }
        System.out.println("==============================");
        for (int i = 0; i < stu.size(); i++) {
            student s = stu.get(i);
            s.show();
        }
        System.out.println("==============================");
        for (student s:stu){
            s.show();
        }
    }
}

数据结构

栈：先进后出

队列：新进先出

数组：查询快，增删慢 ArrayList

链表：查询慢，增删快 linkedList

linkedList集合的特有功能：

方法名	说明
public void addFirst(E e)	在该表开头插入指定元素
public void addLast(E e)	将指定的元素追加到此列表的末尾
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表中的最后一个元素
public E removeFirst()	从此列表中删除并返回第一个元素
public E removeLast()	从此列表中删除并返回最后一个元素

package shujujiegou;

import java.util.linkedList;

public class linkedlist {
    public static void main(String[] args) {
        linkedList list = new linkedList();
        list.add("pjh");
        list.add("tjs");
        list.add("sjl");
        list.add("qcx");
        System.out.println(list);
        System.out.println("==========");
        list.addFirst("cqupt");
        System.out.println(list);
        System.out.println("==========");
        list.addLast("chongqing");
        System.out.println(list);
        System.out.println("==========");
        System.out.println(list.getFirst());
        System.out.println(list.getLast());
        System.out.println(list);
        System.out.println("==========");
        System.out.println(list.removeFirst());
        System.out.println(list.removeLast());
        System.out.println(list);
    }
}

List集合-Java

Java相关栏目本月热门文章