Day01Java-API-List

1. 以下代码用于测试List的基本方法 add\get\size\contains等
List<String> list = new ArrayList<String>();
list.add("java"); // 向集合追加元素
list.add(2, "hadoop"); // 向集合插入元素
System.out.println(list.get(2)); // 根据下标取出元素
System.out.println(list.size()); // 集合中元素的个数
list.remove(2); // 根据下标删除某一个元素
list.contains("java"); //true 看集合中是否包含某一个对象，使用equals比较
list.contains(new String("ibm")); //true
equals与==区别：
1.==是比较对象的地址值，即判断是否是同一个对象
2.equals可以重写，这里比较的是内容是否相同
3.equals在Object中，比较的是是否为同一对象，与==相同

2. 以下代码演示泛型在集合中的应用
集合中放的是Object类型的引用，为的是什么都可以装——放易取难、不同数据类型的混装
<Stirng> 泛型
List<String> list2 = new ArrayList<String>();
list2.add("abc");
String str = list2.get(0);
System.out.println(str);

3. List和数组直接的转换
浅复制：复制引用，用同一个对象
深复制：复制对象、引用

List<Point> list3 = new ArrayList<Point>();
list3.add(new Point(1, 2));
Point[] points = list3.toArray(new Point[] {});//List.toArray（）缺点：浅复制
points[0].setX(100);
System.out.println(list3.get(0).getX());//100

//深复制方法
Point[] points = new Point[list3.size()];
for (int i = 0; i < points.length; i++) {
Point point = list3.get(i);
points[i] = new Point(point.getX(),point.getY());
}

Point[] points1 = { new Point(1, 2), new Point(3, 4), new Point(5, 6) };
List<Point> list4 = new ArrayList<Point>();
list4.addAll(Arrays.asList(points1));//List.aslist（数组），出来List，但该List不能改动即add、remov不能用。
list4.get(0).setX(1000);
System.out.println(points1[0].getX());//1000

Wrapper（包装模式）：设计思想
1.建立新类;
2.将原有的类嵌入新建的类中；
3.修改特定的几种方法;
eg:包装List，产生asList
public class MyArrays {
public List asList(Point[] points) {
List list = new ArrayList();
for (int i = 0; i < points.length; i++) {
list.add(points[i]);
}
return new ArrayListWrapper(list);
}
}

class ArrayListWrapper implements List {
private List list;
//原有方法不变
ArrayListWrapper(List list) {
this.list = list;
}
public int size() {
return list.size();
}
....
//修改方法
public boolean add(Point e) {
throw new UnsupportedOperationException("...");//抛出异常
}
public boolean remove(Object o) {
throw new UnsupportedOperationException("...");//抛出异常
}
}

4. 一些高级的API
list.subList(2, 5);//子序列与原数列占有相同的空间
//对子序列的改变会影响到原序列,
//一组下标[2，5）（前面包括，后面不包括）
list.set(0, "X");//有返回值，是被替换的元素
List.get（）有返回值，是读取的元素
list.set(0, list5.set(2, list5.get(0))); // 实现元素的交换

5. Collections的一些相关方法
Collections.shuffle(list); // 随机打乱
Collections.sort(list); // 排序
Collections.binarySearch();//折半查找，必须是有序列，返回值为查找的字符
//若返回小于零，则查找没有结果

工具类
Math
Arrays
Collections
...
不能产生对象，是静态方法
面向对象的方法与对象状态有关
只与参数有关的方法，放一起，建工具类

6. ArrayList和LinkedList
ArrayList 靠动态数组实现List，内存连续，
优缺：删除、插入效率低，适合随机查找
LinkedList 靠双向列表实现List，内存可以不连续
优缺：（与上相反）

他们都是List（线性表）的实现类，数据量小时，无差别

程序性能低问题：访问文件、数据库访问、网络传输问题

Deque 双向队列 包含栈、队的性质，但建议使用时，只用其一种功能
实现类：LinkedList
队：先进先出
queue.offer() 入队
queue.poll() 出队
queue.peek() 看下一个元素，但不会导致下一个元素出队
栈：先进后出
queue.push() 入栈
queue.pop() 出栈
queue.peek() 看下一个元素，但不会导致下一个元素出栈

7. Comparable, Comparator
Comparable 用于定义默认的排序逻辑：数字顺序、字典顺序、点的比较
Comparator 用于自定义排序逻辑

比较结果：
第一个大于第二个：返回整数
第一个等于第二个：返回0
第一个小于第二个：返回负数

Callback 回调思想（与Compartor相似）
eg：查找符合条件的学生
public class lx002 {
public static void main(String[] args) {
List<Student> list=new ArrayList<Student>();
list.add(new Student("a",80));
list.add(new Student("b",70));
list.add(new Student("c",90));
list.add(new Student("d",78));
List<Student> l=choose(list,new Stuf(){//内部类
public boolean accept(Student stu){
if(stu.getScose()>=80)
return true;
return false;
}});
System.out.println(l);
}

//选择方法
public static List<Student> choose(List<Student> list,Stuf sf){
List<Student> list1=new ArrayList<Student>();
for(int i=0;i<list.size();i++){
Student stu=list.get(i);
if(sf.accept(stu)){
list1.add(stu);
}
}
return list1;
}
}

//接口
interface Stuf{
public boolean accept(Student stu);
}

//学生
class Student{
String string;
int scose;
public Student(String string, int scose){
this.string=string;
this.scose=scose;
}
public int getScose() {
return scose;
}
public String toString(){
return string+" "+scose;
}

}

8
测试ArrayList、Linkedlist的查询性能

ArrayList的算法已经固定
性能要求高时,尽量用数组，算法自己写

UUID产生一个永远不重复的字符串
UUID.randomUUIID().toString();

使用建议：
频繁的首尾查找、删除：使用LinkedList
频繁的查找、删除：使用ArrayList
综合性能使用ArrayList

LinkedList不擅长中部查找删除，但首尾查找比ArrayList快
ArrayList 首、中、尾部查、删性能相差不多