JavaSE核心API--List接口

java.util.List等

1)理论讲解:数组转换为集合

通过数组的工具类Arrays提供的方法:asList
可以将一个数组转换为一个List集合。

代码演示:

    String[] array = { "one", "two", "three" };

    List<String> list = Arrays.asList(array);
    System.out.println("size:" + list.size());
    System.out.println("list:" + list);

    list.set(1, "2");
    System.out.println("list:" + list);
    System.out.println("array:" + Arrays.toString(array));
    /*
     * 从数组转换的集合不支持增删元素
     */
//  list.add("four");
//  System.out.println("list:"+list);
//  System.out.println("array:"+Arrays.toString(array));
    /*
     * 可以自行创建一个集合来操作元素
     */
//  List<String> list2 = new ArrayList<>();
//  list2.addAll(list);
    /*
     * 所有集合都支持一个参数为集合的构造方法，作用是创建当前集合的同时包含给定集合所有元素
     */
    List<String> list2 = new ArrayList<>(list);
    System.out.println("list2:" + list2);
    list2.add("four");
    System.out.println("list2:" + list2);

2)理论讲解:集合转换为数组

Collection接口提供了一个方法:toArray，可以将当前集合转换为一个数组。任何集合都可以转换为数组。

代码演示:

    Collection<String> c = new ArrayList<>();
    c.add("one");
    c.add("two");
    c.add("three");
    System.out.println(c);

//  Object[] array = c.toArray();
    String[] array = c.toArray(new String[c.size()]);
    System.out.println(array.length);
    System.out.println(Arrays.toString(array));

3)理论讲解:双端队列

java.util.Deque接口，该接口继承自Queue
双端队列是两端都可以做出入队操作的队列。
常用实现类:java.util.LinkedList

代码演示:

    Deque<String> deque = new LinkedList<String>();
    deque.offer("one");
    deque.offer("two");
    deque.offer("three");
    System.out.println(deque);

    deque.offerFirst("four");
    System.out.println(deque);

    deque.offerLast("five");
    System.out.println(deque);

    String str = deque.poll();
    System.out.println(str);
    System.out.println(deque);

    str = deque.pollFirst();
    System.out.println(str);
    System.out.println(deque);

    str = deque.pollLast();
    System.out.println(str);
    System.out.println(deque);

4)理论讲解:List接口

java.util.List
List接口
List是Collection的一个常用子接口，表示可重复集，并且
该集合有序。特点是可以通过下标操作元素。
常见实现类：
java.util.ArrayList
数组实现，查询性能更好

java.util.LinkedList
链表实现，增删元素性能更好，尤其收尾增删元素效率最佳。

对性能没有极端苛刻要求时，通常使用ArrayList

代码演示:

    List<String> list = new ArrayList<String>();
    list.add("one");
    list.add("two");
    list.add("three");
    list.add("four");
    System.out.println(list);
    /*
     * E get(int index) 
     * 获取指定下标对应的元素
     */
    String str = list.get(1);
    System.out.println(str);

    for (int i = 0; i < list.size(); i++) {
        str = list.get(i);
        System.out.println(str);
    }

    /*
     * E set(int index,E e) 
     * 将给定元素设置到指定位置，返回值为原位置对应的元素。(替换元素操作)
     * 
     */
    String old = list.set(1, "2");
    System.out.println(list);
    System.out.println("old:" + old);

5)理论讲解:List提供了一对重载的add,remove方法

代码演示:

    List<String> list = new ArrayList<>();
    list.add("one");
    list.add("two");
    list.add("three");
    list.add("four");
    System.out.println(list);

    /*
     * void add(int index,E e)
     * 将给定元素插入到指定位置 
     */
    list.add(1, "2");
    System.out.println(list);

    /*
     * E remove(int index)
     * 删除并返回指定位置的元素
     */
    String old = list.remove(2);
    System.out.println(list);
    System.out.println(old);

6)理论讲解:List集合支持截取子集: List subList(int start,int end)

代码演示:

    List<Integer> list = new ArrayList<Integer>();
    for (int i = 0; i < 10; i++) {
        list.add(i);
    }
    System.out.println(list);
    /*
     * 获取2-7
     */
    List<Integer> subList = list.subList(2, 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);
    // 删除2-7
    list.subList(2, 8).clear();
    System.out.println(list);

7)理论讲解:队列

java.util.Queue接口，该接口是队列接口，规定了队列具有的相关方法。Queue接口继承自Collection，所以同时具备集合的相关方法。

队列可以保存一组元素，但是存取元素必须遵循先进先出原则。
常用实现类:java.util.LinkedList

