集合线性表--List之ArrayList

集合操作——线性表

List： add()、remove()、subList()、list.toArray()、array.asList（）、

List排序： 　　Collections.sort(list);    Comparable、　　comparator

List
List接口是Collection的子接口，用于定义线性表数据结构；可以将List理解为存放对象的数组，只不过其元素个数可以动态的增加或减少。并且List是可重复集

ArrayList和LinkedList

List接口的两个常见实现类为ArrayList和LinkedList，分别用动态数组和链表的方式实现了List接口。
可以认为ArrayList和LinkedList的方法在逻辑上完全一样，只是在性能上有一定的差别，ArrayList更适合于随机访问而LinkedList更适合于插入和删除；在性能要求不是特别苛刻的情形下可以忽略这个差别

LinkedList： 易于增删
ArrayList： 易于查找

1. ArrayList 是由数组实现的 检索 要求不是太苛刻 都可以用这个
2.LinkedList 是由链表实现的 插入删除

get与set方法
这两个方法是List的方法独有的
List除了继承Collection定义的方法外，还根据其线性表的数据结构定义了一系列方法，其中最常用的就是基于下标的get和set方法。
E get(int index):获取集合中指定下标对应的元素，下标从0开始。
E set(int index, E elment):将给定的元素存入给定位置，并将原位置的元素返回。

List是有序，所有 基于下标操作元素

/*
         * get方法获取指定位置的元素
         */
        /*
         * 将cpp替换c++
         * set 方法替换元素 将原来的元素保存起来
         */

        String old =list.set(1, "c++");
        System.out.println(list);
        System.out.println(old);

        /*
         * 将下标1和下标3这两个位置上的元素呼唤
         *
         */

        String e = list.get(1);
        String e2 =list.set(3,e);
        list.set(1, e2);
        //意思是 list.set(1,list.set(3,list.get(1)));
        System.out.println(list);
        

3. 插入和删除

List根据下标的操作还支持插入与删除操作:
void add(int index,E element):
将给定的元素插入到指定位置，原位置及后续元素都顺序向后移动。
E remove(int index):
删除给定位置的元素，并将被删除的元素返回

class Test4{
    /**
     * 插入和删除
     */
    private void mian() {
        List<String> list = new ArrayList<String>();
        list.add("java");
        list.add("cpp");
        list.add("php");
        list.add("c#");
        list.add("python");

        list.add(1,"jsp");

        /*
         * 删除第三个元素
         * remove（int index）
         * 删除指定位置的元素 并返回
         *
         */

        String old =list.remove(2);
        System.out.println(list);

        System.out.println("被删除的是："+old);
    }
}

4. subList方法

List的subList方法用于获取子List。
需要注意的是，subList获取的List与原List占有相同的存储空间，对子List的操作会影响的原List。
List<E> subList(int fromIndex, int toIndex);
fromIndex和toIndex是截取子List的首尾下标（前包括，后不包括) 。

**
 * 取子集
 * @author Administrator
 *
 */
class TestList1{
    /*
     * List subList(int start,int end)
     * 获取当前集合中的子集
     */
    public static void main(String[] args) {
        List<Integer> list =new ArrayList<Integer>();

        //向集合中存入0-9
        for(int i=0;i<10;i++){
            list.add(i);
        }
        System.out.println(list);
        //获取子集
        List<Integer> subList =list.subList(3,8);
        System.out.println(subList);

        //将子集中每个元素扩大10倍
        for(int i=0;i<subList.size();i++){
            int num = subList.get(i);
            num=num*10;
            subList.set(i,num);
        }
        /*
         * 对子集元素的任何操作都会影响原集合
         */
        System.out.println(subList);
        System.out.println(list);

        subList.clear();//清空子集
        System.out.println(subList);
        System.out.println(list);

    }
}
 

5. List转换为数组

List的toArray方法用于将集合转换为数组。但实际上该方法是在Collection中定义的，所以所有的集合都具备这个功能。
其有两个方法:
Object[] toArray()
<T>T[] toArray(T[] a)
其中第二个方法是比较常用的，我们可以传入一个指定类型的数组，该数组的元素类型应与集合的元素类型一致。返回值则是转换后的数组，该数组会保存集合中所有的元素。

/**
 * 集合转换为数组
 */
class TestList2{
    public static void main(String[] args) {
        /*
         * Collection 中定义的方法
         * object[] toArray()
         */
        Collection<String> c = new ArrayList<String>();
        c.add("a");
        c.add("b");
        c.add("c");

        Object[] array =c.toArray();
        //查看数组中第一个字符串的长度
        String str =(String)array[0];
        System.out.println(str.length());

        /*
         * 重载的toArray
         * 该方法会检查我们传入的数组
         * 若传入的数组的长度可以保存集合中所有元素，则
         * 按照我们传入的数组的类型创建一个新数组
         */
        String[] arrays =c.toArray(new String[5]);
        System.out.println(arrays.length);
        str=arrays[0];
        System.out.println(str);

    }
}

6. 数组转换为List

Arrays类中提供了一个静态方法asList，使用该方法我们可以将一个数组转换为对应的List集合。
其方法定义为:
static <T>List<T> asList<T… a>
返回的List的集合元素类型由传入的数组的元素类型决定。
需要注意的是，返回的集合我们不能对其增删元素，否则会抛出异常。并且对集合的元素进行的修改会影响数组对应的元素。
例如:

public class TestListD {

