List集合

java.util.List接口,继承自Collection.

List集合是可重复集,并且有序,提供了一套可以通过下标操作元素的方法

 

list集合有两个常用的实现类:

java.util.ArrayList:内部使用数组实现，查询性能更好。

java.util.LinkedList:内部使用链表实现，增删性能更好，首尾增删性能最佳。

性能没有苛刻要求时，通常使用ArrayList。

 

List集合常用方法(特点:通过下标操作)

E get(int index):获取指定下标index处对应的元素

E set(int index, E e):将给定元素设置到index指定的位置，返回值为该位置被替换的元素。

public class ListDemo {
   public static void main(String[] args) {
       List<String> list = new ArrayList<>();
​
       list.add("one");
       list.add("two");
       list.add("three");
       list.add("four");
       list.add("five");
​
       /*
           E get(int index)
           获取指定下标对应的元素
        */
       //获取第三个元素
       String e = list.get(2);
       System.out.println(e);
​
       for(int i=0;i<list.size();i++){
           e = list.get(i);
           System.out.println(e);
       }
​
       /*
           E set(int index,E e)
           将给定元素设置到指定位置，返回值为该位置原有的元素。
           替换元素操作
        */
       //[one,six,three,four,five]
       String old = list.set(1,"six");
       System.out.println(list);
       System.out.println("被替换的元素是:"+old);
   }
}

void add(int index,E e):将给定元素插入到index指定的位置

E remove(int index):删除并返回下标index处对应的元素。

import java.util.ArrayList;
import java.util.List;
​
/**
* List集合提供了一对重载的add,remove方法
*/
public class ListDemo2 {
   public static void main(String[] args) {
       List<String> list = new ArrayList<>();
       list.add("one");
       list.add("two");
       list.add("three");
       list.add("four");
       list.add("five");
       System.out.println(list);
       /*
           void add(int index,E e)
           将给定元素插入到指定位置
        */
       //[one,two,six,three,four,five]
       list.add(2,"six");
       System.out.println(list);
​
       /*
           E remove(int index)
           删除并返回指定位置上的元素
        */
       //[one,six,three,four,five]
       String e = list.remove(1);
       System.out.println(list);
       System.out.println("被删除的元素:"+e);
   }
}

List subList(int start,int end):获取当前集合中start到end之间的子集。(含头不含尾)

import java.util.ArrayList;
import java.util.List;
​
/**
*  List subList(int start,int end)
*  获取当前集合中指定范围内的子集。两个参数为开始与结束的下标(含头不含尾)
*/
public class ListDemo3 {
   public static void main(String[] args) {
       List<Integer> list = new ArrayList<>();
       for(int i=0;i<10;i++){
           list.add(i);
       }
       System.out.println(list);
       //获取3-7这部分
       List<Integer> subList = list.subList(3,8);
       System.out.println(subList);
       //将子集每个元素扩大10倍
       for(int i=0;i<subList.size();i++){
           subList.set(i,subList.get(i) * 10);
       }
       //[30,40,50,60,70
       System.out.println(subList);
       /*
           对子集元素的操作就是对原集合对应元素的操作
        */
       System.out.println(list);
​
       //删除list集合中的2-8
       list.subList(2,9).clear();
       System.out.println(list);
​
   }
}

 

集合的排序

java.util.Collections类

Collections是集合的工具类,里面定义了很多静态方法用于操作集合.

Collections.sort(List list)方法

可以对List集合进行自然排序(从小到大)

/**
 * 集合的排序
 * 集合的工具类:java.util.Collections提供了一个静态方法sort,可以对List集合
 * 进行自然排序
 */
public class SortListDemo1 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        Random random = new Random();
        for(int i=0;i<10;i++){
            list.add(random.nextInt(100));
        }
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);
    }
}


//排序自定义类型元素

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
​
/**
* 排序自定义类型元素
*/
public class SortListDemo2 {
   public static void main(String[] args) {
       List<Point> list = new ArrayList<>();
       list.add(new Point(1,2));
       list.add(new Point(97,88));
       list.add(new Point(7,6));
       list.add(new Point(9,9));
       list.add(new Point(5,4));
       list.add(new Point(2,3));
       System.out.println(list);
       /*
           编译不通过的原因:
           Collections.sort(List list)该方法要求集合中的元素类型必须实现接口:
           Comparable,该接口中有一个抽象方法compareTo,这个方法用来定义元素之间比较
           大小的规则.所以只有实现了该接口的元素才能利用这个方法比较出大小进而实现排序
           操作.
        */
       Collections.sort(list);//编译不通过 compare比较  comparable可以比较的
       System.out.println(list);
   }
}

 

实际开发中,我们并不会让我们自己定义的类(如果该类作为集合元素使用)去实现Comparable接口,因为这对我们的程序有侵入性.

侵入性:当我们调用某个API功能时,其要求我们为其修改其他额外的代码,这个现象就是侵入性.侵入性越强的API越不利于程序的后期可维护性.应当尽量避免.

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
​
/**
* 排序自定义类型元素
*/
public class SortListDemo2 {
   public static void main(String[] args) {
       List<Point> list = new ArrayList<>();
       list.add(new Point(1,2));
       list.add(new Point(97,88));
       list.add(new Point(7,6));
       list.add(new Point(9,9));
       list.add(new Point(5,4));
       list.add(new Point(2,3));
​
       System.out.println(list);
       Collections.sort(list,(o1,o2)->
               o1.getX() * o1.getX() + o1.getY() * o1.getY() -
               o2.getX() * o2.getX() - o2.getY() * o2.getY()
       );
​
       System.out.println(list);
   }
}