代码演示:

    Queue<String> queue = new LinkedList<>();
    /*
     * offer为入队操作，将元素添加到队列末尾
     */
    queue.offer("one");
    queue.offer("two");
    queue.offer("three");
    queue.offer("four");
    queue.offer("five");
    queue.offer("six");
    System.out.println(queue);

    /*
     * E poll() 出队操作，获取队首元素，获取后该元素即从队列 中被删除
     */
    String str = queue.poll();
    System.out.println(str);
    System.out.println(queue);
    /*
     * peek方法是引用队首元素，获取后该元素依然在 队列当中。
     */
    str = queue.peek();
    System.out.println(str);
    System.out.println(queue);
    /*
     * 使用迭代器遍历不影响队列元素
     */
    for (String s : queue) {
        System.out.println(s);
    }
    System.out.println(queue);

    /*
     * 使用poll方法遍历队列，这种方式遍历后队列 就没有元素了
     */
    while (queue.size() > 0) {
//  for(;queue.size()>0;) {
        str = queue.poll();
        System.out.println(str);
    }
    System.out.println(queue);

8)理论讲解:集合的排序

集合的工具类:java.util.Collections
其提供了一个静态方法:sort，可以对List集合进行自然排序
即:从小到大的排序

代码演示:

    List<Integer> list = new ArrayList<Integer>();
    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);

9)理论讲解:排序保存自定义类型元素的集合

代码演示:

    List<Point> list = new ArrayList<Point>();
    list.add(new Point(3,4));
    list.add(new Point(7,8));
    list.add(new Point(1,6));
    list.add(new Point(5,0));
    list.add(new Point(4,8));
    System.out.println(list);
    /*
     * Collections的该sort方法在排序集合时要求集合
     * 元素必须实现Comparable接口并重写其中定义的比较
     * 方法。否则编译不通过。java API中常见数据类型
     * 都实现了该接口，比如包装类和字符串。
     * 但是我们自定义的元素通常不要去实现该接口。因为
     * 当我们使用某个方法时，该方法要求我们为其修改其他
     * 额外的代码时，这个方法就具有侵入性，这样的方法
     * 对程序结构不利。尽量避免使用。
     */
//  Collections.sort(list);

    /*
     * 重载的Collections.sort(List,Comparator)
     * 该方法要求我们传入要排序的集合外，在额外传入
     * 一个比较器，该比较器是用来为集合元素定义的一
     * 种比较大小的规则。这样sort方法就会利用给定的
     * 比较器的比较规则对集合元素进行比较大小后进行
     * 自然排序了。这也就不再要求集合元素必须去实现
     * 接口:Comparable了。
     */
//  Comparator<Point> c = new Comparator<Point>() {
        /**
         * 实现Comparator接口后，要求必须重写方法:
         * compare，该方法用来定义o1,o2的大小关系
         * 返回值为int型，该值不关心具体取值，只关注
         * 取值范围:
         * 当返回值>0:表示o1>o2
         * 当返回值<0:表示o1<o2
         * 当返回值=0:表示两个对象相等
         */
//  public int compare(Point o1, Point o2) {
//      int olen1 = o1.getX()*o1.getX()+o1.getY()*o1.getY();
//      int olen2 = o2.getX()*o2.getX()+o2.getY()*o2.getY();
//      return olen1-olen2;
//  } 
//          
//};

//  Collections.sort(list, c);

    Collections.sort(list,new Comparator<Point>() {
        public int compare(Point o1, Point o2) {
            int olen1 = o1.getX()*o1.getX()+o1.getY()*o1.getY();
            int olen2 = o2.getX()*o2.getX()+o2.getY()*o2.getY();
            return olen1-olen2;
        }   
    });

    System.out.println(list);

10)理论讲解:排序字符串

String已经实现了Comparable接口，但有时该比较规则不符合我们的排序需求，
这时我们也可以使用比较器来提供额外的比较规则并进行排序。

代码演示:

    List<String> list = new ArrayList<>();
    list.add("马冬梅");
    list.add("小明");
    list.add("王老师");
    System.out.println(list);
//  Collections.sort(list);     
    Collections.sort(list, new Comparator<String>() {
        public int compare(String o1, String o2) {
            return o1.length() - o2.length();
        }
    });
    System.out.println(list);

11)理论讲解:栈

双端队列若只从同一端做进出队操作时，就形成了栈结构。
栈结构存取元素遵循先进后出原则。

通常我们使用栈是完成"后退"这样的功能。

代码演示:

    Deque<String> stack = new LinkedList<>();
    stack.push("one");
    stack.push("two");
    stack.push("three");
    stack.push("four");
    System.out.println(stack);

    String str = stack.pop();
    System.out.println(str);
    System.out.println(stack);

    for (String s : stack) {
        System.out.println(s);
    }
    System.out.println(stack);

    while (stack.size() > 0) {
        str = stack.pop();
        System.out.println(str);
    }
    System.out.println(stack);

附件:作为集合元素测试集合排序

public class Point {
   private int x;
   private int y;

   public Point(int x, int y) {
        super();
        this.x = x;
        this.y = y;
   }

   public int getX() {
        return x;
   }

   public void setX(int x) {
        this.x = x;
   }

   public int getY() {
        return y;
   }

   public void setY(int y) {
        this.y = y;
   }

   public String toString() {
        return "(" + x + "," + y + ")";
   }

   public boolean equals(Object o) {
        if (o == null) {
           return false;
        }
        if (o == this) {
           return true;
        }
        if (o instanceof Point) {
           Point p = (Point) o;
           return this.x == p.x && this.y == p.y;
        }
        return false;
   }
}