集合操作——线性表
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);
}
}