    /**
     * @param args
     */
    public static void main(String[] args) {
        String[] array ={"a","b","c"};
        System.out.println(Arrays.toString(array));
        /*
         * Array 的asList方法，可以将数组转换为List集合
         *
         */
        List<String> list = Arrays.asList(array);
        System.out.println(list);
        /*
         * 数组转换为集合时  这集合是只读的
         * 对此类集合不能进行增删元素，但是可以修改元素
         * 注意： 修改元素会影响原数组
         *
         * 解决方法： 新建一个集合
         */

        List<String> newList = new ArrayList<String>();
        newList.addAll(list);
        newList.add("d");
        System.out.println(newList);
        newList.add("d");
        list.set(0, "d");
        System.out.println(list);
        System.out.println("数组："+ Arrays.toString(array));
    }

}

List排序
1. Collections.sort方法实现排序

Collections是集合的工具类，它提供了很多便于我们操作集合的方法，其中就有用于集合排序的sort方法。该方法的定义为:
void sort(List<T> list)
其作用是对集合元素进行自然排序(按照元素的由小至大的顺序)

/**
 * 集合排序
 */

class TestListD1{
    public static void main(String[] args) {
        /*
         * Collections 是集合的工具类
         *
         * Collection 与 Collections 的区别？
         *  前者定义集合的，是所有集合的父接口
         *  后者是操作集合的   是一个工具类
         *
         *  使用Collections 常用于排序集合
         */
        //在集合中生成10个100以内的随机数
        List<Integer> list = new ArrayList<Integer>();
        //Math.random();//0-1之间的随机数
        Random random= new Random();
        for(int i=0;i<10;i++){
            list.add(random.nextInt());
        }
        System.out.println(list);
        /*
         * Collections.sort(list);
         * 只对List有序集进行排序（由小到大）
         *
         * 想使用sort排序 就要求 集合中的元素必须具有可比价性，能比较出大小
         */
        Collections.sort(list);
        System.out.println(list);
    }
}

2. Comparable

要想对元素进行自然排序那么就必须要有一个必要条件，就是元素的大小。集合中存入的都是引用类型，是以对象的形式存在于内存中，那么对象是如何进行的大小比较呢？实际上，若想对某个集合的元素进行自然排序，该集合的元素有一个要求，就是这些元素必须是Comparable的子类。
Comparable是一个接口，用于定义其子类是可以比较的。因为该接口有一个抽象方法:
int compareTo(T t)
所有子类都需要重写该方法来定义对象间的比较规则。该方法要求返回一个整数，这个整数不关心具体的值，而是关注取值范围。
当返回值>0时，表示当前对象比参数给定的对象大。
当返回值<0时，表示当前对象比参数给定的对象小。
当返回值=0时，表示当前对象和参数给定的对象相等。

class Cell implements Comparable<Cell>{
    private int row;
    private int col;
    @Override
    /*
     * 比较规则 ：谁的行数大谁大
     *
     *  谁的行数小 谁大
     */
    public int compareTo(Cell o){
        return this.row- o.row;
//        return o.row-this.row ;

    }
}

/**
 * 对Cell类进行自然排序
 * @author Administrator
 *
 */

class TestListD2{
    public static void main(String[] args) {
        List<Cell> list = new ArrayList<Cell>();
        list.add(new Cell(2,3));
        list.add(new Cell(5,1));
        list.add(new Cell(3,2));
        System.out.println(list);
        /*
         * 若集合中的元素没有实现Coparable接口
         * 那么调用sort方法编译不通过
         */
        Collections.sort(list);
        System.out.println(list);
    }
}

class Cell implements Comparable<Cell>{
    private int row;
    private int col;
    @Override
    /*
     * 比较规则 ：谁的行数大谁大
     *
     *  谁的行数小 谁大
     */
    public int compareTo(Cell o){
        return this.row- o.row;
//        return o.row-this.row ;

    }
}

/**
 * 对Cell类进行自然排序
 * @author Administrator
 *
 */

class TestListD2{
    public static void main(String[] args) {
        List<Cell> list = new ArrayList<Cell>();
        list.add(new Cell(2,3));
        list.add(new Cell(5,1));
        list.add(new Cell(3,2));
        System.out.println(list);
        /*
         * 若集合中的元素没有实现Coparable接口
         * 那么调用sort方法编译不通过
         */
        Collections.sort(list);
        System.out.println(list);
    }
}

3. comparator

一旦Java类实现了Comparable，其比较逻辑就已经确定；如果希望在排序的操作中临时指定比较规则，可以采用Comparator接口回调的方式。
该接口要求实现类必须重写其定义的方法:
int compare(T o1,T o2)
该方法的返回值要求，若o1>o2则返回值应>0,若o1<o2则返回值应<0，若o1==o2则返回值应为0

当元素自身提供的比较规则 不能满足我们对排序的需求时，我们就可以提供一个比较器，来指定比较规则

class TestListD3{
    public static void main(String[] args) {

        List<String> list = new ArrayList<String>();
        list.add("你好");
        list.add("李绪春");
        list.add("张飞");
        list.add("刘苍松");
        list.add("范传奇");
        Collections.sort(list);
        /*
         * Collections提供了一个重载的sort方法
         * static void sort(List list,Comparator c)
         * 该方法根据给定的比较器对集合元素进行大小的比较
         * 后进行自然排序
         */

        /*
         * 使用匿名内部类定义比较器（推荐做法）
         * 临时用一下  所以 可以直接写成  匿名内部类
         * 当我们需要使用某一个借口的实现类的实例或一个类的子类实例时，这时我们使用
         * 内部类的最佳时机，匿名内部类的特点是不需要声明类，且只有一个实例
         */
        Comparator com = new Comparator<String>(){
            public int compare(String o1, String o2) {
                /*
                 * 排序后 字符多的在前
                 */
                return o2.length()- o1.length();
            }
        };
        Collections.sort(list,com);
        System.out.println(list);

    }
}