[Java知识库]Java集合List子接口

List子接口

有序、有下标、元素可重复

1、方法

• extends Collection<> //继承Collection的方法
• void add(int index ,Object o) //在index位置插入对象o；
• boolean addAll(int index ,Collection c) //将一个集合中的元素添加到此集合中的index位置
• Object get (int Index ) //返回集合中指定位置的元素
• List subList (int fromIndex,int toIndex) //返回fromIndex和toIndex之间的集合元素
• int indexod(Object o) //返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回-1；
• set (in index,E element) //用指定元素替换列表中的指定位置的元素

2、List接口的使用

		//创建一个集合对象
        List list =new ArrayList<>();

        //添加元素
        list.add("苹果");
        list.add(1,"榴莲");
        list.add(0,"香蕉");
        System.out.println(list.toString());

        //删除元素
        list.remove("苹果");

        //遍历
        //1.for循环
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //2.foreach循环
        for (Object s:list
             ) {
            System.out.println(s);
        }
        //3.迭代器遍历
        Iterator it =list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        //4.列表迭代器遍历（可向前遍历可以从后开始遍历）
        ListIterator lit =list.listIterator();
        lit.add("车厘子");                         //ListIterator遍历过程中添加元素
        //从前往后遍历
        while (lit.hasNext()){
            System.out.println(lit.nextIndex()+":"+lit.next());
        }
        //从后往前遍历
        while(lit.hasPrevious()){
            System.out.println(lit.previousIndex()+":"+lit.previous());
        }

        //判断是否存在
        System.out.println(list.contains("车厘子"));
        //判断是否为空
        System.out.println(list.isEmpty());

		 //获取位置
        System.out.println(list.indexOf("车厘子"));

3、List实现类

• ArrayList

  • 数组结构实现，查询快，增删慢；

  • jdk1.2版本，运行效率快、线程不安全；

  • ArrayList的使用：

    • public static void main(String[] args) {
              //创建一个集合
              ArrayList arrayList = new ArrayList<>();
      
              //添加元素
              Person person1 = new Person("马龙", 33, "男");
              Person person2 = new Person("张继科", 25, "男");
              arrayList.add(person1);
              arrayList.add(person2);
              System.out.println(arrayList);
      
              //删除元素
      //        arrayList.remove(person2);
              //实体类重写equals方法判断：
      //        arrayList.remove(new Person("张继科",25,"男"));
              System.out.println(arrayList.size());
      
              //遍历
              //迭代器遍历(迭代器的本身是foreach循环）
              Iterator lt = arrayList.listIterator();
              while (lt.hasNext()) {
                  Person p = (Person) lt.next();
                  System.out.println(p.toString());
              }
              //列表迭代器遍历
              ListIterator lit = arrayList.listIterator();
              while (lit.hasNext()) {
                  Person p = (Person) lit.next();
                  System.out.println(p.toString());
              }
              //逆序遍历
              while (lit.hasPrevious()) {
                  Person p = (Person) lit.previous();
                  System.out.println(p.toString());
              }
      
              //判断是否存在
              System.out.println(arrayList.contains(new Person("张继科",25,"男")));
      
              //查找位置
              System.out.println(arrayList.indexOf(new Person("张继科",25,"男")));
      
      
          }
      

    • //实体类
      public class Person {
          private String name;
          private int age;
          private String sex;
      
          public Person(String name, int age, String sex) {
              this.name = name;
              this.age = age;
              this.sex = sex;
          }
      
      
          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 getSex() {
              return sex;
          }
      
          public void setSex(String sex) {
              this.sex = sex;
          }
      
          @Override
          public String toString() {
              return "Person{" +
                      "name='" + name + '\'' +
                      ", age=" + age +
                      ", sex='" + sex + '\'' +
                      '}';
          }
      
          @Override
          public boolean equals(Object obj) {
              //判断是否为同一对象
              if(this==obj){
                  return true;
              }
              //判断是否为空
              if (obj==null){
                  return false;
              }
              //判断是不是同一类型
              if(obj instanceof Person){
                  Person p=(Person)obj;
                  //比较属性
                  if(this.name==p.name&&this.age==p.age&&this.sex==p.sex){
                      return true;
                  }
              }
              //不满足条件
              return false;
          }
      

• Vector

  • 数组结构实现，查询快，增删慢；

  • jdk1.0版本，运行效率慢，线程安全；

  • Vector的使用：

  //创建集合
          Vector vector =new Vector<>();
  
          vector.add("苹果");
          vector.add("香蕉");
          vector.add("芒果");
  
          //遍历
          //使用枚举器遍历
          Enumeration en = vector.elements();
          while (en.hasMoreElements()){
              String s =(String)en.nextElement();
              System.out.println(s);
          }
  
          //vector的一些其他方法
          System.out.println(vector.firstElement());//第一个元素
          System.out.println(vector.lastElement());//最后一个元素
          System.out.println(vector.elementAt(1));//通过位置获取元素
  

• LinkedList

  • 链表结构实现，增删快，查询慢

  • LinkedList的使用：

  //创建集合
          LinkedList ll = new LinkedList<>();
          //添加元素
          Person person1 = new Person("马龙", 33, "男");
          Person person2 = new Person("张继科", 25, "男");
          ll.add(person1);
          ll.add(person2);
  
  
          //删除
  //        ll.remove(person2);
  //        ll.remove(new Person("马龙",33,"男"));//实体类重写equals方法后可使用
  //        ll.clear();
          System.out.println(ll.toString());
  
          //遍历
          //for循环遍历
          for (int i = 0; i < ll.size(); i++) {
              System.out.println(ll.get(i));
          }
          //foreach遍历
          for (Object obj : ll) {
              System.out.println(obj);
          }
          //迭代器遍历
          Iterator it = ll.iterator();
          while (it.hasNext()){
              System.out.println(it.next());
          }
          //列表迭代器逆序遍历
          System.out.println("逆序遍历");
          ListIterator lit =ll.listIterator(ll.size());//逆序输出需要加上集合大小这个参数来实例化
          while (lit.hasPrevious()){
              Person p =(Person)lit.previous();
              System.out.println(p.toString());
          }
  

• ArrayList与LinkedList的区别：

  • ArrayList是数组结构，必须开辟连续空间，查询快，增删慢
  • LinkedList是双向链表结构，无需开辟连续空间，查询慢，增删快