标签：
集合操作——线性表
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(100)); } 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); } }
标签：
原文地址：http://www.cnblogs.com/manue1/p/4496459.html
